Descarga de node jsonwebtoken - Descarga del código fuente de node jsonwebtoken

nodo jsonwebtoken

Otro código fuente

1.0.0

Descargar

jsonwebtoken

Construir	Dependencia

Una implementación de JSON Web Tokens.

Esto se desarrolló contra draft-ietf-oauth-json-web-token-08 . Hace uso de node-jws.

Instalar

 $ npm instala jsonwebtoken

Notas de migración

De v8 a v9
De v7 a v8

Uso

jwt.sign(carga útil, secretOrPrivateKey, [opciones, devolución de llamada])

(Asíncrono) Si se proporciona una devolución de llamada, la devolución de llamada se llama con err o JWT.

(Sincrónico) Devuelve el JsonWebToken como cadena

payload podría ser un objeto literal, un búfer o una cadena que represente un JSON válido.

Tenga en cuenta que exp o cualquier otro reclamo solo se establece si la carga útil es un objeto literal. No se comprueba la validez JSON de las cargas útiles del búfer o de la cadena.

Si payload no es un búfer o una cadena, se convertirá en una cadena mediante JSON.stringify .

secretOrPrivateKey es una cadena (codificada en utf-8), un búfer, un objeto o un KeyObject que contiene el secreto para los algoritmos HMAC o la clave privada codificada en PEM para RSA y ECDSA. En el caso de una clave privada con frase de contraseña, se puede usar un objeto { key, passphrase } (según la documentación criptográfica); en este caso, asegúrese de pasar la opción de algorithm . Al firmar con algoritmos RSA, la longitud mínima del módulo es 2048, excepto cuando la opción enableInsecureKeySizes está configurada en verdadero. Las claves privadas inferiores a este tamaño se rechazarán con un error.

options :

algorithm (predeterminado: HS256 )
expiresIn : expresado en segundos o una cadena que describe un lapso de tiempo vercel/ms.
Ej: 60 , "2 days" , "10h" , "7d" . Un valor numérico se interpreta como un conteo de segundos. Si utiliza una cadena, asegúrese de proporcionar las unidades de tiempo (días, horas, etc.); de lo contrario, se utilizará la unidad de milisegundos de forma predeterminada ( "120" es igual a "120ms" ).
notBefore : expresado en segundos o una cadena que describe un lapso de tiempo vercel/ms.
Ej: 60 , "2 days" , "10h" , "7d" . Un valor numérico se interpreta como un conteo de segundos. Si utiliza una cadena, asegúrese de proporcionar las unidades de tiempo (días, horas, etc.); de lo contrario, se utilizará la unidad de milisegundos de forma predeterminada ( "120" es igual a "120ms" ).
audience
issuer
jwtid
subject
noTimestamp
header
keyid
mutatePayload : si es verdadero, la función de signo modificará el objeto de carga útil directamente. Esto es útil si necesita una referencia sin formato a la carga útil después de que se le hayan aplicado reclamos pero antes de que se haya codificado en un token.
allowInsecureKeySizes : si es verdadero, permite que se utilicen claves privadas con un módulo inferior a 2048 para RSA
allowInvalidAsymmetricKeyTypes : si es verdadero, permite claves asimétricas que no coinciden con el algoritmo especificado. Esta opción está destinada únicamente a la compatibilidad con versiones anteriores y debe evitarse.

No hay valores predeterminados para expiresIn , notBefore , audience , subject , issuer . Estos reclamos también se pueden proporcionar en la carga útil directamente con exp , nbf , aud , sub e iss respectivamente, pero no se pueden incluir en ambos lugares.

Recuerde que exp , nbf e iat son NumericDate , consulte la Caducidad del token relacionada (reclamo de exp)

El encabezado se puede personalizar mediante el objeto options.header .

Los jwts generados incluirán una reclamación iat (emitida en) de forma predeterminada, a menos que se especifique noTimestamp . Si se inserta iat en la carga útil, se usará en lugar de la marca de tiempo real para calcular otras cosas como exp dado un período de tiempo en options.expiresIn .

Señal síncrona por defecto (HMAC SHA256)

 var jwt = require('jsonwebtoken');var token = jwt.sign({ foo: 'bar' }, 'shhhhh');

Señal síncrona con RSA SHA256

 // firmar con RSA SHA256var privateKey = fs.readFileSync('private.key');var token = jwt.sign({ foo: 'bar' }, privateKey, { algoritmo: 'RS256' });

Firmar de forma asincrónica

 jwt.sign ({ foo: 'bar' }, clave privada, { algoritmo: 'RS256' }, función (err, token) {
  console.log(token);});

Retroceder un jwt 30 segundos

 var old_token = jwt.sign({ foo: 'bar', iat: Math.floor(Date.now() / 1000) - 30 }, 'shhhhh');

Vencimiento del token (reclamo de exp)

El estándar para JWT define un reclamo exp por vencimiento. El vencimiento se representa como una fecha numérica :

Un valor numérico JSON que representa el número de segundos desde 1970-01-01T00:00:00Z UTC hasta la fecha/hora UTC especificada, ignorando los segundos intercalares. Esto es equivalente a la definición de IEEE Std 1003.1, edición 2013 [POSIX.1] "Segundos desde la época", en la que cada día se contabiliza exactamente por 86400 segundos, aparte de que se pueden representar valores no enteros. Consulte RFC 3339 [RFC3339] para obtener detalles sobre fechas/horas en general y UTC en particular.

Esto significa que el campo exp debe contener la cantidad de segundos desde la época.

Firmar un token con 1 hora de vencimiento:

 jwt.sign({
  exp: Math.floor(Fecha.ahora() / 1000) + (60 * 60),
  datos: 'foobar'}, 'secreto');

Otra forma de generar un token como este con esta biblioteca es:

 jwt.sign({
  data: 'foobar'}, 'secret', { expiresIn: 60 * 60 });//o incluso mejor:jwt.sign({
  datos: 'foobar'}, 'secreto', { expiresIn: '1h' });

jwt.verify(token, secretOrPublicKey, [opciones, devolución de llamada])

(Asíncrono) Si se proporciona una devolución de llamada, la función actúa de forma asíncrona. La devolución de llamada se llama con la carga útil decodificada si la firma es válida y el vencimiento, la audiencia o el emisor opcionales son válidos. De lo contrario, se llamará con el error.

(Sincrónico) Si no se proporciona una devolución de llamada, la función actúa de forma sincrónica. Devuelve la carga útil decodificada si la firma es válida y el vencimiento, la audiencia o el emisor opcionales son válidos. Si no, arrojará el error.

Advertencia: cuando el token proviene de una fuente que no es de confianza (por ejemplo, entrada del usuario o solicitudes externas), la carga útil decodificada devuelta debe tratarse como cualquier otra entrada del usuario; asegúrese de desinfectar y trabajar solo con las propiedades que se esperan

token es la cadena JsonWebToken

secretOrPublicKey es una cadena (codificada en utf-8), un búfer o un KeyObject que contiene el secreto para los algoritmos HMAC o la clave pública codificada en PEM para RSA y ECDSA. Si jwt.verify se llama asíncrono, secretOrPublicKey puede ser una función que debería recuperar la clave pública o secreta. Vea a continuación un ejemplo detallado

Como se menciona en este comentario, hay otras bibliotecas que esperan secretos codificados en base64 (bytes aleatorios codificados usando base64), si ese es su caso, puede pasar Buffer.from(secret, 'base64') , al hacer esto se decodificará el secreto. usando base64 y la verificación del token utilizará los bytes aleatorios originales.

options

algorithms : Lista de cadenas con los nombres de los algoritmos permitidos. Por ejemplo, ["HS256", "HS384"] .
Si no se especifica, se utilizarán valores predeterminados según el tipo de clave proporcionada.

secreto - ['HS256', 'HS384', 'HS512']
rsa-['RS256', 'RS384', 'RS512']
ce - ['ES256', 'ES384', 'ES512']
predeterminado - ['RS256', 'RS384', 'RS512']

audience : si desea verificar la audiencia ( aud ), proporcione un valor aquí. La audiencia se puede comparar con una cadena, una expresión regular o una lista de cadenas y/o expresiones regulares.
Por ejemplo: "urn:foo" , /urn:f[o]{2}/ , [/urn:f[o]{2}/, "urn:bar"]
complete : devuelve un objeto con la { payload, header, signature } decodificada en lugar de solo el contenido habitual de la carga útil.
issuer (opcional): cadena o matriz de cadenas de valores válidos para el campo iss .
jwtid (opcional): si desea verificar el ID de JWT ( jti ), proporcione un valor de cadena aquí.
ignoreExpiration : si es true no valide la caducidad del token.
ignoreNotBefore ...
subject : si desea verificar el asunto ( sub ), proporcione un valor aquí
clockTolerance : número de segundos a tolerar al verificar los reclamos nbf y exp , para lidiar con pequeñas diferencias de reloj entre diferentes servidores
maxAge : la edad máxima permitida para que los tokens sigan siendo válidos. Se expresa en segundos o una cadena que describe un lapso de tiempo vercel/ms.
Por ejemplo: 1000 , "2 days" , "10h" , "7d" . Un valor numérico se interpreta como un conteo de segundos. Si utiliza una cadena, asegúrese de proporcionar las unidades de tiempo (días, horas, etc.); de lo contrario, se utilizará la unidad de milisegundos de forma predeterminada ( "120" es igual a "120ms" ).
clockTimestamp : el tiempo en segundos que debe usarse como hora actual para todas las comparaciones necesarias.
nonce : si desea verificar el reclamo nonce , proporcione un valor de cadena aquí. Se utiliza en Open ID para los tokens de identificación. (Notas de implementación de Open ID)
allowInvalidAsymmetricKeyTypes : si es verdadero, permite claves asimétricas que no coinciden con el algoritmo especificado. Esta opción está destinada únicamente a la compatibilidad con versiones anteriores y debe evitarse.

 // verificar un token simétrico - synchronousvar decoded = jwt.verify(token, 'shhhhh');console.log(decoded.foo) // bar// verificar un token simétricojwt.verify(token, 'shhhhh', function(err , decodificado) {
  console.log(decoded.foo) // bar});// token no válido - synchronoustry {
  var decodificado = jwt.verify(token, 'secreto incorrecto');} catch(err) {
  // err}// tokenjwt.verify(token, 'secreto incorrecto', función (err, decodificado) no válido
  // errar
  // decodificado undefinido});// verificar un token ametricvar cert = fs.readFileSync('public.pem');  // obtener la clave públicajwt.verify(token, cert, function(err, decodificado) {
  console.log(decoded.foo) // bar});// verificar audienciavar cert = fs.readFileSync('public.pem');  // obtiene la clave públicajwt.verify(token, cert, { audiencia: 'urna:foo' }, función(err, decodificado) {
  // si la audiencia no coincide, err == audiencia no válida});// verificar el emisorvar cert = fs.readFileSync('public.pem');  // obtener la clave públicajwt.verify(token, cert, { audiencia: 'urna:foo', emisor: 'urna:emisor' }, función(err, decodificado) {
  // si el emisor no coincide, err == emisor no válido});// verificar jwt idvar cert = fs.readFileSync('public.pem');  // obtiene la clave públicajwt.verify(token, cert, { audiencia: 'urna:foo', emisor: 'urna:emisor', jwtid: 'jwtid' }, función(err, decodificado) {
  // si el id de jwt no coincide, err == id de jwt no válido});// verificar sujetovar cert = fs.readFileSync('public.pem');  // obtener la clave públicajwt.verify(token, cert, { audiencia: 'urna:foo', emisor: 'urna:emisor', jwtid: 'jwtid', asunto: 'asunto' }, función(err, decodificado) {
  // si el asunto no coincide, err == asunto no válido});// alg mismatchvar cert = fs.readFileSync('public.pem'); // obtiene la clave públicajwt.verify(token, cert, {algoritmos: ['RS256'] }, función (err, carga útil) {
  // if token alg != RS256, err == firma no válida});// Verificar usando la devolución de llamada getKey// El ejemplo usa https://github.com/auth0/node-jwks-rsa como una forma de recuperar las claves. var jwksClient = require('jwks-rsa');var cliente = jwksClient({
  jwksUri: 'https://sandrino.auth0.com/.well-known/jwks.json'});función getKey(encabezado, devolución de llamada){
  client.getSigningKey(header.kid, function(err, clave) {var signingKey = key.publicKey || key.rsaPublicKey;callback(null, signingKey);
  });}jwt.verify(token, getKey, opciones, función(err, decodificado) {
  console.log(decoded.foo) // bar});

¿Necesita echar un vistazo a un JWT sin verificarlo? (Haga clic para ampliar)

jwt.decode(token [, opciones])

(Síncrono) Devuelve la carga útil decodificada sin verificar si la firma es válida.

Advertencia: Esto no verificará si la firma es válida. No debes usar esto para mensajes que no sean de confianza. Lo más probable es que quieras utilizar jwt.verify en su lugar.

Advertencia: cuando el token proviene de una fuente que no es de confianza (por ejemplo, entrada del usuario o solicitud externa), la carga útil decodificada devuelta debe tratarse como cualquier otra entrada del usuario; asegúrese de desinfectar y trabajar solo con las propiedades que se esperan

token es la cadena JsonWebToken

options :

json : fuerza JSON.parse en la carga útil incluso si el encabezado no contiene "typ":"JWT" .
complete : devuelve un objeto con la carga útil y el encabezado decodificados.

Ejemplo

 // obtiene la carga útil decodificada ignorando la firma, no se necesita secretOrPrivateKeyvar decoded = jwt.decode(token);// obtiene la carga útil decodificada y el encabezadovar decoded = jwt.decode(token, {complete: true});console.log(decoded. encabezado);console.log(decodificado.payload)

Errores y códigos

Posibles errores arrojados durante la verificación. El error es el primer argumento de la devolución de llamada de verificación.

Error de token caducado

Se produce un error si el token ha caducado.

Objeto de error:

nombre: 'TokenExpiredError'
mensaje: 'jwt expiró'
caducado en: [Fecha de caducidad]

 jwt.verify(token, 'shhhhh', función(err, decodificado) {
  if (err) {/* err = { nombre: 'TokenExpiredError', mensaje: 'jwt expiró', expiró en: 1408621000 } */
  }});

Error de JsonWebToken

Objeto de error:

nombre: 'JsonWebTokenError'
mensaje:

'token no válido': no se pudo analizar el encabezado o la carga útil
'jwt mal formado': el token no tiene tres componentes (delimitados por un . ).
'Se requiere firma jwt'
'firma no válida'
'Jwt audiencia inválida. esperado: [OPCIONES AUDIENCIA]'
'Emisor jwt no válido. esperado: [EDITOR DE OPCIONES]'
'Jwt id no válido. esperado: [OPCIONES JWT ID]'
'jwt asunto inválido. esperado: [ASUNTO DE OPCIONES]'

 jwt.verify(token, 'shhhhh', función(err, decodificado) {
  if (err) {/* err = { nombre: 'JsonWebTokenError', mensaje: 'jwt mal formado' } */
  }});

Error no antes

Se lanza si la hora actual es anterior al reclamo nbf.

Objeto de error:

nombre: 'NotBeforeError'
mensaje: 'jwt no activo'
fecha: 2018-10-04T16:10:44.000Z

 jwt.verify(token, 'shhhhh', función(err, decodificado) {
  if (err) {/* err = { nombre: 'NotBeforeError', mensaje: 'jwt no activo', fecha: 2018-10-04T16:10:44.000Z } */
  }});

Algoritmos soportados

Matriz de algoritmos compatibles. Actualmente se admiten los siguientes algoritmos.

Valor del parámetro alg	Firma digital o algoritmo MAC
HS256	HMAC usando el algoritmo hash SHA-256
HS384	HMAC usando el algoritmo hash SHA-384
HS512	HMAC usando el algoritmo hash SHA-512
RS256	RSASSA-PKCS1-v1_5 usando el algoritmo hash SHA-256
RS384	RSASSA-PKCS1-v1_5 usando el algoritmo hash SHA-384
RS512	RSASSA-PKCS1-v1_5 usando el algoritmo hash SHA-512
PS256	RSASSA-PSS usando el algoritmo hash SHA-256 (solo nodo ^6.12.0 O >=8.0.0)
PS384	RSASSA-PSS usando el algoritmo hash SHA-384 (solo nodo ^6.12.0 O >=8.0.0)
PS512	RSASSA-PSS usando el algoritmo hash SHA-512 (solo nodo ^6.12.0 O >=8.0.0)
ES256	ECDSA utilizando la curva P-256 y el algoritmo hash SHA-256
ES384	ECDSA utilizando la curva P-384 y el algoritmo hash SHA-384
ES512	ECDSA utilizando la curva P-521 y el algoritmo hash SHA-512
ninguno	No se incluye firma digital ni valor MAC

JWT refrescantes

En primer lugar, le recomendamos que piense detenidamente si la actualización automática de un JWT no introducirá ninguna vulnerabilidad en su sistema.

No nos sentimos cómodos incluyendo esto como parte de la biblioteca; sin embargo, puede echar un vistazo a este ejemplo para mostrar cómo se podría lograr. Aparte de ese ejemplo, hay un problema y una solicitud de extracción para obtener más conocimientos sobre este tema.

HACER

La cadena de certificados X.509 no está marcada

Informe de problemas

Si encontró un error o si tiene una solicitud de función, infórmelo en esta sección de problemas del repositorio. No informe vulnerabilidades de seguridad en el rastreador de problemas público de GitHub. El Programa de Divulgación Responsable detalla el procedimiento para revelar problemas de seguridad.