shjwt/shjwt.test.js

The setHacked JWT module.

const { encode, decode } = require('./index');

describe("shJWT module", () => {
  let secret, payload, jwt;

  beforeEach(() => {
    secret = 'a_secure_and_long_secret_key_that_is_at_least_32_chars';
    payload = {
      user_id: 1,
      email: 'test@example.com',
      exp: Math.floor(Date.now() / 1000) + 3600 // Token expires in 1 hour
    };
    jwt = '';
  });

  it("should encode payload to jwt and decode jwt back to payload", async () => {
    jwt = await encode(payload, secret);
    expect(typeof jwt).toEqual('string');

    const decodedPayload = await decode(jwt, secret);
    expect(decodedPayload.user_id).toEqual(payload.user_id);
    expect(decodedPayload.email).toEqual(payload.email);
    expect(decodedPayload.exp).toEqual(payload.exp);
  });

  it("should throw an error when jwt signature is not valid", async () => {
    jwt = await encode(payload, secret);
    const forgedJwt = jwt.split('.');
    forgedJwt[2] = "tampered_signature"; // Tamper the signature
    const tamperedJwt = forgedJwt.join('.');

    await expect(decode(tamperedJwt, secret)).rejects.toThrow('Signature verification failed');
  });

  it("should throw an error when jwt is not well formatted", async () => {
    const badlyFormattedJwt = `justSome.Random.Strings`;
    await expect(decode(badlyFormattedJwt, secret)).rejects.toThrow('Invalid token format');
  });

  it("should throw an error for expired tokens", async () => {
    payload.exp = Math.floor(Date.now() / 1000) - 10; // Expired 10 seconds ago
    jwt = await encode(payload, secret);

    await expect(decode(jwt, secret)).rejects.toThrow('Token has expired');
  });

  it("should throw an error if secret key is too short", async () => {
    const shortSecret = 'short';
    await expect(encode(payload, shortSecret)).rejects.toThrow('Secret key must be at least 32 characters long');
    jwt = await encode(payload, secret);
    await expect(decode(jwt, shortSecret)).rejects.toThrow('Secret key must be at least 32 characters long');
  });

  it("should throw an error for unsupported algorithms", async () => {
    jwt = `${Buffer.from(JSON.stringify({ typ: 'JWT', alg: 'RS256' })).toString('base64url')}.${Buffer.from(JSON.stringify(payload)).toString('base64url')}.signature`;
    await expect(decode(jwt, secret)).rejects.toThrow('Unsupported algorithm');
  });
});