feat(security): define security scope (#28571)

* docs(mavlink): present link encryption alongside message signing

The hardening guide told integrators that production deployments must
enable message signing, presenting it as the only way to secure a MAVLink
link. Encrypting the link below MAVLink, with an encrypted radio, a VPN or
IPsec, is at least as strong: it uses standard, reviewed cryptography, it
gives confidentiality as well as authentication, and it covers every
interface on the link rather than only MAVLink.

Present both options, and reword the passages that assumed signing was the
only one.

Assisted-by: Claude:claude-opus-5
Signed-off-by: Julian Oes <julian@oes.ch>

* docs(security): develop security fixes in public pull requests

Record that fixes are developed as ordinary public pull requests, with no
private forks and no embargoed branches.

Assisted-by: Claude:claude-opus-5
Signed-off-by: Julian Oes <julian@oes.ch>

* docs(security): add security scope document

Describe the boundary the code implements today: what PX4 protects, what it
assumes about the layers beneath it, what the shipped default does and does
not do, and two lists for what is always in scope and what is out. It
describes the boundary rather than pre-deciding reports. A finding that fits
neither list stays a judgement call that maintainers make on the report.

Assisted-by: Claude:claude-opus-5
Signed-off-by: Julian Oes <julian@oes.ch>

* docs(security): list a security maintainer for report triage

Security report triage had no named owner, so an unacknowledged report had
nowhere to go except the release managers. Add a Security block to the
maintainers list, and point the follow-up path in SECURITY.md at it.

Assisted-by: Claude:claude-opus-5
Signed-off-by: Julian Oes <julian@oes.ch>

* docs(mavlink): note that the first signing key is unauthenticated

The guide already says to provision over a trusted link, and the info box says
that changing or disabling a key requires a signed message. It does not say that
setting the first one cannot, since there is no key to sign with yet, so a reader
can come away believing provisioning itself is protected.

Say plainly that the window exists, what an attacker gets from it, and how to
recover.

Assisted-by: Claude:claude-opus-5[1m]
Signed-off-by: Julian Oes <julian@oes.ch>

* Apply batched suggestions from code review

Co-authored-by: Sheren N <sherenyn@ad.uni-paderborn.de>
Co-authored-by: Hamish Willee <hamishwillee@gmail.com>
Co-authored-by: Julian Oes <julian@oes.ch>

* feat(security): more review fixup

* fix(security): only 1.18 gets security bugfixes

* fix(security): link to SECURITY_SCOPE

* fix(securiy): small wording fixups

* docs(security): scope by attacker position, not bug class

The "Always in scope" list made any memory corruption, race or hang a
vulnerability regardless of who can reach it. That is not how reports
have been handled: sanitizer runs in SITL have found and fixed many
such bugs as ordinary PRs, and a peer on an unsecured link already has
a shell.

Replace it with one test: a finding is a vulnerability when it gives
capability to an attacker who has neither the operator's access nor
physical access. Keep the in-tree board configuration rule, point to
the sanitizer docs, and fix two typos.

Assisted-by: Claude:claude-opus-5[1m]
Signed-off-by: Julian Oes <julian@oes.ch>

* fix(docs): formatting

* fix(maintainers): add Ramon to security as well

* docs(security): draw the boundary as a mermaid diagram

GitHub renders mermaid natively, so the boundary diagram no longer has to
be maintained as hand-aligned ASCII. Label the two zones with the wording
of the sentences below it, so the picture and the prose say the same
thing.

Assisted-by: Claude:claude-opus-5
Signed-off-by: Julian Oes <julian@oes.ch>

* fix(docs): review fixups

* docs(security): say how to isolate the offboard transports

A direct cable between flight controller and companion is not enough on
its own: the agent or router republishes into the DDS or Zenoh network
on the companion, so that network is inside the boundary too.

Keep the scope document to what is inside the boundary and put the
isolation advice next to the uXRCE-DDS and Zenoh setup instructions.

Assisted-by: Claude:claude-opus-5
Signed-off-by: Julian Oes <julian@oes.ch>

---------

Signed-off-by: Julian Oes <julian@oes.ch>
Co-authored-by: Sheren N <sherenyn@ad.uni-paderborn.de>
Co-authored-by: Hamish Willee <hamishwillee@gmail.com>
This commit is contained in:
authored and GitHub committed 2026-09-21 10:49:01 +12:00
1 parent b637daa4cf
commit f5586139e4
9 files changed
+295 -24

No files matched your search

+9
View File
@@ -51,6 +51,15 @@ Reviewers help maintain PX4 across the project without ownership of a specific c
| Ramón Roche | [@mrpollo](https://github.com/mrpollo) | rroche | <rroche@linuxfoundation.org>
| Daniel Agar | [@dagar](https://github.com/dagar) | daniel_agar | <daniel@agar.ca>
**Security**
Triage incoming security reports and coordinate fixes, as described in [SECURITY.md](SECURITY.md).
| Name | GitHub | Chat | email
|------|--------|------|----------------------
| Julian Oes | [@julianoes](https://github.com/julianoes) | julianoes | <julian@oes.ch>
| Ramón Roche | CI / Testing | [@mrpollo](https://github.com/mrpollo) | rroche | <rroche@linuxfoundation.org>
**Retired Maintainers**
| Name | GitHub | Chat | email
+34 -17
View File
@@ -6,9 +6,8 @@ The following versions receive security updates:
| Version | Supported |
| ------- | ------------------ |
| 1.17.x | :white_check_mark: |
| 1.16.x | :white_check_mark: |
| < 1.16 | :x: |
| 1.18.x | :white_check_mark: |
| < 1.18 | :x: |
## Reporting a Vulnerability
@@ -16,8 +15,11 @@ We receive security vulnerability reports through GitHub Security Advisories.
If AI assistance contributed to your finding, do not file a private advisory:
read [AI-Assisted Discovery](#ai-assisted-discovery) instead.
Before filing, check the finding against [SECURITY_SCOPE.md](SECURITY_SCOPE.md), which describes where PX4's security boundary sits and what is in scope.
Most memory-safety bugs, races and hangs are not vulnerabilities, because they are only reachable from a position that already has the operator's access. Fix those with a pull request, or open an issue.
To begin a report, go to the [PX4/PX4-Autopilot](https://github.com/PX4/PX4-Autopilot) repository
and click on the **Security** tab. If you are on mobile, click the **...** dropdown menu, then click **Security**.
and click on the **Security** tab.
Click **Report a Vulnerability** to open the advisory form. Fill in the advisory details form.
Make sure your title is descriptive and the description contains all relevant details needed
@@ -27,11 +29,28 @@ At the bottom of the form, click **Submit report**.
## Response Process
1. **Acknowledgment**: The maintainer team will acknowledge your report within **7 days**.
2. **Triage**: We will assess severity and impact and communicate next steps.
3. **Disclosure**: We coordinate disclosure with the reporter. We follow responsible disclosure practices and will credit reporters in the advisory unless they request anonymity.
1. **Acknowledgment**: The maintainer team will try to acknowledge your report within **7 days**.
2. **Triage**: We decide scope against [SECURITY_SCOPE.md](SECURITY_SCOPE.md), assess severity and impact, and communicate next steps.
3. **Fix**: The fix is developed as a normal pull request against `main`, in the open. See [How Fixes Are Developed](#how-fixes-are-developed).
4. **Release**: The fix is public once the pull request is merged. Where it applies to a supported release branch it is backported, and it appears in the release notes. If a report warrants a published advisory or a CVE, we publish it through GitHub and credit the reporter unless they request anonymity.
If you do not receive acknowledgment within 7 days, please follow up by emailing the [release managers](MAINTAINERS.md).
If you do not receive acknowledgment within 7 days, please follow up by emailing the security maintainers or the release managers listed in [MAINTAINERS.md](MAINTAINERS.md).
## How Fixes Are Developed
Security fixes are developed as ordinary public pull requests. We do not use
private forks or embargoed branches.
This is a deliberate choice because downstream users do not update quickly enough for a coordinated release date to protect them, and many are not tracking upstream closely at all.
Development in a private fork means fewer reviewers and no CI checks, which can cause issues once merged.
The pull request makes the existence of the bug public, and that is expected.
Keep the reproducer out of it: it works against vehicles in the field until the fix has shipped and been adopted. If you reported through the Security tab, the reproducer is already in the advisory and maintainers have it, so there is nothing further to send.
Describe the demonstrated impact in the pull request and leave it at that.
If you are reporting a bug you cannot fix yourself, report it privately first, through the process above, and maintainers decide when it moves to a public pull request.
The exception is [AI-Assisted Discovery](#ai-assisted-discovery), which goes public from the start.
## AI-Assisted Discovery
@@ -41,23 +60,20 @@ on AI-assisted bug discovery.
If you used AI assistance to identify a bug, treat it as public. You may have
good reasons to believe it is not, but both the kernel security team and PX4
maintainers have seen bugs found this way surface across multiple researchers
at the same time, often on the same day. Instead of filing a private advisory,
open a pull request with a fix. If you cannot submit a fix yourself, first
search the [open pull requests](https://github.com/PX4/PX4-Autopilot/pulls)
at the same time, often on the same day. So skip the private advisory and go
straight to a pull request with a fix. If you cannot submit a fix yourself,
first search the [open pull requests](https://github.com/PX4/PX4-Autopilot/pulls)
for one that already addresses it; only if nothing exists, open an
[issue](https://github.com/PX4/PX4-Autopilot/issues/new/choose).
Your pull request makes the bug public, and that is expected. The reproducer
is different: never post it publicly, it works against vehicles in the field
until the fix ships. Describe the demonstrated impact in the pull request,
state that a reproducer is available, and maintainers will ask for it
privately if they need it.
The rules on reproducers in [How Fixes Are Developed](#how-fixes-are-developed)
apply here too: the pull request is public, the reproducer is not.
### Responsible Use of AI to Find Bugs
A growing share of incoming security reports comes from AI-assisted code review.
It can surface real bugs in rarely exercised code, but it also floods
maintainers with low-quality reports. If AI tooling contributed to your finding,
maintainers with reports. If AI tooling contributed to your finding,
the guidance above applies, and so do the following points:
- **Length**: Lead with a short summary: the affected module or file, the
@@ -96,6 +112,7 @@ The PX4 development team applies the following practices to reduce security risk
- **Code review**: All changes require peer review before merging.
- **Static analysis**: [clang-tidy](https://clang.llvm.org/extra/clang-tidy/) runs on every pull request with warnings treated as errors.
- **Sanitizers**: SITL can be built with [AddressSanitizer, ThreadSanitizer and UndefinedBehaviorSanitizer](docs/en/test_and_ci/sanitizers.md) to find memory-safety bugs and races.
- **Fuzzing**: A daily fuzzing pipeline using [Google fuzztest](https://github.com/google/fuzztest) tests MAVLink message handling and GNSS driver protocol parsing.
- **Input validation**: All external inputs (MAVLink messages, RC signals, sensor data) are validated against expected ranges before use.
- **Compiler hardening**: Builds use `-Wall -Werror`, stack protectors, and other hardening flags where supported by the target platform.
+176
View File
@@ -0,0 +1,176 @@
# PX4 Security Scope
This document says where PX4's security boundary sits, so a reporter can tell before filing whether a finding is considered a vulnerability, and a maintainer can say why it is or isn't.
It is not a threat model.
It does not enumerate threats, rate risks, or prescribe mitigations.
It describes the boundary the code implements today.
To use it: find your deployment under [Configurations](#configurations), then apply [What makes a finding a vulnerability](#what-makes-a-finding-a-vulnerability) and check [Out of scope](#out-of-scope).
The examples there cover the recurring cases, not every case.
A finding that fits none of them is a judgement call, and maintainers make it on the report.
Report through the GitHub Security tab as described in [SECURITY.md](SECURITY.md), which also lists the supported branches.
## What PX4 protects
PX4 protects one thing: who gets to fly/control the aircraft, and who gets to make it stop.
Everything else matters because of what it leads to, not in itself.
Logs, parameters and telemetry are worth protecting because of what someone can do with them next.
Reading a flight log is a far smaller problem than flying away with the vehicle.
Two things PX4 cannot promise: that a vehicle will not crash, and that a sensor is telling the truth about the world.
## The boundary
```mermaid
flowchart TB
subgraph integrator ["the integrator's to secure"]
radio["telemetry radio"]
rclink["RC link"]
companion["companion network"]
end
fc["flight controller"]
subgraph operator ["trusted as the operator"]
sdcard["SD card"]
usb["USB / NSH shell"]
buses["UART / I2C / SPI / CAN<br>peripherals"]
end
radio -->|MAVLink| fc
rclink -->|RC| fc
companion -->|uXRCE-DDS / Zenoh| fc
fc --- sdcard
fc --- usb
fc --- buses
style integrator stroke-dasharray: 5 5
style operator stroke-dasharray: 5 5
```
Everything above the flight controller is the integrator's to secure.
Everything below it is trusted as the operator: whoever has the SD card, the USB port or a peripheral bus can do anything the operator can.
PX4's job is what happens at the flight controller's interfaces: whatever arrives on them must not do more than the interface is documented to do.
## What PX4 assumes
- **Sensors report within specification.**
PX4 cannot reliably distinguish a real GPS fix, rangefinder return or gyro reading from a spoofed one.
Some spoofing detection exists and is best-effort.
- **Peripherals are the ones the operator installed.**
No bus (UART, I2C, SPI, CAN, SMBus) is authenticated.
A device on a bus is trusted as whatever driver the operator enabled for it.
- **Physical access is trusted as the operator.**
The SD card holds logs, the MAVLink signing key, some boards' parameters or parameter backups and staged peripheral firmware, and it can contain boot scripts that are run at startup.
Debug ports and the bootloader allow a full reflash.
- **The onboard shell is trusted as the operator.**
A peer that can open the NSH shell can do anything the operator can.
NuttX supports a console password; no PX4 board enables it.
- **The offboard transports are inside the boundary.**
uXRCE-DDS and Zenoh publishers reach uORB directly, including `/fmu/in/actuator_motors`, `/fmu/in/actuator_servos` and `/fmu/in/vehicle_command`.
They carry no external-origin marking, so the command guards that apply to MAVLink do not apply to them.
A peer that can reach those transports is the operator, which is why keeping that network to trusted parties is the integrator's job and not an optional extra.
A direct cable between the flight controller and the companion secures only that hop: the agent or router republishes into the DDS or Zenoh network on the companion, and anything that can reach the companion or that network reaches uORB too.
- **Securing MAVLink links is the integrator's job.**
See [MAVLink Security Hardening](docs/en/mavlink/security_hardening.md).
These assumptions are the boundary.
If a report starts from one of them already being true, that the attacker has the SD card, or is on the companion network, then it is describing how PX4 works rather than finding a hole in it.
## Configurations
### As shipped
Every control interface is unauthenticated, unsigned and unencrypted.
Anyone who can reach a link can do anything the operator can do: arm, disarm, change mode, upload missions and geofences, set parameters, open a shell over `SERIAL_CONTROL`, read and write files over MAVLink FTP, terminate flight, reboot, etc.
[MAVLink Security Hardening](docs/en/mavlink/security_hardening.md) lists these capabilities in full.
This is the documented default and it is not a defect.
In this configuration a peer on any link already has the operator's access, so a finding reachable only from a link adds nothing to what that peer can do.
See [What makes a finding a vulnerability](#what-makes-a-finding-a-vulnerability).
### Hardened
An integrator can harden a deployment with any of:
- **Secure the link below PX4.**
A secured radio, e.g. through a VPN or IPsec gives confidentiality and authentication using standard, reviewed cryptography.
This is the strongest option (and has no direct PX4 integration).
- **Isolate the offboard transports.**
uXRCE-DDS and Zenoh bypass every MAVLink control, so if an adversary can reach them, the rest of this list buys nothing.
See [uXRCE-DDS](docs/en/middleware/uxrce_dds.md) and [Zenoh](docs/en/middleware/zenoh.md) for how.
- **Enable [MAVLink message signing](docs/en/mavlink/message_signing.md).**
This authenticates MAVLink frames but does not encrypt them.
A small allowlist (`HEARTBEAT`, `RADIO_STATUS`, `ADSB_VEHICLE`, `COLLISION`) is currently accepted unsigned.
Signing is inactive if the key file is absent, which is deliberate: removing the card is the recovery path when a key is lost.
- **Lock the configuration.**
Read-only parameters, [secure boot](docs/en/advanced_config/bootloader_secure_boot.md) with a replaced key, and no wired reflash.
The in-tree secure boot variant ships a publicly committed test key that an integrator must replace.
What each of these buys is described where it is documented.
PX4 is responsible for the mechanisms it ships. If signing fails to authenticate, or secure boot accepts an unsigned image, that is a vulnerability in PX4. What PX4 does not guarantee is whether any combination of above is sufficient for a given deployment. That judgement belongs to the integrator, against the threat model for that deployment.
## What makes a finding a vulnerability
A finding is a vulnerability when it gives capability to an attacker who has neither the operator's access nor physical access.
The positions that already have the operator's access are listed under [What PX4 assumes](#what-px4-assumes): the SD card, USB and the shell, the peripheral buses, the offboard transports, and any MAVLink link that has not been secured.
A finding that is reachable only from one of those positions describes something that attacker could already do, and it is a bug rather than a vulnerability.
That applies to memory corruption, races and hangs as much as to anything else.
These are bugs by default, and they are found and fixed routinely, for example by running SITL under [AddressSanitizer or ThreadSanitizer](docs/en/test_and_ci/sanitizers.md).
Send them as a pull request with a fix, or as an issue.
What makes one a vulnerability is not the class of bug but who can reach it.
The findings that do qualify cross from outside those positions to inside them, for example:
- **Bypassing a mechanism PX4 ships.**
MAVLink signing accepting a message it should reject, including memory corruption in anything parsed before the signature is checked or in a message that is accepted unsigned.
Secure boot with a replaced key accepting an unsigned image.
- **Turning an over-the-air input into more than a false reading.**
Someone transmitting a spoofed GNSS signal, ADS-B traffic or an RC signal has neither the operator's access nor physical access.
If what the receiver passes on from that signal makes PX4 corrupt memory, that is in scope; the vehicle acting on a false position or a phantom aircraft is not.
A receiver that has itself been replaced or tampered with is physical access.
An in-tree board configuration is PX4's responsibility, not the integrator's.
"The integrator should have changed it" does not apply to a default that PX4 ships.
## Out of scope
- **Anything reachable only from a position that already has the operator's access.**
Commanding the vehicle over an unsecured link, publishing on the offboard transports, and bugs in code that only those positions reach, memory corruption included.
- **Physical access**, except where a board is configured with a mechanism whose purpose is to resist it.
On a secure boot board with a replaced key, wired reflash comes back into scope.
- **Spoofed physical inputs.**
GPS spoofing, acoustic or EMI injection, magnetic interference.
The vehicle acting on a false reading is out of scope; see above for when a spoofed input is not.
- **Plaintext telemetry.**
PX4 does not encrypt telemetry, and eavesdropping on a link is not a finding on its own.
- **Code that only ever runs in simulation.**
A finding in a simulator-only code path is a bug, not a vulnerability.
This is about where the affected code runs, not where you reproduced it: if the code also runs on a flight target, a SITL reproducer is fine, and [SECURITY.md](SECURITY.md) asks for one.
- **Unsupported branches.**
See [SECURITY.md](SECURITY.md).
A parameter precondition does not put a finding out of scope if the same link can set that parameter.
## Severity
Decide scope first, using [What makes a finding a vulnerability](#what-makes-a-finding-a-vulnerability) and [Out of scope](#out-of-scope).
A finding that is out of scope is closed, not scored.
What remains is scored with CVSS, because that is what GitHub advisories carry.
When choosing the impact metrics, rate the effect on the aircraft rather than on the data, in roughly this order:
1. Taking control of a vehicle that is flying or could be told to fly, and running your own code on it.
2. Forcing an unsafe state: corrupting the estimator, or spoofing a condition that trips a failsafe.
3. Persistence across reboot.
4. Loss of control or telemetry links, and disclosure.
A safety feature that happens to limit an attacker, such as a geofence around a hijacked vehicle, is not a security control and does not reduce the severity of a vulnerability.
Someone who is already flying the vehicle can reconfigure it.
+1
View File
@@ -967,6 +967,7 @@
- [Gazebo Classic OctoMap Models with ROS 1](sim_gazebo_classic/octomap.md)
- [ROS/MAVROS Installation on RPi](ros/raspberrypi_installation.md)
- [External Position Estimation (Vision/Motion based)](ros/external_position_estimation.md)
- [Security](security/index.md)
- [Community](contribute/index.md)
- [Dev Call](contribute/dev_call.md)
- [Maintainers](contribute/maintainers.md)
+5
View File
@@ -53,6 +53,11 @@ The [Hardware Selection & Setup](hardware/drone_parts.md) section covers flight
Read [Operations](config/operations.md) to understand safety features and failsafe behavior before your first flight. Then see [Basic Flying (Multicopter)](flying/basic_flying_mc.md) or the equivalent for your frame type.
## Security
Securing a deployment is the integrator's responsibility — PX4 ships with every control interface unauthenticated, unsigned, and unencrypted!
The [Security](security/index.md) section collects the hardening documentation, and links to the [security policy](https://github.com/PX4/PX4-Autopilot/blob/main/SECURITY.md) for reporting a vulnerability.
## Support
Get help on the [discussion forums](https://discuss.px4.io/) or [Discord](https://discord.com/invite/dronecode). See the [Support](contribute/support.md) page for diagnosing problems, reporting bugs, and joining the [weekly dev call](contribute/dev_call.md).
+28 -7
View File
@@ -3,16 +3,24 @@
<Badge type="tip" text="PX4 v1.17" />
MAVLink is an open communication protocol designed for lightweight, low-latency communication between drones and ground stations.
By default, all MAVLink messages are unauthenticated.
This is intentional for development and testing, but **production deployments must enable [message signing](message_signing.md)** to prevent unauthorized access.
By default, all MAVLink messages are unauthenticated and unencrypted.
This is intentional for development and testing, but **production deployments must secure the link** to prevent unauthorized access.
There are two ways to do that, and they are not exclusive:
- **Secure the link below MAVLink**, using a radio configured with link-layer security, a VPN, etc.
Configured with authenticated encryption, this uses standard, reviewed cryptography and gives confidentiality and authentication for all traffic on the link, not only MAVLink.
It is outside PX4's scope and depends on your radio and network stack.
- **Enable [MAVLink message signing](message_signing.md)**, which authenticates MAVLink frames without encrypting them.
This is the mechanism PX4 itself ships, and it is described in this guide.
::: warning
Without message signing enabled, any device that can send MAVLink messages to the vehicle (via radio, network, or serial) can execute any command, including shell access, file operations, parameter changes, mission uploads, arming, and flight termination.
On an unsecured link, any device that can send MAVLink messages to the vehicle (via radio, network, or serial) can execute any command, including shell access, file operations, parameter changes, mission uploads, arming, and flight termination.
:::
## What Is at Risk
When MAVLink signing is not enabled, an attacker within communication range can:
On an unsecured link, an attacker within communication range can:
| Capability | MAVLink mechanism |
| ----------------------------- | ------------------------------------------------ |
@@ -27,13 +35,15 @@ When MAVLink signing is not enabled, an attacker within communication range can:
| Reboot the vehicle | `MAV_CMD_PREFLIGHT_REBOOT_SHUTDOWN` |
All of these are standard MAVLink capabilities used by ground control stations.
Without signing, there is no distinction between a legitimate GCS and an unauthorized sender.
Until the link is secured, there is no distinction between a legitimate GCS and an unauthorized sender.
## Hardening Checklist
### 1. Enable Message Signing
### 1. Secure the Link
Message signing provides cryptographic authentication for all MAVLink communication.
If the link is carried over an encrypted radio, a VPN or IPsec, that covers authentication and confidentiality for everything on it, and the rest of this step is optional.
Otherwise, use message signing, which provides cryptographic authentication for all MAVLink communication.
See [Message Signing](message_signing.md) for full details.
Steps:
@@ -50,6 +60,14 @@ Signing changes are rejected while the vehicle is armed.
Signing can also be disabled by physically removing the key file from the SD card.
:::
::: warning
Provision the key before the vehicle is used on an untrusted link, not after.
Until a key is provisioned there is nothing to authenticate against, so any peer that can reach a link can provision one.
Only *changing* a key requires a signed message; setting the first one cannot, because no key exists yet.
A key installed by someone else locks out the legitimate ground station, and the recovery is to remove the key file from the SD card.
:::
### 2. Secure Physical Access
- **SD card**: The signing key is stored at `/mavlink/mavlink-signing-key.bin`.
@@ -67,6 +85,7 @@ If your threat model includes physical access, secure the SD card slot and debug
### 3. Secure Network Links
- Prefer an encrypted transport where one is available: an encrypted radio link, a VPN, etc.
- Do not expose MAVLink UDP/TCP ports to untrusted networks or the internet.
- Place MAVLink communication links behind firewalls or VPNs.
- Segment MAVLink networks from business or public networks.
@@ -77,6 +96,8 @@ If your threat model includes physical access, secure the SD card slot and debug
- **No encryption**:
Message signing provides authentication and integrity, but messages are sent in plaintext.
An eavesdropper can read telemetry and commands but cannot forge them.
- **Unaudited implementation**:
The signing protocol was audited when it was drafted, but PX4's implementation of it has not been.
- **Allowlisted messages**:
A small set of [safety-critical messages](message_signing.md#unsigned-message-allowlist) (`HEARTBEAT`, `RADIO_STATUS`, `ADSB_VEHICLE`, `COLLISION`) are always accepted unsigned on all links.
An attacker could spoof these specific messages.
+8
View File
@@ -26,6 +26,14 @@ In order for PX4 uORB topics to be shared on the DDS network you will need _uXRC
The PX4 [uxrce_dds_client](../modules/modules_system.md#uxrce-dds-client) publishes to/from a defined set of uORB topics to the global DDS data space.
::: warning
The DDS transport is unauthenticated and reaches uORB directly, so the DDS network must be kept isolated.
Connect the flight controller to the companion over serial or a dedicated Ethernet cable, not over a shared or wireless network.
A direct cable is not enough on its own: the agent republishes into the DDS network on the companion, so also keep that local, for example with [UXRCE_DDS_PTCFG](../advanced_config/parameter_reference.md#UXRCE_DDS_PTCFG) set to localhost and `ROS_AUTOMATIC_DISCOVERY_RANGE=LOCALHOST` (`ROS_LOCALHOST_ONLY=1` on Humble).
If the data has to leave the companion, securing it is up to the integrator.
See [Security](../security/index.md) for more.
:::
The [eProsima Micro XRCE-DDS _Agent_](https://github.com/eProsima/Micro-XRCE-DDS-Agent) runs on the companion computer and acts as a proxy for the client in the DDS/ROS 2 network.
The agent itself has no dependency on client-side code and can be built and/or installed independent of PX4 or ROS, as long as version compatibility is ensured.
+8
View File
@@ -19,6 +19,14 @@ The Zenoh-based middleware consists of a client running on PX4 and a Zenoh route
The router acts as a broker and discovery service, enabling PX4 to publish and subscribe to topics in the global Zenoh data space.
This allows seamless integration with ROS 2 nodes using [`rmw_zenoh`](https://github.com/ros2/rmw_zenoh), and supports flexible deployment across distributed systems.
::: warning
The Zenoh transport is unauthenticated and reaches uORB directly, so the Zenoh network must be kept isolated.
Connect the flight controller to the companion over a dedicated Ethernet cable, not over a shared or wireless network.
A direct cable is not enough on its own: the router republishes into the Zenoh network, so the router must also not be reachable from other networks.
If the data has to leave the companion, securing it is up to the integrator.
See [Security](../security/index.md) for more.
:::
![Architecture PX4 Zenoh-Pico with ROS 2](../../assets/middleware/zenoh/architecture-px4-zenoh.svg)
The client is the _PX4 Zenoh-Pico Node_ referred to above, which is implemented in the [PX4 `zenoh` module](../modules/modules_driver.md#zenoh).
+26
View File
@@ -0,0 +1,26 @@
# Security
Securing PX4 for a production vehicle is the integrator's responsibility.
::: tip
PX4 is open by default: every PX4 control interface is unauthenticated, unsigned and unencrypted, and any peer that can reach a link can command the vehicle.
This is intended!
:::
This section provides links to security documentation for integrators and security researchers.
## Integrators
- [MAVLink Security Hardening](../mavlink/security_hardening.md) — what an unauthenticated link exposes, and the checklist for a production deployment.
- [MAVLink Message Signing](../mavlink/message_signing.md) — authenticating MAVLink frames, and what signing does not cover.
- [Bootloader Secure Boot](../advanced_config/bootloader_secure_boot.md) — verifying firmware at boot, and replacing the committed test key.
- [Log Encryption](../dev_log/log_encryption.md) — encrypting flight logs at rest.
- [Read-Only Parameters](../advanced/parameters_and_configurations.md#read-only-parameters) — locking down settings that end users should not change.
Securing the link itself sits below PX4.
An encrypted radio, a VPN or IPsec uses standard cryptography and protects every interface at once, including the ones MAVLink signing does not cover.
## Security Researchers
- [Security Policy](https://github.com/PX4/PX4-Autopilot/blob/main/SECURITY.md) — supported versions, how to report a vulnerability, and the rules for AI-assisted findings.
- [Security Scope](https://github.com/PX4/PX4-Autopilot/blob/main/SECURITY_SCOPE.md) — where PX4's security boundary sits, and what is in scope for a report.