Skip to content

simulate routing

Which firewalls in your inventory does a packet cross, and through which zones?

Synopsis

proteus simulate routing <source> <destination> [flags]
proteus simulate routing <destination> --device <name> [flags]

The source and the destination are IPv4 addresses or FQDNs. Proteus resolves an FQDN with the DNS of this machine.

Examples

A path across two firewalls

The lab has two firewalls, fw01 and fw02, joined by 198.19.0.0/24.

$ proteus simulate routing 198.18.1.10 198.18.10.100
simulate routing 198.18.1.10 -> 198.18.10.100            fidelity: exact

  198.18.1.10
     │ 198.18.1.0/24
  ┌─ fw02 ─ vsys1 ─ router default ─ snapshot 2m ────────┐
  │  zones   home -> labor                               │
  │  in      vlan.1        198.18.1.1/24                 │
  │  out     vlan.32       198.19.0.1/24                 │
  │  route   198.18.0.0/15 via 198.19.0.254   static     │
  └──┬───────────────────────────────────────────────────┘
     │ 198.19.0.0/24   198.19.0.1 -> 198.19.0.254
  ┌─ fw01 ─ vsys1 ─ router default ─ snapshot 2m ────────┐
  │  zones   transport -> server                         │
  │  in      ethernet1/1   198.19.0.254/24               │
  │  out     ethernet1/2   198.18.10.1/24                │
  │  route   198.18.10.0/24  connected                   │
  └──┬───────────────────────────────────────────────────┘
     │ 198.18.10.0/24
  198.18.10.100   delivered

firewalls on the path: fw02 (home -> labor), fw01 (transport -> server)

The path starts at fw02, where the source is connected. Each box starts with the zone pair that a security rule on that firewall must allow.

A path that leaves the inventory

Add --why to see every stage of every hop. Add --output json --detail summary to get the same answer as a compact JSON document.

$ proteus simulate routing 198.18.10.5 8.8.8.8 --why
simulate routing 198.18.10.5 -> 8.8.8.8            fidelity: undermatch

  198.18.10.5
     │ 198.18.10.0/24
  ┌─ fw01 ─ vsys1 ─ router default ─ snapshot 1m ────────┐
  │  zones   server -> transport                         │
  │  in      ethernet1/2   198.18.10.1/24                │
  │  out     ethernet1/1   198.19.0.254/24               │
  │  route   0.0.0.0/0 via 198.19.0.1   static           │
  └──┬───────────────────────────────────────────────────┘
     │ 198.19.0.0/24   198.19.0.254 -> 198.19.0.1
  ┌─ fw02 ─ vsys1 ─ router default ─ snapshot 1m ────────┐
  │  zones   labor -> wan                                │
  │  in      vlan.32       198.19.0.1/24                 │
  │  out     ethernet1/1   192.168.0.138/24              │
  │  route   0.0.0.0/0 via 192.168.0.1   static          │
  └──┬───────────────────────────────────────────────────┘
     │ 192.168.0.0/24
  192.168.0.1   leaves the estate (not in the inventory)

firewalls on the path: fw01 (server -> transport), fw02 (labor -> wan)
may be incomplete: the path leaves the estate at 192.168.0.1

  place       exact      connected: 198.18.10.5 on fw01 ethernet1/2
  hop1/pbf    exact      no PBF rule could match
  hop1/lookup exact      8.8.8.8 in router default: 0.0.0.0/0 via 198.19.0.1 on ethernet1/1
  hop1/zones  exact      server -> transport
  hop1/nat    exact      no NAT rule matches
  hop1/next   exact      next: fw02 vlan.32
  hop2/pbf    exact      no PBF rule could match
  hop2/lookup exact      8.8.8.8 in router default: 0.0.0.0/0 via 192.168.0.1 on ethernet1/1
  hop2/zones  exact      labor -> wan
  hop2/nat    exact      no NAT rule matches
  hop2/next   undermatch the path leaves the estate at 192.168.0.1

The same question with --output json --detail summary. --why changes only the text output; --detail full adds the stages to the JSON.

{
  "format": 2,
  "command": "simulate routing",
  "detail": "summary",
  "input": {
    "at": "",
    "device": "",
    "flow": {
      "source": {
        "addrs": [
          "198.18.10.5"
        ],
        "resolved": false
      },
      "destination": {
        "addrs": [
          "8.8.8.8"
        ],
        "resolved": false
      },
      "protocol": "tcp"
    },
    "rib": false,
    "router": ""
  },
  "results": [
    {
      "answer": "192.168.0.1 leaves the estate (not in the inventory)",
      "needs": [],
      "fidelity": {
        "level": "undermatch",
        "reasons": [
          {
            "code": "path.left-estate",
            "text": "the path leaves the estate at 192.168.0.1"
          }
        ]
      },
      "source": {
        "addrs": [
          "198.18.10.5"
        ],
        "resolved": false
      },
      "destination": {
        "addrs": [
          "8.8.8.8"
        ],
        "resolved": false
      },
      "outcome": "left-estate",
      "end": "192.168.0.1   leaves the estate (not in the inventory)",
      "end_code": "path.left-estate",
      "hops": [
        {
          "device": "fw01",
          "vsys": "vsys1",
          "snapshot": "2026-09-28T10-00-00Z",
          "from_zone": "server",
          "to_zone": "transport",
          "route": "0.0.0.0/0 via 198.19.0.1"
        },
        {
          "device": "fw02",
          "vsys": "vsys1",
          "snapshot": "2026-09-28T10-00-00Z",
          "from_zone": "labor",
          "to_zone": "wan",
          "route": "0.0.0.0/0 via 192.168.0.1"
        }
      ]
    }
  ],
  "holes": [],
  "unresolved": [],
  "notes": []
}

may be incomplete names what Proteus cannot see. Here it is the network behind 192.168.0.1, which no firewall in the inventory owns.

Reading the output

The path starts where the source is connected, or where the most specific route to the source leaves. With --device, the path starts on that firewall. Proteus then follows the stored forwarding table of each firewall to the next firewall.

Line Meaning
simulate routing … fidelity: … the packet and the fidelity of the answer
│ <prefix> the link between two boxes, with the addresses at each end
last line of the path where the path ends, such as delivered or leaves the estate
firewalls on the path each firewall with the zone pair that its security rule must allow
may be on the path, not detected a firewall that can be on the path but that Proteus cannot see, such as one in virtual wire or Layer 2 mode
may be incomplete the reasons the answer can be incomplete, and the stages that Proteus did not evaluate

Each box shows one firewall, its vsys, its logical router and the age of its snapshot. Each row has a label:

Row Meaning
zones the zone the packet enters by and the zone it leaves by
in the ingress interface and its address
out the egress interface and its address
route the route the lookup uses, with its protocol, or connected
ecmp the other equal-cost next hops that Proteus does not follow
pbf a policy-based forwarding rule that could take the packet
nat a NAT rule that changes the packet, or may change it
alt with --rib, another route to the destination; the active route is marked (active)
schema the schema that Proteus uses to check PBF and NAT
note another fact about the hop

Proteus handles these cases as follows:

Case What Proteus does
ECMP follows the lowest next hop and names the others (ecmp)
policy-based forwarding names a PBF rule that could take the packet (pbf) and still follows the forwarding table
NAT applies NAT on every firewall; later firewalls see the translated packet
a source connected to two firewalls stops and asks you to pick one with --device

With --why, a stage table follows. hopN/ is the number of the hop.

Stage What it does
place finds the firewall and interface where the path starts
hopN/pbf names a policy-based forwarding rule that could take the packet
hopN/lookup finds the route to the destination in the logical router
hopN/zones finds the ingress and egress zones
hopN/nat applies the NAT rule that matches, if any
hopN/next finds the next firewall, or where the path ends

With --output json, each hop carries its flow: device, vsys, zones, source and destination. simulate policy takes that flow as its input.

Flags

simulate routing takes --device and --at. See selection flags. With --at, Proteus reads the newest snapshot of each device at or before that time. It also takes --detail.

Flag Default Description
--device <name> start the path on this firewall; required when you give a destination only
--router <name> start in this logical router of --device
--port <port> the destination port, 443 or tcp/443; decides NAT and PBF rules that name a service
--rib off list the other routes to the destination at each firewall and mark the active one
--no-dns off do not resolve an FQDN endpoint
--why off show every stage with its fidelity

The command needs fetched snapshots. It does not take --file, because a path can cross several firewalls.

Limits

  • Proteus traces IPv4 only.
  • Proteus names policy-based forwarding, and the path does not follow it.
  • A path ends where it leaves the inventory, also into a tunnel.
  • Proteus does not see a firewall in virtual wire or Layer 2 mode on a path. The answer names it.

See Limits: simulate routing and Limits: host names.

See also