@gugananuvem/aws-local-simulator 1.0.35 → 1.0.39

package/src/services/opensearch/store.js

@@ -0,0 +1,162 @@
+/**
+ * OpenSearch Store - Persistência de índices e documentos em JSON
+ */
+
+const path = require('path');
+const fs = require('fs');
+const logger = require('../../utils/logger');
+
+class OpenSearchStore {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+    this.indicesDir = path.join(dataDir, 'opensearch');
+    this.metadataFile = path.join(this.indicesDir, '__indices__.json');
+
+    if (!fs.existsSync(this.indicesDir)) {
+      fs.mkdirSync(this.indicesDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Carrega metadados de todos os índices
+   */
+  loadMetadata() {
+    if (fs.existsSync(this.metadataFile)) {
+      try {
+        const data = fs.readFileSync(this.metadataFile, 'utf8');
+        return JSON.parse(data);
+      } catch (error) {
+        logger.warn(`Erro ao ler ${this.metadataFile}: ${error.message}`);
+        return {};
+      }
+    }
+    return {};
+  }
+
+  /**
+   * Salva metadados de todos os índices
+   */
+  saveMetadata(metadata) {
+    try {
+      fs.writeFileSync(this.metadataFile, JSON.stringify(metadata, null, 2), 'utf8');
+      logger.debug(`Metadados salvos em ${this.metadataFile}`);
+    } catch (error) {
+      logger.error(`Erro ao salvar ${this.metadataFile}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Obtém caminho do arquivo de índice
+   */
+  getIndexPath(indexName) {
+    return path.join(this.indicesDir, `${indexName}.json`);
+  }
+
+  /**
+   * Carrega documentos de um índice
+   */
+  loadDocuments(indexName) {
+    const indexPath = this.getIndexPath(indexName);
+
+    if (!fs.existsSync(indexPath)) {
+      return [];
+    }
+
+    try {
+      const data = fs.readFileSync(indexPath, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      logger.warn(`Erro ao ler índice ${indexName}: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * Salva documentos de um índice
+   */
+  saveDocuments(indexName, documents) {
+    try {
+      const indexPath = this.getIndexPath(indexName);
+      fs.writeFileSync(indexPath, JSON.stringify(documents, null, 2), 'utf8');
+      logger.debug(`${documents.length} documentos salvos no índice ${indexName}`);
+    } catch (error) {
+      logger.error(`Erro ao salvar índice ${indexName}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Adiciona documento ao índice
+   */
+  addDocument(indexName, document) {
+    const documents = this.loadDocuments(indexName);
+    
+    // Remove se já existe (atualização)
+    const index = documents.findIndex(doc => doc._id === document._id);
+    if (index !== -1) {
+      documents[index] = document;
+    } else {
+      documents.push(document);
+    }
+
+    this.saveDocuments(indexName, documents);
+  }
+
+  /**
+   * Remove documento do índice
+   */
+  removeDocument(indexName, documentId) {
+    const documents = this.loadDocuments(indexName);
+    const filtered = documents.filter(doc => doc._id !== documentId);
+
+    if (filtered.length < documents.length) {
+      this.saveDocuments(indexName, filtered);
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Deleta índice completamente
+   */
+  deleteIndex(indexName) {
+    try {
+      const indexPath = this.getIndexPath(indexName);
+      if (fs.existsSync(indexPath)) {
+        fs.unlinkSync(indexPath);
+        logger.debug(`Índice ${indexName} deletado`);
+      }
+    } catch (error) {
+      logger.error(`Erro ao deletar índice ${indexName}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Calcula tamanho total do índice em bytes
+   */
+  getIndexSize(indexName) {
+    const documents = this.loadDocuments(indexName);
+    return documents.reduce((sum, doc) => sum + JSON.stringify(doc._source).length, 0);
+  }
+
+  /**
+   * Limpa todos os índices
+   */
+  clear() {
+    try {
+      if (fs.existsSync(this.indicesDir)) {
+        const files = fs.readdirSync(this.indicesDir);
+        files.forEach(file => {
+          if (file.endsWith('.json')) {
+            fs.unlinkSync(path.join(this.indicesDir, file));
+          }
+        });
+        logger.debug('Todos os índices foram limpos');
+      }
+    } catch (error) {
+      logger.error(`Erro ao limpar índices: ${error.message}`);
+    }
+  }
+}
+
+module.exports = OpenSearchStore;

package/src/services/organizations/control-tower-simulator.js

@@ -0,0 +1,321 @@
+/**
+ * AWS Control Tower Simulator
+ * Gerencia landing zones, guardrails e conformidade
+ */
+
+const LocalStore = require('../../utils/local-store');
+const logger = require('../../utils/logger');
+const path = require('path');
+const { v4: uuidv4 } = require('uuid');
+
+class ControlTowerSimulator {
+  constructor(config, organizationsSimulator) {
+    this.config = config;
+    this.organizationsSimulator = organizationsSimulator;
+    
+    const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR || config.dataDir || './.aws-local-simulator-data';
+    this.dataDir = path.join(dataDir, 'control-tower');
+
+    this.store = new LocalStore(this.dataDir);
+    
+    // Landing zones
+    this.landingZones = new Map();
+    
+    // Guardrails (Preventive e Detective)
+    this.guardrails = new Map();
+    this.guardrailStatus = new Map(); // Mapear OU -> guardrails ativos
+    
+    // Compliance checks
+    this.complianceChecks = new Map();
+  }
+
+  async initialize() {
+    logger.debug('Inicializando Control Tower Simulator...');
+    
+    this.createDefaultGuardrails();
+    logger.debug(`✅ Control Tower Simulator inicializado`);
+  }
+
+  /**
+   * Cria guardrails padrão
+   */
+  createDefaultGuardrails() {
+    // Preventive Guardrails
+    this.createGuardrail('DisablePublicS3Buckets', 'PREVENTIVE', {
+      description: 'Bloqueia criação de buckets S3 públicos',
+      service: 's3',
+      action: 'PutBucketPublicAccessBlock'
+    });
+
+    this.createGuardrail('RequireMFA', 'PREVENTIVE', {
+      description: 'Requer MFA para operações sensíveis',
+      service: 'iam',
+      action: 'iam:*'
+    });
+
+    this.createGuardrail('RestrictEC2InstanceTypes', 'PREVENTIVE', {
+      description: 'Restringe tipos de instância EC2 a tipos aprovados',
+      service: 'ec2',
+      action: 'ec2:RunInstances'
+    });
+
+    // Detective Guardrails
+    this.createGuardrail('LogAllAPIActivity', 'DETECTIVE', {
+      description: 'Detecta falta de CloudTrail logging',
+      service: 'cloudtrail',
+      action: 'cloudtrail:StartLogging'
+    });
+
+    this.createGuardrail('DetectRootAccountUsage', 'DETECTIVE', {
+      description: 'Detecta uso de conta root',
+      service: 'iam',
+      action: 'root-account-usage'
+    });
+
+    this.createGuardrail('DetectUnencryptedData', 'DETECTIVE', {
+      description: 'Detecta dados não criptografados',
+      service: 'kms',
+      action: 'kms:Encrypt'
+    });
+  }
+
+  /**
+   * Cria um guardrail
+   */
+  createGuardrail(name, type, config = {}) {
+    const guardrailId = uuidv4().substring(0, 12);
+    
+    const guardrail = {
+      id: guardrailId,
+      name: name,
+      type: type, // PREVENTIVE ou DETECTIVE
+      arn: `arn:aws:controltower::123456789012:guardrail/${guardrailId}`,
+      description: config.description || '',
+      service: config.service,
+      action: config.action,
+      createdAt: new Date().toISOString(),
+      status: 'ACTIVE'
+    };
+
+    this.guardrails.set(guardrailId, guardrail);
+    return guardrail;
+  }
+
+  /**
+   * Estabelece landing zone
+   */
+  setupLandingZone(organizationRootId, config = {}) {
+    const landingZoneId = uuidv4().substring(0, 12);
+    
+    const landingZone = {
+      id: landingZoneId,
+      arn: `arn:aws:controltower::123456789012:landingzone/${landingZoneId}`,
+      organizationRootId: organizationRootId,
+      status: 'ACTIVE',
+      createdAt: new Date().toISOString(),
+      lastUpdatedAt: new Date().toISOString(),
+      version: '2.0',
+      // OUs criadas pela Landing Zone
+      ous: {
+        managementOu: null,
+        securityOu: null,
+        sandboxOu: null
+      },
+      enabledGuardrails: [],
+      complianceStatus: 'COMPLIANT'
+    };
+
+    this.landingZones.set(landingZoneId, landingZone);
+    
+    logger.info(`✅ Landing Zone estabelecida: ${landingZoneId}`);
+
+    return {
+      LandingZone: landingZone
+    };
+  }
+
+  /**
+   * Habilita guardrail em uma OU
+   */
+  enableGuardrail(guardrailId, targetOUId) {
+    const guardrail = this.guardrails.get(guardrailId);
+    if (!guardrail) {
+      throw new Error(`Guardrail '${guardrailId}' not found`);
+    }
+
+    // Valida OU
+    const organization = this.organizationsSimulator.organization;
+    const ou = organization.getOrganizationalUnit(targetOUId);
+    if (!ou) {
+      throw new Error(`OU '${targetOUId}' not found`);
+    }
+
+    if (!this.guardrailStatus.has(targetOUId)) {
+      this.guardrailStatus.set(targetOUId, []);
+    }
+
+    const enabledGuardrails = this.guardrailStatus.get(targetOUId);
+    if (!enabledGuardrails.includes(guardrailId)) {
+      enabledGuardrails.push(guardrailId);
+    }
+
+    logger.info(`✅ Guardrail habilitado: ${guardrail.name} em OU ${targetOUId}`);
+
+    return {
+      GuardrailStatus: {
+        GuardrailId: guardrailId,
+        TargetOUId: targetOUId,
+        Status: 'ENABLED'
+      }
+    };
+  }
+
+  /**
+   * Desabilita guardrail em uma OU
+   */
+  disableGuardrail(guardrailId, targetOUId) {
+    const guardrails = this.guardrailStatus.get(targetOUId);
+    if (!guardrails) {
+      throw new Error(`No guardrails enabled for OU '${targetOUId}'`);
+    }
+
+    const index = guardrails.indexOf(guardrailId);
+    if (index > -1) {
+      guardrails.splice(index, 1);
+    }
+
+    logger.info(`✅ Guardrail desabilitado: ${guardrailId} em OU ${targetOUId}`);
+
+    return {};
+  }
+
+  /**
+   * Lista guardrails disponíveis
+   */
+  listGuardrails() {
+    return {
+      Guardrails: Array.from(this.guardrails.values())
+    };
+  }
+
+  /**
+   * Lista guardrails habilitados em uma OU
+   */
+  getGuardrailsForOU(ouId) {
+    const enabledIds = this.guardrailStatus.get(ouId) || [];
+    const enabledGuardrails = enabledIds.map(id => this.guardrails.get(id));
+
+    return {
+      Guardrails: enabledGuardrails.filter(g => g)
+    };
+  }
+
+  /**
+   * Verifica conformidade de um account
+   */
+  checkCompliance(accountId) {
+    const organization = this.organizationsSimulator.organization;
+    const account = organization.getAccount(accountId);
+    
+    if (!account) {
+      throw new Error(`Account '${accountId}' not found`);
+    }
+
+    // Coleta guardrails aplicáveis
+    const applicableGuardrails = [];
+    
+    let currentOUId = account.parentId;
+    while (currentOUId) {
+      const guardrails = this.guardrailStatus.get(currentOUId) || [];
+      applicableGuardrails.push(...guardrails);
+      
+      const ou = organization.getOrganizationalUnit(currentOUId);
+      currentOUId = ou?.parentId;
+    }
+
+    // Simula verificação de conformidade
+    const results = {
+      AccountId: accountId,
+      ComplianceStatus: 'COMPLIANT',
+      Guardrails: applicableGuardrails.map(guardrailId => {
+        const guardrail = this.guardrails.get(guardrailId);
+        return {
+          GuardrailId: guardrailId,
+          GuardrailName: guardrail?.name,
+          Status: 'COMPLIANT', // Em produção seria baseado em verificações reais
+          LastCheckedAt: new Date().toISOString()
+        };
+      })
+    };
+
+    return results;
+  }
+
+  /**
+   * Gera relatório de conformidade
+   */
+  generateComplianceReport() {
+    const organization = this.organizationsSimulator.organization;
+    const accounts = organization.listAccounts();
+
+    const report = {
+      ReportId: uuidv4().substring(0, 12),
+      GeneratedAt: new Date().toISOString(),
+      AccountsChecked: accounts.length,
+      CompliantAccounts: 0,
+      NonCompliantAccounts: 0,
+      AccountResults: accounts.map(account => {
+        const compliance = this.checkCompliance(account.id);
+        if (compliance.ComplianceStatus === 'COMPLIANT') {
+          report.CompliantAccounts++;
+        } else {
+          report.NonCompliantAccounts++;
+        }
+        return compliance;
+      })
+    };
+
+    return report;
+  }
+
+  /**
+   * Obtém status da landing zone
+   */
+  getLandingZoneStatus(landingZoneId) {
+    const landingZone = this.landingZones.get(landingZoneId);
+    if (!landingZone) {
+      throw new Error(`Landing Zone '${landingZoneId}' not found`);
+    }
+
+    return {
+      LandingZone: landingZone
+    };
+  }
+
+  /**
+   * Obtém estatísticas
+   */
+  getStats() {
+    return {
+      landingZonesCount: this.landingZones.size,
+      guardrailsCount: this.guardrails.size,
+      preventiveGuardrailsCount: Array.from(this.guardrails.values()).filter(g => g.type === 'PREVENTIVE').length,
+      detectiveGuardrailsCount: Array.from(this.guardrails.values()).filter(g => g.type === 'DETECTIVE').length,
+      enabledGuardrailsCount: Array.from(this.guardrailStatus.values()).reduce((sum, arr) => sum + arr.length, 0)
+    };
+  }
+
+  /**
+   * Reset
+   */
+  async reset() {
+    this.landingZones.clear();
+    this.guardrailStatus.clear();
+    this.guardrails.clear();
+    
+    this.createDefaultGuardrails();
+    logger.info('✅ Control Tower Simulator resetado');
+  }
+}
+
+module.exports = ControlTowerSimulator;

package/src/services/organizations/control-tower-store.js

@@ -0,0 +1,182 @@
+/**
+ * Control Tower Store - Persistência de Landing Zones e Guardrails
+ */
+
+const path = require('path');
+const fs = require('fs');
+const logger = require('../../utils/logger');
+
+class ControlTowerStore {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+    this.controlTowerDir = path.join(dataDir, 'control-tower');
+    this.metadataFile = path.join(this.controlTowerDir, '__metadata__.json');
+
+    if (!fs.existsSync(this.controlTowerDir)) {
+      fs.mkdirSync(this.controlTowerDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Carrega landing zones
+   */
+  loadLandingZones() {
+    const landingZonesFile = path.join(this.controlTowerDir, '__landing_zones__.json');
+    
+    if (fs.existsSync(landingZonesFile)) {
+      try {
+        const data = fs.readFileSync(landingZonesFile, 'utf8');
+        return JSON.parse(data);
+      } catch (error) {
+        logger.warn(`Erro ao ler landing zones: ${error.message}`);
+        return {};
+      }
+    }
+    return {};
+  }
+
+  /**
+   * Salva landing zones
+   */
+  saveLandingZones(landingZones) {
+    try {
+      const landingZonesFile = path.join(this.controlTowerDir, '__landing_zones__.json');
+      const data = {};
+
+      for (const [lzId, lz] of landingZones) {
+        data[lzId] = lz;
+      }
+
+      fs.writeFileSync(landingZonesFile, JSON.stringify(data, null, 2), 'utf8');
+      logger.debug(`${Object.keys(data).length} landing zones salvas`);
+    } catch (error) {
+      logger.error(`Erro ao salvar landing zones: ${error.message}`);
+    }
+  }
+
+  /**
+   * Carrega guardrails
+   */
+  loadGuardrails() {
+    const guardrailsFile = path.join(this.controlTowerDir, '__guardrails__.json');
+    
+    if (fs.existsSync(guardrailsFile)) {
+      try {
+        const data = fs.readFileSync(guardrailsFile, 'utf8');
+        return JSON.parse(data);
+      } catch (error) {
+        logger.warn(`Erro ao ler guardrails: ${error.message}`);
+        return {};
+      }
+    }
+    return {};
+  }
+
+  /**
+   * Salva guardrails
+   */
+  saveGuardrails(guardrails) {
+    try {
+      const guardrailsFile = path.join(this.controlTowerDir, '__guardrails__.json');
+      const data = {};
+
+      for (const [guardrailId, guardrail] of guardrails) {
+        data[guardrailId] = guardrail;
+      }
+
+      fs.writeFileSync(guardrailsFile, JSON.stringify(data, null, 2), 'utf8');
+      logger.debug(`${Object.keys(data).length} guardrails salvos`);
+    } catch (error) {
+      logger.error(`Erro ao salvar guardrails: ${error.message}`);
+    }
+  }
+
+  /**
+   * Carrega status de guardrails por OU
+   */
+  loadGuardrailStatus() {
+    const statusFile = path.join(this.controlTowerDir, '__guardrail_status__.json');
+    
+    if (fs.existsSync(statusFile)) {
+      try {
+        const data = fs.readFileSync(statusFile, 'utf8');
+        return JSON.parse(data);
+      } catch (error) {
+        logger.warn(`Erro ao ler status de guardrails: ${error.message}`);
+        return {};
+      }
+    }
+    return {};
+  }
+
+  /**
+   * Salva status de guardrails
+   */
+  saveGuardrailStatus(guardrailStatus) {
+    try {
+      const statusFile = path.join(this.controlTowerDir, '__guardrail_status__.json');
+      const data = {};
+
+      for (const [ouId, guardrails] of guardrailStatus) {
+        data[ouId] = guardrails;
+      }
+
+      fs.writeFileSync(statusFile, JSON.stringify(data, null, 2), 'utf8');
+      logger.debug(`Status de guardrails salvo`);
+    } catch (error) {
+      logger.error(`Erro ao salvar status de guardrails: ${error.message}`);
+    }
+  }
+
+  /**
+   * Carrega compliance checks
+   */
+  loadComplianceChecks() {
+    const checksFile = path.join(this.controlTowerDir, '__compliance_checks__.json');
+    
+    if (fs.existsSync(checksFile)) {
+      try {
+        const data = fs.readFileSync(checksFile, 'utf8');
+        return JSON.parse(data);
+      } catch (error) {
+        logger.warn(`Erro ao ler compliance checks: ${error.message}`);
+        return {};
+      }
+    }
+    return {};
+  }
+
+  /**
+   * Salva compliance checks
+   */
+  saveComplianceChecks(checks) {
+    try {
+      const checksFile = path.join(this.controlTowerDir, '__compliance_checks__.json');
+      fs.writeFileSync(checksFile, JSON.stringify(checks, null, 2), 'utf8');
+      logger.debug(`Compliance checks salvos`);
+    } catch (error) {
+      logger.error(`Erro ao salvar compliance checks: ${error.message}`);
+    }
+  }
+
+  /**
+   * Limpa tudo
+   */
+  clear() {
+    try {
+      if (fs.existsSync(this.controlTowerDir)) {
+        const files = fs.readdirSync(this.controlTowerDir);
+        files.forEach(file => {
+          if (file.endsWith('.json')) {
+            fs.unlinkSync(path.join(this.controlTowerDir, file));
+          }
+        });
+        logger.debug('Todos os dados de Control Tower foram limpos');
+      }
+    } catch (error) {
+      logger.error(`Erro ao limpar Control Tower: ${error.message}`);
+    }
+  }
+}
+
+module.exports = ControlTowerStore;