@oneuptime/common 12.0.30 → 12.0.31

package/Server/API/GlobalConfigAPI.ts

@@ -26,6 +26,11 @@ import {
 import EnterpriseLicenseInstanceSummary from "../../Types/EnterpriseLicense/EnterpriseLicenseInstanceSummary";
 import VersionUtil from "../../Utils/VersionUtil";
 import UserMiddleware from "../Middleware/UserAuthorization";
+import MasterAdminAuthorization from "../Middleware/MasterAdminAuthorization";
+import EnterpriseLicenseSeatUtil from "../Utils/EnterpriseLicense/EnterpriseLicenseSeatUtil";
+import { SeatUsage } from "../../Utils/EnterpriseLicense/EnterpriseLicenseSeats";
+import UserService from "../Services/UserService";
+import PositiveNumber from "../../Types/PositiveNumber";
 
 export default class GlobalConfigAPI extends BaseAPI<
   GlobalConfig,
@@ -104,6 +109,22 @@ export default class GlobalConfigAPI extends BaseAPI<
               config.enterpriseLicenseExpiresAt.getTime() > Date.now(),
           );
 
+          /*
+           * What the seat limit actually means on this installation right now,
+           * as opposed to what oneuptime.com last reported. Only for signed-in
+           * callers: it is derived from the live User table, and an anonymous
+           * visitor on the login page has no business being told how close this
+           * server is to refusing new accounts.
+           */
+          const seatUsage: SeatUsage | null = isAuthenticatedUser
+            ? await EnterpriseLicenseSeatUtil.getSeatUsageForLoadedGlobalConfig(
+                {
+                  config: config,
+                  getLocalUserCount: GlobalConfigAPI.getLocalUserCount,
+                },
+              )
+            : null;
+
           const responseBody: JSONObject = {
             companyName: config?.enterpriseCompanyName || null,
             expiresAt: config?.enterpriseLicenseExpiresAt
@@ -174,6 +195,7 @@ export default class GlobalConfigAPI extends BaseAPI<
             isUpdateCheckDisabled: isAuthenticatedUser
               ? DisableUpdateCheck
               : false,
+            ...GlobalConfigAPI.getSeatUsageResponseFields(seatUsage),
           };
 
           return Response.sendJsonObjectResponse(req, res, responseBody);
@@ -183,9 +205,19 @@ export default class GlobalConfigAPI extends BaseAPI<
       },
     );
 
+    /*
+     * Activating (or replacing) the license key for the whole installation.
+     *
+     * Master admin only. This writes the terms that bound how many users the
+     * installation may have, so anyone who can reach it can change the seat
+     * limit UserService now enforces. It used to run on
+     * UserMiddleware.getUserMiddleware, which lets anonymous callers through
+     * (it has to — the GET above serves the signed-out login page), so the
+     * route was in practice unauthenticated.
+     */
     this.router.post(
       `${new this.entityType().getCrudApiPath()?.toString()}/license`,
-      UserMiddleware.getUserMiddleware,
+      MasterAdminAuthorization.isAuthorizedMasterAdminMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
           const licenseKey: string =
@@ -195,205 +227,352 @@ export default class GlobalConfigAPI extends BaseAPI<
             throw new BadDataException("License key is required");
           }
 
-          const globalConfigId: ObjectID = ObjectID.getZeroObjectID();
+          const responseBody: JSONObject =
+            await this.validateAndStoreLicenseKey(licenseKey);
+
+          return Response.sendJsonObjectResponse(req, res, responseBody);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
 
-          const existingConfig: GlobalConfig | null =
+    /*
+     * Re-fetch the license this installation already holds.
+     *
+     * The seat limit and the expiry live on oneuptime.com and can change on
+     * any day — a customer buys ten more seats at noon. The daily report job
+     * picks that up eventually; this is the button an administrator presses
+     * when "eventually" is not good enough, and it is the only way to apply a
+     * change without re-typing the key.
+     *
+     * Deliberately takes no license key: it uses the stored one. A refresh
+     * that accepted a key would be an activation with a friendlier name, and
+     * would let a mistyped key replace a working license by accident.
+     */
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/license/refresh`,
+      MasterAdminAuthorization.isAuthorizedMasterAdminMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const config: GlobalConfig | null =
             await GlobalConfigService.findOneById({
-              id: globalConfigId,
+              id: ObjectID.getZeroObjectID(),
               select: {
-                _id: true,
-                instanceId: true,
+                enterpriseLicenseKey: true,
               },
               props: {
                 isRoot: true,
-                ignoreHooks: true,
               },
             });
 
-          /*
-           * Send this instance's id and host along with the key so the
-           * license server registers this instance against the license and
-           * it shows up in the instance list on all instances that share
-           * the license.
-           */
-          const instanceId: ObjectID =
-            existingConfig?.instanceId || ObjectID.generate();
-
-          const validationResponse:
-            | HTTPResponse<JSONObject>
-            | HTTPErrorResponse = await API.post<JSONObject>({
-            url: EnterpriseLicenseValidationUrl,
-            data: {
-              licenseKey,
-              instanceId: instanceId.toString(),
-              host: Host,
-              /*
-               * Sent here as well as from the daily report job so the version
-               * lands on the license server the moment the key is validated,
-               * rather than up to 24 hours later.
-               */
-              version: AppVersion,
-            },
-          });
-
-          if (!validationResponse.isSuccess()) {
-            const errorMessage: string =
-              validationResponse instanceof HTTPErrorResponse
-                ? validationResponse.message ||
-                  "Failed to validate license key."
-                : "Failed to validate license key.";
-            throw new BadDataException(errorMessage);
-          }
-
-          const payload: JSONObject = validationResponse.data as JSONObject;
-
-          const companyNameRaw: string =
-            (payload["companyName"] as string | undefined)?.trim() || "";
-          const expiresAtRaw: string =
-            (payload["expiresAt"] as string | undefined) || "";
-          const licenseKeyRaw: string =
-            (payload["licenseKey"] as string | undefined)?.trim() || licenseKey;
-          const licenseToken: string =
-            (payload["token"] as string | undefined) || "";
-
-          let licenseExpiry: Date | undefined = undefined;
-          if (expiresAtRaw) {
-            const parsedDate: Date = new Date(expiresAtRaw);
-
-            if (Number.isNaN(parsedDate.getTime())) {
-              throw new BadDataException(
-                "License expiration returned from server is invalid.",
-              );
-            }
+          const licenseKey: string = config?.enterpriseLicenseKey?.trim() || "";
 
-            licenseExpiry = parsedDate;
-          }
-
-          const userLimitRaw: unknown = payload["userLimit"];
-          const userLimit: number | null =
-            typeof userLimitRaw === "number" && Number.isFinite(userLimitRaw)
-              ? userLimitRaw
-              : null;
-
-          const currentUserCountRaw: unknown = payload["currentUserCount"];
-          const currentUserCount: number | null =
-            typeof currentUserCountRaw === "number" &&
-            Number.isFinite(currentUserCountRaw)
-              ? currentUserCountRaw
-              : null;
-
-          const userCountUpdatedAtRaw: string | undefined = payload[
-            "userCountUpdatedAt"
-          ] as string | undefined;
-          let userCountUpdatedAt: Date | null = null;
-          if (userCountUpdatedAtRaw) {
-            const parsedReportedAt: Date = new Date(userCountUpdatedAtRaw);
-            if (!Number.isNaN(parsedReportedAt.getTime())) {
-              userCountUpdatedAt = parsedReportedAt;
-            }
+          if (!licenseKey) {
+            throw new BadDataException(
+              "This installation does not have an enterprise license key yet. Enter a license key to activate it first.",
+            );
           }
 
-          const isEvaluationLicense: boolean =
-            payload["isEvaluationLicense"] === true;
-
-          const instances: Array<EnterpriseLicenseInstanceSummary> =
-            Array.isArray(payload["instances"])
-              ? (payload[
-                  "instances"
-                ] as Array<EnterpriseLicenseInstanceSummary>)
-              : [];
-
-          const updatePayload: PartialEntity<GlobalConfig> = {
-            enterpriseCompanyName: companyNameRaw || null,
-            enterpriseLicenseKey: licenseKeyRaw || null,
-            enterpriseLicenseExpiresAt: licenseExpiry || null,
-            enterpriseLicenseToken: licenseToken || null,
-            enterpriseLicenseIsEvaluation: isEvaluationLicense,
-            enterpriseLicenseUserLimit: userLimit,
-            enterpriseLicenseCurrentUserCount: currentUserCount,
-            enterpriseLicenseUserCountUpdatedAt: userCountUpdatedAt,
-            enterpriseLicenseInstances: instances,
-          };
-
-          if (!existingConfig?.instanceId) {
-            // Installs that predate instance ids: persist the one we generated.
-            updatePayload.instanceId = instanceId;
-          }
+          const responseBody: JSONObject =
+            await this.validateAndStoreLicenseKey(licenseKey);
 
-          if (existingConfig) {
-            await GlobalConfigService.updateOneById({
-              id: globalConfigId,
-              data: updatePayload,
-              props: {
-                isRoot: true,
-                ignoreHooks: true,
-              },
-            });
-          } else {
-            const newConfig: GlobalConfig = new GlobalConfig();
-            newConfig.id = globalConfigId;
-
-            if (companyNameRaw) {
-              newConfig.enterpriseCompanyName = companyNameRaw;
-            }
-
-            if (licenseKeyRaw) {
-              newConfig.enterpriseLicenseKey = licenseKeyRaw;
-            }
-
-            if (licenseToken) {
-              newConfig.enterpriseLicenseToken = licenseToken;
-            }
-
-            newConfig.enterpriseLicenseIsEvaluation = isEvaluationLicense;
-
-            if (licenseExpiry) {
-              newConfig.enterpriseLicenseExpiresAt = licenseExpiry;
-            }
-
-            if (userLimit !== null) {
-              newConfig.enterpriseLicenseUserLimit = userLimit;
-            }
-
-            if (currentUserCount !== null) {
-              newConfig.enterpriseLicenseCurrentUserCount = currentUserCount;
-            }
-
-            if (userCountUpdatedAt) {
-              newConfig.enterpriseLicenseUserCountUpdatedAt =
-                userCountUpdatedAt;
-            }
-
-            newConfig.enterpriseLicenseInstances = instances;
-            newConfig.instanceId = instanceId;
-
-            await GlobalConfigService.create({
-              data: newConfig,
-              props: {
-                isRoot: true,
-                ignoreHooks: true,
-              },
-            });
-          }
-
-          return Response.sendJsonObjectResponse(req, res, {
-            companyName: companyNameRaw || null,
-            expiresAt: licenseExpiry ? licenseExpiry.toISOString() : null,
-            licenseKey: licenseKeyRaw || null,
-            token: licenseToken || null,
-            isEvaluationLicense: isEvaluationLicense,
-            userLimit: userLimit,
-            currentUserCount: currentUserCount,
-            userCountUpdatedAt: userCountUpdatedAt
-              ? userCountUpdatedAt.toISOString()
-              : null,
-            instances: instances,
-            instanceId: instanceId.toString(),
-          });
+          return Response.sendJsonObjectResponse(req, res, responseBody);
         } catch (err) {
           next(err);
         }
       },
     );
   }
+
+  /*
+   * Ask oneuptime.com what this license key is worth today, and mirror the
+   * answer into GlobalConfig.
+   *
+   * Shared by activation and refresh so the two cannot drift: the whole point
+   * of refresh is that it applies exactly what activation would have applied,
+   * and a second hand-written copy of this mapping is how the seat limit came
+   * to be dropped on the floor by the daily report job before.
+   */
+  private async validateAndStoreLicenseKey(
+    licenseKey: string,
+  ): Promise<JSONObject> {
+    const globalConfigId: ObjectID = ObjectID.getZeroObjectID();
+
+    const existingConfig: GlobalConfig | null =
+      await GlobalConfigService.findOneById({
+        id: globalConfigId,
+        select: {
+          _id: true,
+          instanceId: true,
+        },
+        props: {
+          isRoot: true,
+          ignoreHooks: true,
+        },
+      });
+
+    /*
+     * Send this instance's id and host along with the key so the
+     * license server registers this instance against the license and
+     * it shows up in the instance list on all instances that share
+     * the license.
+     */
+    const instanceId: ObjectID =
+      existingConfig?.instanceId || ObjectID.generate();
+
+    const validationResponse: HTTPResponse<JSONObject> | HTTPErrorResponse =
+      await API.post<JSONObject>({
+        url: EnterpriseLicenseValidationUrl,
+        data: {
+          licenseKey,
+          instanceId: instanceId.toString(),
+          host: Host,
+          /*
+           * Sent here as well as from the daily report job so the version
+           * lands on the license server the moment the key is validated,
+           * rather than up to 24 hours later.
+           */
+          version: AppVersion,
+        },
+      });
+
+    if (!validationResponse.isSuccess()) {
+      const errorMessage: string =
+        validationResponse instanceof HTTPErrorResponse
+          ? validationResponse.message || "Failed to validate license key."
+          : "Failed to validate license key.";
+      throw new BadDataException(errorMessage);
+    }
+
+    const payload: JSONObject = validationResponse.data as JSONObject;
+
+    const companyNameRaw: string =
+      (payload["companyName"] as string | undefined)?.trim() || "";
+    const expiresAtRaw: string =
+      (payload["expiresAt"] as string | undefined) || "";
+    const licenseKeyRaw: string =
+      (payload["licenseKey"] as string | undefined)?.trim() || licenseKey;
+    const licenseToken: string = (payload["token"] as string | undefined) || "";
+
+    let licenseExpiry: Date | undefined = undefined;
+    if (expiresAtRaw) {
+      const parsedDate: Date = new Date(expiresAtRaw);
+
+      if (Number.isNaN(parsedDate.getTime())) {
+        throw new BadDataException(
+          "License expiration returned from server is invalid.",
+        );
+      }
+
+      licenseExpiry = parsedDate;
+    }
+
+    const userLimitRaw: unknown = payload["userLimit"];
+    const userLimit: number | null =
+      typeof userLimitRaw === "number" && Number.isFinite(userLimitRaw)
+        ? userLimitRaw
+        : null;
+
+    const currentUserCountRaw: unknown = payload["currentUserCount"];
+    const currentUserCount: number | null =
+      typeof currentUserCountRaw === "number" &&
+      Number.isFinite(currentUserCountRaw)
+        ? currentUserCountRaw
+        : null;
+
+    const userCountUpdatedAtRaw: string | undefined = payload[
+      "userCountUpdatedAt"
+    ] as string | undefined;
+    let userCountUpdatedAt: Date | null = null;
+    if (userCountUpdatedAtRaw) {
+      const parsedReportedAt: Date = new Date(userCountUpdatedAtRaw);
+      if (!Number.isNaN(parsedReportedAt.getTime())) {
+        userCountUpdatedAt = parsedReportedAt;
+      }
+    }
+
+    const isEvaluationLicense: boolean =
+      payload["isEvaluationLicense"] === true;
+
+    const instances: Array<EnterpriseLicenseInstanceSummary> = Array.isArray(
+      payload["instances"],
+    )
+      ? (payload["instances"] as Array<EnterpriseLicenseInstanceSummary>)
+      : [];
+
+    const updatePayload: PartialEntity<GlobalConfig> = {
+      enterpriseCompanyName: companyNameRaw || null,
+      enterpriseLicenseKey: licenseKeyRaw || null,
+      enterpriseLicenseExpiresAt: licenseExpiry || null,
+      enterpriseLicenseToken: licenseToken || null,
+      enterpriseLicenseIsEvaluation: isEvaluationLicense,
+      enterpriseLicenseUserLimit: userLimit,
+      enterpriseLicenseCurrentUserCount: currentUserCount,
+      enterpriseLicenseUserCountUpdatedAt: userCountUpdatedAt,
+      enterpriseLicenseInstances: instances,
+    };
+
+    if (!existingConfig?.instanceId) {
+      // Installs that predate instance ids: persist the one we generated.
+      updatePayload.instanceId = instanceId;
+    }
+
+    if (existingConfig) {
+      await GlobalConfigService.updateOneById({
+        id: globalConfigId,
+        data: updatePayload,
+        props: {
+          isRoot: true,
+          ignoreHooks: true,
+        },
+      });
+    } else {
+      const newConfig: GlobalConfig = new GlobalConfig();
+      newConfig.id = globalConfigId;
+
+      if (companyNameRaw) {
+        newConfig.enterpriseCompanyName = companyNameRaw;
+      }
+
+      if (licenseKeyRaw) {
+        newConfig.enterpriseLicenseKey = licenseKeyRaw;
+      }
+
+      if (licenseToken) {
+        newConfig.enterpriseLicenseToken = licenseToken;
+      }
+
+      newConfig.enterpriseLicenseIsEvaluation = isEvaluationLicense;
+
+      if (licenseExpiry) {
+        newConfig.enterpriseLicenseExpiresAt = licenseExpiry;
+      }
+
+      if (userLimit !== null) {
+        newConfig.enterpriseLicenseUserLimit = userLimit;
+      }
+
+      if (currentUserCount !== null) {
+        newConfig.enterpriseLicenseCurrentUserCount = currentUserCount;
+      }
+
+      if (userCountUpdatedAt) {
+        newConfig.enterpriseLicenseUserCountUpdatedAt = userCountUpdatedAt;
+      }
+
+      newConfig.enterpriseLicenseInstances = instances;
+      newConfig.instanceId = instanceId;
+
+      await GlobalConfigService.create({
+        data: newConfig,
+        props: {
+          isRoot: true,
+          ignoreHooks: true,
+        },
+      });
+    }
+
+    /*
+     * Seat usage recomputed from what was just stored, so the dialog that
+     * triggered this can show the new limit against the real user count
+     * without a second round trip - and so an administrator who just bought
+     * seats sees them land.
+     */
+    const seatUsage: SeatUsage | null =
+      await GlobalConfigAPI.getSeatUsageForResponse({
+        userLimit: userLimit,
+        currentUserCount: currentUserCount,
+        instances: instances,
+        instanceId: instanceId,
+      });
+
+    return {
+      companyName: companyNameRaw || null,
+      expiresAt: licenseExpiry ? licenseExpiry.toISOString() : null,
+      licenseKey: licenseKeyRaw || null,
+      token: licenseToken || null,
+      isEvaluationLicense: isEvaluationLicense,
+      userLimit: userLimit,
+      currentUserCount: currentUserCount,
+      userCountUpdatedAt: userCountUpdatedAt
+        ? userCountUpdatedAt.toISOString()
+        : null,
+      instances: instances,
+      instanceId: instanceId.toString(),
+      ...GlobalConfigAPI.getSeatUsageResponseFields(seatUsage),
+    };
+  }
+
+  /*
+   * Seat usage built from license terms held in memory rather than re-read
+   * from the database. Used right after a write, where re-reading would race
+   * the write it is describing.
+   */
+  private static async getSeatUsageForResponse(data: {
+    userLimit: number | null;
+    currentUserCount: number | null;
+    instances: Array<EnterpriseLicenseInstanceSummary>;
+    instanceId: ObjectID;
+  }): Promise<SeatUsage | null> {
+    const config: GlobalConfig = new GlobalConfig();
+    config.instanceId = data.instanceId;
+    config.enterpriseLicenseInstances = data.instances;
+
+    if (data.userLimit !== null) {
+      config.enterpriseLicenseUserLimit = data.userLimit;
+    }
+
+    if (data.currentUserCount !== null) {
+      config.enterpriseLicenseCurrentUserCount = data.currentUserCount;
+    }
+
+    return EnterpriseLicenseSeatUtil.getSeatUsageForLoadedGlobalConfig({
+      config: config,
+      getLocalUserCount: GlobalConfigAPI.getLocalUserCount,
+    });
+  }
+
+  /*
+   * How many users exist on this installation right now. Deliberately the live
+   * count rather than the last reported one: the number an administrator is
+   * about to act on is the number that decides whether the next invitation
+   * goes through.
+   */
+  private static async getLocalUserCount(): Promise<number> {
+    const userCount: PositiveNumber = await UserService.countBy({
+      query: {},
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return userCount.toNumber();
+  }
+
+  /*
+   * The seat-enforcement half of a license response. Always the same keys, so
+   * a client never has to tell "this build does not report seats" apart from
+   * "this installation does not enforce them" by which fields are missing:
+   * isSeatLimitEnforced is the single flag that answers that.
+   */
+  private static getSeatUsageResponseFields(
+    seatUsage: SeatUsage | null,
+  ): JSONObject {
+    if (!seatUsage || !seatUsage.isEnforced) {
+      return {
+        isSeatLimitEnforced: false,
+        seatsInUse: null,
+        seatsRemaining: null,
+        canAddMoreUsers: true,
+      };
+    }
+
+    return {
+      isSeatLimitEnforced: true,
+      seatsInUse: seatUsage.seatsInUse,
+      seatsRemaining: seatUsage.seatsRemaining,
+      canAddMoreUsers: seatUsage.hasSeatForNewUser,
+    };
+  }
 }

package/Server/API/TelemetryAPI.ts

@@ -14,7 +14,9 @@ import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCom
 import TelemetryType from "../../Types/Telemetry/TelemetryType";
 import TelemetryAttributeService from "../Services/TelemetryAttributeService";
 import TelemetrySourceMapService from "../Services/TelemetrySourceMapService";
-import SourceMapResolver from "../Utils/Telemetry/SourceMapResolver";
+import SourceMapResolver, {
+  MAX_FRAMES_PER_RESOLVE_REQUEST,
+} from "../Utils/Telemetry/SourceMapResolver";
 import {
   MinifiedStackFrame,
   ResolveStackTraceResult,
@@ -214,10 +216,28 @@ const requireProfileReadAccess: Array<RequestHandler> =
 
 /*
  * Mirrors the read access control declared on the SecurityEvent analytics
- * model.
+ * model - which, unlike every other signal above, is NOT the telemetry list.
+ * Security events read through the Security tiers only, so this route cannot
+ * be built from createTelemetryReadAccessGuard: doing so would leave the
+ * attribute endpoints open to ProjectMember and the Telemetry tiers while the
+ * model-backed CRUD API refused them, and the attribute keys and values of a
+ * SIEM table are themselves the sensitive part - usernames, hostnames, source
+ * IPs, and every value seen for them.
  */
-const requireSecurityEventReadAccess: Array<RequestHandler> =
-  createTelemetryReadAccessGuard(Permission.ReadSecurityEvent);
+const requireSecurityEventReadAccess: Array<RequestHandler> = [
+  UserMiddleware.getUserMiddleware,
+  UserMiddleware.requireUserAuthentication,
+  UserMiddleware.requirePermission({
+    permissions: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.SecurityAdmin,
+      Permission.SecurityMember,
+      Permission.SecurityViewer,
+      Permission.ReadSecurityEvent,
+    ],
+  }),
+];
 
 router.post(
   "/telemetry/metrics/get-attributes",
@@ -346,6 +366,24 @@ router.post(
         );
       }
 
+      /*
+       * Bound the array before sanitizing it. sanitizeMinifiedStackFrames
+       * never throws and never truncates, so without this the only limit on
+       * the work a caller can ask for is the body-size cap.
+       */
+      if (
+        (body["frames"] as Array<unknown>).length >
+        MAX_FRAMES_PER_RESOLVE_REQUEST
+      ) {
+        return Response.sendErrorResponse(
+          req,
+          res,
+          new BadDataException(
+            `frames must contain at most ${MAX_FRAMES_PER_RESOLVE_REQUEST} stack frames.`,
+          ),
+        );
+      }
+
       const frames: Array<MinifiedStackFrame> =
         SourceMapResolver.sanitizeMinifiedStackFrames(body["frames"]);