vulnerability-management · · 11 min read

Asset Identity Is the Hidden Failure in Vulnerability Management

#

Asset Identity Is the Hidden Failure in Vulnerability Management

A vulnerability scanner can be technically correct and still send the remediation program in the wrong direction.

It can find the right CVE on the right service at the time of the scan. The trouble begins when the result is attached to the synthetic documentation address 192.0.2.41, web-01, or another label that later belongs to a different system. A patch team closes the finding against a record that survived a rebuild. A dashboard counts one host twice because its agent and scanner use different names. A deleted virtual machine remains open in the queue while its replacement inherits the same address and an entirely different risk profile.

These look like scanning or ticketing failures. I treat them first as identity failures.

NIST's asset identification specification starts from the same operational need: different information sets must be correlated to the same asset, using known identifiers and information about that asset. CISA makes asset discovery and vulnerability enumeration distinct activities in Binding Operational Directive 23-01. That distinction matters. Discovering an address answers, "What responded?" It does not, by itself, answer, "Which enduring asset record should own this observation?"

A usable vulnerability-management pipeline needs a canonical identity model between discovery and remediation. Without that layer, severity scores, service-level objectives, and closure metrics rest on unstable joins.

Names and addresses are observations, not identity

Hostnames and IP addresses are valuable evidence. They are poor primary keys.

Names and addresses are observations, not identity

A DHCP lease moves. A cloud interface is detached and attached elsewhere. A DNS record is updated during a blue-green deployment. A short hostname is repeated in separate domains. A cluster virtual IP represents a service rather than any one node. A network address translation boundary causes several internal assets to appear under one external address. NetBox reflects this distinction in its data model: an IP address is assigned to an interface, and a device or virtual machine may designate an assigned address as primary. The address is related to the asset. It is not the asset.

Rebuilds create a second trap. Suppose app-07.example.test is destroyed and recreated from an image. The operator intends continuity of service, so the hostname, IP address, application role, and ticket assignment remain. The hypervisor creates a new virtual machine ID. The operating system creates a new machine identity. The endpoint agent enrolls with a new ID. Is this the same asset?

There is no universal answer because several valid identities overlap:

  • Resource identity: the particular VM, cloud instance, container, appliance, or physical device.
  • Installation identity: the operating-system installation running on that resource.
  • Agent identity: the registration known to Wazuh, Fleet, an EDR platform, or another control plane.
  • Service identity: the business service or workload role that users depend on.
  • Record identity: the canonical object used by the CMDB or source of truth.

The rebuilt machine may continue the same service identity while receiving new resource, installation, and agent identities. If the data model collapses all five into a hostname, the pipeline cannot represent that truth.

Build a canonical asset record

I assign each governed asset a generated, opaque canonical_asset_id. It is not copied from a hostname, IP address, serial number, or vendor ID. Those values become typed identifiers attached to the canonical record.

Build a canonical asset record

A compact schema can look like this:

canonical_asset_id: ast_01J8YQ4Q0N7H3MRP6A2K5T9CDE
asset_class: virtual_machine
lifecycle_state: active
service_id: svc_customer_portal
owner: platform-operations
criticality: high
identifiers:
  - type: hypervisor_vm_uuid
    value: 4217d7c1-9ca8-4b73-a723-1a8d2ce99122
    authority: virtualization-api
    immutable_within: resource_lifetime
  - type: os_machine_id
    value_hmac: "hmac-sha256:key-v3:8c1b..."
    hmac_key_owner: asset-correlation-service
    comparison_scope: os_machine_id
    authority: authenticated-osquery
    immutable_within: installation_lifetime
  - type: wazuh_agent_id
    value: "087"
    authority: wazuh-manager
    immutable_within: enrollment_lifetime
  - type: fqdn
    value: app-07.example.test
    authority: dns-and-config-management
    mutable: true
  - type: ipv4
    value: 192.0.2.41
    authority: ipam
    mutable: true
relationships:
  replaced_asset_id: ast_01J5OLDRESOURCE00000000000
observations:
  - source: greenbone
    observed_at: 2026-09-20T08:14:32Z
    target: 192.0.2.41
  - source: wazuh-syscollector
    observed_at: 2026-09-20T08:10:04Z
    agent_id: "087"

The opaque key prevents a mutable property from quietly becoming identity. The identifier list preserves the evidence needed for deterministic matching. immutable_within also makes the boundary explicit. A cloud instance ID is stable for one instance, not for the service forever. An agent ID is stable for one enrollment, not necessarily for the host forever.

This record should retain both the raw value and its source. If an identifier is sensitive, the correlation store can keep an HMAC while the authoritative system retains the original. The HMAC key needs a named owner, rotation process, version identifier, and a comparison scope that prevents unrelated identifier types from sharing one namespace. The scope belongs inside the authenticated input, for example HMAC(key_v3, "os_machine_id\0" || normalized_machine_id), not only beside the digest as metadata. Hashing does not repair a weak identifier, and deterministic HMAC values remain pseudonymous correlators rather than anonymized data. A properly managed keyed construction still reduces unnecessary exposure and resists offline guessing better than plain SHA-256 when the key remains protected.

Prefer immutable provider IDs, with boundaries

The strongest practical identifiers usually come from the system that created the resource:

Asset type Preferred identifiers Important boundary
Physical server manufacturer serial plus hardware UUID Boards can be replaced; firmware values can be blank or duplicated
Hypervisor VM hypervisor or vCenter VM UUID Clone and restore behavior must be tested
AWS workload account ID, region, instance ID Recreated instances get new IDs
Azure workload tenant/subscription plus resource ID and VM ID Resource moves and recreation need explicit handling
GCP workload organization/project plus numeric instance ID Names are reusable
Kubernetes object cluster ID plus object UID Pods are intentionally short-lived
OS installation machine ID or platform equivalent Golden images must not ship a cloned ID
Endpoint agent manager scope plus agent UUID or ID Re-enrollment creates a new identity
Prefer immutable provider IDs, with boundaries

An immutable ID is only immutable inside its issuing authority. i-0123456789abcdef0 without its AWS account and region is incomplete. Agent 087 without the Wazuh manager or tenant is ambiguous. A VM UUID copied by a broken cloning process is evidence of a collision, not permission to merge two machines.

Wazuh Syscollector can contribute hardware, operating-system, installed-software, interface, port, process, service, user, and group inventory from its agents. Fleet and osquery can serve a similar endpoint-inventory role. These are rich observations, but I still keep the agent registration separate from the canonical asset. An agent can be stale, cloned, or re-enrolled.

Make matching deterministic

I process identity evidence from strongest to weakest and stop when the result becomes ambiguous. A simple policy might be:

match_policy:
  exact:
    - [provider_scope, cloud_instance_id]
    - [hypervisor_scope, hypervisor_vm_uuid]
    - [agent_manager, agent_uuid]
    - [manufacturer, serial_number, hardware_uuid]
  corroborated:
    - [fqdn, mac_address, observed_subnet]
    - [ip_address, fqdn, os_fingerprint]
  prohibited_as_sole_key:
    - display_name
    - short_hostname
    - ip_address
    - mac_address
  on_ambiguity: quarantine_for_review
Make matching deterministic

The corroborated rules should be time bounded. An IP-to-hostname match observed six months ago should not merge today's scan automatically. A MAC address can be duplicated by cloning or virtual networking. Even a serial number can be malformed. Weak evidence becomes useful when several independent observations agree within a defined freshness window.

The matcher should emit a reason, confidence class, and evidence set, not just an asset ID:

{
  "observation_id": "obs_greenbone_20260920_48122",
  "decision": "matched",
  "canonical_asset_id": "ast_01J8YQ4Q0N7H3MRP6A2K5T9CDE",
  "rule": "exact.hypervisor_vm_uuid",
  "evidence": ["virtualization-api", "scanner-target-map"],
  "decided_at": "2026-09-20T08:20:00Z"
}

That explanation is essential when an operator disputes ownership or when a later discovery proves the merge was wrong.

Define merge and split rules before the first collision

Identity resolution has two dangerous operations.

Define merge and split rules before the first collision

A merge says two records describe one asset. A split says observations assigned to one record actually describe different assets. Both operations affect finding history, ownership, exceptions, metrics, and audit evidence.

I use these merge rules:

  1. Require an exact authoritative identifier or multiple independent, fresh identifiers.
  2. Refuse an automatic merge when two supposedly unique identifiers conflict.
  3. Preserve the losing IDs as aliases with validity intervals.
  4. Keep provenance for every moved observation and finding.
  5. Make the operation reversible.
  6. Recompute downstream findings rather than merely changing a display name.

A split receives the same care:

  1. Create or identify the correct canonical records.
  2. Divide observations by evidence and time range.
  3. Re-evaluate findings against each resulting asset.
  4. Reopen remediation work if a prior closure depended on the bad merge.
  5. Record who approved the split and why.

Consider an address reused at noon. A Greenbone scan at 09:00 belongs to a retired Linux VM. A scan at 15:00 belongs to its Windows replacement. Moving every historical result for that IP to the new record would invent a vulnerability history the replacement never had. Identifier validity intervals prevent that:

identifier_binding:
  type: ipv4
  value: 192.0.2.41
  canonical_asset_id: ast_new_windows_vm
  valid_from: 2026-09-20T12:31:09Z
  valid_until: null
  asserted_by: dhcp-ipam-reconciliation

Establish source precedence by field

"The CMDB wins" is too blunt. A CMDB may be authoritative for owner and business service while the hypervisor is authoritative for VM existence and power state. DNS may own forward records while IPAM owns allocation. An authenticated agent can report installed packages more accurately than a remote scan, but it cannot decide whether the system is approved to exist.

I define precedence per field:

Field Primary source Secondary evidence Conflict action
Resource existence cloud or hypervisor API NetBox/CMDB Open reconciliation issue
Business owner CMDB or service catalog repository ownership Route to asset governance
IP allocation IPAM DHCP and cloud interface API Time-bound both observations
DNS name authoritative DNS agent FQDN Validate forward and reverse records
Installed packages authenticated Wazuh/Fleet/osquery credentialed scanner Compare collection time
Exposed service network scanner local listening-port inventory Investigate path and firewall context
Vulnerability state validated scanner or package evidence vendor advisory mapping Preserve detection method

NetBox is well suited to intended network and infrastructure state. GLPI can provide CMDB, ownership, and inventory workflows. Wazuh, Fleet, and osquery supply endpoint observations. Greenbone Community Edition, which includes the OpenVAS scanning stack, supplies network and vulnerability observations through its scanner and management components. DefectDojo can aggregate scanner findings and remediation workflow. OpenSearch can hold normalized observations, identity decisions, and reconciliation events.

None of these products should become the universal authority merely because it has a convenient dashboard.

Freshness is part of every fact

An asset fact without an observation time is a rumor that never expires.

Different facts age at different rates. A cloud instance's existence may need a five-minute tolerance. An agent heartbeat might be accepted for fifteen minutes. Package inventory may be acceptable for four hours. Ownership could be reviewed daily. Hardware serial data may remain useful for months, provided the resource still exists.

I represent freshness in policy, not in analyst memory:

freshness_policy:
  resource_existence: 10m
  ip_binding: 30m
  agent_heartbeat: 15m
  package_inventory: 6h
  authenticated_vulnerability_state: 24h
  business_owner: 7d
on_stale:
  identity_evidence: do_not_auto_merge
  vulnerability_status: unknown
  remediation_closure: reject

Stale does not always mean false. It means the pipeline can no longer use the fact for the specified decision without renewed evidence.

Reconcile the CMDB in both directions

A one-way import hides important failures. I compare expected assets to observed assets and observed assets to expected assets.

Reconcile the CMDB in both directions

The first direction finds approved assets with no recent scanner or agent evidence. The second finds active observations with no approved canonical record. I also compare one-to-many and many-to-one mappings:

  • one CMDB record mapped to several live immutable resource IDs
  • several CMDB records mapped to one agent ID
  • one IP currently claimed by multiple active assets
  • one asset with conflicting owners or criticalities
  • findings whose asset binding was made only from a reused name

The output should be a work queue, not a silent synchronization job:

ASSERT every_active_resource_has_one_canonical_asset
ASSERT every_canonical_asset_has_at_most_one_live_resource_identity
ASSERT every_open_finding_maps_to_one_active_or_retained_asset
ASSERT every_closed_finding_has_post_remediation_evidence
ASSERT every_exception_has_owner_and_expiry

CISA BOD 23-01 requires federal civilian agencies in its scope to perform recurring asset discovery and vulnerability enumeration, and its implementation guidance emphasizes that basic IP discovery does not replace hardware, software, or configuration management. Organizations outside that mandate can still use the operational lesson: frequent discovery is necessary, but identity reconciliation has to extend beyond addresses.

Close the remediation loop against the asset

A finding should not close because a ticket moved to Done.

Close the remediation loop against the asset

My preferred loop is:

  1. Ingest the raw finding without discarding the scanner's target and timestamps.
  2. Resolve the observation to one canonical asset.
  3. Enrich it with owner, criticality, exposure, lifecycle state, and service relationships.
  4. Create or update one remediation item using a stable finding identity.
  5. Apply the fix to the intended resource and installation.
  6. Request a targeted rescan or authenticated inventory refresh.
  7. Confirm the original detection is absent on the same canonical asset and that the evidence is newer than the change.
  8. Close the work item while retaining the before-and-after evidence.

DefectDojo can be the finding workflow layer, but its deduplication key should include the canonical asset ID rather than only scanner text, endpoint, or hostname. Greenbone can perform the verification scan. Wazuh or Fleet can confirm package or configuration state. OpenSearch can support timelines and exception reporting. NetBox or GLPI can receive reconciliation tasks when the identity or ownership record is wrong.

The loop must also handle replacement. If the vulnerable VM was destroyed, the old finding can be closed as asset-retired only after the resource authority confirms termination. The replacement gets its own scan and finding state. It does not inherit a clean bill of health from the deleted machine.

Test identity as aggressively as scanning

I use synthetic tests before trusting production joins:

Test Expected result
Reuse an IP for a new immutable VM ID Create a new canonical resource binding; do not move old findings
Rename a host without rebuilding it Preserve canonical asset and finding history
Rebuild a host with the same name Preserve service relationship; create new resource and installation identities
Clone an image with a copied machine ID Raise collision; refuse automatic merge
Re-enroll an agent Link old and new enrollment to the asset with separate validity periods
Receive stale scanner data after replacement Bind by observation time or quarantine
See two active assets claim one serial number Raise identity-integrity incident
Split a mistaken merge Restore finding ownership and recalculate metrics
Close after patch without fresh evidence Reject closure

A useful test fixture stores each source event, the expected canonical decision, and the expected reason. That makes identity rules reviewable code rather than hidden behavior in a dashboard.

The metric that changes the program

Once canonical identity exists, several honest metrics become possible:

  • percentage of live resources mapped to exactly one canonical asset
  • percentage of findings resolved by authoritative ID rather than a weak key
  • stale identifier bindings by source
  • merge and split review backlog
  • active assets without current vulnerability evidence
  • closed findings without a newer verification observation
  • mean time from ambiguous observation to resolved ownership
The metric that changes the program

I would rather report 92 percent deterministically identified coverage than claim 100 percent by joining on hostnames. The first number exposes work. The second hides it.

Vulnerability management begins with knowing what exists, but it succeeds only when every observation, decision, fix, and verification refers to the same thing. Canonical asset identity is not clerical CMDB work. It is the control that keeps the entire remediation loop attached to reality.

Read next