Integração do Vault para gerenciamento de chaves de API CaptchaAI

As chaves de API codificadas no código-fonte são uma responsabilidade de segurança. O HashiCorp Vault centraliza o gerenciamento de segredos - seuCaptchaAIA chave de API é armazenada criptografada, recuperada em tempo de execução e cada acesso é registrado. Este guia mostra como integrar o Vault ao seu pipeline de resolução de CAPTCHA.

Por que o Vault para chaves de API CAPTCHA

Pré-requisitos

• Servidor HashiCorp Vault (auto-hospedado ou HCP Vault)
• Acesso CLI ou API do Vault
• Chave de API CaptchaAI
• Python 3.8+ ou Node.js 18+

Armazene a chave de API no Vault

# Enable the KV secrets engine (if not already enabled)
vault secrets enable -path=secret kv-v2

# Store the CaptchaAI API key
vault kv put secret/captchaai api_key="YOUR_API_KEY"

# Verify
vault kv get secret/captchaai

Crie uma política de cofre

Restrinja os trabalhadores CAPTCHA ao acesso somente leitura:

# captcha-worker-policy.hcl
path "secret/data/captchaai" {
  capabilities = ["read"]
}

path "secret/metadata/captchaai" {
  capabilities = ["read"]
}

Aplique a política:

vault policy write captcha-worker captcha-worker-policy.hcl

Integração Python

# vault_solver.py
import os
import time
import hvac
import requests

# Connect to Vault
vault_client = hvac.Client(
    url=os.environ.get("VAULT_ADDR", "http://127.0.0.1:8200"),
    token=os.environ.get("VAULT_TOKEN"),
)

def get_api_key():
    """Retrieve CaptchaAI API key from Vault."""
    secret = vault_client.secrets.kv.v2.read_secret_version(
        path="captchaai",
        mount_point="secret",
    )
    return secret["data"]["data"]["api_key"]

class CaptchaSolver:
    """CAPTCHA solver with Vault-managed credentials."""

    def __init__(self):
        self.api_key = get_api_key()
        self.session = requests.Session()
        self._key_fetched_at = time.time()
        self._key_refresh_interval = 3600  # Re-fetch key hourly

    def _refresh_key_if_needed(self):
        """Periodically refresh the key from Vault."""
        if time.time() - self._key_fetched_at > self._key_refresh_interval:
            self.api_key = get_api_key()
            self._key_fetched_at = time.time()

    def solve(self, sitekey, pageurl):
        """Solve reCAPTCHA v2 using Vault-managed key."""
        self._refresh_key_if_needed()

        # Submit
        resp = self.session.get("https://ocr.captchaai.com/in.php", params={
            "key": self.api_key,
            "method": "userrecaptcha",
            "googlekey": sitekey,
            "pageurl": pageurl,
            "json": "1",
        })
        result = resp.json()

        if result.get("status") != 1:
            raise Exception(f"Submit failed: {result.get('request')}")

        task_id = result["request"]
        time.sleep(15)

        for _ in range(25):
            poll = self.session.get("https://ocr.captchaai.com/res.php", params={
                "key": self.api_key,
                "action": "get",
                "id": task_id,
                "json": "1",
            })
            poll_result = poll.json()

            if poll_result.get("status") == 1:
                return poll_result["request"]
            if poll_result.get("request") != "CAPCHA_NOT_READY":
                raise Exception(f"Error: {poll_result.get('request')}")

            time.sleep(5)

        raise Exception("Timeout")

# Usage
solver = CaptchaSolver()
token = solver.solve(
    "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-",
    "https://www.google.com/recaptcha/api2/demo"
)
print(f"Token: {token[:30]}...")

Integração JavaScript

// vault_solver.js
const axios = require('axios');

const VAULT_ADDR = process.env.VAULT_ADDR || 'http://127.0.0.1:8200';
const VAULT_TOKEN = process.env.VAULT_TOKEN;

async function getApiKey() {
  const resp = await axios.get(
    `${VAULT_ADDR}/v1/secret/data/captchaai`,
    { headers: { 'X-Vault-Token': VAULT_TOKEN } }
  );
  return resp.data.data.data.api_key;
}

class CaptchaSolver {
  constructor() {
    this.apiKey = null;
    this.keyFetchedAt = 0;
    this.refreshInterval = 3600000; // 1 hour
  }

  async init() {
    this.apiKey = await getApiKey();
    this.keyFetchedAt = Date.now();
  }

  async refreshKeyIfNeeded() {
    if (Date.now() - this.keyFetchedAt > this.refreshInterval) {
      this.apiKey = await getApiKey();
      this.keyFetchedAt = Date.now();
    }
  }

  async solve(sitekey, pageurl) {
    await this.refreshKeyIfNeeded();

    const submit = await axios.get('https://ocr.captchaai.com/in.php', {
      params: {
        key: this.apiKey, method: 'userrecaptcha',
        googlekey: sitekey, pageurl, json: '1',
      },
    });

    if (submit.data.status !== 1) throw new Error(submit.data.request);
    const taskId = submit.data.request;

    await new Promise(r => setTimeout(r, 15000));

    for (let i = 0; i < 25; i++) {
      const poll = await axios.get('https://ocr.captchaai.com/res.php', {
        params: { key: this.apiKey, action: 'get', id: taskId, json: '1' },
      });

      if (poll.data.status === 1) return poll.data.request;
      if (poll.data.request !== 'CAPCHA_NOT_READY') throw new Error(poll.data.request);
      await new Promise(r => setTimeout(r, 5000));
    }
    throw new Error('Timeout');
  }
}

(async () => {
  const solver = new CaptchaSolver();
  await solver.init();

  const token = await solver.solve(
    '6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
    'https://www.google.com/recaptcha/api2/demo'
  );
  console.log(`Token: ${token.slice(0, 30)}...`);
})();

Métodos de autenticação

O Vault oferece suporte a vários métodos de autenticação para trabalhadores:

Exemplo de AppRole (recomendado para produção)

# AppRole authentication — no static token needed
vault_client = hvac.Client(url=os.environ["VAULT_ADDR"])
vault_client.auth.approle.login(
    role_id=os.environ["VAULT_ROLE_ID"],
    secret_id=os.environ["VAULT_SECRET_ID"],
)

# Now read the secret
secret = vault_client.secrets.kv.v2.read_secret_version(path="captchaai")
api_key = secret["data"]["data"]["api_key"]

Fluxo de trabalho de rotação de chaves

1. Gere uma nova chave de API CaptchaAI no painel CaptchaAI
2. Atualizar cofre: vault kv put secret/captchaai api_key="NEW_KEY"
3. Os trabalhadores obtêm automaticamente a nova chave no próximo ciclo de atualização
4. Revogue a chave antiga no painel CaptchaAI depois que todos os trabalhadores forem atualizados

Não são necessárias alterações de código ou implantações.

Solução de problemas

Perguntas frequentes

O que acontece se o Vault estiver inativo?

Armazene em cache a chave de API na memória quando recuperada pela primeira vez. Se o Vault não estiver disponível durante uma atualização, continue usando a chave armazenada em cache e registre a falha.

Devo armazenar uma chave por ambiente?

Sim. Use caminhos de cofre separados: secret/captchaai/dev, secret/captchaai/staging, secret/captchaai/prod.

Posso usar o AWS Secrets Manager em vez do Vault?

Sim. O padrão é idêntico: recupere o segredo em tempo de execução do AWS Secrets Manager usando boto3. O princípio básico (sem chaves codificadas, rotação sem implantações) permanece o mesmo.

Artigos relacionados

• Segurança da chave de API da lista de permissões de IP Captchaai
• Rotação de chave da API Captchaai
• Integração Captchaai do Google Cloud Functions

Próximas etapas

Proteja suas credenciais CaptchaAI com o Vault -obtenha sua chave API.

Guias relacionados:

• Rotação de chave de API
• Protegendo credenciais em Env Vars
• Lista de permissões de IP