Biometric Key & WebAuthn Credential Generator

const express = require('express');
const crypto = require('crypto');
const app = express();

// Store challenges and credentials (use database in production)
const challenges = new Map();
const credentials = new Map();

// Registration endpoint
app.post('/webauthn/register/begin', (req, res) => {
  const { username } = req.body;
  const challenge = crypto.randomBytes(32);
  
  challenges.set(username, challenge);
  
  res.json({
    challenge: challenge.toString('base64url'),
    rp: {
      id: 'example.com',
      name: 'Example Corp'
    },
    user: {
      id: crypto.randomBytes(32).toString('base64url'),
      name: username,
      displayName: username
    },
    pubKeyCredParams: [
      { alg: -7, type: 'public-key' },  // ES256
      { alg: -257, type: 'public-key' } // RS256
    ],
    authenticatorSelection: {
      authenticatorAttachment: 'platform',
      userVerification: 'preferred'
    },
    attestation: 'none'
  });
});

// Registration completion
app.post('/webauthn/register/complete', (req, res) => {
  const { username, credential } = req.body;
  const challenge = challenges.get(username);
  
  if (!challenge) {
    return res.status(400).json({ error: 'Invalid challenge' });
  }
  
  // Verify credential (simplified - use proper WebAuthn library)
  // Store credential for user
  credentials.set(username, {
    credentialId: credential.id,
    publicKey: credential.response.publicKey
  });
  
  challenges.delete(username);
  res.json({ success: true });
});

app.listen(3000);

class WebAuthnAuth {
  async register(username) {
    try {
      // Get registration options from server
      const response = await fetch('/webauthn/register/begin', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ username })
      });
      
      const options = await response.json();
      
      // Convert challenge and user ID from base64url
      options.challenge = this.base64urlToBuffer(options.challenge);
      options.user.id = this.base64urlToBuffer(options.user.id);
      
      // Create credential
      const credential = await navigator.credentials.create({
        publicKey: options
      });
      
      // Send credential to server
      const registerResponse = await fetch('/webauthn/register/complete', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          username,
          credential: {
            id: credential.id,
            rawId: this.bufferToBase64url(credential.rawId),
            response: {
              clientDataJSON: this.bufferToBase64url(credential.response.clientDataJSON),
              attestationObject: this.bufferToBase64url(credential.response.attestationObject)
            }
          }
        })
      });
      
      const result = await registerResponse.json();
      
      if (result.success) {
        console.log('Registration successful!');
        return true;
      } else {
        throw new Error('Registration failed');
      }
      
    } catch (error) {
      console.error('Registration error:', error);
      return false;
    }
  }
  
  base64urlToBuffer(base64url) {
    const base64 = base64url.replace(/-/g, '+').replace(/_/g, '/');
    const padded = base64.padEnd(base64.length + (4 - base64.length % 4) % 4, '=');
    return Uint8Array.from(atob(padded), c => c.charCodeAt(0));
  }
  
  bufferToBase64url(buffer) {
    const base64 = btoa(String.fromCharCode(...new Uint8Array(buffer)));
    return base64.replace(/+/g, '-').replace(///g, '_').replace(/=/g, '');
  }
}

// Usage
const auth = new WebAuthnAuth();
document.getElementById('register-btn').addEventListener('click', () => {
  const username = document.getElementById('username').value;
  auth.register(username);
});