@oneuptime/common 13.0.5 → 13.0.6

package/Utils/NetworkDiscovery/DiscoveredDeviceBuilder.ts

@@ -9,7 +9,9 @@ import {
   isPingOnlyDiscoveredHost,
   monitoringMethodForDiscoveredHost,
 } from "./DiscoveryImportEligibility";
+import { normalizeNetbiosName } from "./NetbiosNameUtil";
 import { normalizeReverseDnsName } from "./ReverseDnsNameUtil";
+import { getShortHostname } from "./ShortHostnameUtil";
 
 /*
  * One discovered host -> one NetworkDevice, the same way everywhere.
@@ -38,15 +40,92 @@ export const MAX_DEVICE_NAME_LENGTH: number = 80;
 // NetworkDevice.description is stored to 500 characters; sysDescr can be 255+.
 export const MAX_DEVICE_DESCRIPTION_LENGTH: number = 500;
 
+/*
+ * NetworkDevice.dnsName is LongText (500), but a DNS name never exceeds 253
+ * characters and normalizeReverseDnsName refuses anything longer, so this is
+ * the real ceiling — kept as a constant so the column and the builder agree.
+ */
+export const MAX_DEVICE_DNS_NAME_LENGTH: number = 253;
+
 function truncate(value: string, maxLength: number): string {
   return value.length > maxLength ? value.substring(0, maxLength) : value;
 }
 
+/**
+ * How the scan being imported from wants its hosts named.
+ *
+ * REQUIRED on every naming function rather than optional, and that is the
+ * point of it. The Review dialog row, the device the dialog creates, the
+ * collision fallback, the Ping monitor's name and both auto-import paths all
+ * derive a name separately; an optional argument that one of them forgot
+ * would still compile, and the operator would tick a box next to
+ * "wb-0660-kds01" and get a device called "wb-0660-kds01.wbhq.com". A
+ * required one makes the compiler find every caller.
+ *
+ * The NetworkDeviceDiscoveryScan model satisfies this structurally, so a
+ * caller holding the scan passes the scan.
+ */
+export interface DiscoveredHostNaming {
+  /*
+   * Name devices by the first label of a fully qualified hostname (issue
+   * #3678). ON only when exactly `true`: the value comes out of a database
+   * row or an API payload, and "true" or 1 must not quietly rename a
+   * project's devices.
+   */
+  useShortDeviceNames?: boolean | null | undefined;
+}
+
+/**
+ * The name a discovered host has before any shortening: its sysName, its
+ * reverse-DNS name, its NetBIOS name, or its address. This is what
+ * `getDiscoveredHostDisplayName` shortens, and what the Review dialog shows
+ * beside a shortened name so the operator can see what was cut.
+ */
+export function getDiscoveredHostFullName(
+  host: DiscoveredNetworkDevice,
+): string {
+  /*
+   * The PTR name is re-normalised here rather than trusted from the column.
+   * `discoveredDevices` is jsonb stored verbatim from the probe's payload, so
+   * "the probe already checked it" holds only for the probe version that
+   * wrote the row — not for a result from an older or a modified probe, and
+   * not for a row written straight through the API. This function is the last
+   * point before the value becomes a rendered line and a slugified device
+   * name, so it is the right place to be sure. See ReverseDnsNameUtil.
+   *
+   * The NetBIOS name is re-normalised here for the same reason, and with more
+   * cause: it is not even a published record but whatever the host at that
+   * address chose to answer (issue #3677). A stored "WORKSTATION01   " — the
+   * raw, space-padded, upper-cased wire form an older or modified probe might
+   * write — is read as "workstation01", and anything that fails the rules
+   * falls through to the address. See NetbiosNameUtil.
+   */
+  /*
+   * `sysName` is read through a typeof guard rather than trusted, for the
+   * same reason `dnsHostname` is normalised: both come out of the same
+   * verbatim jsonb blob, where the declared TypeScript type is a description
+   * of what the probe SHOULD send rather than a guarantee about what is
+   * stored. `(42).trim()` is a TypeError, and since this function became the
+   * dashboard's name line that TypeError would be thrown during render —
+   * taking out the whole Review dialog rather than one row, which is
+   * precisely the failure normalizeDiscoveredHosts was written to end.
+   */
+  const sysName: string =
+    typeof host.sysName === "string" ? host.sysName.trim() : "";
+
+  return (
+    sysName ||
+    normalizeReverseDnsName(host.dnsHostname) ||
+    normalizeNetbiosName(host.netbiosName) ||
+    String(host.ipAddress ?? "")
+  );
+}
+
 /**
  * What a discovered host is CALLED — in the Review dialog, and (clamped by
  * `buildDeviceName`) on the device it imports as.
  *
- * Three sources, in this order, first non-empty wins:
+ * Four sources, in this order, first non-empty wins:
  *
  *   1. `sysName`, the name the device gives for itself over SNMP. It stays
  *      first because it always has been, and because it is the one name the
@@ -58,7 +137,17 @@ function truncate(value: string, maxLength: number): string {
  *      before this it fell straight through to its address. On an estate that
  *      keeps DNS records — the reporter's does — that turns a review list of
  *      "10.18.166.51, 10.18.166.53, ..." into names an operator recognises.
- *   3. The address, unchanged, when neither name exists.
+ *   3. `netbiosName`, the name the host answered a NetBIOS node status query
+ *      with (OneUptime issue #3677), for the hosts neither of the above names:
+ *      no SNMP, no PTR record — on a Windows estate, most of them. It ranks
+ *      BELOW the PTR name because it is self-reported by whatever sits at the
+ *      address rather than published by whoever runs DNS, and because a PTR
+ *      name carries the domain the short-name option and `dnsName` depend on.
+ *      In practice the two rarely meet: the probe only asks hosts that have
+ *      neither a sysName nor a PTR name. The order is for the rows where they
+ *      do anyway — a result written through the API, or by a probe of another
+ *      version — so that every reader settles them the same way.
+ *   4. The address, unchanged, when no name exists.
  *
  * Split out of `buildDeviceName` so the dashboard row and the device it
  * creates cannot disagree: the operator ticks a box next to a name, and that
@@ -82,42 +171,40 @@ function truncate(value: string, maxLength: number): string {
  *     import paths must use it — the rule engine does, and the dashboard's
  *     Review-dialog import does since the same wildcard case made collisions
  *     ordinary rather than rare.
+ *
+ * SHORT NAMES (issue #3678). When the scan asks for them, whichever name won
+ * above is cut to its first label if it is a fully qualified hostname —
+ * sysName included, because network gear routinely reports its FQDN there and
+ * a list where only the PTR-named hosts were shortened would read as broken.
+ * The winner is shortened or kept; shortening never changes WHICH source
+ * wins, and an address is never shortened (see ShortHostnameUtil). The full
+ * reverse-DNS name is not lost: the builder stores it on the device as
+ * `dnsName`. A NetBIOS name passes through unchanged either way: it is a
+ * single dot-free label by construction, so there is nothing to cut, and
+ * getShortHostname declines it.
  */
 export function getDiscoveredHostDisplayName(
   host: DiscoveredNetworkDevice,
+  naming: DiscoveredHostNaming,
 ): string {
-  /*
-   * The PTR name is re-normalised here rather than trusted from the column.
-   * `discoveredDevices` is jsonb stored verbatim from the probe's payload, so
-   * "the probe already checked it" holds only for the probe version that
-   * wrote the row — not for a result from an older or a modified probe, and
-   * not for a row written straight through the API. This function is the last
-   * point before the value becomes a rendered line and a slugified device
-   * name, so it is the right place to be sure. See ReverseDnsNameUtil.
-   */
-  /*
-   * `sysName` is read through a typeof guard rather than trusted, for the
-   * same reason `dnsHostname` is normalised: both come out of the same
-   * verbatim jsonb blob, where the declared TypeScript type is a description
-   * of what the probe SHOULD send rather than a guarantee about what is
-   * stored. `(42).trim()` is a TypeError, and since this function became the
-   * dashboard's name line that TypeError would be thrown during render —
-   * taking out the whole Review dialog rather than one row, which is
-   * precisely the failure normalizeDiscoveredHosts was written to end.
-   */
-  const sysName: string =
-    typeof host.sysName === "string" ? host.sysName.trim() : "";
+  const fullName: string = getDiscoveredHostFullName(host);
 
-  return (
-    sysName ||
-    normalizeReverseDnsName(host.dnsHostname) ||
-    String(host.ipAddress ?? "")
-  );
+  if (naming.useShortDeviceNames !== true) {
+    return fullName;
+  }
+
+  return getShortHostname(fullName) || fullName;
 }
 
 /** The name a discovered host imports under, clamped to the slug's ceiling. */
-export function buildDeviceName(host: DiscoveredNetworkDevice): string {
-  return truncate(getDiscoveredHostDisplayName(host), MAX_DEVICE_NAME_LENGTH);
+export function buildDeviceName(
+  host: DiscoveredNetworkDevice,
+  naming: DiscoveredHostNaming,
+): string {
+  return truncate(
+    getDiscoveredHostDisplayName(host, naming),
+    MAX_DEVICE_NAME_LENGTH,
+  );
 }
 
 /**
@@ -129,7 +216,10 @@ export function buildDeviceName(host: DiscoveredNetworkDevice): string {
  * sysName cut down first so the composed string still fits under the same
  * ceiling.
  */
-export function buildFallbackDeviceName(host: DiscoveredNetworkDevice): string {
+export function buildFallbackDeviceName(
+  host: DiscoveredNetworkDevice,
+  naming: DiscoveredHostNaming,
+): string {
   /*
    * The address is read through the SAME coercion the display path uses, not
    * straight out of the jsonb.
@@ -152,7 +242,7 @@ export function buildFallbackDeviceName(host: DiscoveredNetworkDevice): string {
    */
   const suffix: string = address ? ` (${address})` : "";
 
-  const baseName: string = buildDeviceName(host);
+  const baseName: string = buildDeviceName(host, naming);
 
   /*
    * Clamped as a whole, not just the base. `Math.max(1, ...)` keeps a
@@ -183,8 +273,13 @@ export function buildFallbackDeviceName(host: DiscoveredNetworkDevice): string {
  * SELECTED by every caller, or the credentials silently arrive undefined and
  * the device is created as a ping-only one. That is what
  * Common/Tests/Server/Services/AutoImportScanCredentialSelect.test.ts pins.
+ *
+ * `useShortDeviceNames` is the scan's naming choice (issue #3678), which is
+ * why this interface extends DiscoveredHostNaming: the device's name is part
+ * of the recipe, so a caller that selected the scan without that column
+ * would import full names from a scan that asked for short ones.
  */
-export interface DiscoveredDeviceScanSource {
+export interface DiscoveredDeviceScanSource extends DiscoveredHostNaming {
   probeId?: ObjectID | undefined;
   snmpConfigs?: Array<DiscoveryScanSnmpConfig> | null | undefined;
   snmpVersion?: string | undefined;
@@ -214,9 +309,9 @@ export interface DiscoveredDeviceScanSource {
  * — issue #3447. Reachability is a built-in capability of every probe-polled
  * device now, so that dead end is gone.)
  *
- * The caller supplies the name (normally `buildDeviceName(host)`) so the
+ * The caller supplies the name (normally `buildDeviceName(host, scan)`) so the
  * name-collision retry can rebuild the same device under
- * `buildFallbackDeviceName(host)` without re-deciding anything else.
+ * `buildFallbackDeviceName(host, scan)` without re-deciding anything else.
  */
 export function buildNetworkDeviceFromDiscoveredHost(data: {
   projectId: ObjectID;
@@ -242,7 +337,7 @@ export function buildNetworkDeviceFromDiscoveredHost(data: {
 
   const device: NetworkDevice = new NetworkDevice();
   device.projectId = data.projectId;
-  device.name = data.name || buildDeviceName(host);
+  device.name = data.name || buildDeviceName(host, data.scan);
   /*
    * The address is the device's hostname AND the registered-host dedup key.
    *
@@ -266,6 +361,36 @@ export function buildNetworkDeviceFromDiscoveredHost(data: {
    */
   device.hostname = String(host.ipAddress ?? "").trim();
 
+  /*
+   * The full reverse-DNS name, kept on the device (issue #3678).
+   *
+   * Set whatever the scan's naming choice, because it is a fact about the
+   * host rather than a presentation: with short names on it is the only place
+   * the FQDN survives, and with them off it is still what lets a device be
+   * searched for, and matched by a site rule, by the name DNS gives it once
+   * someone renames it. Normalised again at the point of use for the reasons
+   * given on getDiscoveredHostFullName.
+   *
+   * Written only when there IS a name. An empty string is still a value on a
+   * create payload, and a device with no PTR record should read as "no DNS
+   * name", not as a DNS name that happens to be blank.
+   *
+   * Never taken from sysName: that is the name the device gives itself, it
+   * is already stored as sysName by the first poll, and calling it a DNS name
+   * would be a claim nothing checked.
+   *
+   * Never taken from `netbiosName` either, for the same reason with more
+   * force (issue #3677). A NetBIOS name is whatever the host at the address
+   * answered, not a record anyone published; storing it as a DNS name would
+   * make it searchable and matchable by site-assignment hostname patterns as
+   * though DNS had vouched for it. It names the device and goes no further.
+   */
+  const dnsName: string | undefined = normalizeReverseDnsName(host.dnsHostname);
+
+  if (dnsName) {
+    device.dnsName = truncate(dnsName, MAX_DEVICE_DNS_NAME_LENGTH);
+  }
+
   if (host.sysDescr) {
     device.description = truncate(host.sysDescr, MAX_DEVICE_DESCRIPTION_LENGTH);
   }

package/Utils/NetworkDiscovery/DiscoveredHostUtil.ts

@@ -1,4 +1,5 @@
 import { DiscoveredNetworkDevice } from "../../Models/DatabaseModels/NetworkDeviceDiscoveryScan";
+import { normalizeNetbiosName } from "./NetbiosNameUtil";
 import { normalizeReverseDnsName } from "./ReverseDnsNameUtil";
 
 /*
@@ -45,6 +46,9 @@ function isDiscoveredHostObject(
  * all — `dnsHostname` is a value the SCANNED NETWORK chooses, so it is
  * untrusted by construction rather than by accident, and it is normalised
  * here for the same reason: one reading of the payload for every reader.
+ * A fifth, `netbiosName` (issue #3677), is untrusted for the same reason and
+ * more so — the scanned host reports it about itself — and gets the same
+ * treatment.
  *
  * All of them are fixed here rather than at each call site, so the row the
  * operator sees, the badge above it, the list Import walks, and the hosts an
@@ -118,6 +122,27 @@ export function normalizeDiscoveredHosts(
       delete normalized.dnsHostname;
     }
 
+    /*
+     * The NetBIOS name, the same way and for a stronger version of the same
+     * reason (OneUptime issue #3677): a PTR record is at least published by
+     * someone, but this is whatever the machine at the address chose to say
+     * in reply to a UDP datagram. Normalised (trimmed, lower-cased, one
+     * 1-15 character label with a letter in it) rather than merely checked,
+     * so a row an older or a modified probe stored as "WORKSTATION01   "
+     * reads as "workstation01" to every reader. Anything that fails is
+     * DELETED, not blanked, for the `in`-versus-truthiness reason given above;
+     * a host that never had the key does not gain one.
+     */
+    const netbiosName: string | undefined = normalizeNetbiosName(
+      host.netbiosName,
+    );
+
+    if (netbiosName) {
+      normalized.netbiosName = netbiosName;
+    } else {
+      delete normalized.netbiosName;
+    }
+
     cleaned.push(normalized);
   }
 

package/Utils/NetworkDiscovery/NetbiosNameUtil.ts

@@ -0,0 +1,146 @@
+import { normalizeReverseDnsName } from "./ReverseDnsNameUtil";
+
+/*
+ * What a NetBIOS name is allowed to become, shared by the probe that asks for
+ * it and by every reader of the value it stored (OneUptime issue #3677).
+ *
+ * The problem this solves: a discovered host with no PTR record and no SNMP
+ * has nothing to be called but its address, and on a Windows-heavy estate
+ * that is most of the Review dialog. A NetBIOS node status (NBSTAT) query to
+ * UDP 137 is the one naming method that works across routed networks and from
+ * a probe on Kubernetes pod networking, so the probe asks it.
+ *
+ * The answer is SELF-REPORTED by the scanned host. Unlike a PTR record, which
+ * is at least published by whoever runs DNS for the subnet, a NetBIOS name is
+ * whatever the machine on the other end of the datagram chooses to say — and
+ * a discovery scan is routinely pointed at a subnet nobody in the project
+ * administers. The value goes on to be rendered in the Review dialog and to
+ * become a NetworkDevice's name and slug, so it is normalised HERE, by one pure
+ * function both sides call, and trusted nowhere else.
+ *
+ * Both sides, for the same reason as ReverseDnsNameUtil: `discoveredDevices`
+ * is jsonb written verbatim from the probe's payload, so the server's copy of
+ * these rules is what protects results stored by a probe of a different
+ * version, and rows written through the API by hand.
+ */
+
+/*
+ * RFC 1001/1002: a NetBIOS name is 16 bytes, the last of which is the service
+ * suffix (<00> workstation, <20> file server, ...). Fifteen is what is left for
+ * the name the operator would recognise.
+ */
+export const MAX_NETBIOS_NAME_LENGTH: number = 15;
+
+/*
+ * The browser-election pseudo-name. On the wire it is "\x01\x02__MSBROWSE__\x02"
+ * registered as a GROUP name with suffix <01>, and it names no machine at all:
+ * every master browser on a segment registers it. The control bytes already
+ * fail the label rule below; the bare spelling is refused explicitly as well,
+ * because a responder that strips the control bytes would otherwise hand us a
+ * perfectly label-shaped "__MSBROWSE__" to name a device after.
+ */
+const BROWSER_ELECTION_PSEUDO_NAME: string = "__msbrowse__";
+
+// Letters are what separate a name from a restated number (see below).
+const LETTER_PATTERN: RegExp = /[A-Za-z]/;
+
+/*
+ * Padding a NetBIOS responder may leave on the end of the 15-byte field.
+ * RFC 1001 pads with spaces; some embedded stacks pad with NULs instead, and a
+ * few mix the two. Any other whitespace counts too, so "HOST\u0000\t" is
+ * treated the same as "HOST \u0000" rather than failing on the order of its
+ * junk. Removed from the END only (leading whitespace is trimmed separately):
+ * a NUL or space in the MIDDLE of the field means the bytes were not a name,
+ * and the label rule refuses them.
+ */
+function isTrailingPadding(character: string): boolean {
+  return character === "\u0000" || character.trim() === "";
+}
+
+/*
+ * A manual scan rather than a `/[ \0]+$/` replace. The regex form backtracks
+ * quadratically on a long run of padding followed by one non-padding
+ * character, and on the server side this function reads jsonb values of any
+ * length — a hostile row must not be able to turn a render into a busy loop.
+ */
+function stripTrailingPadding(value: string): string {
+  let end: number = value.length;
+
+  while (end > 0 && isTrailingPadding(value.charAt(end - 1))) {
+    end--;
+  }
+
+  return value.substring(0, end);
+}
+
+/**
+ * The name a NetBIOS answer may be stored and displayed as, or undefined when
+ * the answer is not usable as one.
+ *
+ * Accepts `unknown` rather than `string` on purpose: on the server the input is
+ * read out of a jsonb column, and "the probe sent a number" has to return
+ * undefined rather than throw inside a render.
+ *
+ * The LABEL rule is exactly ReverseDnsNameUtil's — letters, digits, underscore
+ * and hyphen, with no leading or trailing hyphen — and is applied by calling
+ * that normaliser on a value already known to contain no dot, rather than by a
+ * second copy of the pattern. Two copies of a validation regex drift; one
+ * called twice cannot. A single dot-free label that passes
+ * normalizeReverseDnsName unchanged is precisely one label that passes
+ * LABEL_PATTERN and is not all digits.
+ *
+ * Case is DISCARDED, unlike a PTR name's. NetBIOS upper-cases names on the
+ * wire, so "WORKSTATION01" says nothing about how its owner writes it;
+ * lower case matches the DNS names the rest of the estate shows, and device
+ * name uniqueness ignores case anyway.
+ */
+export function normalizeNetbiosName(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+
+  const candidate: string = stripTrailingPadding(value).trim();
+
+  if (!candidate || candidate.length > MAX_NETBIOS_NAME_LENGTH) {
+    return undefined;
+  }
+
+  /*
+   * NetBIOS names have no dots. Refused BEFORE the label check, which would
+   * otherwise accept "host.corp" as a two-label DNS name — and silently strip a
+   * trailing root dot off "HOST." into a name the host never reported.
+   */
+  if (candidate.includes(".")) {
+    return undefined;
+  }
+
+  /*
+   * Must come back UNCHANGED. normalizeReverseDnsName trims and drops a root
+   * dot; neither can apply here (already trimmed, no dots), so any difference
+   * at all means the value was rewritten, and a rewritten name is an invented
+   * one.
+   */
+  if (normalizeReverseDnsName(candidate) !== candidate) {
+    return undefined;
+  }
+
+  /*
+   * At least one LETTER, which is stricter than the DNS rule's "not every label
+   * numeric": "10-18-167" and "____" are single labels that pass it but read
+   * as an address or as nothing, and a name is only worth showing when it is
+   * more useful than the address it replaces.
+   */
+  if (!LETTER_PATTERN.test(candidate)) {
+    return undefined;
+  }
+
+  const lowerCased: string = candidate.toLowerCase();
+
+  if (lowerCased === BROWSER_ELECTION_PSEUDO_NAME) {
+    return undefined;
+  }
+
+  return lowerCased;
+}
+
+export default normalizeNetbiosName;