Generieren von Apple MapKit JS-Tokens mit der Web Crypto API

Generieren von Apple MapKit JS-Tokens mit Web Crypto API: Ein modularer Ansatz

Dieses Skript verwendet die Web Crypto API von JavaScript in einer Edge-Umgebung und konzentriert sich auf die Kompatibilität mit der Next.js-Laufzeitumgebung. Es gewährleistet eine optimierte, modulare und wiederverwendbare Token-Generierung für Apples MapKit.

// Frontend solution using Web Crypto API
async function generateAppleMapKitToken() {
  // Header for the JWT
  const header = {
    alg: 'ES256',
    kid: 'your-key-id', // Replace with your actual key ID
    typ: 'JWT'
  };
  const epoch = Math.floor(Date.now() / 1000);
  const claims = {
    iss: 'your-team-id', // Replace with your actual team ID
    iat: epoch,
    exp: epoch + 60 * 60 * 24 * 7,
    origin: 'http://localhost:3000'
  };
  const unsignedToken = btoa(JSON.stringify(header)) + '.' + btoa(JSON.stringify(claims));
  const privateKeyPem = `-----BEGIN PRIVATE KEY-----\\nYOUR_PRIVATE_KEY\\n-----END PRIVATE KEY-----`;
  const privateKeyBuffer = convertPemToBinary(privateKeyPem);
  const key = await crypto.subtle.importKey(
    'pkcs8',
    privateKeyBuffer,
    { name: 'ECDSA', namedCurve: 'P-256' },
    false,
    ['sign']
  );
  const signature = await crypto.subtle.sign(
    { name: 'ECDSA', hash: { name: 'SHA-256' } },
    key,
    new TextEncoder().encode(unsignedToken)
  );
  const base64Signature = btoa(String.fromCharCode(...new Uint8Array(signature)));
  return unsignedToken + '.' + base64Signature.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
}

// Helper function to convert PEM to binary
function convertPemToBinary(pem) {
  const base64 = pem.replace(/-----\\w+ PRIVATE KEY-----/g, '').replace(/\\s+/g, '');
  return Uint8Array.from(atob(base64), c => c.charCodeAt(0));
}

Backend-Alternative für Node.js

Diese Version demonstriert die Verwendung des „Crypto“-Moduls von Node.js für die Handhabung privater PKCS#8-Schlüssel und nutzt serverseitige Laufzeitfunktionen.

const crypto = require('crypto');
function generateAppleMapKitTokenNode() {
  const header = {
    alg: 'ES256',
    kid: process.env.APPLE_MAPS_P8_KEY_ID,
    typ: 'JWT'
  };
  const epoch = Math.floor(Date.now() / 1000);
  const claims = {
    iss: process.env.APPLE_TEAM_ID,
    iat: epoch,
    exp: epoch + 60 * 60 * 24 * 7,
    origin: 'http://localhost:3000'
  };
  const unsignedToken = Buffer.from(JSON.stringify(header)).toString('base64') + '.' +
    Buffer.from(JSON.stringify(claims)).toString('base64');
  const signer = crypto.createSign('sha256');
  signer.update(unsignedToken);
  signer.end();
  const signature = signer
    .sign({
      key: process.env.APPLE_MAPS_P8_KEY.replace(/\\n/g, '\\n'),
      format: 'pem'
    })
    .toString('base64')
    .replace(/=/g, '')
    .replace(/\\+/g, '-')
    .replace(/\\//g, '_');
  return unsignedToken + '.' + signature;
}

Häufig gestellte Fragen zur Web Crypto API und Apple MapKit-Tokens

1. Was ist PKCS#8 und warum ist es für Web Crypto erforderlich?
2. PKCS#8 ist ein Schlüsselkodierungsformat, das zur sicheren Speicherung privater Schlüssel verwendet wird. Der Web Crypto API erfordert dieses Format aus Gründen der Kompatibilität und des sicheren Schlüsselimports.
3. Wie hilft der TextEncoder bei kryptografischen Operationen?
4. Der TextEncoder Konvertiert Strings in eine Binärdatei Uint8Array, die für das Signieren und andere kryptografische Prozesse notwendig ist.
5. Welche Rolle spielt ECDSA in diesem Prozess?
6. Zur Generierung einer sicheren digitalen Signatur wird ECDSA (Elliptic Curve Digital Signature Algorithm) verwendet. Der crypto.subtle.sign Die Methode wendet diesen Algorithmus in der Web Crypto API an.
7. Warum werden meine Schlüsseldaten während des Schlüsselimports ungültig?
8. Ungültig keyData Fehler treten häufig aufgrund einer falschen PEM-zu-Binär-Konvertierung oder falsch formatierter Schlüsselzeichenfolgen auf.
9. Wie kann ich Probleme mit nicht signierten Token beheben?
10. Überprüfen Sie die Base64-Codierung Ihrer JWT-Komponenten mit btoa und stellen Sie sicher, dass die Zeichenfolge korrekt an die kryptografischen Funktionen übergeben wird.

Zusammenfassung der sicheren Token-Generierung

Der Übergang von Node.js zur Web Crypto API bietet ein tieferes Verständnis moderner kryptografischer Tools. Entwickler können ihre Prozesse anpassen, indem sie sich auf die Schlüsselverarbeitung, Kodierungstechniken und erweiterte APIs konzentrieren, um den Anforderungen von Edge-Laufzeiten und sicherer Token-Generierung gerecht zu werden. 🚀

Ob bei der Bereitstellung auf Next.js oder beim Erstellen für Browser: Mithilfe der Web Crypto API können Entwickler skalierbare, sichere Anwendungen erstellen. Dank ihrer Kompatibilität und Effizienz stellt die API sicher, dass wichtige Aufgaben wie das Signieren von Token robust bleiben und ein reibungsloseres Benutzererlebnis entstehen. 🔐