Skip to main content
skill CX Codex

network-appliance-offensive — Claude Code skill

network-appliance-offensive — a skill for active security testing of firewalls, VPN endpoints, and network appliances.

MIT 120 installs ★ 632 updated 2026-07-29

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add transilienceai/communitytools --skill network-appliance-offensive -a claude-code
Open on GitHub

What network-appliance-offensive does

This skill bundles tools for assessing live perimeter network devices in security testing. Core capabilities include enumerating IKEv1/IKEv2 transforms and Diffie-Hellman groups, detecting aggressive-mode IKEv1 (which leaks the PSK hash), inferring firmware versions from response headers and certificate metadata, confirming TLS versions via completed handshakes, extracting host and domain details from NTLM Type-2 responses, and discriminating between real and firewall-forged RST packets.

The skill contains five primary modules: ike_enum.py to enumerate IKE parameters and flag aggressive mode, checkpoint_sic_opsec.py for Check Point fingerprinting and CVE applicability assessment, appliance_version_infer.py to determine vendor and firmware version across multiple device types, tls_handshake_probe.py to verify which TLS versions actually complete, ntlm_decode.py to parse NTLM information blocks, and perimeter_forensics.py to classify RST packets. Each tool enforces one principle: return undetermined rather than assert confidence where the evidence is weak.

Key boundary: the skill contains no exploit code and performs no destructive actions. All operations are passive: observation, decoding, version inference. CVE applicability is a precondition check for risk scoring, never a blind "vulnerable" assertion.

What it helps with

  • infer firmware version from appliance headers, banners, and certificates
  • detect IKEv1 aggressive mode on a VPN endpoint
  • enumerate weak IKE parameters such as Diffie-Hellman groups 1, 2, or 5
  • confirm real TLS version support via completed handshake, not failed client exit codes
  • distinguish a real host behind a firewall from a firewall-forged RST response

Example prompts for the agent

  • Scan UDP 500 on 10.0.0.1: enumerate IKE transforms and check for IKEv1 aggressive-mode support
  • Decode an NTLM Type-2 challenge block to extract the hostname and operating system version
  • Infer FortiGate version from HTTP response headers and cross-reference applicable CVEs

How to install network-appliance-offensive

1Skills CLI (Vercel)

npx skills add transilienceai/communitytools --skill network-appliance-offensive -a claude-code

2Manually: put the files in place

~/.claude/skills/network-appliance-offensive/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/network-appliance-offensive/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about network-appliance-offensive

How do I install network-appliance-offensive in Claude Code?

Run npx skills add transilienceai/communitytools --skill network-appliance-offensive -a claude-code, then verify installation by opening ~/.claude/skills/network-appliance-offensive/SKILL.md.

What does network-appliance-offensive do and when should I use it?

This skill provides tools to actively test live perimeter firewalls and VPN devices when you need to probe a running system rather than audit its configuration. Use it when you must determine an appliance's real firmware version, verify cryptographic parameters, or assess protocol support.

Does this skill run exploits or cause damage?

No. All tools perform passive operations: observation, decoding, and version inference. No exploit code is included, and no destructive actions are performed.

Source text

SKILL.md · MIT
---
name: network-appliance-offensive
description: Offensive testing of perimeter network appliances and VPN crypto — IKE/IPsec (aggressive-mode, transform/DH enum, NAT-T), Check Point SIC/OPSEC, safe firmware/patch-level inference for FortiGate/PAN-OS/Cisco ASA/Citrix feeding CVE applicability, NTLM Type-2 target-info decode, handshake-completion TLS-version probing, and an RST-TTL forgery discriminator. The active/offensive counterpart to the static firewall-review skill. Use when a perimeter firewall/VPN/appliance is in scope and you must test it (not just audit a config), without reinventing raw-socket protocol tooling each engagement.
---

# Network-Appliance Offensive

`firewall-review` audits a *config* statically; `infrastructure` covers *generic* ports/DNS/SMB. Neither tests a live perimeter **appliance** or its **VPN crypto** — so IKE builders, SIC/OPSEC fingerprinting, and TTL discriminators were reinvented from raw sockets each engagement, often shallowly, and CVE applicability was left UNDETERMINED across whole estates. This skill provides the deterministic, tested tools and the precondition-gated methodology. **Non-destructive only** — every tool observes/decodes/infers; none fires an exploit, and CVE applicability is a *precondition check*, never a blind "vulnerable."

## Tools

| Tool | Does | Anti-footgun |
|------|------|--------------|
| [`tools/ike_enum.py`](../../tools/ike_enum.py) | IKEv1 aggressive-mode detection, IKEv1/IKEv2 transform + DH-group enum, NOTIFY / NAT-T decode (wraps `ike-scan`, raw ISAKMP SA_INIT builder fallback) | Aggressive-mode support (PSK-hash leak) is the finding; enumerate, don't crack in-band |
| [`tools/checkpoint_sic_opsec.py`](../../tools/checkpoint_sic_opsec.py) | Fingerprint SIC (18190/1), OPSEC LEA/ELA (18183/4), CA (18192/18210), FW1 (256/264), Gaia Portal; emit a CVE-**precondition** map incl. CVE-2024-24919 | CVE-2024-24919 is `applicable` ONLY when the RA/Mobile-Access marker is observed — else `undetermined` |
| [`tools/appliance_version_infer.py`](../../tools/appliance_version_infer.py) | Safe firmware/patch-level inference for FortiGate / PAN-OS / Cisco ASA / Citrix from headers, login markers, cert CN/serial → CVE applicability | Never asserts `applicable` on a low-confidence / unknown version — returns `undetermined` |
| [`tools/tls_handshake_probe.py`](../../tools/tls_handshake_probe.py) | Which TLS versions are supported, by **completed handshake** per pinned protocol | Fixes the `openssl s_client` exit/SECLEVEL false-positive — an aborted handshake ≠ support |
| [`tools/ntlm_decode.py`](../../tools/ntlm_decode.py) | Decode an NTLM Type-2 (CHALLENGE) AV_PAIR block → NetBIOS/DNS host, domain, forest, OS build | Info-leak finding from an unauthenticated challenge; no auth attempted |
| [`tools/perimeter_forensics.py`](../../tools/perimeter_forensics.py) | RST-TTL forgery discriminator (real host vs firewall forging a RST) + IKE NOTIFY decode | Never asserts "internal host behind FW" on RSTs alone — a firewall forges RSTs indistinguishably at this layer; returns `undetermined` without an open-service TTL baseline |

## Workflow

1. **Fingerprint the appliance** — from the port set + banners + login markers, run `appliance_version_infer.py` (vendor + version guess + confidence) and, for Check Point, `checkpoint_sic_opsec.py`. A version guess of `undetermined`/low-confidence stays undetermined — do not score CVEs against it.
2. **VPN crypto** — on UDP 500/4500, run `ike_enum.py`: flag IKEv1 **aggressive mode** (leaks the PSK hash → a finding), enumerate accepted transforms + weak DH groups (1/2/5), and decode NAT-T/NOTIFY. IKEv2-only where IKEv1 RA is absent (a CVE requiring IKEv1 aggressive mode is `not_applicable` there — see `severity-calibration.md` rule 5).
3. **TLS posture** — `tls_handshake_probe.py` per host: report only handshake-*completed* versions; TLS 1.0/1.1 completion is the weak-protocol finding (not an openssl exit code).
4. **Info leaks** — decode any NTLM Type-2 challenge (`ntlm_decode.py`) for internal host/domain/OS intel; record it as an information-disclosure finding.
5. **CVE applicability (precondition-gated)** — for each surfaced appliance CVE, take the vendor+version from step 1 and the precondition map (checkpoint_sic_opsec / appliance_version_infer `applicability`) and mark `applicable` / `undetermined` / `not_applicable`. Enrich the CVE via `python3 tools/nvd-lookup.py`. An `undetermined` applicability is reported as such — never inflated to a confirmed vuln.
6. **Forensics** — if a "closed" host appears live behind the firewall, run `perimeter_forensics.py --classify-ttls` before asserting anything: distinguish a real host RST from a filter-forged RST (needs an open-service TTL baseline; otherwise `undetermined`).

## Anti-Patterns

- Do not score an appliance CVE as confirmed on a version banner alone — banners are backported/spoofable; gate on `applicability` (`severity-calibration.md` rules 4-5).
- Do not claim TLS 1.0/1.1 support from an `openssl s_client` non-zero exit — require a completed handshake (`tls_handshake_probe.py`).
- Do not assert "internal host behind the firewall" from RSTs — a firewall forges RSTs; use the TTL discriminator and accept `undetermined`.
- Do not crack an IKE aggressive-mode PSK hash in-band on the engagement — capturing/flagging the aggressive-mode exposure is the finding; offline cracking needs explicit authorization.

## Reference

- Static counterpart: [`firewall-review`](../firewall-review/SKILL.md) (config audit). Generic network: [`infrastructure`](../infrastructure/SKILL.md).
- CVE precondition / applicability discipline: [`../coordination/reference/severity-calibration.md`](../coordination/reference/severity-calibration.md) (rules 4-5).

© transilienceai · MIT · transilienceai/communitytools

Similar skills

All skills for Security →

From the same set42

The whole set →
pentest-engagement pentest-engagement runs scoped penetration tests on web applications or networks, verifies findings immediately, and produces a structured PDF report. CX Codex +1 157installs regression-sweep regression-sweep is a Claude Code skill that rechecks confirmed vulnerabilities weekly for patches, mitigations, and re-introductions. It runs on Mondays or manually after major deployments. CX Codex +1 149installs ti-ingest ti-ingest parses threat-intel payloads with CVEs and affected assets into queue files for validation agents. CX Codex +1 147installs pci-secure-software Checks an app against PCI Secure Software Standard v2.0 and returns a status for every Test Requirement, tied to a cited line of code or docs. CX Codex +1 141installs cloud-defense cloud-defense maps post-compromise cloud attack stages to log signals and preventive controls. Use it for AWS, Azure, and GCP detection work or posture reviews. CX Codex +1 133installs transilience-report-style transilience-report-style is a Claude Code skill that defines styling for Threat Intelligence reports generated as A4 PDFs with ReportLab. Light theme is the default. CX Codex +1 133installs authenticated-session-acquisition The authenticated-session-acquisition skill obtains a legitimate MFA/OTP session and saves reusable artifacts for browser and post-auth API testing. CX Codex +1 126installs protect-with-password protect-with-password — a skill for Claude Code produces a secure password and locks specified files using AES-256. Triggers when encrypting deliverable documents prior to sharing. CX Codex +1 115installs

Project sponsors

Companies that keep this analytics open