171 lines
11 KiB
Plaintext
171 lines
11 KiB
Plaintext
#let capture = json(sys.inputs.at("capture"))
|
|
#let rules = json(sys.inputs.at("rules"))
|
|
#let watchlist = json(sys.inputs.at("watchlist"))
|
|
#let get(data, key, default: none) = data.at(key, default: default)
|
|
#let text(value) = if value == none { "" } else { str(value) }
|
|
#let slug(value) = { let out = lower(str(value).replace(regex("[^A-Za-z0-9._:-]+"), "-").trim("-")); if out == "" { "unknown" } else { out } }
|
|
#let timestamp(value) = type(value) == str and value.match(regex("^[0-9]{4}-[0-9]{2}-[0-9]{2}T.*(Z|[+-][0-9]{2}:[0-9]{2})$")) != none
|
|
#let pointer(parts) = "/" + parts.map(value => str(value).replace("~", "~0").replace("/", "~1")).join("/")
|
|
#let rule-for(provider, id) = rules.find(rule => rule.provider == provider and str(rule.event_id) == str(id))
|
|
|
|
#let normalize-section(section) = {
|
|
if type(section) != dictionary { return (status: "unavailable", record_count: none, truncated: false, reason: "Legacy section is not an object.") }
|
|
let source = get(section, "status")
|
|
let status = if source in ("ok", "skipped", "unavailable") { source } else { "unavailable" }
|
|
let count = get(section, "count")
|
|
if type(count) != int or count < 0 { let data = get(section, "data"); count = if type(data) == array { data.len() } else { none } }
|
|
let truncated = get(section, "truncated", default: false)
|
|
let result = (status: status, record_count: count, truncated: if type(truncated) == bool { truncated } else { false })
|
|
if status != "ok" {
|
|
let reason = get(section, "error")
|
|
if type(reason) != str or reason.match(regex("\\S")) == none {
|
|
reason = if source in ("skipped", "unavailable") { "Legacy capture marked section " + status + " without a reason." } else { "Legacy capture used unsupported section status: " + str(source) + "." }
|
|
}
|
|
result.insert("reason", reason)
|
|
}
|
|
result
|
|
}
|
|
#let event-signature(provider, id, time, message) = json.encode((provider, text(id), text(time).replace(regex("\\.[0-9]+Z$"), "Z"), text(message).replace(regex("\\s+"), " ")))
|
|
#let add-event(section, index, event, time-field, provider-field, id-field) = {
|
|
let time = get(event, time-field, default: get(event, if time-field == "TimeCreated" { "time_created" } else { "TimeCreated" }))
|
|
let provider = str(get(event, provider-field, default: get(event, if provider-field == "ProviderName" { "provider_name" } else { "ProviderName" }, default: "Unknown provider")))
|
|
let id = get(event, id-field, default: get(event, if id-field == "Id" { "id" } else { "Id" }, default: "unknown"))
|
|
let item = (id: "event-" + slug(section) + "-" + str(index + 1), section: section, source_pointer: pointer(("sections", section, "data", index)), value: event,
|
|
_provider: provider, _event_id: id, _signature: event-signature(provider, id, time, get(event, "Message", default: get(event, "message", default: ""))))
|
|
if timestamp(time) { item.insert("observed_at", time) }
|
|
item
|
|
}
|
|
#let watch-matches(matcher) = {
|
|
let section = get(capture.sections, matcher.section)
|
|
if type(section) != dictionary or get(section, "status") != "ok" or type(get(section, "data")) != array { return () }
|
|
let matches = ()
|
|
for pair in section.data.enumerate() {
|
|
let item = pair.last()
|
|
if type(item) == dictionary {
|
|
let raw = text(get(item, matcher.field, default: "")).trim("\"").replace("\\", "/")
|
|
let identity = if get(matcher, "basename", default: false) { raw.split("/").last() } else { raw }
|
|
let accepted = matcher.values.map(value => lower(str(value))).contains(lower(identity))
|
|
let versions = get(matcher, "versions")
|
|
let version-ok = versions == none or versions.contains(text(get(item, get(matcher, "version_field", default: "DriverVersion"), default: "")))
|
|
let enabled-ok = not get(matcher, "enabled_only", default: false) or get(item, "State") in (2, "Enabled", "enabled")
|
|
if accepted and version-ok and enabled-ok { matches.push((section: matcher.section, index: pair.first(), item: item)) }
|
|
}
|
|
}
|
|
matches
|
|
}
|
|
|
|
#let version = get(capture, "schema_version")
|
|
#assert(type(version) == int and version in (1, 2), message: "unsupported legacy capture schema version")
|
|
#assert(type(get(capture, "sections")) == dictionary, message: "legacy capture requires an object at /sections")
|
|
#assert(timestamp(get(capture, "generated_at")), message: "/generated_at requires a timezone-qualified timestamp")
|
|
#assert(timestamp(sys.inputs.at("reference-time")), message: "--reference-time requires a timezone-qualified timestamp")
|
|
|
|
#let sections = (:)
|
|
#for pair in capture.sections.pairs() { sections.insert(pair.first(), normalize-section(pair.last())) }
|
|
#let source-warnings = get(capture, "warnings", default: ()).map(str).filter(item => item.match(regex("\\S")) != none)
|
|
#let complete = sections.len() > 0 and sections.values().all(section => section.status == "ok" and not section.truncated) and source-warnings.len() == 0
|
|
#let collection-status = if complete { "complete" } else { "partial" }
|
|
#let selected = if version == 1 { ("recent_system_errors", "recent_application_errors") } else { ("recent_system_events", "recent_application_events") }
|
|
#let observations = ()
|
|
#for name in selected {
|
|
let section = get(capture.sections, name)
|
|
if type(section) == dictionary and type(get(section, "data")) == array {
|
|
for pair in section.data.enumerate() {
|
|
if type(pair.last()) == dictionary {
|
|
if version == 1 { observations.push(add-event(name, pair.first(), pair.last(), "time_created", "provider_name", "id"))
|
|
} else { observations.push(add-event(name, pair.first(), pair.last(), "TimeCreated", "ProviderName", "Id")) }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#let signatures = observations.map(item => item._signature)
|
|
#let reliability = get(capture.sections, "reliability_records")
|
|
#if type(reliability) == dictionary and type(get(reliability, "data")) == array {
|
|
for pair in reliability.data.enumerate() {
|
|
let record = pair.last()
|
|
if type(record) == dictionary {
|
|
let provider = str(get(record, "SourceName", default: "Unknown provider")); let id = get(record, "EventIdentifier", default: "unknown")
|
|
let rule = rule-for(provider, id); let signature = event-signature(provider, id, get(record, "TimeGenerated"), get(record, "Message", default: ""))
|
|
if rule != none and rule.severity in ("warning", "critical") and not signatures.contains(signature) {
|
|
observations.push(add-event("reliability_records", pair.first(), record, "TimeGenerated", "SourceName", "EventIdentifier")); signatures.push(signature)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#let groups = (:)
|
|
#for event in observations {
|
|
let key = json.encode((event._provider, str(event._event_id)))
|
|
let evidence = get(groups, key, default: (provider: event._provider, event_id: event._event_id, evidence: ()))
|
|
evidence.evidence.push(event.id); groups.insert(key, evidence)
|
|
}
|
|
#let findings = ()
|
|
#for group in groups.values() {
|
|
let rule = rule-for(group.provider, group.event_id)
|
|
if rule == none {
|
|
findings.push((id: "event-" + slug(group.provider) + "-" + slug(group.event_id), severity: "unanalysed", confidence: 0,
|
|
title: "Unanalysed event: " + group.provider + " / " + str(group.event_id), description: "The event is preserved for review; no migrated technical rule matches it.", evidence: group.evidence))
|
|
} else {
|
|
let confidence = if complete { rule.confidence } else { calc.min(50, rule.confidence) }
|
|
let finding = (id: "event-" + slug(group.provider) + "-" + slug(group.event_id), severity: rule.severity, confidence: confidence,
|
|
title: group.provider + " event " + str(group.event_id), description: rule.description, evidence: group.evidence)
|
|
if get(rule, "fading", default: false) { finding.insert("relevance_weight", 1.0) }
|
|
findings.push(finding)
|
|
}
|
|
}
|
|
|
|
#for entry in watchlist {
|
|
let matches = (); for matcher in entry.match { matches += watch-matches(matcher) }
|
|
let requirements = (); for matcher in get(entry, "requires", default: ()) { requirements.push(watch-matches(matcher)) }
|
|
let event-gate = get(entry, "events"); let event-evidence = ()
|
|
if event-gate != none { event-evidence = observations.filter(item => str(get(item.value, "ProviderName", default: get(item.value, "provider_name", default: ""))) == event-gate.provider and event-gate.ids.map(str).contains(str(get(item.value, "Id", default: get(item.value, "id", default: ""))))).map(item => item.id) }
|
|
if matches.len() > 0 and requirements.all(group => group.len() > 0) and (event-gate == none or event-evidence.len() >= event-gate.minimum) {
|
|
let evidence = ()
|
|
for item in matches + requirements.join() {
|
|
let id = "watch-" + slug(entry.id) + "-" + slug(item.section) + "-" + str(item.index + 1)
|
|
if not observations.any(observation => observation.id == id) { observations.push((id: id, section: item.section, source_pointer: pointer(("sections", item.section, "data", item.index)), value: item.item)) }
|
|
if not evidence.contains(id) { evidence.push(id) }
|
|
}
|
|
for id in event-evidence { if not evidence.contains(id) { evidence.push(id) } }
|
|
findings.push((id: "watchlist-" + entry.id, severity: "warning", confidence: if complete { 85 } else { 50 }, title: entry.title, description: entry.description, evidence: evidence))
|
|
}
|
|
}
|
|
|
|
#let warnings = source-warnings
|
|
#if not complete { warnings.push("Legacy capture collection is incomplete; finding confidence is capped at 50.") }
|
|
#warnings.push("Migrated analyser supports " + str(rules.len()) + " event rules and " + str(watchlist.len()) + " candidate watchlist entries; unmatched events remain unanalysed.")
|
|
#let clean-observations = observations.map(item => {
|
|
let clean = item
|
|
let _ = clean.remove("_provider", default: none)
|
|
let _ = clean.remove("_event_id", default: none)
|
|
let _ = clean.remove("_signature", default: none)
|
|
clean
|
|
})
|
|
#let system = (host: get(capture, "host", default: (:)))
|
|
#if type(get(capture, "summary")) == dictionary { system.insert("legacy_summary", capture.summary) }
|
|
#let inventory = (:)
|
|
#for name in (
|
|
"operating_system", "computer_system", "bios", "cpu", "memory_modules",
|
|
"motherboard", "gpus", "storage", "network_adapters", "ip_configuration",
|
|
"dns_servers", "power_plan", "battery", "defender", "firewall_profiles",
|
|
"problem_devices", "automatic_services_not_running", "component_store",
|
|
"system_file_check",
|
|
) {
|
|
let section = get(capture.sections, name)
|
|
if type(section) == dictionary and type(get(section, "data")) == array {
|
|
inventory.insert(name, section.data)
|
|
}
|
|
}
|
|
#system.insert("inventory", inventory)
|
|
#let result = (
|
|
schema_version: 1,
|
|
metadata: (producer: (name: "win-diagnostics", version: sys.inputs.at("producer-version")), collected_at: capture.generated_at,
|
|
analysis_reference_time: sys.inputs.at("reference-time"), source: (artifact: sys.inputs.at("artifact"), schema_version: version, sha256: sys.inputs.at("artifact-hash"))),
|
|
system: system,
|
|
collection: (mode: get(capture, "mode", default: "Full"), status: collection-status, sections: sections),
|
|
observations: clean-observations,
|
|
findings: findings,
|
|
warnings: warnings,
|
|
)
|
|
#metadata(result) <diagnostic>
|