@gugananuvem/aws-local-simulator 1.0.34 → 1.0.39

package/src/services/acm/models/certificate.js

@@ -0,0 +1,202 @@
+/**
+ * ACM Certificate Model
+ * Supports self-signed, email-validated, and DNS-validated certificates
+ */
+
+class Certificate {
+  constructor(domainName, config = {}) {
+    this.CertificateArn = this.generateArn();
+    this.DomainName = domainName;
+    this.SubjectAlternativeNames = config.SubjectAlternativeNames || [domainName];
+    this.Serial = this.generateSerial();
+    this.Subject = `CN=${domainName}`;
+    this.Issuer = config.Issuer || 'AWS Certificate Manager';
+    this.CreatedDate = new Date().toISOString();
+    this.IssuedDate = null;
+    this.Status = 'PENDING_VALIDATION';
+    this.Type = config.Type || 'AMAZON_ISSUED';
+    this.ValidationMethod = config.ValidationMethod || 'DNS';
+    this.NotBefore = null;
+    this.NotAfter = null;
+    this.Signature = this.generateSignature();
+    this.SignatureAlgorithm = 'sha256WithRSAEncryption';
+    this.KeyAlgorithm = 'RSA_2048';
+    this.Tags = config.Tags || [];
+    this.ValidationEmails = [];
+    this.DomainValidationOptions = [];
+    this.InUseBy = [];
+    this.KeyUsages = ['Digital Signature', 'Key Encipherment'];
+    this.ExtendedKeyUsages = ['TLS Web Server Authentication'];
+    this.RenewalEligibility = 'INELIGIBLE';
+    this.Options = {
+      CertificateTransparencyLoggingPreference: 'ENABLED',
+    };
+
+    // Initialize validation options
+    this.initializeValidationOptions(domainName, this.SubjectAlternativeNames);
+  }
+
+  generateArn() {
+    const accountId = '123456789012';
+    const region = 'us-east-1';
+    const random = Math.random().toString(36).substring(2, 15);
+    return `arn:aws:acm:${region}:${accountId}:certificate/${random}`;
+  }
+
+  generateSerial() {
+    let serial = '';
+    for (let i = 0; i < 32; i++) {
+      serial += Math.floor(Math.random() * 16).toString(16);
+    }
+    return serial.toUpperCase();
+  }
+
+  generateSignature() {
+    let signature = '';
+    for (let i = 0; i < 256; i++) {
+      signature += Math.floor(Math.random() * 256)
+        .toString(16)
+        .padStart(2, '0');
+    }
+    return signature.toUpperCase();
+  }
+
+  initializeValidationOptions(primaryDomain, altNames) {
+    const domains = [primaryDomain, ...altNames];
+    const uniqueDomains = [...new Set(domains)];
+
+    for (const domain of uniqueDomains) {
+      this.DomainValidationOptions.push({
+        DomainName: domain,
+        ValidationDomain: domain,
+        ValidationStatus: 'PENDING_VALIDATION',
+        ResourceRecord: {
+          Name: `_${this.generateValidationId()}.${domain}.`,
+          Type: 'CNAME',
+          Value: `_${this.generateValidationId()}.acm-validations.aws.`,
+        },
+        ValidationEmails: [`admin@${domain}`, `webmaster@${domain}`],
+      });
+    }
+  }
+
+  generateValidationId() {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let id = '';
+    for (let i = 0; i < 16; i++) {
+      id += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return id;
+  }
+
+  /**
+   * Validate certificate domain
+   */
+  validateDomain(domain) {
+    const option = this.DomainValidationOptions.find(o => o.DomainName === domain);
+    if (!option) {
+      throw new Error(`Domain not found: ${domain}`);
+    }
+
+    option.ValidationStatus = 'SUCCESS';
+    option.ValidationDate = new Date().toISOString();
+
+    // Check if all domains are validated
+    const allValidated = this.DomainValidationOptions.every(o => o.ValidationStatus === 'SUCCESS');
+    if (allValidated) {
+      this.Status = 'ISSUED';
+      this.IssuedDate = new Date().toISOString();
+
+      // Set expiration date (1 year from now)
+      const expirationDate = new Date();
+      expirationDate.setFullYear(expirationDate.getFullYear() + 1);
+
+      this.NotBefore = new Date().toISOString();
+      this.NotAfter = expirationDate.toISOString();
+    }
+  }
+
+  /**
+   * Check if certificate is valid
+   */
+  isValid() {
+    if (this.Status !== 'ISSUED') return false;
+    if (!this.NotAfter) return false;
+
+    const expirationDate = new Date(this.NotAfter);
+    return expirationDate > new Date();
+  }
+
+  /**
+   * Check if certificate is expiring soon (30 days)
+   */
+  isExpiringsoon() {
+    if (!this.NotAfter) return false;
+
+    const expirationDate = new Date(this.NotAfter);
+    const thirtyDaysFromNow = new Date();
+    thirtyDaysFromNow.setDate(thirtyDaysFromNow.getDate() + 30);
+
+    return expirationDate <= thirtyDaysFromNow && expirationDate > new Date();
+  }
+
+  /**
+   * Renew certificate
+   */
+  renew() {
+    if (!this.isValid()) {
+      throw new Error('Cannot renew invalid certificate');
+    }
+
+    // Create renewal certificate
+    const newCert = new Certificate(this.DomainName, {
+      SubjectAlternativeNames: this.SubjectAlternativeNames,
+      Type: this.Type,
+      ValidationMethod: this.ValidationMethod,
+      Tags: this.Tags,
+    });
+
+    return newCert;
+  }
+
+  toJSON() {
+    return {
+      CertificateArn: this.CertificateArn,
+      DomainName: this.DomainName,
+      SubjectAlternativeNames: this.SubjectAlternativeNames,
+      Serial: this.Serial,
+      Subject: this.Subject,
+      Issuer: this.Issuer,
+      CreatedDate: this.CreatedDate,
+      IssuedDate: this.IssuedDate,
+      Status: this.Status,
+      Type: this.Type,
+      ValidationMethod: this.ValidationMethod,
+      NotBefore: this.NotBefore,
+      NotAfter: this.NotAfter,
+      SignatureAlgorithm: this.SignatureAlgorithm,
+      KeyAlgorithm: this.KeyAlgorithm,
+      KeyUsages: this.KeyUsages,
+      ExtendedKeyUsages: this.ExtendedKeyUsages,
+      DomainValidationOptions: this.DomainValidationOptions,
+      RenewalEligibility: this.RenewalEligibility,
+      InUseBy: this.InUseBy,
+      Tags: this.Tags,
+      Options: this.Options,
+    };
+  }
+
+  toJSONSummary() {
+    return {
+      CertificateArn: this.CertificateArn,
+      DomainName: this.DomainName,
+      Status: this.Status,
+      CreatedDate: this.CreatedDate,
+      IssuedDate: this.IssuedDate,
+      NotAfter: this.NotAfter,
+      Type: this.Type,
+    };
+  }
+}
+
+module.exports = Certificate;

package/src/services/acm/server.js

@@ -0,0 +1,224 @@
+/**
+ * ACM Server
+ * REST API para gerenciamento de certificados SSL/TLS
+ */
+
+const express = require('express');
+const logger = require('../../utils/logger');
+
+class ACMServer {
+  constructor(port, config) {
+    this.port = port;
+    this.config = config;
+    this.app = express();
+    this.setupMiddlewares();
+  }
+
+  setupMiddlewares() {
+    this.app.use(express.json());
+    this.app.use((req, res, next) => {
+      logger.info(`[ACM] ${req.method} ${req.path}`);
+      next();
+    });
+  }
+
+  async initialize(simulator) {
+    this.simulator = simulator;
+    this.setupRoutes();
+  }
+
+  setupRoutes() {
+    // Certificates
+    this.app.post('/acm/request-certificate', (req, res) => this.requestCertificate(req, res));
+    this.app.get('/acm/list-certificates', (req, res) => this.listCertificates(req, res));
+    this.app.get('/acm/describe-certificate/:arn', (req, res) => this.describeCertificate(req, res));
+    this.app.post('/acm/validate-domain', (req, res) => this.validateDomain(req, res));
+    this.app.delete('/acm/delete-certificate/:arn', (req, res) => this.deleteCertificate(req, res));
+    this.app.post('/acm/renew-certificate', (req, res) => this.renewCertificate(req, res));
+    this.app.post('/acm/add-tags-to-certificate', (req, res) => this.addTagsToCertificate(req, res));
+    this.app.get('/acm/stats', (req, res) => this.getStats(req, res));
+    this.app.get('/acm/certificate-by-domain/:domain', (req, res) => this.listByDomain(req, res));
+  }
+
+  async requestCertificate(req, res) {
+    try {
+      const { DomainName, SubjectAlternativeNames, ValidationMethod, Tags, CertificateType } = req.body;
+
+      if (!DomainName) {
+        return res.status(400).json({ error: 'DomainName is required' });
+      }
+
+      const certificate = this.simulator.requestCertificate(DomainName, {
+        SubjectAlternativeNames,
+        ValidationMethod,
+        Tags,
+        CertificateType,
+      });
+
+      res.status(201).json({
+        CertificateArn: certificate.CertificateArn,
+        Status: certificate.Status,
+        ValidationMethod: certificate.ValidationMethod,
+        DomainValidationOptions: certificate.DomainValidationOptions,
+      });
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  }
+
+  async listCertificates(req, res) {
+    try {
+      const { Status } = req.query;
+      const certificates = this.simulator.listCertificates(Status);
+
+      res.json({
+        CertificateSummaryList: certificates.map(c => c.toJSONSummary()),
+        NextToken: null,
+      });
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  }
+
+  async describeCertificate(req, res) {
+    try {
+      const arn = decodeURIComponent(req.params.arn);
+      const certificate = this.simulator.describeCertificate(arn);
+
+      res.json({
+        Certificate: certificate.toJSON(),
+      });
+    } catch (error) {
+      res.status(404).json({ error: error.message });
+    }
+  }
+
+  async validateDomain(req, res) {
+    try {
+      const { CertificateArn, DomainName } = req.body;
+
+      if (!CertificateArn || !DomainName) {
+        return res.status(400).json({ error: 'CertificateArn and DomainName are required' });
+      }
+
+      const certificate = this.simulator.validateDomain(CertificateArn, DomainName);
+
+      res.json({
+        CertificateArn: certificate.CertificateArn,
+        Status: certificate.Status,
+        ValidatedDomains: certificate.DomainValidationOptions
+          .filter(o => o.ValidationStatus === 'SUCCESS')
+          .map(o => o.DomainName),
+      });
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  }
+
+  async deleteCertificate(req, res) {
+    try {
+      const arn = decodeURIComponent(req.params.arn);
+      this.simulator.deleteCertificate(arn);
+
+      res.json({
+        CertificateArn: arn,
+        Deleted: true,
+      });
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  }
+
+  async renewCertificate(req, res) {
+    try {
+      const { CertificateArn } = req.body;
+
+      if (!CertificateArn) {
+        return res.status(400).json({ error: 'CertificateArn is required' });
+      }
+
+      const newCertificate = this.simulator.renewCertificate(CertificateArn);
+
+      res.status(201).json({
+        CertificateArn: newCertificate.CertificateArn,
+        OldCertificateArn: CertificateArn,
+        Status: newCertificate.Status,
+        DomainValidationOptions: newCertificate.DomainValidationOptions,
+      });
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  }
+
+  async addTagsToCertificate(req, res) {
+    try {
+      const { CertificateArn, Tags } = req.body;
+
+      if (!CertificateArn || !Tags) {
+        return res.status(400).json({ error: 'CertificateArn and Tags are required' });
+      }
+
+      const certificate = this.simulator.addTagsToCertificate(CertificateArn, Tags);
+
+      res.json({
+        CertificateArn: certificate.CertificateArn,
+        Tags: certificate.Tags,
+      });
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  }
+
+  async getStats(req, res) {
+    try {
+      const stats = this.simulator.getCertificateStats();
+
+      res.json({
+        Statistics: {
+          TotalCertificates: stats.total,
+          IssuedCertificates: stats.issued,
+          PendingValidationCertificates: stats.pending,
+          ExpiringInThirtyDaysCertificates: stats.expiring_soon,
+          ExpiredCertificates: stats.expired,
+        },
+      });
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  }
+
+  async listByDomain(req, res) {
+    try {
+      const domain = decodeURIComponent(req.params.domain);
+      const certificates = this.simulator.listCertificatesByDomain(domain);
+
+      res.json({
+        CertificateSummaryList: certificates.map(c => c.toJSONSummary()),
+        Domain: domain,
+      });
+    } catch (error) {
+      res.status(400).json({ error: error.message });
+    }
+  }
+
+  async start() {
+    return new Promise((resolve) => {
+      this.server = this.app.listen(this.port, () => {
+        logger.info(`✅ ACM Server running on port ${this.port}`);
+        resolve();
+      });
+    });
+  }
+
+  async stop() {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(resolve);
+      } else {
+        resolve();
+      }
+    });
+  }
+}
+
+module.exports = ACMServer;

package/src/services/acm/simulator.js

@@ -0,0 +1,293 @@
+/**
+ * ACM Simulator
+ * AWS Certificate Manager with DNS validation, renewal, and expiration tracking
+ */
+
+const path = require('path');
+const Certificate = require('./models/certificate');
+const LocalStore = require('../../utils/local-store');
+const logger = require('../../utils/logger');
+
+class ACMSimulator {
+  constructor(config = {}) {
+    this.config = config;
+    this.certificates = new Map(); // arn -> certificate
+    this.certificatesByDomain = new Map(); // domain -> [arns]
+
+    // Inicializar persistência
+    const dataDir = process.env.AWS_LOCAL_SIMULATOR_DATA_DIR || config.dataDir || './.aws-local-simulator-data';
+    this.dataDir = path.join(dataDir, 'acm');
+    this.store = new LocalStore(this.dataDir);
+
+    // Renewal check interval
+    this.renewalCheckInterval = null;
+  }
+
+  async initialize() {
+    // 1. Carregar dados persistidos
+    await this.loadFromPersistence();
+
+    // 2. Criar certificados padrão se configurado
+    if (this.certificates.size === 0 && this.config.certificates && Array.isArray(this.config.certificates)) {
+      logger.info('📚 Carregando Certificados ACM da configuração inicial...');
+      for (const certConfig of this.config.certificates) {
+        this.requestCertificate(certConfig.DomainName, certConfig);
+      }
+    }
+
+    // 3. Iniciar verificação de renovação
+    this.startRenewalCheckInterval();
+  }
+
+  /**
+   * Carrega dados persistidos do storage
+   */
+  async loadFromPersistence() {
+    try {
+      const certificatesData = this.store.read('certificates');
+      if (Array.isArray(certificatesData)) {
+        logger.info(`📂 Carregando ${certificatesData.length} Certificados ACM do storage...`);
+        for (const certData of certificatesData) {
+          const cert = new Certificate(certData.DomainName, {
+            SubjectAlternativeNames: certData.SubjectAlternativeNames,
+            Type: certData.Type,
+            ValidationMethod: certData.ValidationMethod,
+            Tags: certData.Tags,
+          });
+
+          // Restaurar estado do certificado
+          cert.CertificateArn = certData.CertificateArn;
+          cert.Serial = certData.Serial;
+          cert.Status = certData.Status;
+          cert.IssuedDate = certData.IssuedDate;
+          cert.CreatedDate = certData.CreatedDate;
+          cert.NotBefore = certData.NotBefore;
+          cert.NotAfter = certData.NotAfter;
+          cert.DomainValidationOptions = certData.DomainValidationOptions;
+          cert.InUseBy = certData.InUseBy || [];
+
+          this.certificates.set(cert.CertificateArn, cert);
+
+          // Indexar por domínio
+          if (!this.certificatesByDomain.has(cert.DomainName)) {
+            this.certificatesByDomain.set(cert.DomainName, []);
+          }
+          this.certificatesByDomain.get(cert.DomainName).push(cert.CertificateArn);
+        }
+      }
+    } catch (error) {
+      logger.error(`Erro ao carregar persistência ACM: ${error.message}`);
+    }
+  }
+
+  /**
+   * Persiste dados para storage
+   */
+  persistData() {
+    try {
+      const certificatesData = Array.from(this.certificates.values()).map(cert => cert.toJSON());
+      this.store.write('certificates', certificatesData);
+    } catch (error) {
+      logger.error(`Erro ao persistir ACM: ${error.message}`);
+    }
+  }
+
+  /**
+   * Solicita novo certificado
+   */
+  requestCertificate(domainName, config = {}) {
+    // Validar domínio
+    if (!domainName || typeof domainName !== 'string') {
+      throw new Error('DomainName is required');
+    }
+
+    const certificate = new Certificate(domainName, {
+      SubjectAlternativeNames: config.SubjectAlternativeNames || [domainName],
+      Type: config.CertificateType || 'AMAZON_ISSUED',
+      ValidationMethod: config.ValidationMethod || 'DNS',
+      Tags: config.Tags || [],
+    });
+
+    this.certificates.set(certificate.CertificateArn, certificate);
+
+    // Indexar por domínio
+    if (!this.certificatesByDomain.has(domainName)) {
+      this.certificatesByDomain.set(domainName, []);
+    }
+    this.certificatesByDomain.get(domainName).push(certificate.CertificateArn);
+
+    this.persistData();
+    logger.info(`✅ Certificado solicitado: ${domainName} (${certificate.CertificateArn})`);
+    return certificate;
+  }
+
+  /**
+   * Lista certificados
+   */
+  listCertificates(statusFilter = null) {
+    let certs = Array.from(this.certificates.values());
+
+    if (statusFilter) {
+      certs = certs.filter(c => c.Status === statusFilter);
+    }
+
+    return certs;
+  }
+
+  /**
+   * Descreve certificado
+   */
+  describeCertificate(arn) {
+    const certificate = this.certificates.get(arn);
+    if (!certificate) {
+      throw new Error(`Certificate not found: ${arn}`);
+    }
+
+    return certificate;
+  }
+
+  /**
+   * Valida domínio do certificado
+   */
+  validateDomain(arn, domain) {
+    const certificate = this.certificates.get(arn);
+    if (!certificate) {
+      throw new Error(`Certificate not found: ${arn}`);
+    }
+
+    certificate.validateDomain(domain);
+    this.persistData();
+    logger.info(`✅ Domínio validado: ${domain} no certificado ${arn}`);
+    return certificate;
+  }
+
+  /**
+   * Deleta certificado
+   */
+  deleteCertificate(arn) {
+    const certificate = this.certificates.get(arn);
+    if (!certificate) {
+      throw new Error(`Certificate not found: ${arn}`);
+    }
+
+    if (certificate.InUseBy && certificate.InUseBy.length > 0) {
+      throw new Error(`Cannot delete certificate in use by ${certificate.InUseBy.length} resources`);
+    }
+
+    // Remove da indexação por domínio
+    const domainArns = this.certificatesByDomain.get(certificate.DomainName);
+    if (domainArns) {
+      const index = domainArns.indexOf(arn);
+      if (index > -1) {
+        domainArns.splice(index, 1);
+      }
+    }
+
+    this.certificates.delete(arn);
+    this.persistData();
+    logger.info(`✅ Certificado deletado: ${arn}`);
+    return true;
+  }
+
+  /**
+   * Renova certificado
+   */
+  renewCertificate(arn) {
+    const oldCertificate = this.certificates.get(arn);
+    if (!oldCertificate) {
+      throw new Error(`Certificate not found: ${arn}`);
+    }
+
+    if (!oldCertificate.isValid()) {
+      throw new Error(`Cannot renew invalid certificate`);
+    }
+
+    const newCertificate = oldCertificate.renew();
+    this.certificates.set(newCertificate.CertificateArn, newCertificate);
+
+    // Indexar por domínio
+    if (!this.certificatesByDomain.has(newCertificate.DomainName)) {
+      this.certificatesByDomain.set(newCertificate.DomainName, []);
+    }
+    this.certificatesByDomain.get(newCertificate.DomainName).push(newCertificate.CertificateArn);
+
+    this.persistData();
+    logger.info(`✅ Certificado renovado: ${newCertificate.CertificateArn}`);
+    return newCertificate;
+  }
+
+  /**
+   * Adiciona tag ao certificado
+   */
+  addTagsToCertificate(arn, tags) {
+    const certificate = this.certificates.get(arn);
+    if (!certificate) {
+      throw new Error(`Certificate not found: ${arn}`);
+    }
+
+    for (const tag of tags) {
+      const existingTag = certificate.Tags.find(t => t.Key === tag.Key);
+      if (existingTag) {
+        existingTag.Value = tag.Value;
+      } else {
+        certificate.Tags.push(tag);
+      }
+    }
+
+    this.persistData();
+    return certificate;
+  }
+
+  /**
+   * Lista certificados com filtro por domínio
+   */
+  listCertificatesByDomain(domainName) {
+    const arns = this.certificatesByDomain.get(domainName) || [];
+    return arns.map(arn => this.certificates.get(arn));
+  }
+
+  /**
+   * Obter estatísticas de certificados
+   */
+  getCertificateStats() {
+    const certs = Array.from(this.certificates.values());
+    return {
+      total: certs.length,
+      issued: certs.filter(c => c.Status === 'ISSUED').length,
+      pending: certs.filter(c => c.Status === 'PENDING_VALIDATION').length,
+      expiring_soon: certs.filter(c => c.isExpiringsoon()).length,
+      expired: certs.filter(c => !c.isValid()).length,
+    };
+  }
+
+  /**
+   * Inicia verificação de renovação periódica
+   */
+  startRenewalCheckInterval() {
+    if (this.renewalCheckInterval) clearInterval(this.renewalCheckInterval);
+
+    this.renewalCheckInterval = setInterval(() => {
+      const certificatesToRenew = Array.from(this.certificates.values()).filter(c => c.isExpiringsoon());
+
+      for (const cert of certificatesToRenew) {
+        try {
+          this.renewCertificate(cert.CertificateArn);
+        } catch (error) {
+          logger.warn(`Failed to auto-renew certificate: ${error.message}`);
+        }
+      }
+    }, 300000); // 5 minutos
+  }
+
+  /**
+   * Para verificação de renovação periódica
+   */
+  stopRenewalCheckInterval() {
+    if (this.renewalCheckInterval) {
+      clearInterval(this.renewalCheckInterval);
+      this.renewalCheckInterval = null;
+    }
+  }
+}
+
+module.exports = ACMSimulator;