Les agents IA appellent votre API : 5 erreurs d'authentification qui créent des portes dérobées

Ajouter la signature de requête HMAC

Au-delà de l'authentification basée sur des jetons, signez chaque charge utile de demande avec HMAC-SHA256. Votre API vérifie la signature avant traiter la demande. Cela prouve que la charge utile n'a pas été altérée pendant le transport et lie chaque demande à un secret d'agent spécifique.

# Sign a request payload so your API can verify the sender
PAYLOAD='{"agent_id":"agent-refund-processor","action":"refund","order_id":"ORD-7291"}'

curl -s -X POST https://api.botoi.com/v1/hash/hmac \\
  -H "Content-Type: application/json" \\
  -d "{
    \\"text\\": \\"$PAYLOAD\\",
    \\"key\\": \\"kX9mT2vR8nL4wQ6jY3bA5cF7hD1gP0sE9uI2oK4lM6nB8xZ3vC5tR7yW0qJ1aG\\",
    \\"algorithm\\": \\"sha256\\"
  }"

{
  "success": true,
  "data": {
    "hmac": "a3f8c2d1e5b7094f6d2c8a1e3b5f7d9e4c6a8b0d2f4e6c8a0b2d4f6e8c0a2b4",
    "algorithm": "sha256"
  }
}

Votre serveur API recalcule le HMAC à l'aide de sa copie stockée du secret de l'agent. Si les hachages correspondent, le la demande est authentique. Si ce n’est pas le cas, rejetez-le.

Automatisez la rotation des secrets

La rotation manuelle ne s'adapte pas lorsque vous exécutez des dizaines d'agents. Créez un script de rotation qui génère un nouveau secret, le déploie, vérifie la connectivité, puis révoque l'ancien.

import Botoi from "@botoi/sdk";

const botoi = new Botoi({ apiKey: process.env.BOTOI_API_KEY });

async function rotateAgentSecret() {
  // Generate a new 64-character secret
  const { data } = await botoi.password.generate({
    length: 64,
    uppercase: true,
    lowercase: true,
    numbers: true,
    symbols: false,
  });

  console.log("New secret generated. Deploy to agent, then revoke the old one.");

  // Hash the new secret for storage (never store plaintext)
  const hashed = await botoi.hash.sha256({ input: data.password });
  console.log("Hashed for DB:", hashed.data.hash);

  return { secret: data.password, hash: hashed.data.hash };
}

rotateAgentSecret();

Erreur 4 : ignorer la journalisation des demandes pour les appels de machine à machine

48,9 % des organisations ignorent le trafic de machine à machine. Ils enregistrent les appels d'API humains mais exemptent les appels internes communication de service à service à partir de leur pile d'observabilité. Les agents de l’IA tombent dans cet angle mort.

Lorsqu'un agent se comporte mal, envoie un flot de requêtes, accède à des points de terminaison en dehors de sa portée ou obtient compromis, vous devez répondre à trois questions : quel agent, quand et qu'a-t-il touché ? Sans demande en vous connectant, vous ne pouvez répondre à aucune d'entre elles.

// Express middleware: log every agent request
app.use("/v1/*", (req, res, next) => {
  const agentId = req.headers["x-agent-id"] || "unknown";
  const start = Date.now();

  res.on("finish", () => {
    const log = {
      timestamp: new Date().toISOString(),
      agent_id: agentId,
      method: req.method,
      path: req.path,
      status: res.statusCode,
      duration_ms: Date.now() - start,
      ip: req.ip,
      user_agent: req.headers["user-agent"],
    };
    console.log(JSON.stringify(log));
  });

  next();
});

Capturez l'identité de l'agent, le point de terminaison, la méthode HTTP, le code d'état et la durée de chaque demande. Envoi structuré logs sur votre plateforme d’observabilité. Définir des alertes en cas d'anomalies : pics soudains du volume de demandes, demandes de des points de terminaison en dehors de la portée de l'agent ou des taux d'erreur élevés.

Erreur 5 : traiter l'authentification de l'agent de la même manière que l'authentification humaine

Seuls 18 % des responsables de la sécurité sont convaincus que leurs systèmes IAM peuvent gérer les identités des agents. L'autre boulon à 82 % l'accès des agents aux flux d'authentification humaine qui n'ont pas été conçus pour les appelants autonomes.

L'authentification humaine suppose qu'une personne lit un écran de consentement OAuth, saisit un mot de passe et répond à une invite MFA. Les agents ne font rien de tout ça. Ils ont besoin d'un modèle d'authentification différent avec trois propriétés.

1. Jetons étendus avec des autorisations explicites

Chaque jeton d'agent déclare les points de terminaison qu'il peut appeler et les actions qu'il peut effectuer. L'API applique ces portées sur chaque demande. Aucune portée, aucun accès.

2. Limites de taux par identité

Un utilisateur humain envoie quelques requêtes par minute. Un agent en envoie des centaines ou des milliers. Limites de tarifs par agent L'identité empêche un agent d'affamer les autres et limite le rayon d'explosion si un agent devient voyou.

3. Demander l'attribution à chaque couche

Chaque requête transporte l'identité de l'agent du proxy Edge via la couche application jusqu'à la base de données. journal des requêtes. Lorsque quelque chose ne va pas, vous tracez le chemin complet depuis l’agent jusqu’à l’action.

Auditer un jeton d'agent avec le SDK Botoi

Combinez les points de terminaison JWT et de mot de passe en une seule fonction d'audit. Décoder le token, vérifier son expiration, vérifiez la signature et signalez les portées trop larges.

import Botoi from "@botoi/sdk";

const botoi = new Botoi({ apiKey: process.env.BOTOI_API_KEY });

async function auditAgentToken(token: string, secret: string) {
  // Step 1: Decode to inspect claims
  const decoded = await botoi.jwt.decode({ token });
  const claims = decoded.data.payload;

  console.log("Agent:", claims.sub);
  console.log("Scopes:", claims.scopes);

  // Step 2: Check expiration
  const now = Math.floor(Date.now() / 1000);
  const hoursLeft = (claims.exp - now) / 3600;

  if (hoursLeft < 0) {
    console.error("Token expired", Math.abs(hoursLeft).toFixed(1), "hours ago");
    return { valid: false, reason: "expired" };
  }

  if (hoursLeft > 24) {
    console.warn("Token lives longer than 24 hours; rotate sooner");
  }

  // Step 3: Verify signature
  const verified = await botoi.jwt.verify({ token, secret, algorithms: ["HS256"] });

  if (!verified.data.valid) {
    console.error("Signature verification failed");
    return { valid: false, reason: "invalid_signature" };
  }

  // Step 4: Check scope breadth
  const dangerousScopes = claims.scopes.filter(
    (s: string) => s === "*" || s === "admin" || s.endsWith(":*")
  );

  if (dangerousScopes.length > 0) {
    console.warn("Overly broad scopes:", dangerousScopes);
  }

  return { valid: true, agent: claims.sub, scopes: claims.scopes, hoursLeft };
}

const result = await auditAgentToken(process.env.AGENT_TOKEN!, process.env.SIGNING_SECRET!);
console.log(result);

Exécutez cette vérification comme étape préalable au déploiement. Si le jeton est expiré, a un TTL supérieur à 24 heures, échoue à la signature vérification, ou comporte des étendues génériques, bloque le déploiement.

Une liste de contrôle pour l'authentification API de l'agent IA

Les données de l’enquête sont claires : les équipes déploient des agents IA plus rapidement qu’elles ne les sécurisent. 80,9 % ont des agents en activité, mais moins d’un agent sur cinq donne à ces agents leur propre identité. Chaque erreur sur cette liste, clés partagées, portées larges, informations d'identification permanentes, trafic silencieux, authentification en forme humaine, est une porte dérobée attendant le prochain adjoint confus incident.

Choisissez une erreur dans cette liste. Corrigez-le cette semaine. Passez ensuite au suivant.