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.

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.

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 |

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
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.

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:
- Require an exact authoritative identifier or multiple independent, fresh identifiers.
- Refuse an automatic merge when two supposedly unique identifiers conflict.
- Preserve the losing IDs as aliases with validity intervals.
- Keep provenance for every moved observation and finding.
- Make the operation reversible.
- Recompute downstream findings rather than merely changing a display name.
A split receives the same care:
- Create or identify the correct canonical records.
- Divide observations by evidence and time range.
- Re-evaluate findings against each resulting asset.
- Reopen remediation work if a prior closure depended on the bad merge.
- 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-reconciliationEstablish 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: rejectStale 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.

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_expiryCISA 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.

My preferred loop is:
- Ingest the raw finding without discarding the scanner's target and timestamps.
- Resolve the observation to one canonical asset.
- Enrich it with owner, criticality, exposure, lifecycle state, and service relationships.
- Create or update one remediation item using a stable finding identity.
- Apply the fix to the intended resource and installation.
- Request a targeted rescan or authenticated inventory refresh.
- Confirm the original detection is absent on the same canonical asset and that the evidence is newer than the change.
- 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

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.