@oneuptime/common 12.0.21 → 12.0.23

package/Models/DatabaseModels/UserTwoFactorBackupCode.ts

@@ -0,0 +1,262 @@
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import User from "./User";
+import Route from "../../Types/API/Route";
+import AllowAccessIfSubscriptionIsUnpaid from "../../Types/Database/AccessControl/AllowAccessIfSubscriptionIsUnpaid";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
+import AllowUserQueryWithoutTenant from "../../Types/Database/AllowUserQueryWithoutTenant";
+import ColumnLength from "../../Types/Database/ColumnLength";
+import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import CurrentUserCanAccessRecordBy from "../../Types/Database/CurrentUserCanAccessRecordBy";
+import EnableDocumentation from "../../Types/Database/EnableDocumentation";
+import TableColumn from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import TableMetadata from "../../Types/Database/TableMetadata";
+import IconProp from "../../Types/Icon/IconProp";
+import ObjectID from "../../Types/ObjectID";
+import Permission from "../../Types/Permission";
+import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
+
+/*
+ * One single-use recovery code, for the sign-in a user cannot otherwise
+ * complete: the authenticator app went down with the phone, or the security
+ * key is gone.
+ *
+ * ONE ROW PER CODE, NOT ONE ROW PER USER
+ *
+ * The alternative -- a single row holding a JSON array of digests -- would
+ * make consuming a code a read-modify-write of the whole array, and two
+ * sign-in attempts arriving together would each write back a copy of the array
+ * missing only their own code, so one of the two consumed codes would come
+ * back to life. A row per code turns consumption into one conditional UPDATE
+ * that Postgres settles for us (see UserTwoFactorBackupCodeService.consumeCode).
+ *
+ * IT IS NOT A SECOND FACTOR, AND IS DELIBERATELY NOT COUNTED AS ONE
+ *
+ * UserService.countVerifiedTwoFactorAuthMethods sums TOTP apps and security
+ * keys and does NOT look here. That is load-bearing rather than an oversight:
+ * an account whose only remaining "method" was a backup code would read as
+ * fully configured, so login would send it to the two factor CHALLENGE screen
+ * instead of through enrolment -- and the user, having no authenticator left
+ * to enrol from, would burn recovery codes one per sign-in until they ran out
+ * and then be locked out for good. Backup codes are the way BACK IN to an
+ * account that has a factor it cannot currently reach; they are not the
+ * factor.
+ *
+ * NOTHING HERE IS WRITABLE THROUGH THE CRUD API
+ *
+ * Every table permission except read is empty, so codes can only be minted by
+ * the service (which writes as root) -- never by a caller choosing their own.
+ * A user who could POST their own code has turned a stolen password into a
+ * permanent second factor of their own devising.
+ */
+@EnableDocumentation({
+  isMasterAdminApiDocs: true,
+})
+@AllowAccessIfSubscriptionIsUnpaid()
+@TableAccessControl({
+  /*
+   * Minting is POST /user-two-factor-backup-code/generate, which regenerates
+   * the whole set at once. There is no meaningful "create one code" operation
+   * and, more to the point, no safe one: the code is the credential, so a
+   * caller supplying it is choosing their own recovery secret.
+   */
+  create: [],
+
+  /*
+   * Read is open to the owner so the profile page can count what is left. It
+   * exposes nothing: `codeHash` denies read to everybody, so a row read here
+   * carries only its id, its `usedAt` and its owner.
+   */
+  read: [Permission.CurrentUser],
+
+  /*
+   * Consumption is a server-side write on the login path and regeneration
+   * replaces the set wholesale. A user-driven update or delete could only
+   * make a code stop working, which is the same thing regeneration does more
+   * clearly, and would give an attacker holding a session a way to quietly
+   * strip the account's recovery options.
+   */
+  delete: [],
+  update: [],
+})
+@CrudApiEndpoint(new Route("/user-two-factor-backup-code"))
+@Entity({
+  name: "UserTwoFactorBackupCode",
+})
+@TableMetadata({
+  tableName: "UserTwoFactorBackupCode",
+  singularName: "Two Factor Backup Code",
+  pluralName: "Two Factor Backup Codes",
+  icon: IconProp.Key,
+  tableDescription:
+    "Single-use backup codes that let a user sign in when their two factor authentication device is unavailable",
+})
+@AllowUserQueryWithoutTenant(true)
+@CurrentUserCanAccessRecordBy("userId")
+/*
+ * The entire hot path is `WHERE "userId" = ... AND "codeHash" = ...` -- the
+ * conditional UPDATE that consumes a code during a sign-in somebody is locked
+ * out of. `userId` alone leads the index so the profile page's "how many are
+ * left" count uses it too.
+ */
+@Index(["userId", "codeHash"])
+class UserTwoFactorBackupCode extends BaseModel {
+  /*
+   * HMAC-SHA256 of the code, keyed by the instance's EncryptionSecret and
+   * domain separated by the owning user -- see
+   * Common/Server/Utils/TwoFactorBackupCode.ts for the construction.
+   *
+   * Read is denied to EVERYONE, including the owner and a master admin. There
+   * is no product question this column answers: the plaintext is shown once,
+   * at generation, and never again. A master admin bypasses column read
+   * permissions on some paths, which is exactly why nothing here is worth
+   * shipping to a browser even in digest form.
+   *
+   * Not UNIQUE. The digest is domain separated by user, so two users cannot
+   * collide even if they were issued the same code, and within one user
+   * `generateCodeSet` already rules duplicates out -- a unique constraint
+   * would add nothing and would turn an astronomically unlikely collision
+   * into a failed regeneration for somebody who is already having a bad day.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ShortText,
+    canReadOnRelationQuery: false,
+    title: "Backup Code Hash",
+    description: "Keyed hash of this single-use two factor backup code",
+    hideColumnInDocumentation: true,
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: false,
+    unique: false,
+  })
+  public codeHash?: string = undefined;
+
+  /*
+   * When this code was spent, or null while it is still usable.
+   *
+   * The row is kept rather than deleted on use, for two reasons that both
+   * matter to somebody recovering an account: the profile page can say "3 of
+   * 10 remaining" instead of silently shrinking a list, and a user who is
+   * asking "did somebody else get into my account?" has a timestamp to look
+   * at rather than an absence.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.Date,
+    canReadOnRelationQuery: false,
+    title: "Used At",
+    description:
+      "When this backup code was used to sign in. Null while the code is still unused.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+    unique: false,
+  })
+  public usedAt?: Date = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "deletedByUserId",
+    type: TableColumnType.Entity,
+    title: "Deleted by User",
+    modelType: User,
+    description:
+      "Relation to User who deleted this object (if this object was deleted by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      cascade: false,
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "deletedByUserId" })
+  public deletedByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Deleted by User ID",
+    description:
+      "User ID who deleted this object (if this object was deleted by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public deletedByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "userId",
+    type: TableColumnType.Entity,
+    title: "User",
+    modelType: User,
+    description: "Relation to User who owns this backup code",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      cascade: false,
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "userId" })
+  public user?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [Permission.CurrentUser],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "User ID",
+    description: "User ID who owns this backup code",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public userId?: ObjectID = undefined;
+}
+
+export default UserTwoFactorBackupCode;

package/Server/API/UserTwoFactorBackupCodeAPI.ts

@@ -0,0 +1,258 @@
+import ObjectID from "../../Types/ObjectID";
+import Hostname from "../../Types/API/Hostname";
+import Protocol from "../../Types/API/Protocol";
+import Route from "../../Types/API/Route";
+import URL from "../../Types/API/URL";
+import OneUptimeDate from "../../Types/Date";
+import EmailTemplateType from "../../Types/Email/EmailTemplateType";
+import { DashboardRoute } from "../../ServiceRoute";
+import DatabaseConfig from "../DatabaseConfig";
+import MailService from "../Services/MailService";
+import UserService from "../Services/UserService";
+import User from "../../Models/DatabaseModels/User";
+import UserMiddleware from "../Middleware/UserAuthorization";
+import UserTwoFactorBackupCodeService, {
+  Service as UserTwoFactorBackupCodeServiceType,
+  TwoFactorBackupCodeStatus,
+} from "../Services/UserTwoFactorBackupCodeService";
+import TwoFactorBackupCode from "../Utils/TwoFactorBackupCode";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+  OneUptimeRequest,
+} from "../Utils/Express";
+import BaseAPI from "./BaseAPI";
+import UserTwoFactorBackupCode from "../../Models/DatabaseModels/UserTwoFactorBackupCode";
+import NotAuthenticatedException from "../../Types/Exception/NotAuthenticatedException";
+import Response from "../Utils/Response";
+import logger from "../Utils/Logger";
+
+/**
+ * The two routes a signed-in user needs to manage their recovery codes.
+ *
+ * Both act on the CALLER's own codes and nobody else's. There is deliberately
+ * no `:userId` parameter anywhere here: the owner is read from the validated
+ * access token, so there is no id for a caller to substitute and no ownership
+ * check to get wrong. `UserMiddleware.getUserMiddleware` is what puts it
+ * there.
+ */
+export default class UserTwoFactorBackupCodeAPI extends BaseAPI<
+  UserTwoFactorBackupCode,
+  UserTwoFactorBackupCodeServiceType
+> {
+  public constructor() {
+    super(UserTwoFactorBackupCode, UserTwoFactorBackupCodeService);
+
+    const crudApiPath: string =
+      new this.entityType().getCrudApiPath()?.toString() || "";
+
+    /*
+     * Mint a fresh set and return the plaintext codes.
+     *
+     * THIS RESPONSE IS THE ONLY COPY. Nothing is stored but keyed digests, so
+     * if the user closes the tab the codes are gone -- not recoverable by
+     * them, by an operator, or by anybody with the database. The UI is
+     * expected to make that unmissable, and the count of a previous set is
+     * returned alongside so the page can say what was just invalidated.
+     *
+     * It is a POST because it is destructive: calling it throws away every
+     * code the user was previously holding. A GET that silently voided a
+     * printed list -- on a browser prefetch, say -- would be a lockout with no
+     * user action behind it.
+     *
+     * NOT gated on `enableTwoFactorAuth`. Generating codes before turning two
+     * factor auth on is the sensible order to do it in, and refusing here
+     * would push users into the exact sequence -- enable first, find recovery
+     * later -- that produces the lost-device support ticket this whole feature
+     * exists to prevent.
+     */
+    this.router.post(
+      `${crudApiPath}/generate`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const userId: ObjectID =
+            UserTwoFactorBackupCodeAPI.getCurrentUserId(req);
+
+          const previousStatus: TwoFactorBackupCodeStatus =
+            await UserTwoFactorBackupCodeService.getStatusForUser({
+              userId: userId,
+            });
+
+          const codes: Array<string> =
+            await UserTwoFactorBackupCodeService.regenerateForUser({
+              userId: userId,
+            });
+
+          /*
+           * The codes themselves are NEVER logged -- they are sign-in
+           * credentials, and logger output reaches stdout, the recent-log
+           * buffer and telemetry at once. The fact that a set was minted is
+           * worth recording: it is how an operator later reconstructs "who
+           * invalidated the codes this user says they had".
+           */
+          logger.info(
+            `Two factor backup codes regenerated for user: ${userId.toString()}`,
+          );
+
+          /*
+           * Tell the account holder, at their address rather than in this
+           * browser.
+           *
+           * This route is the destructive one and it is the one with the least
+           * standing in front of it: a session alone -- no password, no second
+           * factor -- silently voids every recovery code the user is holding.
+           * Somebody who has stolen a session can therefore remove the owner's
+           * way back in and leave no trace the owner would ever look at, and
+           * the owner finds out at the next sign-in they cannot complete.
+           *
+           * The mail does not prevent that; it makes it visible, which is the
+           * same bargain `sendTwoFactorBackupCodeUsedEmail` strikes on the
+           * login path. Re-prompting for the password here would be stronger
+           * still, and is the obvious next step -- it needs a re-authentication
+           * mechanism this codebase does not have yet, so it is deliberately
+           * not invented on this route alone.
+           *
+           * Detached and never awaited: an unreachable mail server must not
+           * fail a regeneration that has already replaced the user's codes,
+           * because the response carries the only copy of the new ones.
+           */
+          UserTwoFactorBackupCodeAPI.notifyCodesRegenerated({
+            userId: userId,
+            newCodeCount: codes.length,
+          }).catch((err: Error) => {
+            logger.error(err);
+          });
+
+          return Response.sendJsonObjectResponse(req, res, {
+            /*
+             * Hyphenated for the page to render as-is. The verify route
+             * normalizes whatever comes back, so a user may type them with
+             * the hyphen, without it, or with whatever spacing their password
+             * manager pasted in.
+             */
+            codes: codes.map((code: string) => {
+              return TwoFactorBackupCode.formatForDisplay(code);
+            }),
+            replacedCodeCount: previousStatus.total,
+          });
+        } catch (err) {
+          return next(err);
+        }
+      },
+    );
+
+    /*
+     * How many codes the caller has left.
+     *
+     * Carries no code material of any kind -- three numbers and a date -- so
+     * it is safe for the profile page to poll and safe to render anywhere a
+     * session already exists.
+     */
+    this.router.get(
+      `${crudApiPath}/status`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const userId: ObjectID =
+            UserTwoFactorBackupCodeAPI.getCurrentUserId(req);
+
+          const status: TwoFactorBackupCodeStatus =
+            await UserTwoFactorBackupCodeService.getStatusForUser({
+              userId: userId,
+            });
+
+          /*
+           * A stale "you have 8 codes left" served out of a browser cache
+           * after the user has just regenerated is a user who thinks the
+           * button did nothing.
+           */
+          Response.setNoCacheHeaders(res);
+
+          return Response.sendJsonObjectResponse(req, res, {
+            total: status.total,
+            unused: status.unused,
+            generatedAt: status.generatedAt
+              ? status.generatedAt.toISOString()
+              : null,
+          });
+        } catch (err) {
+          return next(err);
+        }
+      },
+    );
+  }
+
+  /**
+   * Mail the owner that their backup codes were replaced.
+   *
+   * Separate from the handler so the handler stays readable, and `private
+   * static` because nothing outside this route should be announcing a
+   * regeneration that did not happen here.
+   *
+   * Reads the address itself rather than taking it from the request: the only
+   * thing the caller proved is which user they are, and the address this goes
+   * to has to be the one on the account, not one they supplied.
+   */
+  private static async notifyCodesRegenerated(data: {
+    userId: ObjectID;
+    newCodeCount: number;
+  }): Promise<void> {
+    const user: User | null = await UserService.findOneById({
+      id: data.userId,
+      select: {
+        email: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!user || !user.email) {
+      return;
+    }
+
+    const host: Hostname = await DatabaseConfig.getHost();
+    const httpProtocol: Protocol = await DatabaseConfig.getHttpProtocol();
+
+    await MailService.sendMail({
+      toEmail: user.email,
+      subject: "Your OneUptime two factor backup codes were replaced",
+      templateType: EmailTemplateType.TwoFactorBackupCodesRegenerated,
+      vars: {
+        generatedAt: OneUptimeDate.getCurrentDateAsFormattedString(),
+        newCodeCount: data.newCodeCount.toString(),
+        twoFactorAuthUrl: new URL(
+          httpProtocol,
+          host,
+          new Route(DashboardRoute.toString()).addRoute(
+            "/user-profile/two-factor-auth",
+          ),
+        ).toString(),
+        homeUrl: new URL(httpProtocol, host).toString(),
+      },
+    });
+  }
+
+  /**
+   * The signed-in caller, from the token the middleware validated.
+   *
+   * Throws rather than returning null: every route in this file acts on the
+   * caller's own credentials, so "no caller" is not a case any of them can
+   * meaningfully proceed with. The middleware ahead of them should already
+   * have refused, which makes this a second lock rather than the first.
+   */
+  private static getCurrentUserId(req: ExpressRequest): ObjectID {
+    const userId: ObjectID | undefined = (req as OneUptimeRequest)
+      .userAuthorization?.userId;
+
+    if (!userId) {
+      throw new NotAuthenticatedException(
+        "You are not authenticated. Please sign in.",
+      );
+    }
+
+    return userId;
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1789100000000-AddNetworkDeviceAutoImportRule.ts

@@ -0,0 +1,60 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Auto-import rules for network device discovery (issue #3378): a rule table
+ * whose conditions decide which discovered hosts become Network Devices with
+ * no manual review step, plus a processed-marker column on the scan so the
+ * worker that evaluates the rules knows which results it has already seen.
+ */
+export class AddNetworkDeviceAutoImportRule1789100000000
+  implements MigrationInterface
+{
+  public name: string = "AddNetworkDeviceAutoImportRule1789100000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "NetworkDeviceAutoImportRule" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "projectId" uuid NOT NULL, "name" character varying(100) NOT NULL, "description" character varying(500), "isEnabled" boolean NOT NULL DEFAULT true, "ipMatchTarget" character varying(100), "sysNamePattern" character varying(500), "sysDescrPattern" character varying(500), "includePingOnlyHosts" boolean NOT NULL DEFAULT false, "isExclusion" boolean NOT NULL DEFAULT false, "createdByUserId" uuid, "deletedByUserId" uuid, CONSTRAINT "PK_network_device_auto_import_rule_id" PRIMARY KEY ("_id"))`,
+    );
+
+    for (const column of ["projectId", "name", "isEnabled", "isExclusion"]) {
+      await queryRunner.query(
+        `CREATE INDEX "IDX_network_device_auto_import_rule_${column}" ON "NetworkDeviceAutoImportRule" ("${column}")`,
+      );
+    }
+
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceAutoImportRule" ADD CONSTRAINT "FK_nd_auto_import_rule_projectId" FOREIGN KEY ("projectId") REFERENCES "Project"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceAutoImportRule" ADD CONSTRAINT "FK_nd_auto_import_rule_createdByUserId" FOREIGN KEY ("createdByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceAutoImportRule" ADD CONSTRAINT "FK_nd_auto_import_rule_deletedByUserId" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "autoImportProcessedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+
+    /*
+     * Backfill EVERY existing scan as already-processed, making the feature
+     * forward-only. One-shot scans stay "Completed" forever, so without this
+     * every scan ever run would sit unprocessed and the first rule a project
+     * creates would mass-import months-old results — the opposite of what an
+     * operator writing a rule about FUTURE discoveries intends. Old results
+     * remain reachable on purpose through the rule's explicit "Run Now".
+     */
+    await queryRunner.query(
+      `UPDATE "NetworkDeviceDiscoveryScan" SET "autoImportProcessedAt" = now()`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "autoImportProcessedAt"`,
+    );
+    await queryRunner.query(
+      `DROP TABLE IF EXISTS "NetworkDeviceAutoImportRule"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1789100000000-AddUserTwoFactorBackupCode.ts

@@ -0,0 +1,63 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Single-use two factor backup codes, so losing an authenticator app or a
+ * security key stops being an account lockout that only a master admin can
+ * undo.
+ *
+ * One row per code rather than an array column on User: consuming a code is
+ * then one conditional UPDATE that Postgres serialises for us, instead of a
+ * read-modify-write of an array where two simultaneous sign-ins would each
+ * write back a copy missing only their own code.
+ *
+ * `codeHash` holds an HMAC-SHA256 keyed by the instance EncryptionSecret and
+ * domain separated by the owning user -- never a code in the clear. It is a
+ * plain varchar rather than a `hashed: true` column because the write path's
+ * hashing lanes do neither of those things: the salted lane is scrypt (right
+ * for a guessable password, pure cost for a 2^50 random code) and the unsalted
+ * lane is a bare SHA-256 with no per-user binding. See
+ * Common/Server/Utils/TwoFactorBackupCode.ts.
+ *
+ * The (userId, codeHash) index is the sign-in lookup, which happens while
+ * somebody is locked out and waiting. `usedAt` is deliberately not in it: a
+ * user holds ten rows, so Postgres filters those in memory for nothing.
+ */
+export class AddUserTwoFactorBackupCode1789100000000
+  implements MigrationInterface
+{
+  public name: string = "AddUserTwoFactorBackupCode1789100000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "UserTwoFactorBackupCode" ("_id" uuid NOT NULL DEFAULT uuid_generate_v4(), "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "deletedAt" TIMESTAMP WITH TIME ZONE, "version" integer NOT NULL, "codeHash" character varying(100) NOT NULL, "usedAt" TIMESTAMP WITH TIME ZONE, "deletedByUserId" uuid, "userId" uuid, CONSTRAINT "PK_8007aa681bcad47b88b906319ed" PRIMARY KEY ("_id"))`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_19a5937a4f6bd993383b31f3a2" ON "UserTwoFactorBackupCode" ("userId", "codeHash") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserTwoFactorBackupCode" ADD CONSTRAINT "FK_b6f9bfb29ab554076a2d8dde717" FOREIGN KEY ("deletedByUserId") REFERENCES "User"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    /*
+     * CASCADE, not SET NULL. An orphaned row would be a live sign-in
+     * credential for an account that no longer exists -- and, with `userId`
+     * null, invisible to every query in the service, which all key on the
+     * owner.
+     */
+    await queryRunner.query(
+      `ALTER TABLE "UserTwoFactorBackupCode" ADD CONSTRAINT "FK_dd1f93f94cd3a4f39435b56d944" FOREIGN KEY ("userId") REFERENCES "User"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "UserTwoFactorBackupCode" DROP CONSTRAINT "FK_dd1f93f94cd3a4f39435b56d944"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "UserTwoFactorBackupCode" DROP CONSTRAINT "FK_b6f9bfb29ab554076a2d8dde717"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_19a5937a4f6bd993383b31f3a2"`,
+    );
+    await queryRunner.query(`DROP TABLE "UserTwoFactorBackupCode"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1789200000000-AddSysObjectIdPatternToAutoImportRule.ts

@@ -0,0 +1,26 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Vendor-based auto-import conditions (issue #3378, phase 2): the probe now
+ * reports the full SNMP system group per discovered host (sysObjectId,
+ * sysLocation, sysContact, sysUpTimeSeconds ride inside the scan's existing
+ * discoveredDevices jsonb, so they need no column), and a rule can match on
+ * the sysObjectID — the vendor's registered enterprise OID.
+ */
+export class AddSysObjectIdPatternToAutoImportRule1789200000000
+  implements MigrationInterface
+{
+  public name: string = "AddSysObjectIdPatternToAutoImportRule1789200000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceAutoImportRule" ADD "sysObjectIdPattern" character varying(500)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceAutoImportRule" DROP COLUMN "sysObjectIdPattern"`,
+    );
+  }
+}