O que é JWT?

JWT significa json web token, é um uso stander aberto para transmitir informações entre as partes como um objeto JSON. É compacto, seguro para URL e amplamente utilizado em aplicações web para autenticação e troca de informações.

JWTs são assinados digitalmente usando chaves e segredos. Verificamos o JWT com essas chaves e a assinatura para autenticar o usuário. A maioria dos sistemas web usa JWTs para autorizar os usuários a acessar determinados recursos.

Componentes de token

Um JWT tem três componentes principais: o cabeçalho, a carga útil e a assinatura. Quando criamos um token, passamos o cabeçalho e a carga útil, e então o token gera a assinatura.

Headre - O cabeçalho de um JWT contém metadados sobre o token. Inclui três valores: alg, typ e kid. O alg especifica o algoritmo usado para assinar o token, typ indica o tipo do token e kid é um parâmetro opcional usado para identificar a chave. A inclusão de criança depende do seu caso de uso.

{
  "alg": "RS256", // allow [HS256,RS256,ES256]
  "typ": "JWT", // Specific Type Of token
  "kid": "12345" // Used to indicate which key was used to sign 
the JWT. This is particularly useful when multiple keys are in use
}

Carga útil - Em carga útil, especificamos alguns dados personalizados, principalmente adicionamos dados específicos do usuário à carga útil, como ID do usuário e função.

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}

Assinatura - A assinatura é gerada codificando o cabeçalho e a carga útil com uma chave secreta (para HS256) ou assinando-os com uma chave privada (para RSA) e, em seguida, fazendo hash do resultado. Esta assinatura é usada para verificar o token.

Como o token é criado

Como discutimos, um JWT tem três componentes: o cabeçalho, a carga útil e a assinatura. Fornecemos o cabeçalho e a carga útil, e a assinatura é gerada a partir deles. Após combinar todos esses componentes, criamos o token.

// Header Encoding
Base64Url Encode({
  "alg": "RS256",
  "typ": "JWT"
}) → eyJhbGciOiAiUlMyNTYiLCAidHlwIjogIkpXVCJ9


// Payload Encoding
Base64Url Encode({
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022
}) → eyJzdWIiOiAiMTIzNDU2Nzg5MCIsICJuYW1lIjogIkpvaG4gRG9lIiwgImlhdCI6IDE1MTYyMzkwMjJ9


// Concatenate Encoded header and payload
ConcatenatedHash =  Base64Url Encode(Header)   "."   Base64Url Encode(Payload)

//Create Signature
Hash = SHA-256(ConcatenatedHash)
Signature = RSA Sign(Hash with Private Key) or HS256 Sign(Hash with secrate)

// Create Token
Token = Base64UrlEncode(Header)  "."  Base64UrlEncode(Payload)  "."  Signature

Portanto, o processo para criar um JWT é o seguinte: codificamos a carga útil e os cabeçalhos e, em seguida, geramos a assinatura a partir deles.

Verificando tokens JWT

Anteriormente, discutimos como criar um JWT. Agora, vamos discutir como verificar um JWT. O processo de verificação é essencialmente o inverso da criação do token. Primeiro, descriptografamos o token usando uma chave secreta ou pública. Em seguida, concatenamos o cabeçalho e a carga útil para gerar uma assinatura. Se o hash gerado corresponder à assinatura, o token é válido; caso contrário, não é válido.

// Token we recive in this formate
Token = Base64UrlEncode(Header)  "."  Base64UrlEncode(Payload)  "."  Signature

// Decrypt Signature
TokenHash = RSA Decrypt(Hash with Public Key) or HS256 Sign(Hash with secrate)

// Generate Hash From Encoded Header and Payload
Hash = SHA-256(Base64UrlEncode(Header)  "."  Base64UrlEncode(Payload))

// Compare Hash
if(TokenHash == Hash) "Valid"
else "Not Valid"

Benefícios de usar JWT

1. Segurança - JWTs são assinados digitalmente, garantindo a integridade e autenticidade dos dados
2. Compacto - JWTs são pequenos em tamanho, tornando-os eficientes para transmissão pela rede.
3. Autocontido - JWTs contêm todas as informações necessárias sobre o usuário, reduzindo a necessidade de consultar o banco de dados várias vezes.

JWT oferece todos os benefícios acima, tornando-o uma escolha popular para a maioria dos mecanismos de autenticação para autorizar usuários. Além disso, o JWT pode ser usado com diversas técnicas de autenticação, como DPoP e outras.

Como usar JWT em seu código

Para usar JWT no código, utilizamos o pacote jsonwebtoken npm. Existem dois métodos para trabalhar com JWTs: o método simples usando uma chave secreta e o método de par de chaves (usando chaves públicas e privadas).

Usando segredo

import jwt from 'jsonwebtoken';

// Define the type for the payload
interface Payload {
  userId: number;
  username: string;
}

// Secret key for signing the JWT
const secretKey: string = 'your-very-secure-secret';

// Payload to be included in the JWT
const payload: Payload = {
  userId: 123,
  username: 'exampleUser'
};

// Sign the JWT
const token: string = jwt.sign(payload, secretKey, { expiresIn: '1h' });
console.log('Generated Token:', token);

import jwt from 'jsonwebtoken';

// Secret key for signing the JWT
const secretKey: string = 'your-very-secure-secret';

// Verify the JWT
try {
  const decoded = jwt.verify(token, secretKey) as Payload;
  console.log('Decoded Payload:', decoded);
} catch (err) {
  console.error('Token verification failed:', (err as Error).message);
}

Usando o método KeyPair

import * as jwt from 'jsonwebtoken';
import { readFileSync } from 'fs';

// Load your RSA private key
const privateKey = readFileSync('private_key.pem', 'utf8');

// Define your payload
const payload = {
  sub: '1234567890',
  name: 'John Doe',
  iat: Math.floor(Date.now() / 1000) // Issued at
};

// Define JWT sign options
const signOptions: jwt.SignOptions = {
  algorithm: 'RS256',
  expiresIn: '1h' // Token expiration time
};

// Generate the JWT
const token = jwt.sign(payload, privateKey, signOptions);
console.log('Generated JWT:', token);

import * as jwt from 'jsonwebtoken';
import { readFileSync } from 'fs';

// Load your RSA public key
const publicKey = readFileSync('public_key.pem', 'utf8');

// Define JWT verify options
const verifyOptions: jwt.VerifyOptions = {
  algorithms: ['RS256'] // Specify the algorithm used
};

try {
  // Verify the JWT
  const decoded = jwt.verify(token, publicKey, verifyOptions) as jwt.JwtPayload;

  console.log('Decoded Payload:', decoded);
} catch (error) {
  console.error('Error verifying token:', error);
}

Conclusão

Em resumo, JSON Web Tokens (JWTs) transmitem informações com segurança entre as partes usando um formato compacto. A assinatura e verificação RSA envolvem o uso de uma chave privada para assinatura e uma chave pública para verificação. Os exemplos TypeScript ilustram a geração de um JWT com uma chave RSA privada e a verificação dele com uma chave RSA pública, garantindo autenticação segura baseada em token e integridade de dados.