@jjlmoya/utils-developer 1.16.0 → 1.17.0

package/src/tool/jwtDecoder/i18n/en.ts

@@ -0,0 +1,247 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { JwtDecoderUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'jwt-decoder-parser-and-claims-inspector';
+const title = 'JWT Decoder, Parser and Claims Inspector';
+const description = 'Paste a JSON Web Token, decode its header and payload instantly, inspect registered claims, spot expired tokens, and copy clean JSON for debugging authentication flows.';
+
+const howTo = [
+  {
+    name: 'Paste the JWT',
+    text: 'Copy a token from an Authorization header, cookie, log entry or identity provider and paste it into the input field.',
+  },
+  {
+    name: 'Read the decoded header and payload',
+    text: 'The tool splits the token into header, payload and signature, then renders the JSON segments in separate panels for fast inspection.',
+  },
+  {
+    name: 'Check important claims',
+    text: 'Review algorithm, issuer, audience, subject, issued-at time, not-before time and expiration time without manually converting Unix timestamps.',
+  },
+  {
+    name: 'Copy the data you need',
+    text: 'Copy one decoded section or the complete decoded output when you need to share a sanitized debugging snapshot with your team.',
+  },
+];
+
+const faq = [
+  {
+    question: 'Does decoding a JWT prove that the token is valid?',
+    answer: 'No. Decoding only reveals the base64url-encoded header and payload. A token is trustworthy only after the signature, issuer, audience, expiration and related claims are validated by the application or identity provider.',
+  },
+  {
+    question: 'Can I use this JWT decoder for access tokens and ID tokens?',
+    answer: 'Yes. The decoder is useful for inspecting OAuth access tokens, OpenID Connect ID tokens, session tokens and service-to-service tokens, as long as they use the standard three-part JWT format.',
+  },
+  {
+    question: 'Why does the signature panel not verify the token?',
+    answer: 'JWT verification requires the correct secret, public key or JWKS configuration. This tool intentionally focuses on decoding and inspection so developers can see token contents without pretending that a visible signature string is proof of validity.',
+  },
+  {
+    question: 'What should I check first when debugging a JWT?',
+    answer: 'Start with exp, nbf, iss, aud and alg. Most real production issues come from expired tokens, clock skew, wrong audience values, unexpected issuer URLs or insecure algorithm assumptions.',
+  },
+];
+
+const ui: JwtDecoderUI = {
+  tokenLabel: 'JWT token',
+  tokenPlaceholder: 'Paste a JWT here: header.payload.signature',
+  sampleButton: 'Load sample',
+  clearButton: 'Clear',
+  statusWaiting: 'Paste a token to decode its JSON header, payload and claims.',
+  statusValid: 'JWT decoded successfully.',
+  statusInvalid: 'This does not look like a valid three-part JWT.',
+  statusExpired: 'JWT decoded, but the exp claim is already expired.',
+  statusUnsigned: 'JWT decoded, but it is unsigned or uses alg none.',
+  headerTitle: 'Header',
+  payloadTitle: 'Payload',
+  signatureTitle: 'Signature',
+  claimsTitle: 'Registered claims',
+  copyHeader: 'Copy decoded header',
+  copyPayload: 'Copy decoded payload',
+  copySignature: 'Copy signature',
+  copyAll: 'Copy all',
+  copiedLabel: 'Copied',
+  invalidTokenTitle: 'Invalid JWT',
+  invalidTokenBody: 'Check that the token has three dot-separated base64url segments.',
+  invalidSegmentError: 'Check that the token has three dot-separated base64url segments.',
+  invalidDecodeError: 'The header or payload could not be decoded as valid JSON.',
+  emptyJson: '{}',
+  signaturePresent: 'Signature segment is present; verify it in your auth layer with the correct key.',
+  signatureMissing: 'No signature segment',
+  algorithmLabel: 'Algorithm',
+  typeLabel: 'Type',
+  issuerLabel: 'Issuer',
+  subjectLabel: 'Subject',
+  audienceLabel: 'Audience',
+  issuedAtLabel: 'Issued at',
+  notBeforeLabel: 'Not before',
+  expiresAtLabel: 'Expires at',
+  claimMissing: 'Not present',
+  privacyNote: 'Decoding runs in your browser session. Do not paste production secrets into any tool unless your security policy allows it.',
+  sampleToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJnYW1lYm9iLXVzZXItNDIiLCJuYW1lIjoiR2FtZUJvYiBEZXZlbG9wZXIiLCJpc3MiOiJodHRwczovL3d3dy5nYW1lYm9iLmRldiIsImF1ZCI6ImRldmVsb3Blci10b29scyIsImlhdCI6MTcxNzIwMDAwMCwibmJmIjoxNzE3MjAwMDAwLCJleHAiOjE4OTM0NTYwMDAsInJvbGUiOiJhZG1pbiJ9.demo-signature',
+};
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faq.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: {
+      '@type': 'Answer',
+      text: item.answer,
+    },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howTo.map((step, index) => ({
+    '@type': 'HowToStep',
+    position: index + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'Any',
+  offers: {
+    '@type': 'Offer',
+    price: '0',
+    priceCurrency: 'EUR',
+  },
+};
+
+export const content: ToolLocaleContent<JwtDecoderUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'JWT decoder FAQ',
+  faq,
+  bibliographyTitle: 'JWT specifications and security references',
+  bibliography,
+  howTo,
+  schemas: [appSchema, faqSchema, howToSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Decode JWTs without losing the security context',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'A JSON Web Token looks compact, but it often carries the exact detail that explains an authentication failure: the signing algorithm, issuer, audience, subject, issued-at time, not-before time, expiration and application-specific authorization claims. This <strong>JWT decoder, parser and claims inspector</strong> turns the three token segments into readable JSON so you can debug auth flows faster.',
+    },
+    {
+      type: 'diagnostic',
+      variant: 'warning',
+      title: 'Decoded does not mean trusted',
+      html: 'Anyone can base64url-decode a JWT. Trust begins only after your application verifies the signature with the correct secret, public key or JWKS, then validates issuer, audience, expiration and any domain-specific claims. Use this tool to inspect data, not to accept a token as authentic.',
+    },
+    {
+      type: 'title',
+      text: 'What each JWT segment tells you',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Segment', 'Typical content', 'Debugging value'],
+      rows: [
+        ['Header', 'Algorithm, token type and optional key id', 'Shows whether the token expects HS256, RS256, ES256 or another verification strategy.'],
+        ['Payload', 'Registered claims and application claims', 'Reveals identity, tenant, scopes, roles, expiration and audience mismatches.'],
+        ['Signature', 'Cryptographic signature bytes encoded as base64url', 'Confirms that a signature segment exists, but must be verified with the right key elsewhere.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Claims that usually explain broken authentication',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>exp:</strong> if the token expired, refresh logic or clock settings may be wrong.',
+        '<strong>nbf:</strong> if the token is not active yet, server and identity provider clocks may be out of sync.',
+        '<strong>iss:</strong> if the issuer URL differs from configuration, the token may come from the wrong tenant or environment.',
+        '<strong>aud:</strong> if the audience does not match the API identifier, the token was minted for another resource.',
+        '<strong>alg:</strong> if the algorithm is unexpected, your verifier may reject the token or expose a dangerous configuration mistake.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Use cases for a JWT parser during development',
+      level: 3,
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Frontend debugging',
+          description: 'Inspect ID tokens and access tokens received after login to confirm scopes, roles and profile claims.',
+          icon: 'mdi:monitor-dashboard',
+          points: ['Check profile claims', 'Confirm scopes and roles', 'Compare login environments'],
+        },
+        {
+          title: 'Backend API QA',
+          description: 'Compare expected issuer and audience values with the token actually sent in an Authorization header.',
+          icon: 'mdi:api',
+          highlight: true,
+          points: ['Validate audience shape', 'Spot issuer mismatches', 'Inspect bearer tokens'],
+        },
+        {
+          title: 'Identity provider setup',
+          description: 'Check whether claims from Auth0, Azure AD, Cognito, Keycloak or a custom provider are shaped as your app expects.',
+          icon: 'mdi:account-key',
+          points: ['Review tenant data', 'Check custom claims', 'Compare provider mappings'],
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Common JWT mistakes this inspector makes obvious',
+      level: 3,
+    },
+    {
+      type: 'proscons',
+      title: 'Fast checks versus trust decisions',
+      items: [
+        {
+          pro: 'See malformed tokens immediately.',
+          con: 'It cannot know your expected audience or issuer.',
+        },
+        {
+          pro: 'Convert Unix timestamp claims into readable dates.',
+          con: 'It cannot verify a signature without the real key material.',
+        },
+        {
+          pro: 'Spot missing issuer, audience, subject or type values.',
+          con: 'It cannot prove that scopes and roles are safe for your application.',
+        },
+      ],
+    },
+    {
+      type: 'summary',
+      title: 'Best practice workflow',
+      items: [
+        'Decode the token to understand what the client or API actually received.',
+        'Check exp, nbf, iss, aud, sub and alg before chasing application logic.',
+        'Verify signatures and trust decisions only in your auth layer.',
+        'Avoid sharing sensitive production JWTs in tickets, logs or screenshots.',
+      ],
+    },
+  ],
+};

package/src/tool/jwtDecoder/i18n/es.ts

@@ -0,0 +1,248 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { JwtDecoderUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'decodificador-jwt-parser-e-inspector-de-claims';
+const title = 'Decodificador JWT, Parser e Inspector de Claims';
+const description = 'Pega un JSON Web Token, decodifica su cabecera y payload al instante, inspecciona claims registrados, detecta tokens expirados y copia JSON limpio para depurar flujos de autenticación.';
+
+const howTo = [
+  {
+    name: 'Pega el JWT',
+    text: 'Copia un token de una cabecera Authorization, cookie, entrada de log o proveedor de identidad y pégalo en el campo de entrada.',
+  },
+  {
+    name: 'Lee la cabecera y el payload decodificados',
+    text: 'La herramienta divide el token en cabecera, payload y firma, luego muestra los segmentos JSON en paneles separados para una inspección rápida.',
+  },
+  {
+    name: 'Comprueba los claims importantes',
+    text: 'Revisa el algoritmo, emisor, audiencia, sujeto, fecha de emisión, fecha de validez inicial y fecha de expiración sin convertir manualmente timestamps Unix.',
+  },
+  {
+    name: 'Copia los datos que necesitas',
+    text: 'Copia una sección decodificada o la salida decodificada completa cuando necesites compartir una instantánea de depuración saneada con tu equipo.',
+  },
+];
+
+const faq = [
+  {
+    question: '¿Decodificar un JWT demuestra que el token es válido?',
+    answer: 'No. Decodificar solo revela la cabecera y el payload codificados en base64url. Un token es confiable solo después de que la firma, el emisor, la audiencia, la expiración y los claims relacionados sean validados por la aplicación o el proveedor de identidad.',
+  },
+  {
+    question: '¿Puedo usar este decodificador JWT para access tokens e ID tokens?',
+    answer: 'Sí. El decodificador es útil para inspeccionar access tokens OAuth, ID tokens OpenID Connect, tokens de sesión y tokens servicio a servicio, siempre que usen el formato JWT estándar de tres partes.',
+  },
+  {
+    question: '¿Por qué el panel de firma no verifica el token?',
+    answer: 'La verificación JWT requiere el secreto correcto, la clave pública o la configuración JWKS. Esta herramienta se centra intencionadamente en la decodificación e inspección para que los desarrolladores puedan ver el contenido del token sin pretender que una cadena de firma visible es prueba de validez.',
+  },
+  {
+    question: '¿Qué debo comprobar primero al depurar un JWT?',
+    answer: 'Empieza por exp, nbf, iss, aud y alg. La mayoría de los problemas reales en producción provienen de tokens expirados, desfase de reloj, valores de audiencia incorrectos, URLs de emisor inesperadas o suposiciones inseguras sobre el algoritmo.',
+  },
+];
+
+const ui: JwtDecoderUI = {
+  tokenLabel: 'Token JWT',
+  tokenPlaceholder: 'Pega un JWT aquí: cabecera.payload.firma',
+  sampleButton: 'Cargar ejemplo',
+  clearButton: 'Limpiar',
+  statusWaiting: 'Pega un token para decodificar su cabecera JSON, payload y claims.',
+  statusValid: 'JWT decodificado correctamente.',
+  statusInvalid: 'Esto no parece un JWT válido de tres partes.',
+  statusExpired: 'JWT decodificado, pero el claim exp ya está expirado.',
+  statusUnsigned: 'JWT decodificado, pero no está firmado o usa el algoritmo none.',
+  headerTitle: 'Cabecera',
+  payloadTitle: 'Payload',
+  signatureTitle: 'Firma',
+  claimsTitle: 'Claims registrados',
+  copyHeader: 'Copiar cabecera decodificada',
+  copyPayload: 'Copiar payload decodificado',
+  copySignature: 'Copiar firma',
+  copyAll: 'Copiar todo',
+  copiedLabel: 'Copiado',
+  invalidTokenTitle: 'JWT no válido',
+  invalidTokenBody: 'Comprueba que el token tiene tres segmentos base64url separados por puntos.',
+  invalidSegmentError: 'Comprueba que el token tiene tres segmentos base64url separados por puntos.',
+  invalidDecodeError: 'La cabecera o el payload no se pudieron decodificar como JSON válido.',
+  emptyJson: '{}',
+  signaturePresent: 'El segmento de firma está presente; verifícalo en tu capa de autenticación con la clave correcta.',
+  signatureMissing: 'Sin segmento de firma',
+  algorithmLabel: 'Algoritmo',
+  typeLabel: 'Tipo',
+  issuerLabel: 'Emisor',
+  subjectLabel: 'Sujeto',
+  audienceLabel: 'Audiencia',
+  issuedAtLabel: 'Emitido el',
+  notBeforeLabel: 'No antes del',
+  expiresAtLabel: 'Expira el',
+  claimMissing: 'No presente',
+  privacyNote: 'La decodificación se ejecuta en tu navegador. No pegues secretos de producción en ninguna herramienta a menos que tu política de seguridad lo permita.',
+  sampleToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJnYW1lYm9iLXVzZXItNDIiLCJuYW1lIjoiR2FtZUJvYiBEZXZlbG9wZXIiLCJpc3MiOiJodHRwczovL3d3dy5nYW1lYm9iLmRldiIsImF1ZCI6ImRldmVsb3Blci10b29scyIsImlhdCI6MTcxNzIwMDAwMCwibmJmIjoxNzE3MjAwMDAwLCJleHAiOjE4OTM0NTYwMDAsInJvbGUiOiJhZG1pbiJ9.demo-signature',
+};
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faq.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: {
+      '@type': 'Answer',
+      text: item.answer,
+    },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howTo.map((step, index) => ({
+    '@type': 'HowToStep',
+    position: index + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'Any',
+  offers: {
+    '@type': 'Offer',
+    price: '0',
+    priceCurrency: 'EUR',
+  },
+  inLanguage: 'es',
+};
+
+export const content: ToolLocaleContent<JwtDecoderUI> = {
+  slug,
+  title,
+  description,
+  ui,
+  faqTitle: 'Preguntas frecuentes sobre el decodificador JWT',
+  faq,
+  bibliographyTitle: 'Especificaciones JWT y referencias de seguridad',
+  bibliography,
+  howTo,
+  schemas: [appSchema, faqSchema, howToSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Decodifica JWTs sin perder el contexto de seguridad',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Un JSON Web Token parece compacto, pero a menudo contiene el detalle exacto que explica un fallo de autenticación: el algoritmo de firma, emisor, audiencia, sujeto, fecha de emisión, fecha de validez inicial, expiración y claims de autorización específicos de la aplicación. Este <strong>decodificador JWT, parser e inspector de claims</strong> convierte los tres segmentos del token en JSON legible para que puedas depurar flujos de autenticación más rápido.',
+    },
+    {
+      type: 'diagnostic',
+      variant: 'warning',
+      title: 'Decodificado no significa confiable',
+      html: 'Cualquiera puede decodificar un JWT en base64url. La confianza comienza solo después de que tu aplicación verifique la firma con el secreto, clave pública o JWKS correctos y luego valide el emisor, la audiencia, la expiración y cualquier claim específico del dominio. Usa esta herramienta para inspeccionar datos, no para aceptar un token como auténtico.',
+    },
+    {
+      type: 'title',
+      text: 'Lo que te dice cada segmento JWT',
+      level: 3,
+    },
+    {
+      type: 'table',
+      headers: ['Segmento', 'Contenido típico', 'Valor de depuración'],
+      rows: [
+        ['Cabecera', 'Algoritmo, tipo de token e ID de clave opcional', 'Muestra si el token espera HS256, RS256, ES256 u otra estrategia de verificación.'],
+        ['Payload', 'Claims registrados y claims de aplicación', 'Revela identidad, tenant, scopes, roles, expiración y desajustes de audiencia.'],
+        ['Firma', 'Bytes de firma criptográfica codificados como base64url', 'Confirma que existe un segmento de firma, pero debe verificarse con la clave correcta en otro lugar.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Claims que suelen explicar fallos de autenticación',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>exp:</strong> si el token expiró, la lógica de renovación o la configuración del reloj pueden estar mal.',
+        '<strong>nbf:</strong> si el token aún no está activo, los relojes del servidor y del proveedor de identidad pueden estar desincronizados.',
+        '<strong>iss:</strong> si la URL del emisor difiere de la configuración, el token puede venir del tenant o entorno equivocado.',
+        '<strong>aud:</strong> si la audiencia no coincide con el identificador de la API, el token fue emitido para otro recurso.',
+        '<strong>alg:</strong> si el algoritmo es inesperado, tu verificador puede rechazar el token o exponer un error de configuración peligroso.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Casos de uso de un parser JWT durante el desarrollo',
+      level: 3,
+    },
+    {
+      type: 'comparative',
+      columns: 3,
+      items: [
+        {
+          title: 'Depuración frontend',
+          description: 'Inspecciona ID tokens y access tokens recibidos tras el inicio de sesión para confirmar scopes, roles y claims de perfil.',
+          icon: 'mdi:monitor-dashboard',
+          points: ['Comprueba claims de perfil', 'Confirma scopes y roles', 'Compara entornos de login'],
+        },
+        {
+          title: 'QA de API backend',
+          description: 'Compara los valores esperados de emisor y audiencia con el token realmente enviado en una cabecera Authorization.',
+          icon: 'mdi:api',
+          highlight: true,
+          points: ['Valida la forma de la audiencia', 'Detecta desajustes de emisor', 'Inspecciona bearer tokens'],
+        },
+        {
+          title: 'Configuración del proveedor de identidad',
+          description: 'Comprueba si los claims de Auth0, Azure AD, Cognito, Keycloak o un proveedor personalizado tienen la forma que tu aplicación espera.',
+          icon: 'mdi:account-key',
+          points: ['Revisa datos del tenant', 'Comprueba claims personalizados', 'Compara mapeos del proveedor'],
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Errores comunes de JWT que este inspector hace evidentes',
+      level: 3,
+    },
+    {
+      type: 'proscons',
+      title: 'Comprobaciones rápidas frente a decisiones de confianza',
+      items: [
+        {
+          pro: 'Ve tokens mal formados inmediatamente.',
+          con: 'No puede conocer tu audiencia o emisor esperados.',
+        },
+        {
+          pro: 'Convierte claims de timestamp Unix en fechas legibles.',
+          con: 'No puede verificar una firma sin el material de clave real.',
+        },
+        {
+          pro: 'Detecta valores faltantes de emisor, audiencia, sujeto o tipo.',
+          con: 'No puede demostrar que los scopes y roles son seguros para tu aplicación.',
+        },
+      ],
+    },
+    {
+      type: 'summary',
+      title: 'Flujo de trabajo recomendado',
+      items: [
+        'Decodifica el token para entender lo que el cliente o la API realmente recibieron.',
+        'Comprueba exp, nbf, iss, aud, sub y alg antes de perseguir la lógica de aplicación.',
+        'Verifica firmas y decisiones de confianza solo en tu capa de autenticación.',
+        'Evita compartir JWTs de producción sensibles en tickets, logs o capturas de pantalla.',
+      ],
+    },
+  ],
+};