BearerAuthenticator.ts

import BaseAuthenticator from "./Base";
import {
  Algorithm,
  BearerAuthenticateOpts,
  BearerClassOptions,
  IBearerClass,
  Payload,
} from "../types/BearerAuthenticator";

class BearerAuthenticator extends BaseAuthenticator implements IBearerClass {
  private secret: string;
  readonly algorithm: Algorithm;

  constructor(options: BearerClassOptions) {
    super(options);
    this.secret = options.secret;
    this.algorithm = options.algorithm || { name: 'HMAC', hash: 'SHA-256', abbreviation: 'HS256' };
  }

  private base64UrlEncode(data: string): string {
    const base64 = btoa(data);
    return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
  }

  private base64UrlDecode(base64Url: string): string {
    let str: string = base64Url.replace(/-/g, '+').replace(/_/g, '/');
    while (str.length % 4) {
      str += '=';
    }
    return atob(str);
  }

  private async importKeyForAlgorithm(): Promise<CryptoKey> {
    return await crypto.subtle.importKey('raw', new TextEncoder().encode(this.secret), this.algorithm, true, ['sign', 'verify']);
  }

  private async signData(data: Uint8Array): Promise<ArrayBuffer> {
    const key = await this.importKeyForAlgorithm();
    return await crypto.subtle.sign(this.algorithm, key, data);
  }

  async verfy(token: string): Promise<boolean> {
    try {
      const [headerB64, payloadB64, signatureB64] = token.split('.');
      const header = JSON.parse(this.base64UrlDecode(headerB64));
      const signature = Uint8Array.from(this.base64UrlDecode(signatureB64), c => c.charCodeAt(0));

      if (header.alg !== this.algorithm.abbreviation) {
        throw new Error('Invalid algorithm');
      }

      const data = new TextEncoder().encode(`${headerB64}.${payloadB64}`);
      const valid = await crypto.subtle.verify(this.algorithm, await this.importKeyForAlgorithm(), signature, data);

      if (!valid) return false;

      const payload = JSON.parse(this.base64UrlDecode(payloadB64));
      const expiration = payload.exp;

      if (!expiration) return true;

      const currentTime = Math.floor(Date.now() / 1000);
      return expiration > currentTime;
    } catch (error) {
      console.error('Error during verification:', error);
      return false;
    }
  }

  getPayload(token: string): Record<string, any> {
    const [, payloadB64] = token.split('.');
    const payload = JSON.parse(this.base64UrlDecode(payloadB64));
    return payload;
  }

  getTokenFromRequest(request: Request): string | undefined {
    const authorization = request.headers.get('Authorization');
    if (!authorization || !authorization.startsWith('Bearer ')) return;

    const [, token] = authorization.split('Bearer ');
    return token;
  }

  async isAuthenticated({ request }: BearerAuthenticateOpts): Promise<boolean> {
    const token = this.getTokenFromRequest(request);
    if (!token) return false;

    return await this.verfy(token);
  }

  async sign<P extends Payload>(payload: P): Promise<string> {
    try {
      const header = {
        alg: this.algorithm.abbreviation,
        typ: 'JWT'
      };

      const encodedHeader = this.base64UrlEncode(JSON.stringify(header));
      const encodedPayload = this.base64UrlEncode(JSON.stringify(payload));

      const data = new TextEncoder().encode(`${encodedHeader}.${encodedPayload}`);
      const signature = await this.signData(data);
      const encodedSignature = this.base64UrlEncode(String.fromCharCode(...new Uint8Array(signature)));

      return `${encodedHeader}.${encodedPayload}.${encodedSignature}`;
    } catch (error) {
      console.error('Error during signing:', error);
      throw new Error('Failed to sign the payload.');
    }
  }
}

export default BearerAuthenticator;