README.md

---
license: cc-by-4.0
task_categories:
  - text-generation
language:
  - en
tags:
  - satellite-security
  - cubesat
  - sparta
  - red-teaming
  - defensive-security
  - shift-left
pretty_name: SatSec Objective-Decomposition Tuning Set
size_categories:
  - n<1K
configs:
  - config_name: default
    data_files:
      - split: train
        path: data/train-*
      - split: test
        path: data/test-*
---

# 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](#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

```python
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/`):

```bash
# 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).

```bibtex
@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:

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