Melhores Práticas de Segurança do Synkra AIOS

┌─────────────────────────────────────────┐
│           Camada de Aplicação           │
├─────────────────────────────────────────┤
│         Camada de Autenticação          │
├─────────────────────────────────────────┤
│      Camada de Validação de Entrada     │
├─────────────────────────────────────────┤
│         Camada de Rate Limiting         │
├─────────────────────────────────────────┤
│            Camada de Rede               │
└─────────────────────────────────────────┘

const AuthSystem = require('./security/auth');
 
const auth = new AuthSystem({
  secretKey: process.env.JWT_SECRET,
  tokenExpiry: '1h',
  refreshExpiry: '7d'
});
 
// Criar usuário com requisitos de senha forte
await auth.createUser({
  username: 'admin',
  password: 'SecureP@ssw0rd123!',
  email: 'admin@example.com',
  role: 'admin'
});

# .env - Configurações de autenticação
JWT_SECRET=your-super-secure-random-key-here
AUTH_TOKEN_EXPIRY=1h
AUTH_REFRESH_EXPIRY=7d
AUTH_MAX_LOGIN_ATTEMPTS=5
AUTH_LOCKOUT_DURATION=15m

const InputSanitizer = require('./security/sanitizer');
 
// Sanitização de path
const safePath = InputSanitizer.sanitizePath(userInput, basePath);
 
// Validação de nome de projeto
const safeProjectName = InputSanitizer.sanitizeProjectName(name);
 
// Sanitização de comando
const safeCommand = InputSanitizer.sanitizeCommand(userCommand);
 
// Valores de configuração
const safeValue = InputSanitizer.sanitizeConfigValue(value, 'string');

const { RateLimiters } = require('./security/rate-limiter');
 
// Diferentes limitadores para diferentes operações
const apiLimiter = RateLimiters.createApiLimiter();
const authLimiter = RateLimiters.createAuthLimiter();
const metaAgentLimiter = RateLimiters.createMetaAgentLimiter();
 
// Verificar antes da operação
const identifier = RateLimiter.createIdentifier({
  ip: req.ip,
  userId: req.user?.id,
  operation: 'meta-agent'
});
 
const result = metaAgentLimiter.check(identifier);
if (!result.allowed) {
  throw new Error(`Limite de rate excedido. Tente novamente após ${result.retryAfter} segundos`);
}

# Configurações de rate limiting
RATE_LIMIT_API_WINDOW=900000
RATE_LIMIT_API_MAX=1000
RATE_LIMIT_AUTH_WINDOW=900000
RATE_LIMIT_AUTH_MAX=5
RATE_LIMIT_INSTALL_WINDOW=3600000
RATE_LIMIT_INSTALL_MAX=10

# Configurações de segurança obrigatórias
NODE_ENV=production
JWT_SECRET=your-256-bit-secret-key
DATABASE_ENCRYPTION_KEY=your-database-encryption-key
SESSION_SECRET=your-session-secret

# API Keys (nunca hardcode!)
OPENAI_API_KEY=sk-your-openai-key
ANTHROPIC_API_KEY=sk-your-anthropic-key

# Headers de segurança
SECURITY_HEADERS_ENABLED=true
HELMET_ENABLED=true
CORS_ORIGIN=https://yourdomain.com

# Logging de auditoria
AUDIT_LOG_ENABLED=true
AUDIT_LOG_LEVEL=info
AUDIT_LOG_FILE=/var/log/aios/audit.log

# Permissões de arquivo seguras
chmod 600 .env
chmod 600 .aios/config.json
chmod 600 .aios/users.json
chmod 600 .aios/sessions.json
chmod 700 .aios/
chmod 700 security/

// Validar configuração crítica na inicialização
const requiredEnvVars = [
  'JWT_SECRET',
  'NODE_ENV'
];
 
for (const envVar of requiredEnvVars) {
  if (!process.env[envVar]) {
    throw new Error(`Variável de ambiente obrigatória ausente: ${envVar}`);
  }
}
 
// Validar força do JWT secret
if (process.env.JWT_SECRET.length < 32) {
  throw new Error('JWT_SECRET deve ter pelo menos 32 caracteres');
}

const crypto = require('crypto');
 
class DataEncryption {
  constructor(key) {
    this.key = key;
    this.algorithm = 'aes-256-gcm';
  }
 
  encrypt(text) {
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipher(this.algorithm, this.key, iv);
 
    let encrypted = cipher.update(text, 'utf8', 'hex');
    encrypted += cipher.final('hex');
 
    const authTag = cipher.getAuthTag();
 
    return {
      encrypted,
      iv: iv.toString('hex'),
      authTag: authTag.toString('hex')
    };
  }
 
  decrypt(encryptedData) {
    const decipher = crypto.createDecipher(
      this.algorithm,
      this.key,
      Buffer.from(encryptedData.iv, 'hex')
    );
 
    decipher.setAuthTag(Buffer.from(encryptedData.authTag, 'hex'));
 
    let decrypted = decipher.update(encryptedData.encrypted, 'hex', 'utf8');
    decrypted += decipher.final('utf8');
 
    return decrypted;
  }
}

const winston = require('winston');
 
const securityLogger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({
      filename: 'logs/security.log',
      level: 'warn'
    }),
    new winston.transports.File({
      filename: 'logs/audit.log'
    })
  ]
});
 
// Registrar eventos de segurança
securityLogger.warn('Falha de autenticação', {
  username: req.body.username,
  ip: req.ip,
  userAgent: req.get('User-Agent'),
  timestamp: new Date().toISOString()
});

const alertThresholds = {
  failedLogins: 10, // por hora
  rateLimitViolations: 50, // por hora
  suspiciousFileAccess: 5, // por hora
  configChanges: 1, // qualquer mudança
  errorRate: 0.05 // taxa de erro de 5%
};

const https = require('https');
const fs = require('fs');
 
const options = {
  key: fs.readFileSync('path/to/private-key.pem'),
  cert: fs.readFileSync('path/to/certificate.pem'),
  // Melhorias de segurança
  secureProtocol: 'TLSv1_2_method',
  ciphers: 'ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384',
  honorCipherOrder: true
};
 
https.createServer(options, app).listen(443);

const helmet = require('helmet');
 
app.use(helmet({
  contentSecurityPolicy: {
    directives: {
      defaultSrc: ["'self'"],
      scriptSrc: ["'self'", "'unsafe-inline'"],
      styleSrc: ["'self'", "'unsafe-inline'"],
      imgSrc: ["'self'", "data:", "https:"]
    }
  },
  hsts: {
    maxAge: 31536000,
    includeSubDomains: true,
    preload: true
  }
}));

const cors = require('cors');
 
app.use(cors({
  origin: process.env.CORS_ORIGIN || 'https://yourdomain.com',
  credentials: true,
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization']
}));

# Auditorias de segurança regulares
npm audit
npm audit fix
 
# Usando yarn
yarn audit
yarn audit fix
 
# Varredura avançada com snyk
npx snyk test
npx snyk monitor

{
  "scripts": {
    "security:audit": "npm audit",
    "security:update": "npm update",
    "security:check": "snyk test",
    "security:monitor": "snyk monitor"
  }
}

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"
    open-pull-requests-limit: 5
    reviewers:
      - "security-team"

// Configuração de resposta a emergências
const emergencyConfig = {
  securityTeam: {
    primary: 'security-lead@company.com',
    backup: 'security-backup@company.com'
  },
  escalation: {
    level1: 'team-lead@company.com',
    level2: 'engineering-manager@company.com',
    level3: 'cto@company.com'
  },
  externalContacts: {
    hosting: 'support@hosting-provider.com',
    security: 'security@security-vendor.com'
  }
};