convez.ai
MCP Server
techblaze-au

idprova

techblaze-au/idprova

Ver no GitHub
BomPluginScore · de 0 a 100

Cryptographic identity for AI agents — Ed25519 keys, delegated authority, hash-chained audit receipts. Rust core + Python/TypeScript SDKs.

Instalação

$npx convez-ai techblaze-au/idprova

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
87%
Último commit
há 3 meses
Versão
v0.4.0
Issues abertas
11
Contribuidores
4

README

A tradução para o português deste README ainda está na fila.

CI Crates.io PyPI npm Docs.rs License Spec NIST

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:

PrimitivePurpose
Agent Identity Documents (AIDs)W3C DID-based identity bound to Ed25519 + ML-DSA-65 hybrid keys
Delegation Attestation Tokens (DATs)Signed, scoped, time-bounded, chainable permission tokens
Action ReceiptsHash-chained, tamper-evident audit log of every agent action, mapped to compliance controls

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. Starting at $149/mo. → 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

Existing IdPIntegration patternEffort
OktaOIDC ID token → RFC 8693 token exchange → IDProva DAT~50 lines of code
Microsoft Entra IDEntra Agent ID provisions → IDProva wraps actions in DATs + signs receipts (complementary)Configurable; existing Entra deployment unchanged
Auth0Auth0 Action calls IDProva /v1/dat/issue after user authentication~30 lines of JavaScript
Custom / SAMLGeneric OIDC bridge or direct DAT issuance from your auth callbackVaries; ~1 day for typical integrations

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:

StandardRoleStatus
W3C DID Core 1.0Identifier model (did:aid: method)Aligned; submitted to DID Method Registry
NIST SP 800-53 Rev 5Compliance control mapping (US Federal + global enterprise)docs/controls.md
NIST SP 800-207 Zero TrustArchitectural alignmentdocs/compliance.md
NIST CAISI submissionAI standards body engagementFiled (NIST-2025-0035)
GDPR (EU 2016/679)EU privacy compliance mappingdocs/gdpr.md
EU AI Act (2024/1689)Logging + transparency obligationsdocs/gdpr.md §EU AI Act
ISO 27001:2022Annex A control mapping(planned v1.0)
Australian ISMDefence-aligned controlsdocs/compliance.md
Singapore MAS TRMSG financial services(planned v1.0)
UAE NESAUAE government + financial(planned v1.0)
HIPAA Security RuleUS healthcare(planned v1.0)
SOC 2 Type II readinessUS enterprise procurement(planned v1.0 mapping pack; certification v1.1)
JOSE / JWSDAT token formatRFC 7515-compliant
RFC 8693OAuth token exchange (IdP integration)Supported in idprova-bridge
FIPS 204 (ML-DSA-65)Post-quantum signatures (hybrid mode)Supported in idprova-core
BLAKE3Receipt hash chainNative
Ed25519 (RFC 8032)Classical signaturesNative

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

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 security@idprova.dev 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 hello@techblaze.com.au.

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.

Ver o original no GitHub

Bom para

Relacionados