#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 leap(year) = calc.rem(year, 4) == 0 and (calc.rem(year, 100) != 0 or calc.rem(year, 400) == 0) #let day-index(year, month, day) = { let prior = (0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334) let previous = year - 1 365 * previous + int(calc.floor(previous / 4)) - int(calc.floor(previous / 100)) + int(calc.floor(previous / 400)) + prior.at(month - 1) + day + if month > 2 and leap(year) { 1 } else { 0 } } #let timestamp-day(value) = { let source = str(value) let iso = source.match(regex("^(\\d{4})-(\\d{2})-(\\d{2})")) if iso != none { day-index(int(iso.captures.at(0)), int(iso.captures.at(1)), int(iso.captures.at(2))) } else { let milliseconds = source.match(regex("^/Date\\((-?\\d+)")) if milliseconds == none { none } else { day-index(1970, 1, 1) + int(calc.floor(float(milliseconds.captures.at(0)) / 86400000)) } } } #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) { let first-event = observations.find(item => item.id == group.evidence.first()) let event-day = timestamp-day(get(first-event.value, "TimeCreated", default: get(first-event.value, "time_created", default: get(first-event.value, "TimeGenerated", default: "")))) let reference-day = timestamp-day(sys.inputs.at("reference-time")) let age = if event-day == none or reference-day == none { none } else { calc.max(0, reference-day - event-day) } let starts = get(rule, "fade_after_days", default: 7) let half = calc.max(starts + 1, get(rule, "fade_to_half_days", default: 90)) let weight = if age == none or age <= starts { 1.0 } else { calc.max(0.5, 1.0 - 0.5 * (age - starts) / (half - starts)) } finding.insert("relevance_weight", weight) if age != none { finding.insert("age_days", age) } } 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)) } } // Preserve the device exceptions that the earlier diagnostic report surfaced. #let device-section = get(capture.sections, "problem_devices") #if type(device-section) == dictionary and type(get(device-section, "data")) == array { let device-evidence = () for pair in device-section.data.enumerate() { let device = pair.last() if type(device) == dictionary and "text" not in device { let id = "device-problem-" + str(pair.first() + 1) observations.push((id: id, section: "problem_devices", source_pointer: pointer(("sections", "problem_devices", "data", pair.first())), value: device)) device-evidence.push(id) let code = get(device, "ConfigManagerErrorCode", default: get(device, "Problem", default: 0)) if code == 22 or str(code).contains("CM_PROB_DISABLED") { let name = text(get(device, "FriendlyName", default: get(device, "Name", default: "Device"))) findings.push((id: "device-disabled-" + str(pair.first() + 1), severity: "warning", confidence: if complete { 99 } else { 50 }, title: name + " is disabled (Code 22)", description: "The device is disabled. This does not establish hardware failure or who disabled it.", evidence: (id,))) } } } if device-evidence.len() > 0 { findings.push((id: "devices-report-problems", severity: "warning", confidence: if complete { 90 } else { 50 }, title: "Devices report problems", description: str(device-evidence.len()) + " present device(s) did not report a healthy state.", evidence: device-evidence)) } } #if type(get(capture, "legacy")) == dictionary { sections.insert("legacy_conversion", (status: "unavailable", record_count: 1, truncated: false, reason: "Converted from a formatted text report; some evidence cannot be recovered.")) observations.push((id: "legacy-conversion", section: "legacy_conversion", source_pointer: "/legacy", value: capture.legacy)) findings.push((id: "legacy-incomplete-evidence", severity: "warning", confidence: 100, title: "Legacy conversion has incomplete evidence", description: "This report was converted from formatted text. Table rows and event-message formatting may have been lost. Unrecoverable inventories and device/firewall states are unavailable; empty converted storage is not evidence that no disks exist. Legacy event dates retain their original format and receive no age discount.", evidence: ("legacy-conversion",))) } #if source-warnings.len() > 0 { sections.insert("source_warnings", (status: "ok", record_count: source-warnings.len(), truncated: false)) for pair in source-warnings.enumerate() { let id = "collector-warning-" + str(pair.first() + 1) observations.push((id: id, section: "source_warnings", source_pointer: pointer(("warnings", pair.first())), value: pair.last())) findings.push((id: id, severity: "warning", confidence: 100, title: "Collector warning", description: pair.last(), evidence: (id,))) } } #for (section-name, phrase, excluded, id, severity, title, description) in ( ("component_store", "repairable", "non-repairable", "component-store-repairable", "warning", "Windows component store is repairable", "DISM found component-store corruption and classified the image as repairable with RestoreHealth."), ("system_file_check", "integrity violations", "did not find any integrity violations", "system-file-integrity-violations", "critical", "System-file integrity violations", "SFC verification found integrity violations; review CBS.log and repair after DISM."), ) { let section = get(capture.sections, section-name) if type(section) == dictionary { let lines = get(section, "legacy_raw", default: ()) if type(lines) != array { lines = () } let observed-value = lines let source-pointer = pointer(("sections", section-name, "legacy_raw")) if lines.len() == 0 { let records = get(section, "data", default: ()) if type(records) == array and records.len() > 0 and type(records.first()) == dictionary { let recorded = get(records.first(), "output") if type(recorded) == array { lines = recorded.map(str); observed-value = recorded } else if type(recorded) == str { lines = (recorded,); observed-value = recorded } if type(recorded) in (array, str) { source-pointer = pointer(("sections", section-name, "data", 0, "output")) } } } let output-text = if lines.len() > 0 { str(lines.map(str).join("\n")) } else { "" } if lower(output-text).contains(phrase) and not lower(output-text).contains(excluded) { let observation-id = "check-" + section-name observations.push((id: observation-id, section: section-name, source_pointer: source-pointer, value: observed-value)) findings.push((id: id, severity: severity, confidence: if complete { 98 } else { 50 }, title: title, description: description, evidence: (observation-id,))) } } } #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)