paolocmo/satsec-decomposition

SatSec Objective-Decomposition Tuning Set

A small, chat-format supervised dataset that teaches an attacker model to decompose a satellite-security objective into an ordered sequence of checkable, standards-traceable steps. Each step is mapped to a SPARTA technique and paired with a deterministic check that confirms it. The retrieved grounding block in each prompt mixes the reference techniques with plausible in-domain distractors, so the supervised task is to select the reference subset and order it, not to echo the retrieved list (see Grounding composition).

This dataset is the training corpus for the paper "Decomposition Adapters for Offline Security Campaign Planning" (decomp-adapt). It also supports the sibling testbed paper "A Grounded, Verifiable LLM Testbed for Satellite Security" (LLM-satsec), which uses the same testbed but reports its detection results on the base model and defers the decomposition adapter to the decomp-adapt paper. It is released to make the decomposition-tuning pass reproducible. While the paper is under review this repository is kept private; it will be made public alongside publication.

Defensive scope (read first)

This work is strictly defensive and must stay that way in any downstream use:

• The supervision targets decomposition behavior (how to turn an objective into ordered, checkable steps), not vulnerability facts. Concrete vulnerability details stay in a separate retrieval index and are not part of this dataset.
• Intended use is authorized, development-time (shift-left) security testing against emulated or consented targets, in an offline / air-gapped setting.
• No live RF, no on-orbit action, no operational targeting of real assets. Findings are handled under responsible disclosure.
• Every step names a defensive check, reflecting the testbed's constraint and verification layer, which is the paper's actual contribution (not the model).

Do not use this dataset to plan or conduct operations against systems you are not authorized to test.

Dataset structure

One row per training example. Columns:

Column	Type	Description
messages	list of dicts	OpenAI chat format: system / user / assistant turns.
type	string	decompose (objective -> full ordered plan) or next_step (objective + steps-so-far -> single next step). In next_step rows the steps-so-far block lists each prior step with the SPARTA technique it used, so the model sees which techniques are already covered as planning state. These ids sit in the prompt only, never as a training target (completion-only masking), so the facts-in-retrieval boundary is preserved.
case	string	Source case identifier (incident or generic pattern).
root	string	Attack-tree root node id the example was built from.
step	int (nullable)	For next_step rows, which step in the plan.
split	string	train or test.

Grounding composition

The user turn of each example carries a Grounding: block of SPARTA techniques retrieved for the objective. Each block is padded to eight distinct techniques: the reference techniques of the plan plus plausible in-domain distractors drawn deterministically from the SPARTA technique pool (any technique sharing a parent with a reference is excluded, so a distractor is a genuine near-miss). The combined block is shuffled, so retrieval order carries no signal about which techniques are reference or in what order they belong. The assistant completion names only the reference techniques, in order. A model must therefore pick the reference subset out of the noisy block and sequence it; a policy that emits the whole block scores full recall but low precision. Metrics that capture this are completeness (recall), precision (selectivity), and ordering fidelity.

Splits

Splits are disjoint by case, not by row, so no case leaks between train and test. Six cases are held out for evaluation, chosen to span distinct attack families: Pavur-SATCOM-eavesdrop, Turla-satellite-C2, Space-Odyssey-unauth-TC, JTAG-debug-firmware, GNSS-spoofing, and TC-replay-no-SDLS.

The Parquet files under data/ are what load_dataset reads. A byte-faithful, human-readable copy of the same records is mirrored at raw/tuning_set.jsonl (chat format with a nested meta block) for inspection or non-datasets use.

Split	Rows
train	84
test	26
total	110

By example type: next_step = 86, decompose = 24. Built from 24 cases spanning documented incidents/research (Starlink UT fault injection, ViaSat/AcidRain, BEESAT-1, ROSAT, Space Odyssey unauthenticated telecommand, ESA OPS-SAT authorized takeover, GMR satphone cipher analysis, Iridium plaintext eavesdrop, and others), canonical standards-grounded patterns (command injection, protocol integrity, replay without SDLS, debug-interface firmware extraction, safe-mode abuse, supply chain), and development-time bench-interface checks a developer runs on their own hardware (serial/UART console exposure, SDR TM/TC link authentication/anti-replay/confidentiality, internal-bus authorization). The bench-interface cases are framed as security checks with deterministic verification, not general hardware operation.

Loading

from datasets import load_dataset

ds = load_dataset("paolocmo/satsec-decomposition")
train, test = ds["train"], ds["test"]
print(train[0]["messages"])

Provenance and regeneration

Examples are assembled deterministically from an attack-tree corpus of public satellite-security incidents and generic patterns, grounded in the SPARTA matrix (The Aerospace Corporation) and space-security standards. The grounding text is derived and truncated, not a verbatim reproduction of standards. The generator lives in the LLM-satsec testbed; the snapshot and the publishing artifacts live with this paper (decomp-adapt/data/, decomp-adapt/hf/):

# 1. regenerate in the testbed (see LLM-satsec/satsec-testbed)
#    --enrich-nextstep puts each prior step's SPARTA id in the next_step context;
#    --distractors 8 pads+shuffles each grounding block to 8 techniques (ref + distractors)
python -m satsec.training.build_tuning_set --enrich-nextstep --distractors 8   # writes tuning_set.jsonl
# 2. snapshot it into this paper
cp .../satsec-testbed/data/training/tuning_set.jsonl decomp-adapt/data/
# 3. publish from here (reads data/tuning_set.jsonl)
python decomp-adapt/hf/export_hf.py --repo paolocmo/satsec-decomposition --private

Licensing

Released under CC-BY-4.0 (see LICENSE). Attribution to the authors and the companion paper is required. Note: grounding content is derived from the SPARTA matrix and public incident write-ups; raw ECSS/ESA standard documents are not included (copyright-restricted). Confirm SPARTA's own reuse terms before redistributing derived grounding text.

Citation

If you use this dataset, please cite it as a dataset and also cite the companion paper (see below).

@dataset{oliveira2026satsecod,
  title     = {SatSec Objective-Decomposition Tuning Set},
  author    = {Oliveira, Joao Paolo Cavalcante Martins and Teske, Lucas},
  year      = {2026},
  publisher = {HuggingFace},
  doi       = {10.57967/hf/9586},
  url       = {https://huggingface.co/datasets/paolocmo/satsec-decomposition},
  note      = {110 chat-format supervised examples that teach an attacker model to
               decompose a satellite-security objective into ordered, verifiable,
               SPARTA-traceable steps, each paired with a deterministic check.
               Training corpus for the paper "Decomposition Adapters for Offline
               Security Campaign Planning."
               ORCIDs: Oliveira (0000-0003-4117-953X), Teske (0009-0002-8526-7662).
               Affiliations: Oliveira, J.P.C.M.: UFRN and SETI Institute;
               Teske, L.: Teske's Lab.}
}

The dataset was prepared by J. P. C. M. Oliveira and L. Teske. Please also cite the paper this corpus trains:

@inproceedings{oliveira2026decompadapt,
  title     = {Decomposition Adapters for Offline Security Campaign Planning},
  author    = {Oliveira, Joao Paolo Cavalcante Martins and Teske, Lucas},
  year      = {2026},
  note      = {Under review}
}