2. Derivazione Deterministica ActivityPub (Ed25519)

Calcola l'identità ActivityPub deterministica (WebFinger, actorUri e coppia di chiavi PEM Ed25519 per le firme HTTP ActivityPub) a partire dal dominio e dall'username dell'utente.

import { createZenMasterKeySource, deriveApIdentity } from 'fid';

// Crea la sorgente di chiavi master Zen SEA
const zenSource = createZenMasterKeySource(masterPrivKey, zenPubKey);

// Deriva l'identità ActivityPub isolata per dominio (PBKDF2-SHA256, 10,000 iterazioni)
const apIdentity = deriveApIdentity(zenSource, 'tunecamp.org', 'alice');

console.log(apIdentity.webfingerHandle); // @alice@tunecamp.org
console.log(apIdentity.actorUri);        // https://tunecamp.org/users/alice
console.log(apIdentity.publicKeyPem);    // -----BEGIN PUBLIC KEY-----\n...
console.log(apIdentity.privateKeyPem);   // -----BEGIN PRIVATE KEY-----\n...

// La derivazione è pura e deterministica:
// (zenSource + domain + username) produrrà SEMPRE le stesse chiavi Ed25519.
// Se l'utente cambia dominio, le chiavi cambiano automaticamente, isolando la privacy.

3. Linking Cross-Instance & Passaporti FID

Collega il profilo locale di un'istanza con l'identità globale Zen SEA generando e verificando una sfida monouso tramite signature HMAC-SHA256 dell'istanza.

import { signPayload } from 'fid';

// 1. Richiedi la sfida dall'istanza passando la chiave pubblica Zen
const challengeRes = await fetch(
    `https://sudorecords.scobrudot.dev/api/auth/zen/challenge?zenPubKey=${encodeURIComponent(zenPubKey)}`
);
const { challenge } = await challengeRes.json();

// 2. Firma il payload "${username}:${nonce}" con la chiave privata Zen SEA
const payloadToSign = `${challenge.username}:${challenge.nonce}`;
const seaSignature = await signPayload(payloadToSign, masterPrivKey);

// 3. Invia la firma al server per consumare la sfida ed emettere l'Instance Passport
const linkRes = await fetch('https://sudorecords.scobrudot.dev/api/auth/zen/link', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
        zenPubKey,
        challenge,
        seaSignature
    })
});

const { success, passport } = await linkRes.json();
console.log('Passaporto Istanza verificato ed emesso:', passport);

// 4. Salva il record nel FID Registry locale per autorizzare l'artista tra istanze
const registryRecord = {
    instanceDomain: 'sudorecords.scobrudot.dev',
    publicKey: zenPubKey,
    passportSignature: passport.passportSignature,
    linkedAt: new Date().toISOString()
};

4. Integrazione Server Node.js / Express

Codice di backend Node.js per convalidare i token SSO, riscattare i codici d'accesso e gestire la generazione delle sfide di autenticazione.

import express from 'express';
import crypto from 'node:crypto';
import { FidChallengeManager, FidPassportIssuer, FidSsoHandler, seedToEd25519Pem } from 'fid';

const app = express();
app.use(express.json());

const INSTANCE_SECRET = process.env.INSTANCE_SECRET || 'secret-chiave-istanza';
const challengeMgr = new FidChallengeManager(10, 5); // 10 min TTL
const passportIssuer = new FidPassportIssuer(INSTANCE_SECRET);
const ssoHandler = new FidSsoHandler(INSTANCE_SECRET);

const codeStore = new Map();

// Endpoint 1: Generazione Sfida (GET /api/auth/zen/challenge)
app.get('/api/auth/zen/challenge', (req, res) => {
    const { username, instanceDomain, zenPubKey } = req.query;
    const targetUser = username || 'alice'; // In prod: trova da DB via zenPubKey
    const challenge = challengeMgr.createChallenge(targetUser, instanceDomain || 'tunecamp.org');
    res.json({ challenge, username: targetUser, nonce: challenge.nonce });
});

// Endpoint 2: Validazione Sfida & Erogazione Passaporto (POST /api/auth/zen/link)
app.post('/api/auth/zen/link', async (req, res) => {
    const { zenPubKey, challenge, seaSignature } = req.body;
    const isValid = await challengeMgr.consumeChallenge(
        challenge.username, challenge.nonce, seaSignature, zenPubKey
    );
    if (!isValid) return res.status(401).json({ error: 'Sfida scaduta o firma non valida' });

    const passport = passportIssuer.issuePassport(challenge.instanceDomain, challenge.username, zenPubKey);
    res.json({ success: true, passport });
});

// Endpoint 3: Ricezione Token SSO e apSeed (POST /api/auth/zen/sso)
app.post('/api/auth/zen/sso', async (req, res) => {
    const { ssoToken, apSeed } = req.body;

    // Convalida firma token, freshness (< 15 min) e protezione da replay
    const validation = await ssoHandler.validateSsoToken(ssoToken);
    if (!validation.valid) return res.status(401).json({ error: validation.error });

    // Converte l'apSeed 32-byte nella chiave privata Ed25519 PEM ActivityPub
    const seedBuffer = Buffer.from(apSeed, 'hex');
    const { privateKeyPem, publicKeyPem } = seedToEd25519Pem(seedBuffer);

    // Salva la sessione e restituisce il codice di scambio monouso
    const code = crypto.randomBytes(16).toString('hex');
    codeStore.set(code, { username: ssoToken.username, zenPubKey: ssoToken.zenPubKey, privateKeyPem, publicKeyPem });

    res.json({ success: true, code });
});

app.listen(3000, () => console.log('Server FID attivo su porta 3000'));