security_pentest_planner 1.0.1

data/lib/security_pentest_planner/vector_catalog.rb

@@ -0,0 +1,439 @@
+# frozen_string_literal: true
+
+module SecurityPentestPlanner
+  class VectorCatalog
+    Vector = Struct.new(
+      :id,
+      :name,
+      :category_slug,
+      :category_title,
+      :layer,
+      :triggers,
+      :objective,
+      :procedure,
+      :payload,
+      :payload_type,
+      :expected_validation,
+      :failure_criteria,
+      :risk,
+      keyword_init: true
+    )
+
+    Category = Struct.new(:slug, :title, :layer, keyword_init: true)
+
+    API_CATEGORIES = [
+      Category.new(slug: "controle-de-acesso", title: "Testes de Controle de Acesso (BOLA/IDOR)", layer: :api),
+      Category.new(slug: "ataques-de-injecao-e-manipulacao-de-params", title: "Ataques de Injeção e Manipulação de Parâmetros", layer: :api),
+      Category.new(slug: "seguranca-da-camada-de-negocio-e-logica", title: "Segurança da Camada de Negócio e Lógica", layer: :api),
+      Category.new(slug: "fuzzing-e-tratamento-de-erros", title: "Fuzzing e Tratamento de Erros", layer: :api)
+    ].freeze
+
+    DATALAKE_CATEGORIES = [
+      Category.new(slug: "testes-de-injecao-e-logica", title: "Testes de Injeção e Lógica", layer: :datalake),
+      Category.new(slug: "testes-de-controle-de-acesso", title: "Testes de Controle de Acesso (IAM & Permissões)", layer: :datalake),
+      Category.new(slug: "testes-de-performance-e-custo", title: "Testes de Performance e Custo (DoS de Data Lake)", layer: :datalake)
+    ].freeze
+
+    def self.vectors_for(analyzer)
+      new(analyzer).selected_vectors
+    end
+
+    def initialize(analyzer)
+      @analyzer = analyzer
+      @context = build_context
+    end
+
+    def selected_vectors
+      all_vectors.select { |vector| applicable?(vector) }.map { |vector| expand(vector) }
+    end
+
+    def grouped_vectors
+      selected_vectors.group_by { |v| [v.layer, v.category_slug] }
+    end
+
+    private
+
+    attr_reader :analyzer, :context
+
+    def build_context
+      endpoint = analyzer.primary_endpoint
+      {
+        team: "TIME",
+        tenant_header: analyzer.tenant_header_name,
+        endpoint_path: endpoint&.path || "/api/v1/resource",
+        method: endpoint&.method || "GET",
+        host: analyzer.host.gsub(%r{^https?://}, ""),
+        date_params: analyzer.date_param_names,
+        date_param_1: analyzer.date_param_names[0] || "start_date",
+        date_param_2: analyzer.date_param_names[1] || "end_date",
+        enum_param: analyzer.enum_param&.name || "channels",
+        enum_values: analyzer.enum_param&.enum_values&.join(", ") || "email, sms, whatsapp",
+        timezone_header: analyzer.timezone_headers.first&.name || "Timezone",
+        input_sources: analyzer.parser.source_path || "OpenAPI spec"
+      }
+    end
+
+    def applicable?(vector)
+      vector.triggers.all? { |trigger| analyzer.signals[trigger] }
+    end
+
+    def expand(vector)
+      Vector.new(
+        id: vector.id,
+        name: vector.name,
+        category_slug: vector.category_slug,
+        category_title: vector.category_title,
+        layer: vector.layer,
+        triggers: vector.triggers,
+        objective: interpolate(vector.objective),
+        procedure: vector.procedure.map { |step| interpolate(step) },
+        payload: interpolate(vector.payload),
+        payload_type: vector.payload_type,
+        expected_validation: interpolate(vector.expected_validation),
+        failure_criteria: interpolate(vector.failure_criteria),
+        risk: vector.risk
+      )
+    end
+
+    def interpolate(text)
+      text.gsub(/\{\{(\w+)\}\}/) { context[Regexp.last_match(1).to_sym] || "{{#{Regexp.last_match(1)}}}" }
+    end
+
+    def all_vectors
+      @all_vectors ||= api_vectors + datalake_vectors
+    end
+
+    def api_vectors
+      [
+        vector(
+          id: "tenant-traversal",
+          name: "Tenant Traversal",
+          category_slug: "controle-de-acesso",
+          category_title: API_CATEGORIES[0].title,
+          layer: :api,
+          triggers: [:tenant_scoping],
+          objective: "Substituir o header `{{tenant_header}}` por ID de outro cliente ou ID inexistente.",
+          procedure: [
+            "Obter baseline com tenant legítimo e intervalo de datas válido.",
+            "Repetir a requisição substituindo `{{tenant_header}}` por ID de tenant alheio.",
+            "Repetir com IDs inexistentes e valores extremamente longos."
+          ],
+          payload: "GET {{endpoint_path}}?{{date_param_1}}=2026-01-01&{{date_param_2}}=2026-01-31 HTTP/1.1\nHost: {{host}}\n{{tenant_header}}: 999999999999999999",
+          payload_type: "http",
+          expected_validation: "Sem retorno de estatísticas/dados de terceiros; preferencialmente métricas zeradas ou 403/404.",
+          failure_criteria: "200 com estatísticas ou dados de tenant não autorizado.",
+          risk: "BOLA/IDOR — Cross-Tenant Data Leak"
+        ),
+        vector(
+          id: "header-injection",
+          name: "Header Injection",
+          category_slug: "controle-de-acesso",
+          category_title: API_CATEGORIES[0].title,
+          layer: :api,
+          triggers: [:tenant_scoping],
+          objective: "Enviar headers conflitantes para verificar qual valor o backend prioriza.",
+          procedure: [
+            "Enviar `Tenant-ID` e `X-Tenant-ID` com valores distintos.",
+            "Inverter ordem dos headers e repetir.",
+            "Comparar resposta com baseline de cada tenant isolado."
+          ],
+          payload: "Tenant-ID: tenant-vitima\nX-Tenant-ID: tenant-atacante",
+          payload_type: "http",
+          expected_validation: "Comportamento determinístico; priorização segura do header canônico; sem vazamento do tenant vítima.",
+          failure_criteria: "Resposta alinhada ao tenant errado ou comportamento inconsistente.",
+          risk: "Bypass de isolamento por ambiguidade de parsing HTTP"
+        ),
+        vector(
+          id: "privilege-escalation",
+          name: "Privilege Escalation — omissão de tenant",
+          category_slug: "controle-de-acesso",
+          category_title: API_CATEGORIES[0].title,
+          layer: :api,
+          triggers: [:tenant_scoping],
+          objective: "Acessar o endpoint omitindo o header `{{tenant_header}}`.",
+          procedure: [
+            "Chamar `{{endpoint_path}}` sem `{{tenant_header}}`.",
+            "Verificar se query param alternativo de tenant é aceito.",
+            "Observar se a API retorna dados agregados cross-tenant."
+          ],
+          payload: "GET {{endpoint_path}}?{{date_param_1}}=2026-01-01&{{date_param_2}}=2026-01-31 HTTP/1.1\nHost: {{host}}",
+          payload_type: "http",
+          expected_validation: "400 Bad Request ou 401/403; nunca dados agregados cross-tenant.",
+          failure_criteria: "200 com métricas de negócio sem escopo de tenant.",
+          risk: "Visualização de dados de todos os clientes"
+        ),
+        vector(
+          id: "sqli-basic",
+          name: "SQL Injection — parâmetros de data",
+          category_slug: "ataques-de-injecao-e-manipulacao-de-params",
+          category_title: API_CATEGORIES[1].title,
+          layer: :api,
+          triggers: [:date_range],
+          objective: "Inserir payloads de escape em campos de data/filtro (`{{date_param_1}}`, `{{date_param_2}}`).",
+          procedure: [
+            "Substituir datas por payloads SQLi clássicos.",
+            "Observar código HTTP e corpo de erro.",
+            "Verificar se queries downstream permanecem inalteradas."
+          ],
+          payload: "{{date_param_1}}=2026-01-01' OR 1=1--\n{{date_param_2}}=2026-01-01' /*\n' OR '1'='1\n1; DROP TABLE users--",
+          payload_type: "txt",
+          expected_validation: "Sanitização ou rejeição; query inalterada; sem erro 500.",
+          failure_criteria: "Erro 500, stack trace SQL ou dados fora do escopo esperado.",
+          risk: "Injeção SQL via parâmetros de filtro"
+        ),
+        vector(
+          id: "enum-injection",
+          name: "Enum Injection",
+          category_slug: "ataques-de-injecao-e-manipulacao-de-params",
+          category_title: API_CATEGORIES[1].title,
+          layer: :api,
+          triggers: [:enum_params],
+          objective: "Enviar valores fora do enum/array homologado no parâmetro `{{enum_param}}`.",
+          procedure: [
+            "Enviar valores válidos como baseline ({{enum_values}}).",
+            "Testar `{{enum_param}}=all`, `{{enum_param}}=admin` e arrays malformados.",
+            "Verificar se o escopo da query permanece inalterado."
+          ],
+          payload: "{{enum_param}}=all\n{{enum_param}}=admin\n{{enum_param}}[]=invalid",
+          payload_type: "txt",
+          expected_validation: "Rejeição ou ignore seguro; escopo da query inalterado.",
+          failure_criteria: "Dados retornados fora do canal/escopo esperado.",
+          risk: "Bypass de filtro por enum corrompido"
+        ),
+        vector(
+          id: "timezone-manipulation",
+          name: "Timezone Manipulation",
+          category_slug: "ataques-de-injecao-e-manipulacao-de-params",
+          category_title: API_CATEGORIES[1].title,
+          layer: :api,
+          triggers: [:free_text_headers],
+          objective: "Explorar header `{{timezone_header}}` como string livre.",
+          procedure: [
+            "Enviar timezone inválido (ex: `Invalid/Zone`).",
+            "Testar CRLF injection no header.",
+            "Enviar buffer longo (8KB) para testar robustez do parser."
+          ],
+          payload: "{{timezone_header}}: Invalid/Zone\n{{timezone_header}}: America/Sao_Paulo\\r\\nInjected-Header: true\n{{timezone_header}}: AAAA...(buffer 8KB)",
+          payload_type: "txt",
+          expected_validation: "Whitelist IANA ou rejeição; sem crash; sem header injection reflexivo.",
+          failure_criteria: "Crash, 500 ou headers injetados refletidos na resposta.",
+          risk: "Header injection e parsing inseguro"
+        ),
+        vector(
+          id: "data-range-exhaustion",
+          name: "Data Range Exhaustion (DoS Lógico)",
+          category_slug: "seguranca-da-camada-de-negocio-e-logica",
+          category_title: API_CATEGORIES[2].title,
+          layer: :api,
+          triggers: [:date_range],
+          objective: "Solicitar intervalo de datas massivo para forçar processamento pesado.",
+          procedure: [
+            "Enviar `{{date_param_1}}=1900-01-01` e `{{date_param_2}}=2100-12-31`.",
+            "Medir tempo de resposta e consumo downstream.",
+            "Verificar se há limite máximo de intervalo."
+          ],
+          payload: "{{date_param_1}}=1900-01-01\n{{date_param_2}}=2100-12-31",
+          payload_type: "txt",
+          expected_validation: "Limite máximo de intervalo; timeout controlado; 400 com mensagem clara.",
+          failure_criteria: "200 com processamento completo de range abusivo ou timeout sem controle.",
+          risk: "DoS lógico no banco / motor analítico"
+        ),
+        vector(
+          id: "negative-values",
+          name: "Negative Values — datas invertidas",
+          category_slug: "seguranca-da-camada-de-negocio-e-logica",
+          category_title: API_CATEGORIES[2].title,
+          layer: :api,
+          triggers: [:date_range],
+          objective: "Enviar data de início posterior à data de fim.",
+          procedure: [
+            "Enviar `{{date_param_1}}=2026-12-31` e `{{date_param_2}}=2026-01-01`.",
+            "Observar código HTTP e consistência dos resultados."
+          ],
+          payload: "{{date_param_1}}=2026-12-31\n{{date_param_2}}=2026-01-01",
+          payload_type: "txt",
+          expected_validation: "Rejeição com erro controlado; sem 500; sem resultados inconsistentes.",
+          failure_criteria: "500 ou resultados incoerentes retornados.",
+          risk: "Lógica de negócio frágil em validação cronológica"
+        ),
+        vector(
+          id: "rate-limit-absence",
+          name: "Rate Limit Absence",
+          category_slug: "seguranca-da-camada-de-negocio-e-logica",
+          category_title: API_CATEGORIES[2].title,
+          layer: :api,
+          triggers: [:analytics],
+          objective: "Verificar proteção contra abuso volumétrico em endpoints analíticos.",
+          procedure: [
+            "Enviar N requisições paralelas (ex: 50 em 10s) com payload válido.",
+            "Observar se há throttling por tenant/usuário.",
+            "Documentar ausência como item de hardening se não houver 429."
+          ],
+          payload: "50 requisições GET {{endpoint_path}} em 10 segundos",
+          payload_type: "txt",
+          expected_validation: "429 Too Many Requests ou throttling por tenant/usuário.",
+          failure_criteria: "Todas as requisições processadas sem limitação.",
+          risk: "DoS volumétrico em endpoint analítico"
+        ),
+        vector(
+          id: "verbosity-check",
+          name: "Verbosity Check",
+          category_slug: "fuzzing-e-tratamento-de-erros",
+          category_title: API_CATEGORIES[3].title,
+          layer: :api,
+          triggers: [:enum_params],
+          objective: "Provocar erros 400/404 e inspecionar corpo da resposta.",
+          procedure: [
+            "Path inexistente → 404.",
+            "Parâmetro malformado → 400.",
+            "Body JSON inválido → 400 (se aplicável)."
+          ],
+          payload: "GET /api/v1/inexistente HTTP/1.1\nGET {{endpoint_path}}?{{date_param_1}}=INVALID HTTP/1.1",
+          payload_type: "http",
+          expected_validation: "Mensagens genéricas; sem stack trace, paths internos ou nomes de colunas.",
+          failure_criteria: "Vazamento de stack trace, `/usr/src/app`, nomes de tabelas ou versões de framework.",
+          risk: "Information disclosure via error handling"
+        ),
+        vector(
+          id: "type-juggling",
+          name: "Type Juggling",
+          category_slug: "fuzzing-e-tratamento-de-erros",
+          category_title: API_CATEGORIES[3].title,
+          layer: :api,
+          triggers: [:enum_params],
+          objective: "Enviar tipos inesperados onde se espera array/object/primitive em `{{enum_param}}`.",
+          procedure: [
+            "Enviar boolean, hash, null e integer no lugar de array.",
+            "Observar código HTTP e robustez do parser JSON."
+          ],
+          payload: "{ \"{{enum_param}}\": true }\n{ \"{{enum_param}}\": { \"value\": \"email\" } }\n{ \"{{enum_param}}\": null }",
+          payload_type: "json",
+          expected_validation: "Parser JSON robusto; 400 controlado; sem 500.",
+          failure_criteria: "500 ou execução parcial de lógica de negócio.",
+          risk: "Type confusion em parsing de entrada"
+        )
+      ]
+    end
+
+    def datalake_vectors
+      [
+        vector(
+          id: "bypass-tenant",
+          name: "Bypass de Tenant",
+          category_slug: "testes-de-injecao-e-logica",
+          category_title: DATALAKE_CATEGORIES[0].title,
+          layer: :datalake,
+          triggers: [:datalake],
+          objective: "Omitir ou neutralizar filtro de tenant na query final.",
+          procedure: [
+            "Executar query sem cláusula WHERE tenant_id.",
+            "Forçar bypass lógico com `OR 1=1`.",
+            "Verificar se row-level security impede cross-tenant."
+          ],
+          payload: "SELECT count(*) FROM `project.dataset.table`;\n\nSELECT count(*) FROM `project.dataset.table`\nWHERE tenant_id = @tenant_id OR 1=1;",
+          payload_type: "sql",
+          expected_validation: "Impossível cruzar dados de múltiplos tenants; parametrização enforced.",
+          failure_criteria: "Contagem ou dados de múltiplos tenants retornados.",
+          risk: "Cross-Tenant Data Leak no Data Lake"
+        ),
+        vector(
+          id: "union-exploitation",
+          name: "Union Exploitation",
+          category_slug: "testes-de-injecao-e-logica",
+          category_title: DATALAKE_CATEGORIES[0].title,
+          layer: :datalake,
+          triggers: [:datalake],
+          objective: "Injetar UNION apontando para metadados ou tabelas sensíveis.",
+          procedure: [
+            "Simular input malicioso chegando à camada SQL.",
+            "Tentar UNION ALL SELECT em INFORMATION_SCHEMA.",
+            "Verificar permissões da Service Account."
+          ],
+          payload: "SELECT cols FROM `table` WHERE tenant_id = @tenant_id\nUNION ALL SELECT table_name, column_name, data_type\nFROM `project.dataset.INFORMATION_SCHEMA.COLUMNS`;",
+          payload_type: "sql",
+          expected_validation: "SA sem permissão de leitura em INFORMATION_SCHEMA alheio; query rejeitada.",
+          failure_criteria: "Metadados de tabelas sensíveis retornados.",
+          risk: "Schema enumeration via SQL injection"
+        ),
+        vector(
+          id: "sa-overprivilege",
+          name: "Service Account Overprivilege",
+          category_slug: "testes-de-controle-de-acesso",
+          category_title: DATALAKE_CATEGORIES[1].title,
+          layer: :datalake,
+          triggers: [:datalake],
+          objective: "Verificar se a Service Account da API pode executar DDL/DML.",
+          procedure: [
+            "Tentar CREATE TABLE, DROP TABLE, INSERT, UPDATE, DELETE.",
+            "Verificar roles atribuídas (bigquery.dataViewer, jobUser)."
+          ],
+          payload: "CREATE TABLE test_pentest (id INT64);\nDROP TABLE `project.dataset.table`;\nINSERT INTO `table` VALUES (1);",
+          payload_type: "sql",
+          expected_validation: "SA estritamente Read-Only; DDL/DML rejeitados.",
+          failure_criteria: "Qualquer operação de escrita executada com sucesso.",
+          risk: "Comprometimento de integridade de dados"
+        ),
+        vector(
+          id: "metadata-leak",
+          name: "Metadata Leak",
+          category_slug: "testes-de-controle-de-acesso",
+          category_title: DATALAKE_CATEGORIES[1].title,
+          layer: :datalake,
+          triggers: [:datalake],
+          objective: "Mapear estrutura física via metadados (INFORMATION_SCHEMA).",
+          procedure: [
+            "Consultar INFORMATION_SCHEMA.COLUMNS e TABLES.",
+            "Verificar se SA expõe clusterização/particionamento.",
+            "Documentar como ATENÇÃO se leitura permitida sem vazamento de dados de negócio."
+          ],
+          payload: "SELECT * FROM `project.dataset.INFORMATION_SCHEMA.COLUMNS` WHERE table_name LIKE '%';\nSELECT ddl FROM `project.dataset.INFORMATION_SCHEMA.TABLES`;",
+          payload_type: "sql",
+          expected_validation: "Mínimo privilégio; SA não expõe metadados sensíveis via API.",
+          failure_criteria: "DDL completo ou esquema físico exposto a atacante.",
+          risk: "Information disclosure de metadados"
+        ),
+        vector(
+          id: "cartesian-product",
+          name: "Cartesian Product (Cross Join)",
+          category_slug: "testes-de-performance-e-custo",
+          category_title: DATALAKE_CATEGORIES[2].title,
+          layer: :datalake,
+          triggers: [:datalake],
+          objective: "Forçar cross join entre tabelas grandes para exaurir cotas.",
+          procedure: [
+            "Executar CROSS JOIN entre tabelas de alto volume.",
+            "Monitorar bytes billed e tempo de execução."
+          ],
+          payload: "SELECT a.*, b.*\nFROM `big_table` a\nCROSS JOIN `big_table` b\nWHERE a.tenant_id = @tenant_id\nLIMIT 100;",
+          payload_type: "sql",
+          expected_validation: "Timeout, quota exceeded ou bloqueio por policy; custo monitorado.",
+          failure_criteria: "Query executada com custo financeiro significativo sem alerta.",
+          risk: "DoS financeiro no Data Lake"
+        ),
+        vector(
+          id: "full-scan",
+          name: "Full Scan Forçado",
+          category_slug: "testes-de-performance-e-custo",
+          category_title: DATALAKE_CATEGORIES[2].title,
+          layer: :datalake,
+          triggers: [:datalake],
+          objective: "Query que ignora coluna de partição.",
+          procedure: [
+            "Executar COUNT sem filtro de partição.",
+            "Comparar bytes billed com query particionada.",
+            "Verificar se API sempre injeta filtro de partição."
+          ],
+          payload: "SELECT count(*) FROM `partitioned_table` WHERE tenant_id = @tenant_id;\n\n-- Comparar com:\nSELECT count(*) FROM `partitioned_table`\nWHERE tenant_id = @tenant_id AND partition_date BETWEEN '2026-01-01' AND '2026-01-31';",
+          payload_type: "sql",
+          expected_validation: "API sempre injeta filtro de partição; bytes billed controlados.",
+          failure_criteria: "Full scan de tabela particionada sem restrição.",
+          risk: "DoS de custo por scan completo"
+        )
+      ]
+    end
+
+    def vector(**attrs)
+      Vector.new(**attrs)
+    end
+  end
+end

data/lib/security_pentest_planner/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SecurityPentestPlanner
+  VERSION = "1.0.1"
+end

data/lib/security_pentest_planner.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "security_pentest_planner/version"
+require_relative "security_pentest_planner/errors"
+require_relative "security_pentest_planner/openapi_parser"
+require_relative "security_pentest_planner/contract_analyzer"
+require_relative "security_pentest_planner/vector_catalog"
+require_relative "security_pentest_planner/plan_renderer"
+require_relative "security_pentest_planner/planner"
+require_relative "security_pentest_planner/cli"
+
+module SecurityPentestPlanner
+  class << self
+    def generate(input_path:, **options)
+      Planner.new(input_path: input_path, **options).call
+    end
+
+    def generate_from_spec(spec:, **options)
+      Planner.new(spec: spec, **options).call
+    end
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: security_pentest_planner
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Saulo Filho
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: |
+  Ruby gem que analisa contratos OpenAPI/Swagger e gera Planos de Ação de Pentest
+  estruturados com vetores OWASP API Security, procedimentos, payloads, critérios
+  de validação e recomendações de remediação para sistemas multi-tenant e Data Lake.
+email:
+- saulofilho@users.noreply.github.com
+executables:
+- security-pentest-planner
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/security-pentest-planner
+- lib/security_pentest_planner.rb
+- lib/security_pentest_planner/cli.rb
+- lib/security_pentest_planner/contract_analyzer.rb
+- lib/security_pentest_planner/errors.rb
+- lib/security_pentest_planner/openapi_parser.rb
+- lib/security_pentest_planner/plan_renderer.rb
+- lib/security_pentest_planner/planner.rb
+- lib/security_pentest_planner/vector_catalog.rb
+- lib/security_pentest_planner/version.rb
+homepage: https://saulofilho.github.io/security-pentest-planner/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://saulofilho.github.io/security-pentest-planner/
+  source_code_uri: https://github.com/saulofilho/security-pentest-planner
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.1
+specification_version: 4
+summary: Gera Planos de Ação de Pentest a partir de especificações OpenAPI
+test_files: []