Idprova

Documentation | Getting Started | Protocol Spec | Compliance | Cloud Product

Why IDProva?

You've already invested in identity infrastructure. Okta, Entra ID, Auth0, your custom CIAM — these handle humans well. Now AI agents are calling your APIs, delegating to sub-agents, and accessing sensitive systems on behalf of users.

The gap: every line of your existing identity stack was designed for humans who type passwords, click "allow", and authenticate dozens of times per day. None of it answers the questions that matter for AI agents:

• Who is this agent — cryptographically, not just by API key?
• What is it allowed to do, and who granted that permission?
• What did it do — and can you prove the audit trail wasn't tampered with?

OAuth tokens don't chain. JWTs don't carry delegation provenance. API keys can't scope to specific actions. SPIFFE was built for workloads, not delegation chains. None of them produce tamper-evident audit logs you can take to a compliance auditor.

IDProva is the layer that fits alongside your existing IdP — three cryptographic primitives designed specifically for AI agents:

You keep Okta. You keep Entra ID. You keep Auth0. You add IDProva for the agents.

Where this fits

Three deployment stories — pick whichever fits your environment:

1. Global Cloud

Hosted IDProva on AWS, GCP, or Azure in your region of choice. AU (live), US East (v1.0), EU Frankfurt (v1.0 stretch), Singapore + UAE (v1.1). Web dashboard, SSO, RBAC, compliance report generator, SIEM integration, anomaly detection. Contact us for pricing. → idprova.com

2. Self-hosted Enterprise

Run the full stack inside your VPC. Apache 2.0 source. No licence fees for the protocol. Commercial Enterprise Edition available with SLA, support, and additional management features.

3. Sovereign / air-gapped

Deploy in PROTECTED, classified, or otherwise isolated environments. Offline issuance and verification. Epoch-based revocation list distribution. No phone-home requirement. Designed for defence, intelligence, and critical infrastructure.

Works alongside your existing identity stack

See docs/integrations/ for full integration walkthroughs (LangChain, MCP, CrewAI, AutoGen).

Quick Install

From package registries

# Rust (CLI + core library)
cargo install idprova-cli

# Python SDK (PyO3 bindings)
pip install idprova

# TypeScript SDK (napi-rs bindings)
npm install @idprova/core

Build from source

git clone https://github.com/techblaze-au/idprova.git
cd idprova
cargo build --release
# Binaries at: target/release/idprova and target/release/idprova-registry

Docker

docker pull techblazeau/idprova:latest
docker run -p 8080:8080 techblazeau/idprova:latest

60-Second Quickstart

CLI: generate keys, create identity, issue delegation

# 1. Generate an Ed25519 keypair
idprova keygen --output operator.key

# 2. Create an Agent Identity Document
idprova aid create \
  --id "did:aid:example.com:my-agent" \
  --name "My Agent" \
  --controller "did:aid:example.com:operator" \
  --key operator.key

# 3. Issue a scoped delegation token (read-only, 24h expiry)
idprova dat issue \
  --issuer "did:aid:example.com:operator" \
  --subject "did:aid:example.com:my-agent" \
  --scope "mcp:tool:filesystem:read" \
  --expires-in 24h \
  --key operator.key

# 4. Verify the token
idprova dat verify <TOKEN> --key operator.pub --scope "mcp:tool:filesystem:read"

Python: LangChain integration

Shipped in-repo as the idprova_agents package (enforce and audit-only modes). The guard checks every tool call against the scopes the agent was delegated and writes a signed, hash-chained receipt that passes idprova receipt verify. On PyPI: pip install "idprova-agents[langchain]". Full runnable example: examples/langchain/quickstart.py.

from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
from langchain_core.tools import Tool
from idprova_agents import ToolGuard, guarded_tool

# 1. Map each tool to the scope it needs; list what this agent was granted.
#    In production, granted_scopes comes from the agent's delegation token (DAT).
SCOPES = {"knowledge_base_search": "mcp:tool:knowledge-base:read",
          "send_email": "mcp:tool:email:send"}
GRANTED = ["mcp:tool:knowledge-base:read"]   # send_email is NOT granted

# 2. Build the guard (signing_key would come from your key store / IdP).
guard = ToolGuard(
    aid="did:aid:co:customer-support-agent",
    dat="dat-customer-support-001",
    signing_key=Ed25519PrivateKey.generate(),
    scope_for_tool=lambda name: SCOPES.get(name, "mcp:tool:unknown:none"),
    granted_scopes=GRANTED,
    receipts_path="receipts.jsonl",
)

# 3. Wrap each LangChain tool so its execution is scope-gated, then give the
#    guarded tools to your agent as usual.
kb = guarded_tool(Tool.from_function(
    func=your_kb_search, name="knowledge_base_search", description="Search the KB"), guard)
email = guarded_tool(Tool.from_function(
    func=your_send_email, name="send_email", description="Send an email"), guard)

kb.invoke("quantum computing")    # in scope  -> runs, writes a "success" receipt
email.invoke("...")               # out of scope -> raises PermissionError, "denied" receipt

Every guarded tool call appends to receipts.jsonl — an audit-grade record, signed and hash-chained. Verify it independently with idprova receipt verify receipts.jsonl. (An IDProvaGuardCallbackHandler for audit-only logging is also included — see the quickstart.)

Rust: programmatic usage

use idprova_core::crypto::KeyPair;
use idprova_core::aid::AidBuilder;
use idprova_core::dat::Dat;
use chrono::{Utc, Duration};

// Generate keys
let keypair = KeyPair::generate();

// Create an Agent Identity Document
let aid = AidBuilder::new()
    .id("did:aid:example.com:my-agent")
    .controller("did:aid:example.com:operator")
    .name("My Agent")
    .add_ed25519_key(&keypair)
    .build()?;

// Issue a Delegation Attestation Token
let dat = Dat::issue(
    "did:aid:example.com:operator",   // issuer
    "did:aid:example.com:my-agent",   // subject
    vec!["mcp:tool:filesystem:read".into()],
    Utc::now() + Duration::hours(24), // expiry
    None,                              // constraints
    None,                              // config attestation
    &keypair,
)?;

// Receipts produced by `idprova-verify` middleware automatically

Standards alignment

IDProva is designed to fit into existing standards rather than invent new ones where it doesn't have to:

Cryptographic foundations

• Ed25519 for classical signatures (RFC 8032). Constant-time, 128-bit security level, 64-byte signatures.
• ML-DSA-65 for post-quantum signatures (FIPS 204). Hybrid signing supported — operators choose classical-only, hybrid, or PQ-only per identity.
• BLAKE3 for content hashing in the receipt chain. Parallelisable, faster than SHA-256 on modern CPUs.

See docs/security.md for cryptographic rationale and docs/STRIDE-THREAT-MODEL.md for the formal threat analysis.

Documentation

• Getting Started — install, configure, issue your first DAT
• Protocol Specification — the full spec, normative
• Concepts — AIDs, DATs, scopes, trust levels, receipts
• Core API — Rust core library reference
• Python SDK — PyO3 bindings reference
• TypeScript SDK — napi-rs bindings reference
• API Reference — registry HTTP API
• Adoption Guide — for engineering leaders considering IDProva
• Technical Requirements — detailed technical requirements
• Threat Model — what IDProva protects, what it does not, and trust assumptions
• STRIDE Threat Model — formal STRIDE analysis
• Security Model — cryptographic foundations
• Key Rotation — operator playbook
• NIST 800-53 Mapping — compliance control mapping
• GDPR Mapping — EU privacy + AI Act alignment
• Compliance Overview — ISM + Zero Trust mapping

Status

IDProva v0.1 was published 2026-03-23. Spec is v0.1-draft; v1.0 launch targeted for late August 2026. Track progress at the public roadmap.

Contributing

We accept contributions via Developer Certificate of Origin (DCO) — sign off your commits with git commit -s. See CONTRIBUTING.md for the full contribution guide and CODE_OF_CONDUCT.md for community standards.

Security disclosures: please email [email protected] rather than opening a public issue. See SECURITY.md for our vulnerability disclosure policy.

Built by

Tech Blaze — a Canberra-based cybersecurity consultancy. We build IDProva and publish what we learn building it on the Tech Blaze YouTube channel.

For commercial support, IDProva Cloud, or implementation consulting, see idprova.com or contact [email protected].

Licence

Protocol spec, core library, SDKs, and registry: Apache License 2.0. See LICENSE.

The Cloud product (idprova.com) and the commercial Self-hosted Enterprise Edition are separately licensed; see idprova.com/terms for details.