@purecore/one-jwt-4-all 1.2.0

package/src/examples.mcps.ts

@@ -0,0 +1,86 @@
+import * as crypto from 'node:crypto';
+import { SignJWT, jwtVerify, generateKeyPair } from './eddsa_jwt'; // Importando nossa lib
+
+// --- Cenário: Setup Inicial ---
+const { privateKey: AUTH_SERVER_PRIVATE_KEY, publicKey: API_PUBLIC_KEY } = generateKeyPair();
+
+const ISSUER = 'https://meu-auth-server.com';
+
+// Audiences do nosso sistema
+const AUDIENCE_FINANCEIRO = 'https://api.financeira.com';
+const MCP_ECOSYSTEM_AUD = 'urn:mcp:ecosystem'; // Audiência que representa TODOS os seus MCPs
+
+// URLs específicas de alguns servidores MCP
+const MCP_SERVER_ALPHA = 'https://mcp-alpha.internal';
+const MCP_SERVER_BETA  = 'https://mcp-beta.internal';
+const MCP_SERVER_GAMA  = 'https://mcp-gama.internal';
+const MCP_SERVER_DELTA = 'https://mcp-delta.internal'; // Este ficará de fora do grupo
+
+// --- 1. O Authorization Server (Emissor) ---
+// Agora aceita 'audience' dinâmico (pode ser string única ou array)
+async function generateAccessToken(userId: string, scopes: string[], audience: string | string[]) {
+  
+  const jwt = await new SignJWT({
+    sub: userId,
+    scope: scopes.join(' '),
+    role: 'user'
+  })
+    .setProtectedHeader({ alg: 'EdDSA' })
+    .setIssuedAt()
+    .setIssuer(ISSUER)
+    .setAudience(audience) // Aceita string ou array de strings
+    .setExpirationTime('1h')
+    .setJti(crypto.randomUUID())
+    .sign(AUTH_SERVER_PRIVATE_KEY);
+
+  return jwt;
+}
+
+// --- 2. O Resource Server (Simulação de um MCP Server) ---
+// Cada servidor sabe QUEM ELE É (sua própria URL ou ID de audiência)
+async function protectMCPServer(serverName: string, myAudienceId: string, tokenRecebido: string) {
+  try {
+    // Ao verificar, o servidor passa 'myAudienceId'.
+    // A validação passa se 'myAudienceId' estiver presente na lista 'aud' do token.
+    const { payload } = await jwtVerify(tokenRecebido, API_PUBLIC_KEY, {
+      issuer: ISSUER,
+      audience: myAudienceId 
+    });
+
+    console.log(`✅ [${serverName}] Acesso permitido! (Token aud: ${JSON.stringify(payload.aud)})`);
+    return true;
+
+  } catch (error) {
+    console.error(`❌ [${serverName}] Acesso negado: ${(error as Error).message}`);
+    return false;
+  }
+}
+
+// --- Simulação dos Cenários ---
+(async () => {
+  console.log("--- Cenário A: Token para um Ecossistema Inteiro ---\n");
+  // Útil se você tem muitos microserviços e todos confiam no mesmo token 'geral'
+  
+  const tokenEcosystem = await generateAccessToken('user-A', ['mcp:read'], MCP_ECOSYSTEM_AUD);
+  
+  // O servidor Alpha aceita tokens do ecossistema
+  // Nota: O servidor precisa estar configurado para aceitar 'urn:mcp:ecosystem' como audiência válida
+  await protectMCPServer('MCP Alpha (Modo Ecossistema)', MCP_ECOSYSTEM_AUD, tokenEcosystem);
+
+
+  console.log("\n--- Cenário B: Token Restrito a um Grupo Específico (3 Servers) ---\n");
+  // O usuário quer acessar Alpha, Beta e Gama, mas NÃO o Delta.
+  
+  const targetGroup = [MCP_SERVER_ALPHA, MCP_SERVER_BETA, MCP_SERVER_GAMA];
+  const tokenGroup = await generateAccessToken('user-B', ['mcp:write'], targetGroup);
+  
+  // 1. MCP Alpha tenta validar (Ele espera ver sua URL no token)
+  await protectMCPServer('MCP Alpha', MCP_SERVER_ALPHA, tokenGroup);
+
+  // 2. MCP Gama tenta validar
+  await protectMCPServer('MCP Gama', MCP_SERVER_GAMA, tokenGroup);
+
+  // 3. MCP Delta tenta validar (Ele NÃO está na lista do token)
+  await protectMCPServer('MCP Delta', MCP_SERVER_DELTA, tokenGroup);
+
+})();

package/src/examples.ts

@@ -0,0 +1,81 @@
+import { SignJWT, jwtVerify, generateKeyPair } from './index'; // Importando nossa lib
+
+// --- Cenário: Setup Inicial ---
+// Em um cenário real, estas chaves seriam geradas uma vez e salvas em variáveis de ambiente ou KMS.
+// O Auth Server tem a PRIVADA. As APIs têm a PÚBLICA.
+const { privateKey: AUTH_SERVER_PRIVATE_KEY, publicKey: API_PUBLIC_KEY } = generateKeyPair();
+
+// Identificadores do nosso sistema
+const ISSUER = 'https://meu-auth-server.com'; // Quem gerou o token
+const AUDIENCE_FINANCEIRO = 'https://api.financeira.com'; // API de Destino
+
+// --- 1. O Authorization Server (Emissor) ---
+// Função que gera um Access Token quando o usuário loga com sucesso
+async function generateAccessToken(userId: string, scopes: string[]) {
+  
+  // No OAuth 2.1, o token geralmente tem validade curta (ex: 1 hora)
+  const jwt = await new SignJWT({
+    // Claims padrão do OAuth/OIDC
+    sub: userId,           // Subject: Quem é o usuário (ID)
+    scope: scopes.join(' '), // Scopes: O que ele pode fazer
+    // Claims personalizadas
+    role: 'admin' 
+  })
+    .setProtectedHeader({ alg: 'EdDSA' })
+    .setIssuedAt()
+    .setIssuer(ISSUER)
+    .setAudience(AUDIENCE_FINANCEIRO) // DISS: "Este token é SÓ para o Financeiro"
+    .setExpirationTime('1h') // Token de acesso de curta duração
+    .setJti(crypto.randomUUID()) // ID único do token (para revogação/blacklist se necessário)
+    .sign(AUTH_SERVER_PRIVATE_KEY);
+
+  return jwt;
+}
+
+// --- 2. O Resource Server (API Financeira) ---
+// Middleware que protege a rota da API
+async function protectFinanceRoute(tokenRecebido: string) {
+  try {
+    const { payload } = await jwtVerify(tokenRecebido, API_PUBLIC_KEY, {
+      issuer: ISSUER,               // Valida se veio do nosso Auth Server confiável
+      audience: AUDIENCE_FINANCEIRO // Valida se o token foi feito PARA NÓS
+    });
+
+    // Se passou daqui, a assinatura é válida e a audiência está correta.
+    console.log(`✅ Acesso permitido ao usuário ${payload.sub}`);
+    console.log(`Escopos permitidos: ${payload.scope}`);
+    
+    return true;
+
+  } catch (error) {
+    console.error(`❌ Acesso negado: ${(error as Error).message}`);
+    return false;
+  }
+}
+
+// --- Simulação do Fluxo ---
+(async () => {
+  console.log("--- Iniciando Fluxo OAuth 2.1 com EdDSA ---\n");
+
+  // 1. Usuário loga e ganha token
+  console.log("1. Gerando Access Token no Auth Server...");
+  const token = await generateAccessToken('user-123', ['read:invoices', 'write:payments']);
+  console.log("Token gerado:\n", token);
+
+  // 2. Usuário tenta acessar a API Financeira com o token
+  console.log("\n2. Tentando acessar API Financeira...");
+  await protectFinanceRoute(token);
+
+  // 3. Teste de Audiência Inválida (Hacker tenta usar token em outra API)
+  console.log("\n3. Teste de Segurança (Audiência Errada)...");
+  // Vamos simular que a verificação espera 'api-de-chat' mas o token é para 'financeiro'
+  try {
+    await jwtVerify(token, API_PUBLIC_KEY, {
+      issuer: ISSUER,
+      audience: 'https://api.chat.com' // <--- Audiência diferente da que está no token
+    });
+  } catch (e) {
+    console.log(`Bloqueio esperado: ${(e as Error).message}`);
+  }
+
+})();

package/src/index.ts

@@ -0,0 +1,286 @@
+import * as crypto from 'node:crypto';
+
+// --- Interfaces & Types (Compatíveis com 'jose') ---
+
+export interface JWTPayload {
+  iss?: string;
+  sub?: string;
+  aud?: string | string[];
+  exp?: number;
+  nbf?: number;
+  iat?: number;
+  jti?: string;
+  [key: string]: any;
+}
+
+export interface JWTHeaderParameters {
+  alg?: string;
+  typ?: string;
+  kid?: string;
+  [key: string]: any;
+}
+
+export interface JWTVerifyResult {
+  payload: JWTPayload;
+  protectedHeader: JWTHeaderParameters;
+}
+
+export interface JWTVerifyOptions {
+  issuer?: string | string[];
+  audience?: string | string[];
+  algorithms?: string[];
+  currentDate?: Date; // Para mockar tempo em testes
+  maxTokenAge?: string | number; // Ex: '2h' ou segundos
+}
+
+// --- Utilitários Internos ---
+
+const Encoder = new TextEncoder();
+const Decoder = new TextDecoder();
+
+/**
+ * Converte strings de tempo (ex: "2h", "1d", "30m") para segundos.
+ * Se for número, assume que já são segundos.
+ */
+function parseTime(time: string | number | undefined): number {
+  if (typeof time === 'number') return time;
+  if (!time) return 0;
+
+  const regex = /^(\d+)([smhdwy])$/;
+  const match = time.match(regex);
+
+  if (!match) throw new Error(`Formato de tempo inválido: ${time}`);
+
+  const value = parseInt(match[1], 10);
+  const unit = match[2];
+
+  switch (unit) {
+    case 's': return value;
+    case 'm': return value * 60;
+    case 'h': return value * 60 * 60;
+    case 'd': return value * 24 * 60 * 60;
+    case 'w': return value * 7 * 24 * 60 * 60;
+    case 'y': return value * 365.25 * 24 * 60 * 60;
+    default: return value;
+  }
+}
+
+function base64UrlEncode(input: Uint8Array | string | object): string {
+  let buffer: Buffer;
+  if (typeof input === 'string') {
+    buffer = Buffer.from(input, 'utf-8');
+  } else if (Buffer.isBuffer(input)) {
+    buffer = input;
+  } else if (input instanceof Uint8Array) {
+    buffer = Buffer.from(input);
+  } else {
+    buffer = Buffer.from(JSON.stringify(input), 'utf-8');
+  }
+  
+  return buffer.toString('base64url'); // Node.js moderno suporta 'base64url' nativamente
+}
+
+function base64UrlDecode(str: string): string {
+  return Buffer.from(str, 'base64url').toString('utf-8');
+}
+
+// --- Classe SignJWT (Builder Pattern) ---
+
+export class SignJWT {
+  private _payload: JWTPayload;
+  private _protectedHeader: JWTHeaderParameters = { alg: 'EdDSA', typ: 'JWT' };
+
+  constructor(payload: JWTPayload) {
+    this._payload = { ...payload };
+  }
+
+  setProtectedHeader(protectedHeader: JWTHeaderParameters): this {
+    this._protectedHeader = { ...this._protectedHeader, ...protectedHeader };
+    return this;
+  }
+
+  setIssuer(issuer: string): this {
+    this._payload.iss = issuer;
+    return this;
+  }
+
+  setSubject(subject: string): this {
+    this._payload.sub = subject;
+    return this;
+  }
+
+  setAudience(audience: string | string[]): this {
+    this._payload.aud = audience;
+    return this;
+  }
+
+  setJti(jwtId: string): this {
+    this._payload.jti = jwtId;
+    return this;
+  }
+
+  setNotBefore(input: number | string): this {
+    const now = Math.floor(Date.now() / 1000);
+    this._payload.nbf = now + parseTime(input);
+    return this;
+  }
+
+  setIssuedAt(input?: number): this {
+    this._payload.iat = input ?? Math.floor(Date.now() / 1000);
+    return this;
+  }
+
+  setExpirationTime(input: number | string): this {
+    const now = this._payload.iat ?? Math.floor(Date.now() / 1000);
+    const offset = typeof input === 'number' ? input - now : parseTime(input); 
+    // Nota: 'jose' geralmente trata string como duração relativa (ex: "2h" a partir de agora/iat)
+    // Se o input for string, somamos ao 'iat' ou 'now'. 
+    // Se for number, assume-se timestamp absoluto na maioria das libs, mas 'jose' string é duração.
+    // Aqui simplifico: string = duração, number = timestamp absoluto.
+    
+    if (typeof input === 'string') {
+        this._payload.exp = now + parseTime(input);
+    } else {
+        this._payload.exp = input;
+    }
+    
+    return this;
+  }
+
+  async sign(privateKey: crypto.KeyObject | string): Promise<string> {
+    if (this._protectedHeader.alg !== 'EdDSA') {
+      throw new Error('Apenas o algoritmo EdDSA é suportado por esta implementação.');
+    }
+
+    const encodedHeader = base64UrlEncode(this._protectedHeader);
+    const encodedPayload = base64UrlEncode(this._payload);
+    const data = `${encodedHeader}.${encodedPayload}`;
+
+    const signature = crypto.sign(
+      null,
+      Buffer.from(data),
+      (typeof privateKey === 'string') ? crypto.createPrivateKey(privateKey) : privateKey
+    );
+
+    const encodedSignature = base64UrlEncode(signature);
+
+    return `${data}.${encodedSignature}`;
+  }
+}
+
+// --- Função jwtVerify (Funcional) ---
+
+export async function jwtVerify(
+  jwt: string,
+  key: crypto.KeyObject | string,
+  options?: JWTVerifyOptions
+): Promise<JWTVerifyResult> {
+  const parts = jwt.split('.');
+  if (parts.length !== 3) {
+    throw new Error('JWT inválido: Formato deve ser header.payload.signature');
+  }
+
+  const [encodedHeader, encodedPayload, encodedSignature] = parts;
+  const data = `${encodedHeader}.${encodedPayload}`;
+
+  // 1. Validar Assinatura Criptográfica
+  const publicKey = (typeof key === 'string') ? crypto.createPublicKey(key) : key;
+  
+  // No Node moderno, crypto.verify infere Ed25519 pela chave
+  const verified = crypto.verify(
+    null,
+    Buffer.from(data),
+    publicKey,
+    Buffer.from(encodedSignature, 'base64url')
+  );
+
+  if (!verified) {
+    throw new Error('Assinatura do JWT inválida.');
+  }
+
+  // 2. Parse do Conteúdo
+  const protectedHeader = JSON.parse(base64UrlDecode(encodedHeader)) as JWTHeaderParameters;
+  const payload = JSON.parse(base64UrlDecode(encodedPayload)) as JWTPayload;
+
+  // 3. Validações de Claims (exp, nbf, iss, aud)
+  const now = options?.currentDate 
+    ? Math.floor(options.currentDate.getTime() / 1000) 
+    : Math.floor(Date.now() / 1000);
+    
+  // Clock tolerance padrão de 0s (pode ser adicionado se quiser)
+
+  if (payload.exp && now > payload.exp) {
+    throw new Error(`Token expirado (exp). Expirou em ${new Date(payload.exp * 1000).toISOString()}`);
+  }
+
+  if (payload.nbf && now < payload.nbf) {
+    throw new Error(`Token ainda não ativo (nbf). Válido a partir de ${new Date(payload.nbf * 1000).toISOString()}`);
+  }
+
+  if (options?.issuer) {
+    const issuers = Array.isArray(options.issuer) ? options.issuer : [options.issuer];
+    if (!payload.iss || !issuers.includes(payload.iss)) {
+      throw new Error(`Issuer inválido. Esperado: ${issuers.join(' ou ')}, Recebido: ${payload.iss}`);
+    }
+  }
+
+  if (options?.audience) {
+    const audiences = Array.isArray(options.audience) ? options.audience : [options.audience];
+    const payloadAud = Array.isArray(payload.aud) ? payload.aud : [payload.aud];
+    
+    // Verifica se há intersecção entre as audiências
+    const hasValidAud = payloadAud.some(a => a && audiences.includes(a));
+    if (!hasValidAud) {
+      throw new Error(`Audience inválida. Esperado: ${audiences.join(', ')}, Recebido: ${payload.aud}`);
+    }
+  }
+  
+  if (options?.maxTokenAge && payload.iat) {
+      const maxAge = parseTime(options.maxTokenAge);
+      if (now - payload.iat > maxAge) {
+           throw new Error(`Token excedeu a idade máxima permitida de ${options.maxTokenAge}.`);
+      }
+  }
+
+  return { payload, protectedHeader };
+}
+
+// --- Utilitário de Geração de Chaves (Bônus) ---
+export function generateKeyPair() {
+  return crypto.generateKeyPairSync('ed25519', {
+    publicKeyEncoding: { type: 'spki', format: 'pem' },
+    privateKeyEncoding: { type: 'pkcs8', format: 'pem' },
+  });
+}
+
+// --- Exemplo de Uso estilo 'jose' (Descomente para rodar) ---
+/*
+(async () => {
+  try {
+    const { publicKey, privateKey } = generateKeyPair();
+
+    // 1. Assinatura (Builder Pattern)
+    const jwt = await new SignJWT({ 'urn:example:claim': true, userID: 123 })
+      .setProtectedHeader({ alg: 'EdDSA' })
+      .setIssuedAt()
+      .setIssuer('urn:system:issuer')
+      .setAudience('urn:system:audience')
+      .setExpirationTime('2h') // Expira em 2 horas
+      .sign(privateKey);
+
+    console.log('Token Gerado:', jwt);
+
+    // 2. Verificação
+    const { payload, protectedHeader } = await jwtVerify(jwt, publicKey, {
+      issuer: 'urn:system:issuer',
+      audience: 'urn:system:audience',
+    });
+
+    console.log('Header Verificado:', protectedHeader);
+    console.log('Payload Verificado:', payload);
+
+  } catch (err) {
+    console.error('Falha:', err);
+  }
+})();
+*/

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": [
+      "ES2022"
+    ],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "noImplicitAny": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "**/*.spec.ts"
+  ]
+}