Secure C2 links

Example 1 Signing and verifying a HEARTBEAT frame

The key is derived from a sample phrase for teaching only; a real key must come from a secure random source.

import hashlib
import struct

def crc_x25(data, crc=0xFFFF):
    for b in data:
        tmp = b ^ (crc & 0xFF)
        tmp = (tmp ^ (tmp << 4)) & 0xFF
        crc = ((crc >> 8) ^ (tmp << 8) ^ (tmp << 3) ^ (tmp >> 4)) & 0xFFFF
    return crc

KEY = hashlib.sha256(b"lesson-demo-passphrase").digest()   # 32 bytes, for teaching only
HEARTBEAT = struct.pack("<IBBBBB", 0, 2, 3, 0x81, 4, 3)     # custom_mode, type, autopilot, base_mode, status, version

def sign(seq, payload, ts, link_id=0, sysid=1, compid=1, msgid=0, crc_extra=50):
    hdr = bytes([0xFD, len(payload), 0x01, 0x00, seq, sysid, compid]) + msgid.to_bytes(3, "little")
    crc = crc_x25(hdr[1:] + payload + bytes([crc_extra]))
    tail = struct.pack("<H", crc) + bytes([link_id]) + ts.to_bytes(6, "little")
    return hdr + payload + tail + hashlib.sha256(KEY + hdr + payload + tail).digest()[:6]

last_ts = {}
def verify(frame, now):
    body, sig = frame[:-6], frame[-6:]
    if hashlib.sha256(KEY + body).digest()[:6] != sig:
        return "reject: bad signature"
    ts = int.from_bytes(body[-6:], "little")
    stream = (body[5], body[6], body[-7])                    # system ID, component ID, link ID
    if stream in last_ts and ts <= last_ts[stream]:
        return "reject: replayed or out-of-order timestamp"
    if ts < now - 6_000_000:                                 # 1 minute = 6,000,000 units of 10 µs
        return "reject: older than 1 minute"
    last_ts[stream] = ts
    return "accept"

now = 123_456_839
f1 = sign(7, HEARTBEAT, 123_456_789)
print(f"frame {len(f1)} bytes: {f1.hex()}")
print("first delivery   ->", verify(f1, now))
print("same frame again ->", verify(f1, now))
tampered = bytearray(sign(8, HEARTBEAT, 123_456_800))
tampered[13] ^= 0x01                                         # flip 1 payload bit
print("tampered payload ->", verify(bytes(tampered), now))
print("old frame, link 1->", verify(sign(9, HEARTBEAT, now - 7_000_000, link_id=1), now))

frame 34 bytes: fd0901000701010000000000000002038104033bac0015cd5b070000c82d318a978f
first delivery   -> accept
same frame again -> reject: replayed or out-of-order timestamp
tampered payload -> reject: bad signature
old frame, link 1-> reject: older than 1 minute

The frame is 10 + 9 + 2 + 13 = 34 bytes. The instructor checked that these bytes match the frame pymavlink 2.4.50 produces with the same key, timestamp and sequence. Changing a single payload bit breaks the signature, and the same frame sent again is rejected because its timestamp does not increase.

Example 2 C2 availability

Availabilities are assumed values from route statistics; each flight lasts 30 minutes.

A_RADIO, A_LTE, P_COMMON = 0.97, 0.95, 0.002
FLIGHT_MIN = 30

options = {
    "radio only": A_RADIO,
    "radio + LTE (independent)": 1 - (1 - A_RADIO) * (1 - A_LTE),
    "radio + LTE with common mode": (1 - P_COMMON) * (1 - (1 - A_RADIO) * (1 - A_LTE)),
}
for name, a in options.items():
    print(f"{name:<30} availability {a:.4f}  expected outage {(1 - a) * FLIGHT_MIN * 60:5.1f} s per flight")

radio only                     availability 0.9700  expected outage  54.0 s per flight
radio + LTE (independent)      availability 0.9985  expected outage   2.7 s per flight
radio + LTE with common mode   availability 0.9965  expected outage   6.3 s per flight

The second path cuts link outage time sharply, but a common-mode failure of just 0.2% more than doubles the outage compared with the independent case. Power, network and location of the two paths must be separated as far as possible.