123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192
import { encode, decode } from "./deps.ts";
function rotl(x: number, n: number): number {  return (x << n) | (x >>> (32 - n));}
/** Byte length of a SHA1 digest. */export const BYTES: number = 20;
/**  A class representation of the SHA1 algorithm. */export class SHA1 {  readonly hashSize: number = BYTES;
  private _buf: Uint8Array = new Uint8Array(64);  private _bufIdx!: number;  private _count!: Uint32Array;  private _K: Uint32Array = new Uint32Array([0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6]);  private _H!: Uint32Array;  private _finalized!: boolean;
  /** Creates a SHA1 instance. */  constructor() {    this.init();  }
  /** Reduces the four input numbers to a single one. */  protected static F(t: number, b: number, c: number, d: number): number {    if (t <= 19) {      return (b & c) | (~b & d);    } else if (t <= 39) {      return b ^ c ^ d;    } else if (t <= 59) {      return (b & c) | (b & d) | (c & d);    } else {      return b ^ c ^ d;    }  }
  /** Initializes a hash instance. */  init(): SHA1 {    // prettier-ignore    this._H = new Uint32Array([      0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0    ]);
    this._bufIdx = 0;    this._count = new Uint32Array(2);    this._buf.fill(0);    this._finalized = false;
    return this;  }
  /** Updates a hash with additional message data. */  update(msg: string | Uint8Array, inputEncoding?: string): SHA1 {    if (msg === null) {      throw new TypeError("msg must be a string or Uint8Array.");    } else if (typeof msg === "string") {      msg = encode(msg, inputEncoding) as Uint8Array;    }
    // process the msg as many times as possible, the rest is stored in the buffer    // message is processed in 512 bit (64 byte chunks)    for (let i: number = 0; i < msg.length; i++) {      this._buf[this._bufIdx++] = msg[i];      if (this._bufIdx === 64) {        this.transform();        this._bufIdx = 0;      }    }
    // counter update (number of message bits)    const c: Uint32Array = this._count;
    if ((c[0] += msg.length << 3) < msg.length << 3) {      c[1]++;    }
    c[1] += msg.length >>> 29;
    return this;  }
  /** Finalizes a hash with additional message data. */  digest(outputEncoding?: string): string | Uint8Array {    if (this._finalized) {      throw new Error("digest has already been called.")    }
    this._finalized = true;
    // append '1'    const b: Uint8Array = this._buf;    let idx: number = this._bufIdx;    b[idx++] = 0x80;
    // zeropad up to byte pos 56    while (idx !== 56) {      if (idx === 64) {        this.transform();        idx = 0;      }      b[idx++] = 0;    }
    // append length in bits    const c: Uint32Array = this._count;
    b[56] = (c[1] >>> 24) & 0xff;    b[57] = (c[1] >>> 16) & 0xff;    b[58] = (c[1] >>> 8) & 0xff;    b[59] = (c[1] >>> 0) & 0xff;    b[60] = (c[0] >>> 24) & 0xff;    b[61] = (c[0] >>> 16) & 0xff;    b[62] = (c[0] >>> 8) & 0xff;    b[63] = (c[0] >>> 0) & 0xff;
    this.transform();
    // return the hash as byte array (20 bytes)    const hash: Uint8Array = new Uint8Array(BYTES);
    for (let i: number = 0; i < 5; i++) {      hash[(i << 2) + 0] = (this._H[i] >>> 24) & 0xff;      hash[(i << 2) + 1] = (this._H[i] >>> 16) & 0xff;      hash[(i << 2) + 2] = (this._H[i] >>> 8) & 0xff;      hash[(i << 2) + 3] = (this._H[i] >>> 0) & 0xff;    }
    // clear internal states and prepare for new hash    this.init();
    return outputEncoding ? decode(hash, outputEncoding) : hash;  }
  /** Performs one transformation cycle. */  private transform(): void {    const h: Uint32Array = this._H;    let a: number = h[0];    let b: number = h[1];    let c: number = h[2];    let d: number = h[3];    let e: number = h[4];
    // convert byte buffer to words    const w: Uint32Array = new Uint32Array(80);
    for (let i: number = 0; i < 16; i++) {      w[i] =        this._buf[(i << 2) + 3] |        (this._buf[(i << 2) + 2] << 8) |        (this._buf[(i << 2) + 1] << 16) |        (this._buf[i << 2] << 24);    }
    for (let t: number = 0; t < 80; t++) {      if (t >= 16) {        w[t] = rotl(w[t - 3] ^ w[t - 8] ^ w[t - 14] ^ w[t - 16], 1);      }
      const tmp: number =        (rotl(a, 5) +          SHA1.F(t, b, c, d) +          e +          w[t] +          this._K[Math.floor(t / 20)]) |        0;
      e = d;      d = c;      c = rotl(b, 30);      b = a;      a = tmp;    }
    h[0] = (h[0] + a) | 0;    h[1] = (h[1] + b) | 0;    h[2] = (h[2] + c) | 0;    h[3] = (h[3] + d) | 0;    h[4] = (h[4] + e) | 0;  }}
/** Generates a SHA1 hash of the input data. */export function sha1(  msg: string | Uint8Array,  inputEncoding?: string,  outputEncoding?: string): string | Uint8Array {  return new SHA1().update(msg, inputEncoding).digest(outputEncoding);}