Generated banner for Security Planning
Generated logo for Security Planning

Security Planning

MicrosoftOfficialPublished by Microsoft

  • Skill
  • Tool integration
  • Security
  • MIT
  • Medium risk
  • Has scripts

From the author

Security planning and plan-drift analysis for STRIDE, standards, controls, backlog handoff, current findings, and TM7 generation.
— the description by Microsoft

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

Security Planning provides a structured framework for managing application security throughout the development lifecycle. It includes methodologies for STRIDE threat analysis, NIST control mapping, and data classification. The skill supports plan-drift analysis to correlate security baselines with current findings, and provides robust workflows for generating and validating Microsoft Threat Modeling Tool (TM7) files, including an optional Windows-native feedback loop for visual model validation.

What it does

  • Classifies application components into operational security buckets.
  • Performs STRIDE-based threat analysis with support for AI-specific extensions.
  • Maps security findings to industry standards and NIST control families.
  • Generates security-focused backlog items for implementation handoff.
  • Analyzes plan-drift by comparing security baselines against current repository findings.
  • Automates the generation of TM7 threat models and associated markdown reports.

When to use it

  • When performing initial security planning or threat modeling for an application.
  • When you need to reconcile an existing security plan with current audit or code review findings.
  • When preparing security-related work items for a development backlog.
  • When generating or updating TM7 threat model files for compliance or audit workflows.

Advantages

  • Provides a consistent, repeatable methodology for security planning and threat modeling.
  • Reduces manual effort in mapping security findings to regulatory standards.
  • Enables automated detection of drift between planned security controls and actual implementation.
  • Supports both portable markdown reporting and native integration with the Microsoft Threat Modeling Tool.

Usage examples

“Analyze my application components and generate a security backlog based on the current STRIDE findings.”
The agent will classify the components into operational buckets, perform a STRIDE analysis, and output a prioritized list of security work items formatted for your backlog.
“Compare my existing security baseline with these new code review findings to identify control drift.”
The agent will correlate the findings, filter out excluded paths, and produce a report detailing validated controls, residual risks, and any identified control drift.
“Generate a TM7 threat model file from my current YAML threat-model specification.”
The agent will process the specification and output a .tm7 file compatible with the Microsoft Threat Modeling Tool, along with a corresponding markdown report.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/microsoft/security-planning/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip security-planning.zip -d .agents/skills

Documentation by Microsoft

Security Planning

This skill packages durable security-planning and plan-drift analysis used by Security Planner, Security Reviewer, and Code Review: operational bucket guidance, STRIDE analysis patterns, standards cross-references, NIST control-family references, security-specific backlog formats, and correlation of a Security Planner baseline with current security findings.

When to use

Use this skill when you need to:

  • Classify application components into the operational security buckets used during planning.

  • Evaluate threats with STRIDE-based analysis, including AI-specific extensions when raiEnabled is true.

  • Map bucket findings to standards references and control families without re-embedding long standard tables.

  • Derive security-specific backlog priorities and RAI work item categories for Phase 5 handoff.

  • Correlate a Security Planner baseline with caller-supplied current findings to identify validated controls, control drift, residual planned risks, newly introduced threats, and obsolete plan items.

  • Generate a dual-output TM7 model plus markdown report from a YAML/JSON threat-model spec for human-reviewed audit workflows.

Security plan drift analysis

Use the drift capability when a Security Planner baseline and current-state security findings already exist. It correlates supplied evidence only: it does not scan, profile, select security skills, verify findings, re-rate severity, invoke another agent, or modify source, plan, reviewer, backlog, or state artifacts.

  1. Resolve and extract the baseline through drift-input-contracts.md.

  2. Normalize caller-supplied audit, diff, or Code Review findings without treating plan-mode evidence as repository state.

  3. Filter default exclusions, then classify only conclusions supported by drift-comparison-model.md.

  4. Render the direct, Security Reviewer, Security Planner, or Code Review adaptation from drift-report-contract.md.

  5. Use drift-worked-examples.md for deterministic behavior scenarios and expected category suppression.

Before full conversational or durable drift output, display the Security Planning CAUTION block in this skill verbatim. Report the default exclusions below in the canonical body's Current repository evidence section. A bounded Code Review section may point to these blocks because its containing review already carries the Code-Review disclaimer.

Default exclusions in effect. Planning and agent-customization artifacts are excluded from drift findings:

  • Paths: .copilot-tracking/**, docs/planning/**, docs/adrs/**, .github/agents/**, .github/prompts/**, .github/instructions/**, .github/skills/**

  • File globs: *.prompt.md, *.agent.md, *.instructions.md, SKILL.md

To override, pass scope= explicitly. Overlapping user scope wins and is reported as a warning.

A write-capable direct caller may create one sequence-safe report under .copilot-tracking/security-audits/<project-slug>/. Security Reviewer and Security Planner render in conversation. Code Review renders a bounded section and optional security_plan_drift field. Every destination keeps inputs read-only and recommends follow-up without dispatch.

Stop the affected conclusion when a baseline is incomplete, a required fact is unresolved, evidence scope does not cover the claim, or input format drift prevents exclusions. Report suppressed categories as insufficient evidence rather than zero findings. Stop the entire correlation when no baseline resolves or no finding location is available to enforce exclusions.

TM7 generation workflow

When the user asks for a TM7 threat model, the runtime can generate a .tm7 file and a matching markdown report from the same spec. The generator supports the pre-populated-comprehensive and diagram-only-defer-to-tmt modes and can update an existing model with --update. Use the generate_tm7.py and generate_markdown.py entry points with --template to select a profile.

The .tm7 output mirrors the Microsoft Threat Modeling Tool's real SerializableModelData DataContract and deserializes cleanly under the tool's own DataContractSerializer. Fidelity is validated against the tool's own assemblies by scripts/Deserialize-Tm7.ps1, which the pytest suite runs when the tool is installed and skips cleanly otherwise. See references/tm7-generation.md for the verified contract.

Native TM7 visual feedback workflow

The skill also supports an opt-in, Windows-local feedback loop for the native Microsoft Threat Modeling Tool UI. The feature is off by default. The generator and standard validator keep their existing portable behavior when the feedback flags are absent. Native feedback is enabled only when validate_tm7_with_tmt.py is run with --feedback-loop, --spec, and --overlay-output; optional --overlay-input, --max-iterations, and --require-feedback-evidence refine the execution contract.

The workflow requires Microsoft Threat Modeling Tool 7.3.51110.1, a Windows desktop session, and UI Automation access. The loop is bounded to a baseline run plus at most three refinement iterations, and defaults to a baseline plus one. A single run holds the mouse and keyboard continuously across the baseline and every refinement iteration; control returns only at the release notice. Replaying a corrected overlay is a new run and a new takeover. Exit codes, stop reasons, and the discovery-failure rules are defined in the generation reference.

The harness controls TMT windows and may open, close, and reopen the app for save/reopen validation. It emits a start notice before automation begins, progress updates for the baseline and each refinement candidate, and a release notice when the loop completes or aborts so the operator knows when control is returned. These are notices only; the harness does not block on operator acknowledgment. The agent-facing lockout and release obligations that surround a run are owned by references/tm7-generation-workflow.md.

The loop records one evidence bundle per run under the requested evidence directory, with per-iteration screenshots, UI Automation snapshots, summaries, and candidate models. A run that captured at least one surface and either passed the automated gates or stopped for layout exhaustion also emits agent-review-request.json at the bundle root. The overlay payload remains in approval_state: pending, and no runtime path or flag auto-promotes it to approved or rewrites the canonical baseline.

Scoring keeps deterministic geometry gates separate from advisory screenshot heuristics. Screenshot heuristics are not a semantic approval signal.

A Windows-native example uses the skill's locked Windows dependency group:

uv run --project "<security-planning-skill-root>" --group windows \
  python "<security-planning-skill-root>/scripts/validate_tm7_with_tmt.py" model.tm7 \
  --evidence-dir ./artifacts/feedback \
  --feedback-loop \
  --spec ./specs/model.yaml \
  --overlay-output ./artifacts/feedback/overlay.json \
  --max-iterations 3 \
  --require-feedback-evidence

Resolve <security-planning-skill-root> from the loaded skill location before running the command.

The overlay contract is versioned and deterministic. It carries layout intent in named rule collections and is invalidated unless its full fingerprint block matches, so a stale overlay is rejected rather than replayed onto a changed model.

See references/tm7-generation.md for the full CLI surface, exit codes, stop reasons, geometry thresholds, the evidence-bundle layout, the overlay fingerprint contract, and the operator runbook covering prerequisites, abort, recovery, and rollback.

Agent-assisted visual review

Some layout defects never reach a metric. TM7 persists no connector label geometry and UI Automation exposes no label element, so label collisions, unreadable label text, and visual crowding are invisible to the deterministic gates. An agent that reads the rendered screenshots can see them and author corrections into the overlay the harness publishes.

This review is a default step of every feedback-loop run, not an opt-in extra. A run that captured at least one surface and either passed the automated gates or stopped for layout exhaustion emits agent-review-request.json at the evidence root, carrying per surface the screenshot and UI Automation paths, the node and zone rectangles, the connector handle points, and the predicted label rectangles in model coordinates, plus the coordinate-translation constants and the port convention. The agent reviews from that payload rather than hand-parsing UI Automation trees. automated-ready-pending-human means the automated gates passed and the result awaits review; it is not an approval. The remedy remains documented rather than proven: it has not yet been demonstrated end to end on a real defect.

On the success path the published overlay addresses every captured surface, so a correction can be authored for any of them. When the run found no automated correction, that overlay is the seed shape, carrying an overlay-seed- identifier and empty rule collections. A layout-exhaustion stop publishes the same seed shape; a correctness or environment stop publishes nothing at all.

See references/tm7-generation.md for the protocol, the request payload, the accepted rule fields, the coordinate translation, and the constraints that bound an agent-authored overlay.

[!CAUTION] Disclaimer: This agent is an assistive tool only. It does not provide legal, regulatory, or compliance advice and does not replace professional security review boards, penetration testing teams, compliance auditors, legal counsel, or other qualified human reviewers. The output consists of suggested actions and considerations to support a user's own internal security review and decision‑making. All security plans, threat models, security models, and mitigation recommendations generated by this tool must be independently reviewed and validated by appropriate security and compliance reviewers before use. Outputs from this tool do not constitute security approval, compliance certification, or regulatory sign‑off.

The human-in-the-loop contract governing authorship confirmation, native feedback-loop operator safety, and layout overlay promotion is owned by references/tm7-generation-workflow.md. This skill owns the mechanics only.

Skill layout

Load the reference file that matches the phase or topic you need.

ReferenceTopic
references/00-index.mdNavigation catalog and consolidated attribution
references/operational-buckets.mdOperational bucket definitions, GS overlay, and classification guidance
references/stride-model.mdSTRIDE methodology, AI extensions, risk matrix, and data-flow analysis
references/standards-cross-reference.mdBucket-to-standards mapping table and component mapping output format
references/nist-control-families.mdNIST 800-53 priority tiers and NIST AI RMF subcategory mappings
references/backlog-formats.mdSecurity-specific prioritization and RAI work item categories
references/data-classification.mdPublic-safe data-classification taxonomy, tiers/categories/retention, and schema mapping
references/threat-model-review.mdThreat-model completeness checklist, PASS/INCOMPLETE verdict, and gap list
references/drift-input-contracts.mdSecurity Planner baseline extraction, normalized current-finding forms, evidence scope, and drift handling
references/drift-comparison-model.mdExclusions, evidence preconditions, five plan-drift categories, matching order, and recommendation-only handoffs
references/drift-report-contract.mdCanonical body and direct, Security Reviewer, Security Planner, and Code Review destination adaptations
references/drift-worked-examples.mdSynthetic complete, incomplete, malformed, diff-scoped, exclusion, and caller-regression behavior scenarios
references/tm7-generation-workflow.mdHuman-in-the-loop contract for TM7 generation: authorship confirmation, native feedback-loop operator safety, and layout overlay promotion
references/tm7-generation.mdTM7 input schema, dual-output generation contract, profile mapping, emission contract, native feedback loop, overlay and fingerprint contract, and operator runbook

Bundled executable and data resources:

ResourceUse
scripts/generate_tm7.pyRun to build a .tm7 from a threat-model spec
scripts/generate_markdown.pyRun to render the same spec as a markdown report
scripts/generate_tb7.pyRun to emit a template file
scripts/validate_tm7_with_tmt.pyRun for native Windows TMT validation and the opt-in feedback loop
scripts/Deserialize-Tm7.ps1Run to check round-trip fidelity against the tool's own assemblies
assets/schemas/tm7-layout-overlay.schema.jsonRead as the layout overlay schema
assets/schemas/tm7-agent-review-request.schema.jsonRead as the agent visual-review request schema
assets/schemas/tm7-visual-feedback-manifest.schema.jsonRead as the evidence manifest schema
templates/threat-model-spec-example.yamlCopy as the starting point for a new spec

The skill ships public defaults for the taxonomy and the completeness checklist. Organization-specific internal details such as internal data-type taxonomies, internal auth service names, and internal review-gate steps are supplied through a private config overlay referenced by state.overlayConfigPath and are never embedded in the public skill.

Attribution

The durable reference content in this skill is organized by reference file and summarized in references/00-index.md. See that index for the consolidated attribution and delegation notes.

Files

SECURITY.md


title: Security Planning Skill Security Model description: STRIDE threat model for the TM7 generation and native feedback runtime that parses untrusted specs, template XML, local screenshots, UI Automation traces, and overlay evidence with human-review gates author: microsoft/hve-core ms.topic: reference ms.date: 2026-08-05 estimated_reading_time: 8 keywords:

  • security

  • STRIDE

  • threat model

  • tm7

  • security-planning


Security Planning Skill Security Model

This document records the STRIDE threat model for the TM7 generation and native feedback runtime in the security-planning skill. The runtime now includes the generator, the native Microsoft Threat Modeling Tool validator, local UI Automation interaction, screenshot capture, evidence persistence, and overlay replay. The model is organized by trust bucket around the executable surfaces that the runtime directly touches: TMT process automation and UI Automation (B1), local screenshot and evidence capture (B2), and overlay and evidence path handling (B3). Each bucket enumerates all six STRIDE categories with the mitigations that address them. Assets and adversaries are enumerated first, and enterprise readiness gaps appear at the end. The runtime writes redacted evidence bundles under a local evidence root with manifest.json, status.json, action.log, and per-run screenshots/UIA/summaries folders, writes iteration-scoped candidate models and overlay.yaml files under iterations/00-baseline and iterations/01 through iterations/03, emits pending overlay outputs for human review, and never rewrites the canonical baseline or auto-promotes overlays to approved.

See also: repo-wide STRIDE model. This skill participates in the repository-wide threat model at docs/security/security-model.md and is registered in its Skill Security Models section.

Executive Summary

The highest-risk behavior is running a local executable against a threat-model artifact and then treating the resulting UI evidence and overlay as trustworthy enough for review, even though the automation only has partial visibility and the workflow must remain human-led. The runtime accepts a YAML or JSON spec, optional overlay inputs, a bundled template profile, and a local TM7 model, then drives Microsoft Threat Modeling Tool 7.3.51110.1 through process automation and UI Automation when the feedback loop is enabled. The workflow uses pinned versions, deterministic manifests, redaction, bounded timeouts, window-scoped capture, and a pending-approval overlay contract to prevent silent promotion or over-trust in visual scores.

Security Posture Overview
DimensionValue
Runtime surfaceLocal Python generator, native TMT validation harness, Windows UI Automation, screenshot capture, and evidence/overlay handling
Trust bucketsB1 TMT process automation and UI Automation; B2 local screenshots and evidence capture; B3 overlay-manifest and output path handling
CredentialsNone handled or persisted by the runtime; no network egress is expected
Network egressNone
Open residual gaps10 (executable trust, UIA ambiguity, evidence disclosure, evidence tampering, overlay tampering, path confinement, visual-score over-trust, automation stalls, marked-workspace deletion, local assembly loading)

Contents

  • System Description

  • Trust Boundaries

  • Assets

  • Adversaries

  • Bucket B1: TMT process automation and UI Automation

  • Bucket B2: Local screenshots and evidence capture

  • Bucket B3: Overlay manifest and output path handling

  • Enterprise Readiness Gaps

  • References

System Description

Components
  1. scripts/generate_tm7.py: loads and validates the input spec, selects a template profile, emits deterministic .tm7 content, and replays a validated overlay when requested.

  2. scripts/validate_tm7_with_tmt.py: discovers the local TMT executable, enforces the pinned version, launches the native UI, runs validation and feedback-loop modes, and writes redacted evidence bundles.

  3. scripts/tm7_visual_feedback.py: evaluates geometry metrics, derives overlay candidates, ranks them deterministically, and evaluates convergence and semantic regression.

  4. assets/schemas/: defines the overlay and evidence-manifest contracts that constrain replay and evidence output.

  5. Generated evidence and overlays: manifest.json, status.json, iteration bundles, screenshots, UIA snapshots, and pending overlay output written for human review.

Data Flow
flowchart TD
    subgraph INPUT["Local and untrusted runtime inputs"]
        SPEC["Threat-model spec"]
        OVERLAY["Overlay input"]
        MODEL["Existing TM7 model"]
    end
    subgraph RUNTIME["TM7 generation and feedback runtime"]
        GEN["Generator"]
        VALIDATE["TMT validator"]
        UIA["UI Automation capture"]
        EVIDENCE["Redacted evidence bundle"]
        OVERLAYOUT["Pending overlay output"]
    end
    SPEC --> GEN
    OVERLAY --> GEN
    MODEL --> VALIDATE
    GEN --> VALIDATE
    VALIDATE --> UIA
    UIA --> EVIDENCE
    EVIDENCE --> OVERLAYOUT

Trust Boundaries

Boundary Diagram
┌──────────────────────────────────────────────────────────────┐
│ TRUST BOUNDARY: local executable runtime                    │
│  ┌─────────────────┐  ┌─────────────────┐  ┌──────────────┐ │
│  │ Threat-model    │  │ Overlay/       │  │ TMT UIA and  │ │
│  │ spec and model  │  │ evidence files │  │ screenshots  │ │
│  └─────────────────┘  └─────────────────┘  └──────────────┘ │
└──────────────────────────────┬───────────────────────────────┘
                               │ consumed by runtime
   ┌───────────────────────────▼───────────────────────────────┐
   │ TRUST BOUNDARY: local TM7 generation and feedback runtime │
   │  ┌───────────────┐  ┌───────────────┐  ┌──────────────┐ │
   │  │ Generator     │  │ TMT validator │  │ Evidence     │ │
   │  │ + overlay     │  │ + UIA         │  │ writer       │ │
   │  └───────────────┘  └───────────────┘  └──────────────┘ │
   └──────────────────────────────────────────────────────────┘
Boundary Descriptions
BoundaryAssets ProtectedControls Enforced
Local executable runtimeIntegrity of the local TMT process and UI stateVersion pinning, executable metadata checks, harness-owned process tracking, bounded timeouts, no network egress
Evidence and overlay filesIntegrity of screenshots, manifests, and overlaysPath confinement, redaction, deterministic manifests, pending approval, human review before promotion

Assets

IdAssetLifetimeNotes
A1Threat-model specEphemeralYAML or JSON input that drives generation and overlay invalidation
A2TM7 model and candidate modelsEphemeral to persistentBaseline model plus candidate models generated for each iteration
A3Overlay payloadEphemeral to persistentVersioned replay rule that must remain pending until reviewed
A4TMT executable and UI Automation contextRuntimeLocal Windows executable and desktop session used to validate the model
A5Screenshots and UIA tracesPersistent within evidence bundleLocal-only evidence that may contain model content and layout details
A6Manifest and status filesPersistentRedacted evidence summary that records status, stop reason, and iteration data

Adversaries

IdAdversaryIn-scope mitigations
ADV-aAttacker supplies a forged or spoofed executable path to redirect the harness to an unintended binaryPath validation, executable metadata checks, pinned version, harness-owned process tracking
ADV-bAttacker causes UI Automation to select the wrong window or pane, or to interact with unrelated contentExplicit surface identity checks, fail-closed selection, bounded timeouts
ADV-cAttacker causes a hang, modal loop, or resource exhaustion in TMT or the harnessBounded timeouts, modal detection, clean shutdown, retry boundaries, evidence flush on exit
ADV-dAttacker or operator discloses sensitive model content through screenshots or UIA tracesText-evidence redaction, local-only evidence handling, window-handle-isolated capture, no network egress
ADV-eAttacker tampers with overlay manifests, fingerprints, or output pathsDeterministic manifest fingerprints, path confinement, strict schema validation, pending approval
ADV-fOperator over-trusts a visual score or pending overlay without semantic reviewHuman approval before promotion, semantic regression checks, no automatic promotion

Bucket B1: TMT process automation and UI Automation

Spoofing
  • Not applicable. The harness does not authenticate the discovered executable as an authority; it treats the local path and version as a runtime target and validates them before use.

Tampering
  • The runtime validates the executable path and pinned version before launch, and records the discovered executable metadata in the evidence manifest. It rejects mismatches rather than proceeding with an unverified binary.

Repudiation
  • Not applicable. The runtime does not claim an operator identity, but it does record a redacted action log and manifest for each run.

Information Disclosure
  • The runtime does not transmit evidence or process details over the network. It stores only local evidence bundles and redacted status records.

Denial of Service
  • The runtime uses bounded timeouts, handles unexpected modal windows as failures, and stops the loop on automation timeout or unexpected modal conditions.

Elevation of Privilege
  • The runtime does not grant code execution from the input model. It only launches a local desktop process and interacts with UI Automation controls that the host operator can access.

Risk Rating
ThreatLikelihoodImpactResidual RiskStatus
Executable discovery or path spoofing causes the harness to launch the wrong binaryLowHighMediumMitigated (absolute installation roots, Authenticode publisher check, pinned version, deterministic selection) (G-SPF-1)
UI Automation selects an unrelated window or paneMediumMediumMediumMitigated (explicit surface identity checks, fail-closed behavior) (G-TAM-1)
TMT hangs, modal loops, or resource exhaustion stops the run or leaves partial evidenceMediumMediumMediumMitigated (timeouts, modal handling, bounded iterations) (G-DOS-1)

Bucket B2: Local screenshots and evidence capture

Spoofing
  • Not applicable. Screenshots and UIA traces are captured from the local desktop session and are never treated as an identity proof.

Tampering
  • The runtime writes redacted evidence bundles with deterministic manifest and status records. It stores screenshots and UIA traces under a local evidence root rather than accepting externally supplied evidence paths.

Repudiation
  • Not applicable. The runtime records the evidence bundle and action log as machine-readable output, but it does not claim a human identity for a screenshot or UIA state.

Information Disclosure
  • Screenshot and UIA capture can reveal the model content and layout. Screenshots cover the whole Threat Modeling Tool window rather than the diagram pane alone, so anything the tool displays is captured. Redaction applies to text evidence only; captured pixels are never redacted, and this document does not claim otherwise. Capture is refused unless the host can address a single native window handle, so a desktop-region capture that could include an unrelated application is never persisted. Where isolation is unavailable, capture is disabled, and a run that requires complete evidence fails closed rather than continuing without it. Evidence remains local-only.

Denial of Service
  • Evidence capture is bounded by the capture scope and output directories. The harness writes to a contained evidence path and does not allow arbitrary network or file-system expansion.

Elevation of Privilege
  • Local screenshots and UIA traces are read-only observational data. They do not execute code and do not grant the runtime new privileges beyond the host desktop session.

Risk Rating
ThreatLikelihoodImpactResidual RiskStatus
Screenshots or UIA traces expose sensitive model contentMediumMediumMediumPartially mitigated (text-evidence redaction, window-handle-isolated capture that is refused when isolation is unavailable, local-only evidence) (G-INF-1)
Evidence files are replaced or tampered with after captureMediumMediumMediumMitigated (deterministic manifests, local ownership, explicit status updates) (G-TAM-2)

Bucket B3: Overlay manifest and output path handling

Spoofing
  • Not applicable. The overlay and manifest contract does not establish identity; it only validates shape and fingerprints before replay.

Tampering
  • The runtime validates overlay schema, required fingerprints, and path confinement before replay. It rejects overlays that do not match the current spec, generator profile, or surface identity fingerprint and keeps emitted overlays in approval_state: pending until a human review action promotes them outside the loop.

Repudiation
  • Not applicable. The runtime does not create a human review record for the overlay; it writes a pending overlay and leaves promotion to an explicit human action.

Information Disclosure
  • The overlay and manifest are local file artifacts with no network egress. They contain only redacted provenance and deterministic metadata.

Denial of Service
  • The runtime constrains overlay paths to local output directories and rejects absolute or traversal paths in overlay references.

Elevation of Privilege
  • Overlay content does not execute code. Its effect is limited to candidate generation and the pending overlay output file.

Risk Rating
ThreatLikelihoodImpactResidual RiskStatus
Overlay or manifest tampering changes the replay contract or the evidence metadataMediumMediumMediumMitigated (strict schema, required complete invalidation fingerprints, path confinement, pending approval) (G-TAM-3)
A path traversal or output-escape bug writes evidence or overlay content outside the intended local evidence directoryLowMediumLowMitigated (path validation and confinement) (G-EOP-1)
Visual scores or pending overlays are treated as equivalent to a semantic approvalMediumHighMediumMitigated (semantic regression checks, no automatic promotion, human review gate) (G-REP-1)

Enterprise Readiness Gaps

The following residual gaps should be tracked before the runtime is treated as fully enterprise-ready for broad, policy-governed usage.

IdGapSeverityStatus
G-SPF-1Executable discovery selects from absolute installation roots and requires a valid Authenticode signature from the accepted publisher, but the harness still trusts the local installation it finds, so operators must confirm the discovered binary and pinned version.Spoofing-HighOpen; requires operator review and a trusted installation path
G-TAM-1UI Automation can still target an unintended window or pane when the surface identity is ambiguous, so strict mode must remain fail-closed.Tampering-MedOpen; requires surface identification discipline and human inspection
G-INF-1Screenshots capture the whole Threat Modeling Tool window and UIA traces carry model text. Text evidence is redacted; captured pixels are not, so retention and handling of screenshots is a policy control rather than a runtime one.InfoDisc-MedOpen; requires retention and handling controls for pixel evidence
G-TAM-2Evidence files can still be modified or replaced after capture if the local environment is compromised, so bundle integrity checks remain important.Tampering-MedOpen; requires integrity and access controls
G-TAM-3Overlay and manifest tampering remain a practical risk when untrusted files are replayed, so strict schema and fingerprint validation must stay mandatory.Tampering-MedOpen; requires review of overlay provenance and path origin
G-EOP-1Output-path handling should remain confined to the runtime-owned evidence directory and reject traversal or escape attempts.EoP-MedOpen; requires path-confinement validation and monitoring
G-REP-1Visual scores and pending overlays are not semantic approval signals, so the workflow must continue to require human review before any promotion.Repudiation-HighOpen; requires explicit review and promotion process
G-DOS-1TMT or UI Automation can still hit a modal or resource exhaustion state, so the runtime must continue to enforce bounded timeouts and stop conditions.DoS-MedOpen; requires runtime monitoring and operator response
G-EOP-2Recursive workspace deletion is restricted to a directory the harness created and marked itself, so an operator-supplied --workspace-root is treated as a parent only. The marker is a local file and offers no protection against a compromised host.EoP-MedOpen; requires local file-system integrity
G-SPF-2The PowerShell fidelity probe loads a .NET assembly from the discovered TMT installation to deserialize a model. The assembly is verified as signed by the accepted publisher before loading, but loading any local assembly executes publisher code in-process.Spoofing-MedOpen; requires a trusted installation and operator confirmation

References

🤖 Crafted with precision by ✨Copilot following brilliant human instruction, then carefully refined by our team of discerning human reviewers.

Requirements and compatibility

Written for: GitHub Copilot, Claude Code

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Claude Code frontmatter, Needs Python, Needs Node.js

The author says: Generation requires Python 3.11+ and uv. The native TM7 feedback loop additionally requires Windows with an interactive desktop session and the pinned Microsoft Threat Modeling Tool 7.3.51110.1.

Security

What our scanner noticed· Medium risk

  • Large base64-encoded blobs
  • Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by
Microsoft
Publisher
Microsoft (Official)
Source
microsoft/hve-core · .github/skills/project-planning/security-planning · commit f425e94
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Microsoft.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download security-planning.zip