@yielded/crypto 0.0.0-stage → 0.1.0-beta.19

package/src/internal/common.ts

@@ -0,0 +1,44 @@
+import { Effect, Predicate, Redacted, Schema } from "effect";
+
+import { CryptoUnavailable, InvalidInput, UnsupportedAlgorithm } from "../Errors";
+
+export const decode = <A>(schema: Schema.Codec<A, A>, input: A, reason: InvalidInput["reason"]) =>
+  // Erased Redacted values can defect during Schema decoding. Keep decoder
+  // construction and evaluation inside the typed, secret-safe input boundary.
+  Effect.suspend(() => Schema.decodeEffect(schema)(input)).pipe(
+    Effect.mapError(() => InvalidInput.make({ reason })),
+    Effect.catchDefect(() => InvalidInput.make({ reason })),
+  );
+
+export const nativeErrorName = (cause: unknown): string | undefined =>
+  Predicate.hasProperty(cause, "name") && Predicate.isString(cause.name) ? cause.name : undefined;
+
+export const nativeError = (cause: unknown) =>
+  nativeErrorName(cause) === "NotSupportedError"
+    ? UnsupportedAlgorithm.make({})
+    : CryptoUnavailable.make({});
+
+export const importError = (cause: unknown) =>
+  nativeErrorName(cause) === "DataError" || nativeErrorName(cause) === "SyntaxError"
+    ? InvalidInput.make({ reason: "key" })
+    : nativeError(cause);
+
+/** Own a secret copy through cleanup. Native users must join work that cannot be cancelled. */
+export const withSecret = <A, E, R>(
+  value: Redacted.Redacted<Uint8Array>,
+  use: (owned: Uint8Array<ArrayBuffer>) => Effect.Effect<A, E, R>,
+) =>
+  Effect.acquireUseRelease(
+    Effect.try({
+      try: () => new Uint8Array(Redacted.value(value)),
+      catch: () => InvalidInput.make({ reason: "data" }),
+    }),
+    use,
+    (owned) => Effect.sync(() => owned.fill(0)),
+  );
+
+export const copy = (value: Uint8Array) =>
+  Effect.try({
+    try: () => new Uint8Array(value),
+    catch: () => InvalidInput.make({ reason: "data" }),
+  });

package/src/internal/hmac.ts

@@ -0,0 +1,111 @@
+import { Effect, Exit, Fiber, Redacted, Schema, Scope } from "effect";
+
+import { CryptoUnavailable } from "../Errors";
+import { Hmac, Input, type Key, KeyInput, VerifyInput } from "../Hmac";
+import { copy, decode, importError, nativeError, withSecret } from "./common";
+
+const keyBytes = Schema.Uint8Array.check(Schema.isMinLength(1));
+
+export const makeHmac = (subtle: SubtleCrypto): Hmac["Service"] => {
+  const importKey = Effect.fnUntraced(function* (input: KeyInput) {
+    const value = yield* decode(KeyInput, input, "key");
+
+    yield* decode(keyBytes, Redacted.value(value.key), "key");
+
+    // A sequential child joins every native call before dropping the key, even
+    // when the caller's Scope runs its other finalizers in parallel.
+    const scope = yield* Scope.fork(yield* Effect.scope, "sequential");
+    let imported: CryptoKey | undefined;
+
+    yield* Scope.addFinalizer(
+      scope,
+      Effect.sync(() => {
+        imported = undefined;
+      }),
+    );
+
+    const available = Effect.suspend(() =>
+      scope.state._tag === "Closed" ? Effect.fail(CryptoUnavailable.make({})) : Effect.void,
+    );
+
+    const run = <A, E>(operation: Effect.Effect<A, E>) =>
+      Effect.acquireUseRelease(
+        available.pipe(Effect.andThen(Effect.forkIn(operation, scope, { uninterruptible: false }))),
+        (fiber) =>
+          Effect.gen(function* () {
+            const exit = yield* Fiber.await(fiber);
+
+            yield* available;
+
+            return yield* exit;
+          }),
+        Fiber.interrupt,
+      );
+
+    yield* run(
+      withSecret(value.key, (material) =>
+        Effect.tryPromise({
+          try: () =>
+            subtle.importKey("raw", material, { name: "HMAC", hash: value.algorithm }, false, [
+              "sign",
+              "verify",
+            ]),
+          catch: importError,
+        }).pipe(
+          Effect.tap((key) =>
+            Effect.sync(() => {
+              imported = key;
+            }),
+          ),
+          Effect.uninterruptible,
+        ),
+      ),
+    ).pipe(
+      Effect.onExit((exit) => (Exit.isFailure(exit) ? Scope.close(scope, exit) : Effect.void)),
+    );
+
+    const use = <A>(operation: (key: CryptoKey) => Promise<A>) =>
+      run(
+        Effect.suspend(() => {
+          const key = imported;
+
+          return key === undefined
+            ? Effect.fail(CryptoUnavailable.make({}))
+            : Effect.tryPromise({ try: () => operation(key), catch: nativeError });
+        }).pipe(Effect.uninterruptible),
+      );
+
+    return {
+      sign: Effect.fnUntraced(function* (input) {
+        const data = yield* decode(Schema.Uint8Array, input, "data").pipe(Effect.flatMap(copy));
+
+        return new Uint8Array(yield* use((key) => subtle.sign("HMAC", key, data)));
+      }),
+      verify: Effect.fnUntraced(function* (input, signature) {
+        const data = yield* decode(Schema.Uint8Array, input, "data").pipe(Effect.flatMap(copy));
+        const tag = yield* decode(Schema.Uint8Array, signature, "data").pipe(Effect.flatMap(copy));
+
+        return yield* use((key) => subtle.verify("HMAC", key, tag, data));
+      }),
+    } satisfies Key;
+  });
+
+  return Hmac.of({
+    importKey,
+    sign: Effect.fnUntraced(function* (input) {
+      const value = yield* decode(Input, input, "data");
+      const data = yield* copy(value.data);
+      const key = yield* importKey(value);
+
+      return yield* key.sign(data);
+    }, Effect.scoped),
+    verify: Effect.fnUntraced(function* (input) {
+      const value = yield* decode(VerifyInput, input, "data");
+      const data = yield* copy(value.data);
+      const tag = yield* copy(value.tag);
+      const key = yield* importKey(value);
+
+      return yield* key.verify(data, tag);
+    }, Effect.scoped),
+  });
+};

package/src/internal/kdf.ts

@@ -0,0 +1,150 @@
+import { Effect, Redacted, Schema } from "effect";
+
+import { InvalidInput, type OperationError, UnsupportedAlgorithm } from "../Errors";
+import { Argon2idInput, HkdfInput, Kdf, type Limits, Pbkdf2Input } from "../Kdf";
+import { KdfAdmission } from "../KdfAdmission";
+import { copy, decode, importError, nativeError, withSecret } from "./common";
+
+export interface Argon2Parameters {
+  readonly password: Uint8Array<ArrayBuffer>;
+  readonly salt: Uint8Array<ArrayBuffer>;
+  readonly memoryKiB: number;
+  readonly passes: number;
+  readonly parallelism: number;
+  readonly length: number;
+  readonly secret?: Uint8Array<ArrayBuffer>;
+  readonly associatedData: Uint8Array<ArrayBuffer>;
+}
+
+export type Argon2 = (input: Argon2Parameters) => Effect.Effect<Uint8Array, OperationError>;
+
+export const makeKdf = Effect.fnUntraced(function* (
+  subtle: SubtleCrypto,
+  limits: Limits,
+  argon2?: Argon2,
+) {
+  const admission = yield* KdfAdmission;
+  const boundedBytes = Schema.Uint8Array.check(Schema.isMaxLength(limits.maximumInputBytes));
+
+  const output = Schema.Int.check(
+    Schema.isBetween({ minimum: 1, maximum: limits.maximumOutputBytes }),
+  );
+
+  const inputBytes = (input: Uint8Array) => decode(boundedBytes, input, "data");
+  const outputLength = (input: number) => decode(output, input, "parameters");
+
+  return Kdf.of({
+    pbkdf2: (input) =>
+      admission.run(
+        Effect.gen(function* () {
+          const value = yield* decode(Pbkdf2Input, input, "parameters");
+
+          yield* decode(
+            Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: limits.maximumIterations })),
+            value.iterations,
+            "parameters",
+          );
+          yield* outputLength(value.length);
+          yield* inputBytes(Redacted.value(value.password));
+          yield* inputBytes(value.salt);
+          const salt = yield* copy(value.salt);
+
+          return yield* withSecret(value.password, (password) =>
+            Effect.gen(function* () {
+              const key = yield* Effect.tryPromise({
+                try: () => subtle.importKey("raw", password, "PBKDF2", false, ["deriveBits"]),
+                catch: importError,
+              });
+
+              const result = yield* Effect.tryPromise({
+                try: () =>
+                  subtle.deriveBits(
+                    { name: "PBKDF2", hash: "SHA-256", salt, iterations: value.iterations },
+                    key,
+                    value.length * 8,
+                  ),
+                catch: nativeError,
+              });
+
+              return Redacted.make(new Uint8Array(result));
+            }).pipe(Effect.uninterruptible),
+          );
+        }),
+      ),
+    hkdf: (input) =>
+      admission.run(
+        Effect.gen(function* () {
+          const value = yield* decode(HkdfInput, input, "parameters");
+
+          yield* outputLength(value.length);
+          yield* inputBytes(Redacted.value(value.key));
+          yield* inputBytes(value.salt);
+          yield* inputBytes(value.info);
+          const salt = yield* copy(value.salt);
+          const info = yield* copy(value.info);
+
+          return yield* withSecret(value.key, (material) =>
+            Effect.gen(function* () {
+              const key = yield* Effect.tryPromise({
+                try: () => subtle.importKey("raw", material, "HKDF", false, ["deriveBits"]),
+                catch: importError,
+              });
+
+              const result = yield* Effect.tryPromise({
+                try: () =>
+                  subtle.deriveBits(
+                    { name: "HKDF", hash: "SHA-256", salt, info },
+                    key,
+                    value.length * 8,
+                  ),
+                catch: nativeError,
+              });
+
+              return Redacted.make(new Uint8Array(result));
+            }).pipe(Effect.uninterruptible),
+          );
+        }),
+      ),
+    argon2id: (input) =>
+      admission.run(
+        Effect.gen(function* () {
+          const value = yield* decode(Argon2idInput, input, "parameters");
+
+          yield* outputLength(value.length);
+          yield* inputBytes(Redacted.value(value.password));
+          yield* inputBytes(value.salt);
+          if (value.secret !== undefined) yield* inputBytes(Redacted.value(value.secret));
+          if (value.associatedData !== undefined) yield* inputBytes(value.associatedData);
+
+          if (
+            value.memoryKiB < 8 * value.parallelism ||
+            value.memoryKiB > limits.maximumMemoryKiB ||
+            value.passes > limits.maximumPasses ||
+            value.parallelism > limits.maximumParallelism ||
+            value.memoryKiB * value.passes > limits.maximumMemoryPasses
+          )
+            return yield* InvalidInput.make({ reason: "parameters" });
+          if (argon2 === undefined) return yield* UnsupportedAlgorithm.make({});
+
+          const salt = yield* copy(value.salt);
+          const associatedData = yield* copy(value.associatedData ?? new Uint8Array());
+
+          return yield* withSecret(value.password, (password) => {
+            const derive = (secret?: Uint8Array<ArrayBuffer>) =>
+              argon2({
+                password,
+                salt,
+                ...(secret === undefined ? {} : { secret }),
+                associatedData,
+                memoryKiB: value.memoryKiB,
+                passes: value.passes,
+                parallelism: value.parallelism,
+                length: value.length,
+              }).pipe(Effect.map((bytes) => Redacted.make(bytes)));
+
+            return value.secret === undefined ? derive() : withSecret(value.secret, derive);
+          });
+        }),
+      ),
+  });
+});

package/src/internal/layer.ts

@@ -0,0 +1,32 @@
+import { Context, Effect, Layer } from "effect";
+
+import { Aead } from "../Aead";
+import { Hmac } from "../Hmac";
+import { defaultLimits, Kdf, Limits } from "../Kdf";
+import { Signature } from "../Signature";
+import { makeAead, type XChaCha } from "./aead";
+import { decode } from "./common";
+import { makeHmac } from "./hmac";
+import { type Argon2, makeKdf } from "./kdf";
+import { makeSignature } from "./signature";
+
+export const makeLayer = (
+  subtle: SubtleCrypto,
+  input: Partial<Limits>,
+  extensions: { readonly argon2?: Argon2; readonly xchacha?: XChaCha } = {},
+) => {
+  const snapshot = { ...defaultLimits, ...input };
+
+  return Layer.effectContext(
+    Effect.gen(function* () {
+      const limits = yield* decode(Limits, snapshot, "parameters");
+      const kdf = yield* makeKdf(subtle, limits, extensions.argon2);
+
+      return Context.make(Aead, makeAead(subtle, extensions.xchacha)).pipe(
+        Context.add(Hmac, makeHmac(subtle)),
+        Context.add(Kdf, kdf),
+        Context.add(Signature, makeSignature(subtle)),
+      );
+    }),
+  );
+};

package/src/internal/node.ts

@@ -0,0 +1,46 @@
+import * as crypto from "node:crypto";
+
+import { Effect, Result } from "effect";
+
+import { CryptoUnavailable, UnsupportedAlgorithm } from "../Errors";
+import type { Limits } from "../Kdf";
+import type { Argon2, Argon2Parameters } from "./kdf";
+import { makeLayer } from "./layer";
+import { xchacha } from "./xchacha";
+
+const argon2: Argon2 = Effect.fnUntraced(function* (input: Argon2Parameters) {
+  // Namespace import keeps this module loadable on Node versions without Argon2.
+  if (typeof crypto.argon2 !== "function") return yield* UnsupportedAlgorithm.make({});
+
+  // Node cannot cancel this work. Keep borrowed buffers and admission until the
+  // callback completes, including when its caller has requested interruption.
+  return yield* Effect.callback<Uint8Array, CryptoUnavailable>((resume) => {
+    const registration = Result.try({
+      try: () =>
+        crypto.argon2(
+          "argon2id",
+          {
+            message: input.password,
+            nonce: input.salt,
+            parallelism: input.parallelism,
+            memory: input.memoryKiB,
+            passes: input.passes,
+            tagLength: input.length,
+            secret: input.secret,
+            associatedData: input.associatedData,
+          },
+          (error, key) =>
+            resume(error === null ? Effect.succeed(key) : Effect.fail(CryptoUnavailable.make({}))),
+        ),
+      catch: () => CryptoUnavailable.make({}),
+    });
+
+    if (Result.isFailure(registration)) resume(Effect.fail(registration.failure));
+  }).pipe(Effect.uninterruptible);
+});
+
+/** Node-compatible WebCrypto/Argon2id with the portable XChaCha20-Poly1305 extension. */
+export const layer = (limits: Partial<Limits> = {}) =>
+  // Node's declarations include additional key usages absent from lib.dom. The
+  // standard operations used here share the WebCrypto ABI; no payload is cast.
+  makeLayer(crypto.webcrypto.subtle as SubtleCrypto, limits, { argon2, xchacha });

package/src/internal/poly1305.ts

@@ -0,0 +1,289 @@
+/**
+ * Adapted from noble-ciphers, Copyright (c) 2022 Paul Miller.
+ * MIT; source revision 785181b0772ba84afbe812025714163e4e48262f.
+ * Poly1305 arithmetic derives from the public-domain poly1305-donna implementation.
+ * See ../../THIRD_PARTY_NOTICES.md for source mapping and licenses.
+ */
+function u8to16(a: Uint8Array, i: number) {
+  return (a[i++] & 0xff) | ((a[i++] & 0xff) << 8);
+}
+
+export class Poly1305 {
+  readonly blockLen = 16;
+  readonly outputLen = 16;
+  private buffer = new Uint8Array(16);
+  private r = new Uint16Array(10);
+  private h = new Uint16Array(10);
+  private pad = new Uint16Array(8);
+  private pos = 0;
+
+  constructor(key: Uint8Array) {
+    const t0 = u8to16(key, 0);
+    const t1 = u8to16(key, 2);
+    const t2 = u8to16(key, 4);
+    const t3 = u8to16(key, 6);
+    const t4 = u8to16(key, 8);
+    const t5 = u8to16(key, 10);
+    const t6 = u8to16(key, 12);
+    const t7 = u8to16(key, 14);
+
+    // https://github.com/floodyberry/poly1305-donna/blob/e6ad6e091d30d7f4ec2d4f978be1fcfcbce72781/poly1305-donna-16.h#L47
+    this.r[0] = t0 & 0x1fff;
+    this.r[1] = ((t0 >>> 13) | (t1 << 3)) & 0x1fff;
+    this.r[2] = ((t1 >>> 10) | (t2 << 6)) & 0x1f03;
+    this.r[3] = ((t2 >>> 7) | (t3 << 9)) & 0x1fff;
+    this.r[4] = ((t3 >>> 4) | (t4 << 12)) & 0x00ff;
+    this.r[5] = (t4 >>> 1) & 0x1ffe;
+    this.r[6] = ((t4 >>> 14) | (t5 << 2)) & 0x1fff;
+    this.r[7] = ((t5 >>> 11) | (t6 << 5)) & 0x1f81;
+    this.r[8] = ((t6 >>> 8) | (t7 << 8)) & 0x1fff;
+    this.r[9] = (t7 >>> 5) & 0x007f;
+    for (let i = 0; i < 8; i++) this.pad[i] = u8to16(key, 16 + 2 * i);
+  }
+
+  private process(data: Uint8Array, offset: number, isLast = false) {
+    const hibit = isLast ? 0 : 1 << 11;
+    const { h, r } = this;
+    const r0 = r[0];
+    const r1 = r[1];
+    const r2 = r[2];
+    const r3 = r[3];
+    const r4 = r[4];
+    const r5 = r[5];
+    const r6 = r[6];
+    const r7 = r[7];
+    const r8 = r[8];
+    const r9 = r[9];
+
+    const t0 = u8to16(data, offset + 0);
+    const t1 = u8to16(data, offset + 2);
+    const t2 = u8to16(data, offset + 4);
+    const t3 = u8to16(data, offset + 6);
+    const t4 = u8to16(data, offset + 8);
+    const t5 = u8to16(data, offset + 10);
+    const t6 = u8to16(data, offset + 12);
+    const t7 = u8to16(data, offset + 14);
+
+    let h0 = h[0] + (t0 & 0x1fff);
+    let h1 = h[1] + (((t0 >>> 13) | (t1 << 3)) & 0x1fff);
+    let h2 = h[2] + (((t1 >>> 10) | (t2 << 6)) & 0x1fff);
+    let h3 = h[3] + (((t2 >>> 7) | (t3 << 9)) & 0x1fff);
+    let h4 = h[4] + (((t3 >>> 4) | (t4 << 12)) & 0x1fff);
+    let h5 = h[5] + ((t4 >>> 1) & 0x1fff);
+    let h6 = h[6] + (((t4 >>> 14) | (t5 << 2)) & 0x1fff);
+    let h7 = h[7] + (((t5 >>> 11) | (t6 << 5)) & 0x1fff);
+    let h8 = h[8] + (((t6 >>> 8) | (t7 << 8)) & 0x1fff);
+    let h9 = h[9] + ((t7 >>> 5) | hibit);
+
+    let c = 0;
+
+    let d0 = c + h0 * r0 + h1 * (5 * r9) + h2 * (5 * r8) + h3 * (5 * r7) + h4 * (5 * r6);
+
+    c = d0 >>> 13;
+    d0 &= 0x1fff;
+    d0 += h5 * (5 * r5) + h6 * (5 * r4) + h7 * (5 * r3) + h8 * (5 * r2) + h9 * (5 * r1);
+    c += d0 >>> 13;
+    d0 &= 0x1fff;
+
+    let d1 = c + h0 * r1 + h1 * r0 + h2 * (5 * r9) + h3 * (5 * r8) + h4 * (5 * r7);
+
+    c = d1 >>> 13;
+    d1 &= 0x1fff;
+    d1 += h5 * (5 * r6) + h6 * (5 * r5) + h7 * (5 * r4) + h8 * (5 * r3) + h9 * (5 * r2);
+    c += d1 >>> 13;
+    d1 &= 0x1fff;
+
+    let d2 = c + h0 * r2 + h1 * r1 + h2 * r0 + h3 * (5 * r9) + h4 * (5 * r8);
+
+    c = d2 >>> 13;
+    d2 &= 0x1fff;
+    d2 += h5 * (5 * r7) + h6 * (5 * r6) + h7 * (5 * r5) + h8 * (5 * r4) + h9 * (5 * r3);
+    c += d2 >>> 13;
+    d2 &= 0x1fff;
+
+    let d3 = c + h0 * r3 + h1 * r2 + h2 * r1 + h3 * r0 + h4 * (5 * r9);
+
+    c = d3 >>> 13;
+    d3 &= 0x1fff;
+    d3 += h5 * (5 * r8) + h6 * (5 * r7) + h7 * (5 * r6) + h8 * (5 * r5) + h9 * (5 * r4);
+    c += d3 >>> 13;
+    d3 &= 0x1fff;
+
+    let d4 = c + h0 * r4 + h1 * r3 + h2 * r2 + h3 * r1 + h4 * r0;
+
+    c = d4 >>> 13;
+    d4 &= 0x1fff;
+    d4 += h5 * (5 * r9) + h6 * (5 * r8) + h7 * (5 * r7) + h8 * (5 * r6) + h9 * (5 * r5);
+    c += d4 >>> 13;
+    d4 &= 0x1fff;
+
+    let d5 = c + h0 * r5 + h1 * r4 + h2 * r3 + h3 * r2 + h4 * r1;
+
+    c = d5 >>> 13;
+    d5 &= 0x1fff;
+    d5 += h5 * r0 + h6 * (5 * r9) + h7 * (5 * r8) + h8 * (5 * r7) + h9 * (5 * r6);
+    c += d5 >>> 13;
+    d5 &= 0x1fff;
+
+    let d6 = c + h0 * r6 + h1 * r5 + h2 * r4 + h3 * r3 + h4 * r2;
+
+    c = d6 >>> 13;
+    d6 &= 0x1fff;
+    d6 += h5 * r1 + h6 * r0 + h7 * (5 * r9) + h8 * (5 * r8) + h9 * (5 * r7);
+    c += d6 >>> 13;
+    d6 &= 0x1fff;
+
+    let d7 = c + h0 * r7 + h1 * r6 + h2 * r5 + h3 * r4 + h4 * r3;
+
+    c = d7 >>> 13;
+    d7 &= 0x1fff;
+    d7 += h5 * r2 + h6 * r1 + h7 * r0 + h8 * (5 * r9) + h9 * (5 * r8);
+    c += d7 >>> 13;
+    d7 &= 0x1fff;
+
+    let d8 = c + h0 * r8 + h1 * r7 + h2 * r6 + h3 * r5 + h4 * r4;
+
+    c = d8 >>> 13;
+    d8 &= 0x1fff;
+    d8 += h5 * r3 + h6 * r2 + h7 * r1 + h8 * r0 + h9 * (5 * r9);
+    c += d8 >>> 13;
+    d8 &= 0x1fff;
+
+    let d9 = c + h0 * r9 + h1 * r8 + h2 * r7 + h3 * r6 + h4 * r5;
+
+    c = d9 >>> 13;
+    d9 &= 0x1fff;
+    d9 += h5 * r4 + h6 * r3 + h7 * r2 + h8 * r1 + h9 * r0;
+    c += d9 >>> 13;
+    d9 &= 0x1fff;
+
+    c = ((c << 2) + c) | 0;
+    c = (c + d0) | 0;
+    d0 = c & 0x1fff;
+    c = c >>> 13;
+    d1 += c;
+
+    h[0] = d0;
+    h[1] = d1;
+    h[2] = d2;
+    h[3] = d3;
+    h[4] = d4;
+    h[5] = d5;
+    h[6] = d6;
+    h[7] = d7;
+    h[8] = d8;
+    h[9] = d9;
+  }
+
+  private finalize() {
+    const { h, pad } = this;
+    const g = new Uint16Array(10);
+    let c = h[1] >>> 13;
+
+    h[1] &= 0x1fff;
+    for (let i = 2; i < 10; i++) {
+      h[i] += c;
+      c = h[i] >>> 13;
+      h[i] &= 0x1fff;
+    }
+    h[0] += c * 5;
+    c = h[0] >>> 13;
+    h[0] &= 0x1fff;
+    h[1] += c;
+    c = h[1] >>> 13;
+    h[1] &= 0x1fff;
+    h[2] += c;
+
+    g[0] = h[0] + 5;
+    c = g[0] >>> 13;
+    g[0] &= 0x1fff;
+    for (let i = 1; i < 10; i++) {
+      g[i] = h[i] + c;
+      c = g[i] >>> 13;
+      g[i] &= 0x1fff;
+    }
+    g[9] -= 1 << 13;
+
+    let mask = (c ^ 1) - 1;
+
+    for (let i = 0; i < 10; i++) g[i] &= mask;
+    mask = ~mask;
+    for (let i = 0; i < 10; i++) h[i] = (h[i] & mask) | g[i];
+    h[0] = (h[0] | (h[1] << 13)) & 0xffff;
+    h[1] = ((h[1] >>> 3) | (h[2] << 10)) & 0xffff;
+    h[2] = ((h[2] >>> 6) | (h[3] << 7)) & 0xffff;
+    h[3] = ((h[3] >>> 9) | (h[4] << 4)) & 0xffff;
+    h[4] = ((h[4] >>> 12) | (h[5] << 1) | (h[6] << 14)) & 0xffff;
+    h[5] = ((h[6] >>> 2) | (h[7] << 11)) & 0xffff;
+    h[6] = ((h[7] >>> 5) | (h[8] << 8)) & 0xffff;
+    h[7] = ((h[8] >>> 8) | (h[9] << 5)) & 0xffff;
+
+    let f = h[0] + pad[0];
+
+    h[0] = f & 0xffff;
+    for (let i = 1; i < 8; i++) {
+      f = (((h[i] + pad[i]) | 0) + (f >>> 16)) | 0;
+      h[i] = f & 0xffff;
+    }
+    g.fill(0);
+  }
+  update(data: Uint8Array): this {
+    const { buffer, blockLen } = this;
+    const len = data.length;
+
+    for (let pos = 0; pos < len;) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+
+      // Fast path: we have at least one block in input
+      if (take === blockLen) {
+        for (; blockLen <= len - pos; pos += blockLen) this.process(data, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(buffer, 0, false);
+        this.pos = 0;
+      }
+    }
+
+    return this;
+  }
+  destroy(): void {
+    this.h.fill(0);
+    this.r.fill(0);
+    this.buffer.fill(0);
+    this.pad.fill(0);
+    this.pos = 0;
+  }
+  digestInto(out: Uint8Array): Uint8Array {
+    const { buffer, h } = this;
+    let { pos } = this;
+
+    if (pos) {
+      buffer[pos++] = 1;
+      for (; pos < 16; pos++) buffer[pos] = 0;
+      this.process(buffer, 0, true);
+    }
+    this.finalize();
+    let opos = 0;
+
+    for (let i = 0; i < 8; i++) {
+      out[opos++] = h[i] >>> 0;
+      out[opos++] = h[i] >>> 8;
+    }
+
+    return out;
+  }
+  digest(): Uint8Array {
+    const { buffer, outputLen } = this;
+
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+
+    this.destroy();
+
+    return res;
+  }
+}