sangamdas/A-Satellite-Can-Be-Cyber-Secure-and-Still-Execute-the-Wrong-Command

A Satellite Can Be Cyber-Secure and Still Execute the Wrong Command

Execution-Finality for the EU Space Act

Author: Sangam Das Independent Inventor, India

Overview

A satellite can use encrypted links, authenticated commands, protected keys, access control, secure software, intrusion detection, logging and incident-response procedures—and still face a different class of risk:

What if the command is authentic, but the exact consequence it requests should not be allowed to occur?

A legitimate operator credential can be stolen or misused. An authorised software component can be compromised. An autonomous system can generate a syntactically valid but unsafe manoeuvre. A software-defined radio can receive a valid configuration request that is outside the permitted frequency, power, beam, destination or temporal envelope.

This publication examines Execution-Finality Governance as an infrastructure-level complement to conventional satellite cybersecurity.

The core principle is:

Computation is not authority. Authentication is not final authority. A proposed satellite act should not become a physical, RF, payload, software or inter-satellite consequence merely because software generated it or an authenticated channel delivered it.

The architecture separates:

COMMAND GENERATION from FINAL AUTHORITY FOR EFFECTUATION

and introduces a protected control path:

Operator / AI / Autonomous Software | v Candidate Act | v Non-Effective State | v Protected Validation | v Scoped Execution Authority | v Finality Sink Verification | +-------+-------+ | | FAIL PASS | | v v No Effect / External Effect Safe Handling

Regulatory Context

The accompanying paper discusses Europe's emerging space-regulatory framework and explicitly does not treat the proposed EU Space Act as a final adopted law.

As described in the paper, the regulatory discussion increasingly addresses cybersecurity, operational resilience, access control, cryptographic practices, incident handling, business continuity, supply-chain security and technical conformity.

Execution-Finality is not presented as an existing legal requirement.

Instead, the research question is:

Could selected high-level resilience, access-control and spacecraft-control requirements eventually be translated into machine-verifiable pre-effectuation constraints for consequential space operations?

The distinction is important:

LAW determines obligations

GOVERNANCE determines applicable policy

INFRASTRUCTURE enforces selected machine-verifiable conditions

1. The Problem: Cyber-Secure Does Not Necessarily Mean Consequence-Secure

Consider a command:

FIRE THRUSTER B FOR 14 SECONDS

The communication can be cryptographically authentic.

But the relevant effectuation questions are broader:

Is this the correct spacecraft? Is Thruster B the intended actuator? Is the manoeuvre inside the authorised envelope? Is the command fresh? Is the command still unrevoked? Is the current mission state compatible? Is the collision-avoidance state compatible? Is the purpose authorised? Is a second approval required? Was the command generated under an approved software/model state? Is this exact consequence authorised now?

Traditional authentication primarily answers:

Who or what presented the command?

Execution-Finality asks:

Does this exact proposed consequence possess valid authority to become effective now?

Those are different security questions.

2. From Cybersecurity to Consequence Security

Conventional spacecraft security is essential. It protects communication, identity, keys, command integrity, software, networks and operational access.

Execution-Finality adds a separate layer around the final transition from a proposed machine operation to an externally consequential state change.

SECURITY OF ACCESS + SECURITY OF COMMUNICATION + SECURITY OF SOFTWARE + SECURITY OF EFFECTUATION

The final layer asks:

WHAT EXACT CONSEQUENCE? WHO OR WHAT AUTHORIZED IT? FOR WHAT PURPOSE? FOR WHICH SPACECRAFT? FOR WHICH SUBSYSTEM? UNDER WHAT MISSION STATE? UNTIL WHEN? UNDER WHICH SECURITY EPOCH? HAS AUTHORITY BEEN REVOKED? CAN THE RELEASE BOUNDARY VERIFY ALL OF THIS?

3. Candidate Act

A Candidate Act is not necessarily the raw transport command.

It should represent the load-bearing attributes of the requested consequence.

For an orbital manoeuvre, a Candidate Act could include:

CandidateAct { spacecraft_id command_class actuator_id thrust_vector thrust_duration execution_window mission_purpose operational_state collision_avoidance_state destination_subsystem command_origin_class software_or_model_identity security_epoch authority_scope human_approval_requirement revocation_state_reference transaction_or_command_nonce }

For RF transmission, the load-bearing fields may instead include:

spacecraft_id radio_subsystem frequency_range bandwidth power_envelope waveform beam_direction destination transmission_window purpose security_epoch

The Candidate Act should capture the meaning of the consequence, not merely the bytes used to request it.

4. Non-Effective State

The Candidate Act enters a Non-Effective State.

During this state:

the command may exist;

the operator may be authenticated;

the AI may have generated a plan;

the flight software may have accepted the request;

cryptographic signatures may verify;

policy checks may run;

a human approval may be obtained;

but the consequential operation still lacks final authority to become effective.

This preserves the distinction:

GENERATED != AUTHORIZED AUTHENTICATED != AUTHORIZED COMPUTED != AUTHORIZED TRANSPORTED != AUTHORIZED ACCEPTED != EFFECTUATED

5. Protected Validation

Protected validation evaluates the predicates that matter for the exact consequence.

Depending on the operation, these may include:

spacecraft identity;

actuator or subsystem identity;

command origin;

mission purpose;

mission state;

manoeuvre envelope;

collision-avoidance state;

RF frequency, power, beam or waveform;

destination;

execution window;

command freshness;

monotonic sequence state;

security epoch;

revocation state;

software/model identity;

operator authority;

human approval;

delegation scope;

jurisdictional context;

rate limits;

safe-state restrictions;

conflicting-command state.

Successful upstream authentication remains useful, but it becomes one predicate, not unrestricted consequence authority.

6. Scoped Execution Authority

If the required conditions are satisfied, the protected validation layer can issue a bounded execution authority.

An illustrative authority could mean:

PERMIT

Spacecraft: SAT-17 Actuator: Thruster-B Operation: manoeuvre M-224 Vector: V Maximum duration: 14 seconds Execution window: T1..T2 Purpose: collision avoidance Security epoch: E91 Sink: PROPULSION_SINK_2 Uses: 1 Delegation: prohibited Status: unused

Desired properties include:

ACT_SPECIFIC PURPOSE_BOUND DESTINATION_BOUND TIME_BOUND STATE_BOUND SINK_BOUND FRESHNESS_BOUND REVOCATION_AWARE NON_REPLAYABLE NON_BEARER CONSUMABLE

A general operator credential should not automatically become unlimited authority to actuate any spacecraft subsystem.

7. Why Non-Bearer Authority Matters

A bearer-like token can become dangerous if possession alone is enough to exercise power.

Execution authority should instead depend on protected context.

For example:

valid use = correct Candidate Act + correct spacecraft + correct subsystem + correct Finality Sink + correct security epoch + correct mission state + correct destination + valid freshness + unused status

Copying the artifact should not create a second usable authority.

8. Finality Sink

A Finality Sink is defined functionally.

It is the first protected boundary at which the proposed operation can produce the relevant usable external consequence.

It does not have to be one additional hardware box.

Examples:

Consequential Operation

Possible Finality Sink

Orbital manoeuvre

Protected boundary before thruster-driver enablement

RF transmission

Protected release boundary before transmitter/power-amplifier enablement

Payload activation

Protected payload-control boundary

Imaging/data release

Boundary before sensor activation or protected data leaves a controlled domain

Software-defined radio change

Boundary before frequency/power/waveform/beam configuration becomes effective

Software update

Protected transition from received package to executable operational state

Inter-satellite command

Protected boundary before forwarding or downstream actuation

Deployment mechanism

Protected controller before physical release

The defining question is:

Does the exact operation presented for effectuation match valid, current and bounded authority at this release boundary?

9. Sink-Side Reconstruction

A strong implementation should not merely trust an upstream assertion saying:

candidate_digest = ABC123

The Finality Sink should independently reconstruct or obtain the finality-critical attributes of the actual operation it is about to release.

Conceptually:

actual_effect = RECONSTRUCT_FROM_RELEASE_FORM()

actual_digest = HASH_CANONICAL(actual_effect)

IF actual_digest != authority.bound_candidate_digest: DENY

This protects against substitution.

Example:

AUTHORIZED: Thruster B +0.35 m/s 03:42 UTC Spacecraft SAT-17

PRESENTED AT SINK: Thruster B +0.80 m/s 03:42 UTC Spacecraft SAT-17

RESULT: NO FINALITY

The security question is not:

Did an upstream system once validate something?

It is:

Is the effect I am about to produce the same effect that was authorized?

10. Simplified Pseudocode — Candidate Authorization

FUNCTION AUTHORIZE_CANDIDATE_ACT(candidate, protected_state, policy):

canonical_candidate =
    CANONICALIZE_LOAD_BEARING_ATTRIBUTES(candidate)

candidate_digest =
    HASH(canonical_candidate)

IF candidate.spacecraft_id != protected_state.spacecraft_id:
    RETURN DENY_WRONG_SPACECRAFT

IF candidate.destination_subsystem NOT IN policy.allowed_subsystems:
    RETURN DENY_DESTINATION

IF candidate.command_class NOT IN policy.allowed_command_classes:
    RETURN DENY_COMMAND_CLASS

IF candidate.mission_purpose NOT IN policy.allowed_purposes:
    RETURN DENY_PURPOSE

IF candidate.security_epoch != protected_state.current_security_epoch:
    RETURN DENY_STALE_EPOCH

IF candidate.revocation_state != CLEAR:
    RETURN DENY_REVOKED

IF NOT MISSION_STATE_COMPATIBLE(candidate, protected_state):
    RETURN DENY_MISSION_STATE

IF NOT WITHIN_OPERATIONAL_ENVELOPE(candidate, policy):
    RETURN DENY_OPERATIONAL_ENVELOPE

IF HUMAN_APPROVAL_REQUIRED(candidate, policy):
    IF NOT VERIFY_HUMAN_APPROVAL(candidate):
        RETURN DENY_MISSING_APPROVAL

IF NOT VERIFY_SOFTWARE_OR_MODEL_IDENTITY(candidate, policy):
    RETURN DENY_RUNTIME_IDENTITY

authority =
    CREATE_SCOPED_NON_BEARER_AUTHORITY(
        candidate_digest    = candidate_digest,
        spacecraft_id       = candidate.spacecraft_id,
        destination_sink    = DERIVE_FINALITY_SINK(candidate),
        security_epoch      = candidate.security_epoch,
        execution_window    = candidate.execution_window,
        nonce               = FRESH_NONCE(),
        uses                = 1,
        delegation_scope    = NONE,
        status              = UNUSED
    )

RETURN authority

11. Simplified Pseudocode — Finality Sink Verification

FUNCTION FINALITY_SINK_VERIFY(actual_release_request, execution_authority, sink_state):

actual_candidate =
    RECONSTRUCT_ACTUAL_EFFECT(actual_release_request)

actual_digest =
    HASH(CANONICALIZE_LOAD_BEARING_ATTRIBUTES(actual_candidate))

IF actual_digest != execution_authority.candidate_digest:
    RETURN NO_FINALITY_CANDIDATE_MISMATCH

IF sink_state.identity != execution_authority.destination_sink:
    RETURN NO_FINALITY_WRONG_SINK

IF execution_authority.status != UNUSED:
    RETURN NO_FINALITY_ALREADY_CONSUMED

IF execution_authority.security_epoch != sink_state.current_security_epoch:
    RETURN NO_FINALITY_STALE_EPOCH

IF NOT FRESH(execution_authority):
    RETURN NO_FINALITY_STALE

IF REVOKED(execution_authority):
    RETURN NO_FINALITY_REVOKED

IF CONFLICT_EXISTS(actual_candidate, sink_state):
    RETURN NO_FINALITY_CONFLICT

BEGIN PROTECTED_TRANSITION

    MARK execution_authority AS CONSUMED

    ADVANCE sink_state.monotonic_sequence

    COMMIT finality_evidence

    ENABLE consequential_subsystem

END PROTECTED_TRANSITION

RETURN EFFECTUATE

12. Low-Latency and High-Rate Control

Execution-Finality does not require a new cryptographic transaction for every low-level control-loop operation.

High-frequency attitude-control, fault-protection, thermal-protection and safing functions may operate under previously established bounded standing authority.

For example:

AUTHORIZE ENVELOPE:

Thruster B may operate between T1 and T2 within thrust envelope E for manoeuvre M under security epoch E91

The real-time loop can operate locally inside that envelope.

The protected sink prevents the controller from exceeding it.

FUNCTION CONTROL_LOOP_REQUEST(pulse, authorized_envelope):

IF CURRENT_TIME NOT IN authorized_envelope.window:
    DENY

IF pulse.thrust > authorized_envelope.max_thrust:
    DENY

IF pulse.vector NOT IN authorized_envelope.vector_range:
    DENY

IF aggregate_effect > authorized_envelope.total_budget:
    DENY

ALLOW pulse

This keeps enforcement compatible with fast spacecraft control while preserving finality constraints for high-consequence transitions.

13. Loss of Ground Contact and Safe Autonomy

Fail-closed governance must not mean:

NO GROUND CONTACT -> DISABLE SPACECRAFT

Spacecraft need autonomous survival behavior.

The architecture can distinguish:

ORDINARY_OPERATIONAL_AUTHORITY from PRE_AUTHORIZED_SAFETY_AUTHORITY

Examples of bounded safety authority may include:

attitude stabilization;

thermal protection;

battery preservation;

collision avoidance;

emergency beacon transmission;

safe-mode entry.

The goal is:

Preserve necessary autonomy without converting autonomy into unbounded authority.

14. Autonomous Collision Avoidance

Conventional simplified flow:

Detect ↓ Calculate ↓ Decide ↓ Thruster Command

Execution-Finality flow:

Detect ↓ Calculate ↓ Simulate ↓ Propose Manoeuvre ↓ Candidate Act ↓ Non-Effective State ↓ Protected Validation ↓ Scoped Manoeuvre Authority ↓ Propulsion Finality Sink ↓ Thruster Actuation

The AI can remain computationally capable.

It does not automatically possess the power to alter the orbit.

Autonomy may generate a decision. Finality determines whether the decision may alter the physical world.

15. RF Transmission Example

Candidate Act:

TRANSMIT Payload-X USING Beam-Y ON Frequency-Z TOWARD Ground-Station-A POWER <= P DURING T1..T2 FOR Purpose-M

Protected validation may consider:

spacecraft radio subsystem frequency bandwidth power waveform beam direction destination time purpose operator authority mission state security epoch revocation

The RF Finality Sink verifies that the actual release configuration matches the authorized configuration.

General access to radio-control software should not imply authority to:

transmit anything on any frequency at any power in any direction for any duration

16. Software-Defined Satellite Example

Software-defined satellites make this architecture especially relevant because software can modify capabilities that were historically more hardware-fixed.

Candidate Acts can include:

frequency reconfiguration;

waveform selection;

beam direction;

transmit power;

routing behavior;

payload modes;

processing functions;

security configuration;

executable software transition.

A signed update package can therefore satisfy:

PACKAGE_SIGNATURE = VALID

while a separate finality decision still asks:

MAY THIS PACKAGE BECOME OPERATIONALLY EXECUTABLE NOW?

Signature verification and operational effectuation authority remain distinct.

17. Compromised Ground Credential

Threat:

Attacker steals a legitimate operator credential | v Authentication succeeds | v Dangerous command is constructed

Without consequence-level control, sufficiently privileged authentication may expose broad capabilities.

Execution-Finality adds:

AUTHENTICATED IDENTITY | v Candidate Act | +--> purpose? +--> spacecraft? +--> actuator? +--> manoeuvre envelope? +--> mission state? +--> time? +--> second approval? +--> revocation? | v Finality Sink Verification

A stolen credential therefore does not necessarily become unrestricted spacecraft authority.

18. Replay Resistance

Execution authority may use:

nonces;

monotonic sequence state;

security epochs;

bounded execution windows;

one-time-use semantics;

sink-local consumed state.

Example:

AUTHORITY A-781 status = CONSUMED

REPLAY A-781

Finality Sink: authority already consumed

RESULT: NO FINALITY

Replay protection should be tied to the finality state, not only to transport-layer message freshness.

19. Revocation Under Intermittent Connectivity

Space systems cannot assume continuous contact.

Possible mechanisms include:

short-lived execution authorities;

monotonic security epochs;

cached revocation state;

time-limited mission windows;

ground-synchronized policy state;

preconfigured expiry;

sink-local state transitions.

Freshness should not depend solely on an untrusted clock.

Possible combinations include:

trusted spacecraft time + monotonic counter + mission epoch + sequence state + bounded validity window

The architecture does not prescribe one revocation mechanism.

20. Delegation and Constellations

Constellations introduce transitive authority risks.

If Satellite A has authority for a limited operation, delegation to Satellite B should not silently create broader power.

Delegated authority should be attenuating, not expanding.

Possible constraints include:

operation class spacecraft identity destination duration number of uses mission jurisdiction actuator scope subdelegation prohibition

Example:

A has authority: "forward telemetry to B"

A delegates to B

B MUST NOT obtain: "command C's propulsion system"

Each downstream consequential act can require independently scoped authority.

21. Conflicting Commands

Simultaneous valid-looking commands should not silently become effectuation.

Possible protected conflict policies include:

newest valid command wins higher-priority safety authority supersedes operational authority conflicting pending operations are poisoned human escalation required mission-control policy decides precedence

The important invariant is:

Ambiguity does not automatically become physical consequence.

22. Finality Sink Availability and Fault Tolerance

The logical Finality Sink should not be engineered as an unprotected single point of failure.

Possible implementations include:

redundant sinks;

replicated protected validation;

failover controllers;

deterministic verification;

fault-tolerant hardware;

independently protected execution channels.

The logical rule remains single:

NO CONSEQUENCE WITHOUT VALID FINAL AUTHORITY

The physical implementation can still be redundant and fault tolerant.

23. Comparison With Conventional Satellite Architecture

Area

Conventional Satellite Architecture

Execution-Finality Architecture

Core security question

Is the command authentic and from an authorized source?

Is this exact act authorized to produce this exact consequence now?

Command handling

Authenticated command may proceed to execution logic

Command becomes a Candidate Act and remains non-effective until validation

Authentication

Often a central security control

Necessary but not sufficient

Authorization scope

Often tied to user, role, subsystem or session

Bound to specific act, purpose, destination, time, state and scope

AI-generated command

Accepted AI output may enter normal command pipeline

AI may propose freely but has no inherent execution authority

Compromised credential

High privilege may expose dangerous capabilities

Credential alone does not authorize the final consequence

Mission-state validation

Often in application/flight logic

Can become protected pre-effectuation validation

Purpose limitation

Often implicit

Can be explicitly bound to execution authority

Destination binding

Command identifies target subsystem

Authority can be bound to exact sink/destination

Thruster command

Valid command reaches propulsion controller/safety logic

Manoeuvre remains non-effective until finality verification

RF transmission

Control software configures transmitter

Frequency, power, beam, destination and time can be checked before RF release

Payload activation

Authorized software activates payload

Requires scoped finality authority

Software-defined radio

Authorized software may modify configuration

Reconfiguration itself becomes a Candidate Act

Software update

Signature verified then package installed/activated

Signature verification plus separate authority for operational transition

Replay protection

Nonces/counters/timestamps protect commands

Also bound to finality authority and sink-local consumption

Revocation

Revokes user/key/session/command authority

Can invalidate pending finality authority before effectuation

Delegation

Roles/credentials may propagate

Delegation can be constrained and non-expanding

Inter-satellite command

Trusted peer may forward commands

Downstream consequences can require separately scoped authority

Collision avoidance

AI/algorithm may trigger manoeuvre subject to flight rules

AI proposes; protected authority is required before thruster effect

Human approval

Often workflow-level control

Can become machine-verifiable finality prerequisite

Logging

Records what happened

Evidence can be generated before or atomically with effectuation

Audit model

Post-event reconstruction

Pre-effectuation evidence plus post-event audit

Failure handling

Subsystem-specific

Missing/stale/ambiguous authority can fail closed for consequential acts

Offline operation

Preprogrammed autonomy

Bounded pre-authorized safe autonomy

Final execution boundary

Often implicit

Explicit Finality Sink at first effectuation boundary

Trust in application software

Flight/application software often carries major authority

Application can request an act without possessing final authority

Primary objective

Secure commands and systems

Secure the transition from computation to real-world consequence

Simplified comparison:

CONVENTIONAL

Operator / AI ↓ Authentication ↓ Flight Software ↓ Actuator ↓ External Effect

EXECUTION-FINALITY

Operator / AI ↓ Candidate Act ↓ Non-Effective State ↓ Protected Validation ↓ Scoped Execution Authority ↓ Finality Sink Verification ↓ External Effect

24. Why Post-Event Logs Are Not Enough

Logging answers:

What happened?

Execution-Finality asks:

Should we permit it to happen?

For some spacecraft operations, post-event evidence may arrive too late.

Examples include:

thruster firing;

RF radiation;

orbit-changing manoeuvre;

protected data release;

destructive memory operation;

payload deployment;

software transition into active operational state.

Pre-effectuation evidence can therefore be particularly valuable for irreversible or high-consequence acts.

25. Implementation Neutrality

The architecture does not require one predetermined:

token format;

cryptographic algorithm;

ledger;

satellite bus;

operating system;

AI model;

communication protocol;

ground-station architecture;

frequency;

identity standard;

cloud provider;

hardware vendor.

Possible implementation components include:

secure elements;

trusted hardware;

isolated execution environments;

HSMs;

TEEs;

protected control processors;

flight computers;

FPGAs;

secure radio subsystems;

protected policy engines;

distributed validation.

The architecture specifies the security invariant, not one mandatory product.

26. Does This Require a New Spacecraft Box?

No.

A Finality Sink may be implemented as a protected verification function at an existing consequence boundary.

Examples:

thruster-driver enable boundary transmitter enable boundary payload activation boundary protected data-release boundary software activation boundary

Where secure elements, protected processors, FPGAs or isolated control logic already exist, portions of the validation/finality function may reuse them.

27. Engineering Cost and Latency

Execution-Finality is not cost-free.

Potential costs include:

verification and validation;

hardware/firmware qualification;

protected-state management;

key and credential management;

integration with flight software;

ground-system changes;

safe failure handling;

recovery logic;

denial-of-service analysis;

fault-tree expansion;

certification and test burden.

The engineering proposition is not:

zero weight zero latency zero complexity zero cost

The narrower proposition is:

Apply protected finality selectively to consequential operations where the cost of incorrect execution justifies the additional assurance.

Routine telemetry, housekeeping queries and reversible internal computation need not necessarily pass through the same mechanism.

28. SME and Reusable Infrastructure Perspective

A large satellite operator may have specialist security, cryptography, mission-assurance and compliance teams.

A small operator may not.

A future standards-based finality layer could potentially allow smaller operators to reuse:

canonical Candidate Act semantics;

authority formats;

anti-replay rules;

sink verification interfaces;

revocation/epoch logic;

actuator-gating patterns;

evidence formats;

safe-state conventions.

This is one reason Execution-Finality may be relevant not only to security, but also to interoperability and SME implementation cost.

29. Standardisation Questions

Potential research and standards questions include:

How should consequential spacecraft acts be represented?

Which attributes are load-bearing for each operation class?

How should the sink independently reconstruct the actual release form?

How should authority be bound to destination and subsystem?

How should replay and one-time consumption be handled?

How should freshness work when spacecraft clocks are imperfect?

How should revocation work under intermittent contact?

How should emergency and safety authority be separated from ordinary operational authority?

How should high-rate control loops operate inside bounded authority envelopes?

How should redundant Finality Sinks preserve availability without weakening authorization?

How should inter-satellite delegation be attenuated?

How should AI-generated and human-generated commands carry provenance?

How should model/software identity participate in act authorization?

How should evidence be generated without exposing unnecessary mission-sensitive data?

How can SMEs adopt these controls without excessive cost?

Which operations should be considered high-consequence enough to require finality gating?

30. Technical FAQs

FAQ 1 — How is Execution-Finality different from ordinary command authentication?

Authentication establishes that a command came from an accepted source or cryptographic identity. Execution-Finality asks whether the specific command is authorized to produce the specific external consequence under the current mission, temporal, operational and security state.

FAQ 2 — Where is the Finality Sink located?

It is defined functionally as the first protected release boundary where the Candidate Act can produce the relevant external effect. It may be near propulsion, RF, payload, software-update or inter-satellite release logic.

FAQ 3 — Why keep the Candidate Act non-effective?

Because post-event validation can be too late. Thruster firing, RF emission, deployment and destructive software changes can be difficult or impossible to reverse.

FAQ 4 — What can be a Candidate Act?

Orbital manoeuvres, thruster pulses, RF transmissions, beam steering, frequency changes, payload activation, sensor retasking, firmware activation, inter-satellite forwarding, deployment, key-management operations, destructive memory operations and safe-mode transitions can all be Candidate Acts where consequential.

FAQ 5 — Is the Candidate Act the command message?

Not necessarily. It should represent the load-bearing meaning of the consequence rather than merely the transport packet or command string.

FAQ 6 — How is command substitution prevented?

Authority is bound to a canonical representation/digest of the Candidate Act, and the Finality Sink independently reconstructs the actual effect before release.

FAQ 7 — Why is sink-side reconstruction important?

It prevents an upstream component from obtaining authority for one operation and attaching it to another.

FAQ 8 — How are replay attacks handled?

Nonce, monotonic state, epoch, execution window, one-time semantics and sink-local consumed state can all participate.

FAQ 9 — Why non-bearer authority?

Because possession of a copied token or message should not itself become spacecraft power. Valid use should depend on protected execution context.

FAQ 10 — What if ground contact is lost?

Necessary autonomous survival behavior can continue under separately bounded safety authority. Loss of contact should not automatically disable spacecraft survival functions.

FAQ 11 — Can autonomous collision avoidance still work?

Yes. AI can detect, calculate, simulate and propose. The protected propulsion boundary controls whether the proposed manoeuvre acquires actuation authority.

FAQ 12 — What prevents a compromised AI from requesting actions repeatedly?

The AI does not control final authorization. Protected validation can independently enforce purpose, scope, mission state, rate limits, destination, software/model identity, time, revocation and policy epoch.

FAQ 13 — Can human and AI commands be treated differently?

Yes. Provenance may identify human operator, onboard AI, ground AI, autonomous controller, emergency controller or maintenance system, with different policy requirements.

FAQ 14 — Can model/software identity be checked?

Yes, conceptually. Authority may bind to approved software version, model ID, runtime measurement, algorithmic fingerprint, protected execution state or security epoch.

FAQ 15 — Why is this relevant to software-defined satellites?

Because software can change RF, routing, payload, processing and other capabilities. Those changes can themselves become Candidate Acts.

FAQ 16 — How does it apply to RF transmission?

The authority can bind spacecraft, subsystem, frequency, bandwidth, power, waveform, beam, destination, time, purpose and epoch. The RF sink verifies the actual requested emission.

FAQ 17 — Can this guarantee no harmful interference?

No. It can reduce one class of risk by preventing general software access from becoming unrestricted authority to transmit outside bounded conditions.

FAQ 18 — How is revocation handled with intermittent connectivity?

Possible approaches include short-lived authority, epochs, cached revocation state, bounded mission windows, synchronized policy state and expiry.

FAQ 19 — What if the spacecraft clock is wrong?

Freshness should not rely exclusively on one clock. Monotonic counters, mission epochs, sequence numbers, trusted time and bounded validity windows can be combined.

FAQ 20 — How is this different from a hardware interlock?

A conventional interlock often checks one narrow safety condition. Execution-Finality can bind identity, purpose, destination, state, time, jurisdiction, revocation and operational limits to one specific act.

FAQ 21 — Does it replace fault-tolerant flight software?

No. Redundancy, voting, watchdogs, fault detection, isolation and recovery remain necessary. Execution-Finality asks an additional authority question before physical effectuation.

FAQ 22 — Does the Finality Sink become a single point of failure?

It should not. The logical finality function can be implemented with redundant protected sinks, replicated validation, failover controllers and fault-tolerant hardware.

FAQ 23 — Can it work across constellations?

Yes. Authority can be scoped to one spacecraft, operation, destination and validity window rather than granting broad constellation-wide power.

FAQ 24 — How does it apply to inter-satellite links?

Forwarding or downstream command actions can themselves become Candidate Acts. Each receiving or forwarding spacecraft can verify the authority to communicate, delegate, forward, command or modify state.

FAQ 25 — How is delegated authority controlled?

Delegation should attenuate authority. It can be limited by operation class, destination, duration, uses, mission, jurisdiction, actuator and subdelegation rights.

FAQ 26 — What happens with conflicting commands?

Protected conflict policy can resolve, poison, supersede or escalate conflicting operations. Ambiguity should not silently become effectuation.

FAQ 27 — Can Execution-Finality operate with low latency?

Potentially. Local protected verification, cached policy, compact authority objects and pre-authorized envelopes can avoid unnecessary network round trips.

FAQ 28 — How does high-rate actuator control work?

The system can authorize a bounded control envelope rather than cryptographically authorizing every individual motor pulse.

FAQ 29 — Will this consume excessive satellite bandwidth?

It need not. Only machine-verifiable predicates, identifiers, commitments and compact state needed for the operation must be represented. Full legal or policy documents do not need to travel with every command.

FAQ 30 — What is the core invariant?

GENERATE != AUTHORIZE AUTHENTICATE != AUTHORIZE COMPUTE != AUTHORIZE TRANSPORT != AUTHORIZE

VERIFY AT FINALITY SINK ↓ EFFECTUATE

No externally consequential satellite operation obtains final authority merely because it was generated, transmitted, authenticated or computationally accepted.

31. Important Limitations

This proposal does not claim that:

the proposed EU Space Act has already been finally adopted;

EU law currently requires Execution-Finality;

Execution-Finality replaces NIS2;

authentication or encryption are unnecessary;

every satellite operation requires identical validation;

every legal obligation can be represented in software;

AI should interpret international space law;

the Finality Sink must use a particular hardware product;

all satellite cyberattacks would be prevented;

protected hardware is infallible;

revocation can always be instantaneous under lost connectivity;

additional assurance has zero cost or zero latency;

human oversight becomes unnecessary.

The narrower proposition is:

For satellite operations capable of significant external consequences, cybersecurity may be strengthened by separating generation or receipt of a command from authority for that command to become effective.

32. Research Scope

This publication presents an architectural and standardisation research direction.

It does not propose replacing conventional satellite cybersecurity.

Instead:

AUTHENTICATION ENCRYPTION KEY MANAGEMENT ANTI_REPLAY ACCESS CONTROL FLIGHT SAFETY FAULT TOLERANCE INCIDENT RESPONSE + EXECUTION_FINALITY

can form a layered architecture.

Execution-Finality focuses on the final question:

Does this exact proposed act possess valid authority to become a real-world consequence at this exact boundary and state?

33. Central Principle

The future satellite should not merely ask:

Is this command authentic?

It should also be able to ask:

Does this exact command possess authority to become a real-world consequence?

That is the transition from:

SATELLITE CYBERSECURITY to SATELLITE CONSEQUENCE SECURITY

and from:

SECURITY OF ACCESS to SECURITY OF EFFECTUATION

Source Files

This README is based on the accompanying materials:

Main paper: Execution-Finality Governance for Europe's Emerging Space-Regulatory Framework

Comparison with Conventional Satellite Architecture

30 High-Technical FAQs: Execution-Finality Governance for Satellite and Space Systems

Suggested Citation

Das, Sangam. A Satellite Can Be Cyber-Secure and Still Execute the Wrong Command: Execution-Finality for the EU Space Act. 2026.

Keywords

EU Space Act · Satellite Cybersecurity · Execution-Finality · Consequence Security · Autonomous Satellites · AI Governance · Spacecraft Control · Cyber Resilience · NIS2 · Satellite Communications · Software-Defined Satellites · Inter-Satellite Links · Finality Sink · Candidate Act · Non-Effective State · Scoped Execution Authority · Space Infrastructure