Implementando Controles de Segurança de Gateway de API

Quando Usar

• Implantando uma camada centralizada de autenticação e autorização para APIs de microsserviços
• Implementando gerenciamento de limite de taxa, estrangulamento e cotas em todos os endpoints de API
• Configurando validação de requisição/resposta contra especificações OpenAPI no nível do gateway
• Configurando terminação TLS, TLS mútua e gerenciamento de certificados para tráfego de API
• Integrando regras de WAF com o gateway de API para bloquear injeção, XSS e padrões de ataque conhecidos

Não use como a única camada de segurança. Gateways de API fornecem defesa em profundidade, mas os serviços de backend também devem validar autorização e entrada.

Pré-requisitos

• Plataforma de gateway de API selecionada e implantada (Kong, AWS API Gateway, Azure APIM ou Apigee)
• Especificações OpenAPI/Swagger para todas as APIs de backend
• Certificados TLS para o domínio do gateway
• Provedor de identidade (IdP) configurado para OAuth2/OIDC (Okta, Auth0, Azure AD)
• Infraestrutura de monitoramento e logging (CloudWatch, Datadog, ELK)
• Endpoints de serviço de backend registrados e alcançáveis a partir do gateway

Fluxo de Trabalho

Etapa 1: Configuração de Segurança do Kong Gateway

# kong.yml - Declarative Kong configuration with security plugins
_format_version: "3.0"

services:
  - name: user-service
    url: http://user-service:8080
    routes:
      - name: user-api
        paths:
          - /api/v1/users
        methods:
          - GET
          - POST
          - PUT
          - PATCH
          - DELETE
        strip_path: false

plugins:
  # 1. Authentication: JWT validation
  - name: jwt
    config:
      uri_param_names:
        - jwt
      header_names:
        - Authorization
      claims_to_verify:
        - exp
      maximum_expiration: 3600  # Max 1 hour token TTL

  # 2. Rate Limiting
  - name: rate-limiting
    config:
      minute: 60
      hour: 1000
      policy: redis
      redis_host: redis
      redis_port: 6379
      fault_tolerant: true
      hide_client_headers: false
      limit_by: credential  # Per-user, not per-IP

  # 3. Request Size Limiting
  - name: request-size-limiting
    config:
      allowed_payload_size: 1  # 1 MB max
      size_unit: megabytes

  # 4. IP Restriction (admin endpoints)
  - name: ip-restriction
    service: admin-service
    config:
      allow:
        - 10.0.0.0/8
        - 172.16.0.0/12

  # 5. Bot Detection
  - name: bot-detection
    config:
      deny:
        - "sqlmap"
        - "nikto"
        - "nmap"
        - "masscan"

  # 6. CORS Configuration
  - name: cors
    config:
      origins:
        - "https://app.example.com"
      methods:
        - GET
        - POST
        - PUT
        - PATCH
        - DELETE
      headers:
        - Authorization
        - Content-Type
      credentials: true
      max_age: 3600

  # 7. Response Transformer - Remove sensitive headers
  - name: response-transformer
    config:
      remove:
        headers:
          - X-Powered-By
          - Server
      add:
        headers:
          - "X-Content-Type-Options: nosniff"
          - "X-Frame-Options: DENY"
          - "Strict-Transport-Security: max-age=31536000; includeSubDomains"
          - "Content-Security-Policy: default-src 'none'"

Etapa 2: Configuração de Segurança do AWS API Gateway

import boto3
import json

apigw = boto3.client('apigatewayv2')

# Criar API com TLS mútua
api_response = apigw.create_api(
    Name='secure-api',
    ProtocolType='HTTP',
    DisableExecuteApiEndpoint=True,  # Forçar domínio personalizado
)
api_id = api_response['ApiId']

# Configurar autorizador (JWT com Cognito)
authorizer = apigw.create_authorizer(
    ApiId=api_id,
    AuthorizerType='JWT',
    IdentitySource='$request.header.Authorization',
    Name='cognito-jwt-authorizer',
    JwtConfiguration={
        'Audience': ['your-app-client-id'],
        'Issuer': 'https://cognito-idp.us-east-1.amazonaws.com/us-east-1_xxxxx'
    }
)

# Criar rota com autorizador
apigw.create_route(
    ApiId=api_id,
    RouteKey='GET /api/v1/users',
    AuthorizerId=authorizer['AuthorizerId'],
    AuthorizationType='JWT',
)

# Configurar estrangulamento
apigw.create_stage(
    ApiId=api_id,
    StageName='prod',
    DefaultRouteSettings={
        'ThrottlingBurstLimit': 100,
        'ThrottlingRateLimit': 50.0,  # 50 requisições por segundo
    },
    AccessLogSettings={
        'DestinationArn': 'arn:aws:logs:us-east-1:123456789:log-group:api-access-logs',
        'Format': json.dumps({
            'requestId': '$context.requestId',

…