Primary Provider Integration

import { p256 } from '@noble/curves/p256';

// Generate HPKE keypair for Privy
function generateHPKEKeyPair() {
// Generate random 32-byte private key
const privateKeyBytes = p256.utils.randomPrivateKey();
const publicKeyBytes = p256.getPublicKey(privateKeyBytes);

// Format as SPKI (public) and PKCS#8 (private)
const spkiPublicKey = createSPKIPublicKey(publicKeyBytes);
const pkcs8PrivateKey = createPKCS8PrivateKey(privateKeyBytes);

return {
publicKey: Buffer.from(spkiPublicKey).toString('base64'),
privateKey: Buffer.from(pkcs8PrivateKey).toString('base64')
};
}

// Algorithm:
// 1. Generate random 32-byte private key using P-256 curve
// 2. Compute public key: publicKey = privateKey \* G (curve point)
// 3. Wrap public key in SPKI DER format
// 4. Wrap private key in PKCS#8 DER format
// 5. Base64-encode both keys

// Store the private key securely - you'll need it to decrypt the response!
const keypair = generateHPKEKeyPair();

from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import ec
import base64

# Generate HPKE keypair for Privy
def generate_hpke_keypair():
    # Generate P-256 private key
    private_key = ec.generate_private_key(ec.SECP256R1())
    public_key = private_key.public_key()

    # Serialize to DER format
    public_key_spki = public_key.public_key_bytes(
        encoding=serialization.Encoding.DER,
        format=serialization.PublicFormat.SubjectPublicKeyInfo
    )
    private_key_pkcs8 = private_key.private_bytes(
        encoding=serialization.Encoding.DER,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption()
    )

    return {
        'public_key': base64.b64encode(public_key_spki).decode(),
        'private_key': base64.b64encode(private_key_pkcs8).decode()
    }

# Algorithm:
# 1. Generate random 32-byte private key using P-256 curve
# 2. Compute public key from private key
# 3. Serialize public key to SPKI DER format
# 4. Serialize private key to PKCS#8 DER format
# 5. Base64-encode both keys

# Store the private key securely - you'll need it to decrypt the response!
keypair = generate_hpke_keypair()

import { CipherSuite, KemId, KdfId, AeadId } from "@hpke/core";

async function decryptAuthorizationKey(
encryptedData: any,
privateKeyB64: string
): Promise<string> {
// Configure HPKE suite for Privy
const suite = new CipherSuite({
kem: KemId.DhP256HkdfSha256,
kdf: KdfId.HkdfSha256,
aead: AeadId.Chacha20Poly1305
});

// Decode the encrypted data
const encapsulatedKey = Buffer.from(encryptedData.encapsulated_key, 'base64');
const ciphertext = Buffer.from(encryptedData.ciphertext, 'base64');
const privateKeyDer = Buffer.from(privateKeyB64, 'base64');

// Create recipient context
const recipient = await suite.createRecipientContext({
recipientKey: privateKeyDer,
enc: encapsulatedKey,
info: new Uint8Array(), // Empty info
});

// Decrypt the ciphertext
const plaintext = await recipient.open(ciphertext, new Uint8Array()); // Empty AAD
const authKey = new TextDecoder().decode(plaintext);

// Remove "wallet-auth:" prefix if present
return authKey.replace("wallet-auth:", "");
}

// Usage after API call
const privyAuth = response.authentication.find(auth => auth.provider === 'Privy');
const encryptedAuthKey = privyAuth.session.session.encrypted_authorization_key;
const decryptedAuthKey = await decryptAuthorizationKey(encryptedAuthKey, keypair.privateKey);

from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives.ciphers.aead import ChaCha20Poly1305
import base64

def decrypt_authorization_key(encrypted_data, private_key_b64):
    # Import private key from PKCS#8 DER
    private_key_der = base64.b64decode(private_key_b64)
    private_key = serialization.load_der_private_key(private_key_der, password=None)

    # Import ephemeral public key from SPKI DER
    ephemeral_key_der = base64.b64decode(encrypted_data['encapsulated_key'])
    ephemeral_key = serialization.load_der_public_key(ephemeral_key_der)

    # Perform ECDH to get shared secret
    shared_secret = private_key.exchange(ec.ECDH(), ephemeral_key)

    # HPKE Suite IDs for key derivation context
    KEM_SUITE_ID = b'KEM' + (0x0010).to_bytes(2, 'big')  # 7 bytes
    HPKE_SUITE_ID = (0x0010).to_bytes(2, 'big') + (0x0001).to_bytes(2, 'big') + (0x0003).to_bytes(2, 'big')

    # HKDF key derivation following RFC 9180
    # Step 1: Extract KEM shared secret
    kem_hkdf = HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=b'',
        info=b'eae_prk' + KEM_SUITE_ID
    )
    kem_shared_secret = kem_hkdf.derive(shared_secret)

    # Step 2: Expand to get decryption key
    decrypt_hkdf = HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=kem_shared_secret,
        info=b'key' + HPKE_SUITE_ID
    )
    decrypt_key = decrypt_hkdf.derive(b'')

    # Step 3: Expand to get base nonce
    nonce_hkdf = HKDF(
        algorithm=hashes.SHA256(),
        length=12,
        salt=kem_shared_secret,
        info=b'base_nonce' + HPKE_SUITE_ID
    )
    base_nonce = nonce_hkdf.derive(b'')

    # Decrypt with ChaCha20-Poly1305
    cipher = ChaCha20Poly1305(decrypt_key)
    ciphertext = base64.b64decode(encrypted_data['ciphertext'])

    plaintext = cipher.decrypt(base_nonce, ciphertext, None)  # No AAD
    auth_key = plaintext.decode()

    # Remove "wallet-auth:" prefix if present
    return auth_key.replace("wallet-auth:", "")

# Usage after POST /accounts/verify response
privy_auth = next(auth for auth in response['authentication'] if auth['provider'] == 'Privy')
encrypted_auth_key = privy_auth['session']['session']['encrypted_authorization_key']
decrypted_auth_key = decrypt_authorization_key(encrypted_auth_key, keypair['private_key'])

function extractSigningKey(authKeyB64: string): Uint8Array {
  const pkcs8Bytes = Buffer.from(authKeyB64, 'base64');

// Look for pattern [0x04, 0x20] followed by 32-byte key
const pattern = Buffer.from([0x04, 0x20]);
const patternIndex = pkcs8Bytes.indexOf(pattern);

if (patternIndex === -1) {
throw new Error('Private key marker not found');
}

const keyStart = patternIndex + 2;
return new Uint8Array(pkcs8Bytes.slice(keyStart, keyStart + 32));
}

def extract_signing_key(auth_key_b64):
    pkcs8_bytes = base64.b64decode(auth_key_b64)

    # Look for pattern [0x04, 0x20] followed by 32-byte key
    pattern = bytes([0x04, 0x20])
    pattern_index = pkcs8_bytes.find(pattern)

    if pattern_index == -1:
        raise ValueError('Private key marker not found')

    key_start = pattern_index + 2
    return pkcs8_bytes[key_start:key_start + 32]

function canonicalizeJson(obj: any): any {
  if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
    const sorted: any = {};
    // Sort keys alphabetically
    Object.keys(obj).sort().forEach(key => {
      sorted[key] = canonicalizeJson(obj[key]);
    });
    return sorted;
  } else if (Array.isArray(obj)) {
    return obj.map(item => canonicalizeJson(item));
  }
  return obj;
}

function serializeCanonical(payload: any): string {
const canonical = canonicalizeJson(payload);
return JSON.stringify(canonical);
}

import json

def canonicalize_json(obj):
    if isinstance(obj, dict):
        # Sort keys alphabetically and recursively canonicalize values
        return {k: canonicalize_json(v) for k, v in sorted(obj.items())}
    elif isinstance(obj, list):
        return [canonicalize_json(item) for item in obj]
    else:
        return obj

def serialize_canonical(payload):
    canonical = canonicalize_json(payload)
    return json.dumps(canonical, separators=(',', ':'))

import { p256 } from '@noble/curves/p256';

function signPayload(kmsPayloadB64: string, authKeyB64: string): string {
// Decode and parse the KMS payload
const payloadJson = Buffer.from(kmsPayloadB64, 'base64').toString('utf-8');
const payload = JSON.parse(payloadJson);

// Canonicalize the JSON
const canonicalPayload = serializeCanonical(payload);

// Extract the signing key
const privateKeyBytes = extractSigningKey(authKeyB64);

// Sign with ECDSA P-256
const signature = p256.sign(Buffer.from(canonicalPayload), privateKeyBytes);

// Return base64 DER signature
return Buffer.from(signature.toDERRawBytes()).toString('base64');
}

// Usage
const signature = signPayload(kmsPayload.payload, decryptedAuthKey);

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import hashes

def sign_payload(kms_payload_b64, auth_key_b64):
    # Decode and parse the KMS payload
    payload_json = base64.b64decode(kms_payload_b64).decode('utf-8')
    payload = json.loads(payload_json)

    # Canonicalize the JSON
    canonical_payload = serialize_canonical(payload)

    # Extract the signing key
    private_key_bytes = extract_signing_key(auth_key_b64)

    # Create signing key
    private_key = ec.derive_private_key(
        int.from_bytes(private_key_bytes, 'big'),
        ec.SECP256R1()
    )

    # Sign with ECDSA P-256
    signature = private_key.sign(
        canonical_payload.encode(),
        ec.ECDSA(hashes.SHA256())
    )

    # Return base64 DER signature
    return base64.b64encode(signature).decode()

# Usage with KMS payload from Grid API
signature = sign_payload(kms_payload['payload'], decrypted_auth_key)