Patterns, integrations, and shared practice for enterprise AI identity.

# FastAPI middleware — verify before serving
from fastapi import Request, HTTPException

@app.middleware("http")
async def verify_passport(request: Request, call_next):
    passport_id = request.headers.get("X-AI-Keypass-ID")
    if not passport_id:
        raise HTTPException(401, "No Passport ID supplied")

    res = httpx.get(
        "https://aikeypass.com/functions/api/v1/passports/verify",
        params={"id": passport_id},
        headers={"x-api-key": settings.KEYPASS_KEY},
    )
    body = res.json()
    # reliably_current = attested AND current_version_attested (revocation folded in)
    if not body.get("registered") or not body.get("reliably_current"):
        raise HTTPException(403, "Unregistered or not current AI")

    return await call_next(request)

# .github/workflows/deploy.yml
- name: Verify AI Passport before deploy
  env:
    AI_KEYPASS_ID: ai_pspt_7F3A92K1
    KEYPASS_API_KEY: ${{ secrets.KEYPASS_API_KEY }}
  run: |
    # reliably_current = attested AND current_version_attested (revocation folded in)
    RELIABLE=$(curl -s "https://aikeypass.com/functions/api/v1/passports/verify?id=$AI_KEYPASS_ID" \
      -H "x-api-key: $KEYPASS_API_KEY" | jq -r .reliably_current)

    if [ "$RELIABLE" != "true" ]; then
      echo "::error::Passport $AI_KEYPASS_ID is not reliably current"
      exit 1
    fi

# cron: record a system attestation under a named API key when a
# pipeline deploys. This is a machine assertion with provenance — distinct
# from owner attestation, which is an explicit human reconfirmation.
for pid in $(cat .keypass/registered_passports.txt); do
  curl -s -X POST "https://aikeypass.com/functions/api/v1/passports/manage" \
    -H "x-api-key: $KEYPASS_KEY" \
    -H "Content-Type: application/json" \
    -d "{ \"action\": \"attest\", \"passport_id\": \"$pid\", \"notes\": \"system: deploy v${BUILD_VERSION}\" }"
done

# nightly: pull the registry and flag AIs that expired or were revoked
PASSPORTS=$(curl -s "https://aikeypass.com/functions/api/v1/passports/list?limit=500" \
  -H "x-api-key: $KEYPASS_KEY" | jq -c '.passports[]')

echo "$PASSPORTS" | while read -r p; do
  PID=$(echo "$p" | jq -r .passport_id)
  STATUS=$(echo "$p" | jq -r .status)
  NAME=$(echo "$p" | jq -r .name)
  if [ "$STATUS" = "expired" ] || [ "$STATUS" = "revoked" ]; then
    echo "::warn::$NAME ($PID) is $STATUS — stop routing to it"
  fi
done

# gap analysis: anything in your CMDB or deploy manifest without a
# passport_id is an unregistered AI. Diff the list output against your
# deployed inventory to surface what's running without an identity.

# gateway middleware: resolve a Vault entity to its Passport, then
# apply policy by trust level. Three adoption modes:
#   observe  — log every resolution; never block (shadow mode)
#   warn     — declared bindings warn; stale/flagged blocks
#   enforce  — only owner_attested or system_verified pass through
MODE="${KEYPASS_MODE:-enforce}"

VAULT_ENTITY="fe2a8568-91cc-4d2f-a9b1-7e3c5f8d2a90"

RESOLVED=$(curl -s "https://aikeypass.com/functions/api/v1/resolve" \
  --get \
  --data-urlencode "system=hashicorp_vault" \
  --data-urlencode "external_id=$VAULT_ENTITY" \
  -H "x-api-key: $KEYPASS_KEY")

PID=$(echo "$RESOLVED" | jq -r .key_id // empty)
STATUS=$(echo "$RESOLVED" | jq -r .binding.status // empty)

if [ -z "$PID" ]; then
  echo "Vault entity $VAULT_ENTITY is not bound to any Passport"
  [ "$MODE" = "observe" ] && exit 0
  exit 1
fi

case "$STATUS" in
  system_verified|owner_attested)
    echo "Binding accepted: $VAULT_ENTITY -> $PID ($STATUS)"
    ;;
  declared)
    echo "Binding exists but is not yet attested: $PID"
    [ "$MODE" = "enforce" ] && exit 2
    ;;
  stale)
    echo "Binding is flagged for review: $PID"
    [ "$MODE" = "observe" ] && exit 0
    exit 1
    ;;
  *)
    echo "Binding is not trusted: $PID ($STATUS)"
    [ "$MODE" = "observe" ] && exit 0
    exit 1
    ;;
esac