Spécification KYC portable Ed25519

# pip install pynacl requests
import json, base64, requests
from nacl.signing import VerifyKey
from nacl.exceptions import BadSignatureError

# 1. Fetch issuer public key (cache locally with rotation hints)
WK = requests.get("https://www.getinopay.com/.well-known/inopay", timeout=5).json()
pub_b64 = next(k["public_key"] for k in WK["keys"] if k["key_id"] == attestation["key_id"])
verify_key = VerifyKey(base64.urlsafe_b64decode(pub_b64 + "=="))

# 2. Canonicalize (RFC 8785 — keys sorted, no whitespace) and verify
payload = {k: v for k, v in attestation.items() if k != "signature"}
canonical = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()
sig = base64.urlsafe_b64decode(attestation["signature"] + "==")

try:
    verify_key.verify(canonical, sig)
    print("OK — attestation signature valid")
except BadSignatureError:
    raise SystemExit("REJECT — invalid signature")

// npm install libsodium-wrappers node-fetch
import sodium from 'libsodium-wrappers';

await sodium.ready;
const wk = await fetch('https://www.getinopay.com/.well-known/inopay').then(r => r.json());
const pub = wk.keys.find(k => k.key_id === attestation.key_id).public_key;
const pubBytes = sodium.from_base64(pub, sodium.base64_variants.URLSAFE_NO_PADDING);

const { signature, ...payload } = attestation;
const canonical = JSON.stringify(
  Object.fromEntries(Object.entries(payload).sort(([a], [b]) => a.localeCompare(b)))
);
const sigBytes = sodium.from_base64(signature, sodium.base64_variants.URLSAFE_NO_PADDING);

const valid = sodium.crypto_sign_verify_detached(
  sigBytes, sodium.from_string(canonical), pubBytes
);
if (!valid) throw new Error('REJECT — invalid attestation signature');

// import: encoding/base64 · encoding/json · crypto/ed25519 · net/http
package main

import (
    "crypto/ed25519"
    "encoding/base64"
    "encoding/json"
    "fmt"
    "net/http"
    "sort"
)

func verifyAttestation(att map[string]any) error {
    // 1. Fetch issuer public key from .well-known
    resp, _ := http.Get("https://www.getinopay.com/.well-known/inopay")
    defer resp.Body.Close()
    var wk struct{ Keys []struct{ KeyID, PublicKey string } }
    json.NewDecoder(resp.Body).Decode(&wk)

    var pub ed25519.PublicKey
    for _, k := range wk.Keys {
        if k.KeyID == att["key_id"].(string) {
            b, _ := base64.URLEncoding.DecodeString(k.PublicKey)
            pub = ed25519.PublicKey(b)
        }
    }

    // 2. Canonicalize (RFC 8785 stub — sorted keys, no whitespace)
    sig := att["signature"].(string)
    delete(att, "signature")
    keys := make([]string, 0, len(att))
    for k := range att { keys = append(keys, k) }
    sort.Strings(keys)
    canon := make(map[string]any, len(att))
    for _, k := range keys { canon[k] = att[k] }
    body, _ := json.Marshal(canon)

    sigBytes, _ := base64.URLEncoding.DecodeString(sig)
    if !ed25519.Verify(pub, body, sigBytes) {
        return fmt.Errorf("REJECT — invalid signature")
    }
    return nil
}