@oneuptime/common 12.0.13 → 12.0.14

package/Tests/Server/TestingUtils/AuthenticatorApp.ts

@@ -0,0 +1,248 @@
+import crypto from "crypto";
+
+/*
+ * A stand-in for the authenticator app on the user's phone.
+ *
+ * Every function here is derived from RFC 4648 (base32), RFC 4226 (HOTP) and
+ * RFC 6238 (TOTP) using Node's own crypto primitives. Nothing in this file
+ * imports `otpauth`, and that is the entire point: the server verifies with
+ * `otpauth`, so a test that also generates its expected codes with `otpauth`
+ * proves only that the library agrees with itself. It would have passed
+ * happily throughout issue #3275, while every user with Google Authenticator
+ * was locked out.
+ *
+ * The most useful thing in here is `googleAuthenticatorCode`, which models the
+ * behaviour that caused that bug: real phone apps parse the otpauth:// URI,
+ * IGNORE its `algorithm` parameter, and compute SHA1 regardless.
+ */
+
+const BASE32_ALPHABET: string = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
+export const DEFAULT_DIGITS: number = 6;
+export const DEFAULT_PERIOD_IN_SECONDS: number = 30;
+
+/** The algorithm a phone app uses no matter what the QR code claims. */
+export const PHONE_APP_ALGORITHM: string = "SHA1";
+
+export type Base32EncodeFunction = (bytes: Buffer) => string;
+
+export const base32Encode: Base32EncodeFunction = (bytes: Buffer): string => {
+  let bits: string = "";
+
+  for (const byte of bytes) {
+    bits += byte.toString(2).padStart(8, "0");
+  }
+
+  let output: string = "";
+
+  for (let i: number = 0; i < bits.length; i += 5) {
+    const chunk: string = bits.slice(i, i + 5).padEnd(5, "0");
+    output += BASE32_ALPHABET[parseInt(chunk, 2)];
+  }
+
+  return output;
+};
+
+export type Base32DecodeFunction = (encoded: string) => Buffer;
+
+export const base32Decode: Base32DecodeFunction = (encoded: string): Buffer => {
+  let bits: string = "";
+
+  for (const character of encoded.replace(/[=]+$/, "").toUpperCase()) {
+    const value: number = BASE32_ALPHABET.indexOf(character);
+
+    if (value === -1) {
+      throw new Error(`Not base32: ${character}`);
+    }
+
+    bits += value.toString(2).padStart(5, "0");
+  }
+
+  const bytes: Array<number> = [];
+
+  for (let i: number = 0; i + 8 <= bits.length; i += 8) {
+    bytes.push(parseInt(bits.slice(i, i + 8), 2));
+  }
+
+  return Buffer.from(bytes);
+};
+
+/*
+ * HOTP, RFC 4226 section 5.3: HMAC the 8-byte big-endian counter under the
+ * shared key, take the low nibble of the last byte as an offset, read a
+ * big-endian 31-bit integer from there, reduce modulo 10^digits.
+ */
+export type HotpFunction = (data: {
+  key: Buffer;
+  counter: number;
+  algorithm: string;
+  digits: number;
+}) => string;
+
+export const hotp: HotpFunction = (data: {
+  key: Buffer;
+  counter: number;
+  algorithm: string;
+  digits: number;
+}): string => {
+  const counterBytes: Buffer = Buffer.alloc(8);
+  counterBytes.writeBigUInt64BE(BigInt(data.counter));
+
+  const digest: Buffer = crypto
+    .createHmac(data.algorithm.toLowerCase(), data.key)
+    .update(counterBytes)
+    .digest();
+
+  const offset: number = digest[digest.length - 1]! & 0x0f;
+
+  const binary: number =
+    ((digest[offset]! & 0x7f) << 24) |
+    ((digest[offset + 1]! & 0xff) << 16) |
+    ((digest[offset + 2]! & 0xff) << 8) |
+    (digest[offset + 3]! & 0xff);
+
+  return (binary % 10 ** data.digits).toString().padStart(data.digits, "0");
+};
+
+/*
+ * TOTP: HOTP with the counter derived from the clock (RFC 6238 section 4).
+ */
+export type AuthenticatorCodeFunction = (data: {
+  secretBase32: string;
+  algorithm?: string | undefined;
+  digits?: number | undefined;
+  periodInSeconds?: number | undefined;
+  atUnixSeconds?: number | undefined;
+}) => string;
+
+export const authenticatorCode: AuthenticatorCodeFunction = (data: {
+  secretBase32: string;
+  algorithm?: string | undefined;
+  digits?: number | undefined;
+  periodInSeconds?: number | undefined;
+  atUnixSeconds?: number | undefined;
+}): string => {
+  const period: number = data.periodInSeconds || DEFAULT_PERIOD_IN_SECONDS;
+
+  const seconds: number =
+    data.atUnixSeconds === undefined
+      ? Math.floor(Date.now() / 1000)
+      : data.atUnixSeconds;
+
+  return hotp({
+    key: base32Decode(data.secretBase32),
+    counter: Math.floor(seconds / period),
+    algorithm: data.algorithm || PHONE_APP_ALGORITHM,
+    digits: data.digits === undefined ? DEFAULT_DIGITS : data.digits,
+  });
+};
+
+export type OtpauthUriParams = {
+  secret: string;
+  algorithm: string;
+  digits: number;
+  periodInSeconds: number;
+  issuer: string | null;
+};
+
+export type ParseOtpauthUriFunction = (uri: string) => OtpauthUriParams;
+
+export const parseOtpauthUri: ParseOtpauthUriFunction = (
+  uri: string,
+): OtpauthUriParams => {
+  const params: URLSearchParams = new URLSearchParams(
+    uri.slice(uri.indexOf("?") + 1),
+  );
+
+  return {
+    secret: params.get("secret") || "",
+    algorithm: params.get("algorithm") || PHONE_APP_ALGORITHM,
+    digits: parseInt(params.get("digits") || String(DEFAULT_DIGITS), 10),
+    periodInSeconds: parseInt(
+      params.get("period") || String(DEFAULT_PERIOD_IN_SECONDS),
+      10,
+    ),
+    issuer: params.get("issuer"),
+  };
+};
+
+/*
+ * What an app that honours every parameter in the URI shows — 1Password,
+ * Bitwarden, Aegis, FreeOTP.
+ */
+export type CodeFromUriFunction = (
+  uri: string,
+  atUnixSeconds?: number,
+) => string;
+
+export const conformingAppCode: CodeFromUriFunction = (
+  uri: string,
+  atUnixSeconds?: number,
+): string => {
+  const params: OtpauthUriParams = parseOtpauthUri(uri);
+
+  return authenticatorCode({
+    secretBase32: params.secret,
+    algorithm: params.algorithm,
+    digits: params.digits,
+    periodInSeconds: params.periodInSeconds,
+    atUnixSeconds: atUnixSeconds,
+  });
+};
+
+/*
+ * What Google Authenticator shows: the secret from the URI, but SHA1 whatever
+ * the URI says. This is the function that reproduces issue #3275 — hand it a
+ * SHA256 URI and the code it returns is the one the user typed in and the
+ * server rejected.
+ */
+export const googleAuthenticatorCode: CodeFromUriFunction = (
+  uri: string,
+  atUnixSeconds?: number,
+): string => {
+  const params: OtpauthUriParams = parseOtpauthUri(uri);
+
+  return authenticatorCode({
+    secretBase32: params.secret,
+    algorithm: PHONE_APP_ALGORITHM,
+    digits: params.digits,
+    periodInSeconds: params.periodInSeconds,
+    atUnixSeconds: atUnixSeconds,
+  });
+};
+
+/*
+ * The otpauth:// URI a server hands to a QR code, built by hand so a test can
+ * produce the exact shape the OLD OneUptime code used to emit.
+ */
+export type BuildOtpauthUriFunction = (data: {
+  secret: string;
+  label: string;
+  issuer?: string | undefined;
+  algorithm?: string | undefined;
+  digits?: number | undefined;
+  periodInSeconds?: number | undefined;
+}) => string;
+
+export const buildOtpauthUri: BuildOtpauthUriFunction = (data: {
+  secret: string;
+  label: string;
+  issuer?: string | undefined;
+  algorithm?: string | undefined;
+  digits?: number | undefined;
+  periodInSeconds?: number | undefined;
+}): string => {
+  const issuer: string = data.issuer || "OneUptime";
+
+  const query: string = [
+    `issuer=${encodeURIComponent(issuer)}`,
+    `secret=${data.secret}`,
+    `algorithm=${data.algorithm || PHONE_APP_ALGORITHM}`,
+    `digits=${data.digits === undefined ? DEFAULT_DIGITS : data.digits}`,
+    `period=${data.periodInSeconds || DEFAULT_PERIOD_IN_SECONDS}`,
+  ].join("&");
+
+  return `otpauth://totp/${encodeURIComponent(issuer)}:${encodeURIComponent(
+    data.label,
+  )}?${query}`;
+};

package/Tests/Server/Types/Database/Permissions/NotificationChannelVerificationColumns.test.ts

@@ -0,0 +1,135 @@
+import UserCall from "../../../../../Models/DatabaseModels/UserCall";
+import UserEmail from "../../../../../Models/DatabaseModels/UserEmail";
+import UserIncomingCallNumber from "../../../../../Models/DatabaseModels/UserIncomingCallNumber";
+import UserSMS from "../../../../../Models/DatabaseModels/UserSMS";
+import UserWhatsApp from "../../../../../Models/DatabaseModels/UserWhatsApp";
+import BaseModel from "../../../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
+import { ColumnAccessControl } from "../../../../../Types/BaseDatabase/AccessControl";
+import { TableColumnMetadata } from "../../../../../Types/Database/TableColumn";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * GHSA-5cr8-vph4-3hrf, the parts of the fix that live in model metadata
+ * rather than in code.
+ *
+ * Two properties, both of which a later well-meaning edit could remove
+ * without breaking a single functional test:
+ *
+ * 1. THE IDENTITY IS IMMUTABLE. The advisory's remediation list ends with
+ *    "invalidate outstanding codes when contact details change". There is no
+ *    such code path here, and that is not an oversight — the address or number
+ *    on a channel row cannot be changed at all, because its column grants
+ *    nobody update. A code is therefore bound to the contact detail it was
+ *    sent to for the whole life of the row. Make one of these columns
+ *    updatable and that stops being true: a caller verifies their own address,
+ *    then rewrites the row to point at somebody else's, and arrives at a
+ *    verified channel they do not own.
+ *
+ * 2. THE VERIFICATION STATE IS NOT WRITABLE BY THE CALLER. isVerified, the
+ *    stored digest, its expiry and the attempt counter are all server-owned.
+ *    A caller who could write any of them would not need to guess a code:
+ *    they could set isVerified directly, or push the expiry out, or reset the
+ *    attempt counter between guesses and never hit the limit.
+ */
+
+interface ChannelUnderTest {
+  name: string;
+  model: BaseModel;
+  identityColumn: string;
+}
+
+const CHANNELS: Array<ChannelUnderTest> = [
+  { name: "UserEmail", model: new UserEmail(), identityColumn: "email" },
+  { name: "UserSMS", model: new UserSMS(), identityColumn: "phone" },
+  { name: "UserCall", model: new UserCall(), identityColumn: "phone" },
+  { name: "UserWhatsApp", model: new UserWhatsApp(), identityColumn: "phone" },
+  {
+    name: "UserIncomingCallNumber",
+    model: new UserIncomingCallNumber(),
+    identityColumn: "phone",
+  },
+];
+
+/* Server-owned: writable by nobody through the API, at any point. */
+const SERVER_OWNED_COLUMNS: Array<string> = [
+  "isVerified",
+  "verificationCode",
+  "verificationCodeExpiresAt",
+  "verificationFailedAttempts",
+  "verificationCodeSentAt",
+];
+
+describe.each(CHANNELS)(
+  "$name verification column metadata",
+  (channel: ChannelUnderTest) => {
+    const accessControlFor: (columnName: string) => ColumnAccessControl = (
+      columnName: string,
+    ) => {
+      const accessControl: ColumnAccessControl | null =
+        channel.model.getColumnAccessControlFor(columnName);
+
+      expect(accessControl).not.toBeNull();
+
+      return accessControl as ColumnAccessControl;
+    };
+
+    it("does not let anybody change the address or number after creation", () => {
+      expect(accessControlFor(channel.identityColumn).update).toEqual([]);
+    });
+
+    it.each(SERVER_OWNED_COLUMNS)(
+      "does not let anybody create or update %s",
+      (columnName: string) => {
+        const accessControl: ColumnAccessControl = accessControlFor(columnName);
+
+        expect(accessControl.create).toEqual([]);
+        expect(accessControl.update).toEqual([]);
+      },
+    );
+
+    it.each([
+      "verificationCode",
+      "verificationCodeExpiresAt",
+      "verificationFailedAttempts",
+      "verificationCodeSentAt",
+    ])("does not expose %s to any reader", (columnName: string) => {
+      expect(accessControlFor(columnName).read).toEqual([]);
+    });
+
+    /*
+     * The row is born with a placeholder no six-digit code can hash to; the
+     * real code is issued by the service once the insert has assigned an id,
+     * because the id is part of the hashed message. A default that produced
+     * something SHORT would be a live guessable code sitting on every new row
+     * for the moment before the service overwrote it.
+     */
+    it("defaults verificationCode to a value no code can hash to", () => {
+      const metadata: TableColumnMetadata =
+        channel.model.getTableColumnMetadata("verificationCode");
+
+      expect(metadata.forceGetDefaultValueOnCreate).toBeDefined();
+
+      const generated: string = (
+        metadata.forceGetDefaultValueOnCreate as () => string
+      )();
+
+      expect(generated).toHaveLength(64);
+      expect(generated).not.toMatch(/^[0-9]{1,10}$/);
+    });
+
+    it("generates a different placeholder for every row", () => {
+      const metadata: TableColumnMetadata =
+        channel.model.getTableColumnMetadata("verificationCode");
+
+      const generated: Set<string> = new Set<string>();
+
+      for (let i: number = 0; i < 50; i++) {
+        generated.add(
+          (metadata.forceGetDefaultValueOnCreate as () => string)(),
+        );
+      }
+
+      expect(generated.size).toBe(50);
+    });
+  },
+);