# IKE Enumeration with Patator: Extracting VPN Transform Sets and Security Parameters

> Discover what information IKE enumeration with Patator can extract about VPN transform sets including encryption, hash, authentication, and DH group details.

- Repository: [lanjelot/patator](https://github.com/lanjelot/patator)
- Tags: how-to-guide
- Published: 2026-03-05

---

**Patator's `IKE_enum` module extracts the four critical components of IKEv1 VPN transform sets—encryption algorithm, hash algorithm, authentication method, and Diffie-Hellman group—by wrapping and parsing the output of the external `ike-scan` tool.**

The `lanjelot/patator` framework includes a dedicated **IKE enumeration module** that automates the discovery of VPN security policies. By systematically testing combinations of cryptographic parameters against IKEv1 endpoints, security professionals can identify supported transform sets and determine whether a VPN gateway accepts aggressive mode connections.

## What Information Does Patator Reveal During IKE Enumeration?

When targeting an IKEv1 VPN gateway, Patator specifically harvests the four numeric identifiers that define a **transform set**. These components are mapped to human-readable names using static lookup tables defined in [`src/patator/patator.py`](https://github.com/lanjelot/patator/blob/main/src/patator/patator.py) (lines 4164–4175):

- **Encryption algorithms** (`IKE_ENC`): DES, 3DES, AES-128/192/256, Camellia, and others
- **Hash algorithms** (`IKE_HASH`): MD5, SHA-1, SHA-2-256/384/512, Tiger
- **Authentication methods** (`IKE_AUTH`): PSK (Pre-Shared Key), RSA-Sig, XAUTH with PSK, and Harkins-CRACK
- **Diffie-Hellman groups** (`IKE_GROUP`): modp768, modp1024, modp1536, modp2048, and higher

Patator does not retrieve credentials or configuration files; it only enumerates which cryptographic combinations the target endpoint will accept for establishing a Security Association (SA).

## How the IKE_enum Module Works

The `IKE_enum` class serves as a thin orchestration layer around the `ike-scan` binary. It handles transform generation, command execution, and response parsing through several internal mechanisms.

### Transform Generation and Cartesian Product

The `generate_transforms()` function (located around line 4180 in [`src/patator/patator.py`](https://github.com/lanjelot/patator/blob/main/src/patator/patator.py)) constructs an exhaustive list of transform strings by computing the Cartesian product of the four static tables. Each iteration yields a comma-separated 4-tuple in the format `encryption,hash,auth,group`, representing one possible security policy to test against the target.

### Executing ike-scan and Parsing Responses

During execution, Patator builds and launches the following command structure:

```bash
ike-scan -M --sport <src_port> <host> --dport <port> --trans <transform> [-A --id <groupname>] [--vendor <vid> ...]

```

The module uses `subprocess.Popen` to execute this command and captures both stdout and stderr. It then parses the output for the presence of `SA=` (Security Association), which indicates that the VPN gateway accepted the proposed transform set. If detected, the raw transform string and endpoint information are stored in the response object.

### Result Aggregation and Display

The `Controller_IKE` class manages result collection through its `push_final()` method (around lines 4249–4250), storing each valid transform in a dictionary keyed by endpoint and mode (Main or Aggressive). Finally, the `show_final()` method (lines 4187–4222) translates the numeric IDs into human-readable names and displays a formatted matrix showing the accepted encryption, hash, authentication, and group parameters for each discovered SA.

## Practical IKE Enumeration Examples

### Basic Main Mode Enumeration

To enumerate all possible transform sets against a target VPN gateway in Main Mode:

```bash
patator ike_enum host=10.0.0.1 \
                transform=MOD0 \
                0=TRANS \
                -x ignore:fgrep=NO-PROPOSAL

```

Here, `transform=MOD0` instructs Patator to use the generated transform iterator, while `0=TRANS` maps this iterator to the module's first positional argument. The `-x ignore:fgrep=NO-PROPOSAL` filter excludes unsuccessful probes from the output.

### Aggressive Mode with Group Identification

To test Aggressive Mode and specify a custom group name for identification:

```bash
patator ike_enum host=10.0.0.1 \
                transform=MOD0 \
                aggressive=1 \
                groupname=TestGroup \
                0=TRANS \
                -x ignore:fgrep=NO-PROPOSAL

```

Setting `aggressive=1` appends the `-A` flag to the underlying `ike-scan` command, while `groupname` populates the `--id` parameter required for Aggressive Mode handshakes.

### Enumerating with Custom Vendor IDs

To include specific vendor IDs in the IKE handshake:

```bash
patator ike_enum host=10.0.0.1 \
                transform=MOD0 \
                vid=0x00a0b1,0x00a0b2 \
                0=TRANS \
                -x ignore:fgrep=NO-PROPOSAL

```

The `vid` parameter accepts comma-separated hexadecimal values, each passed as `--vendor <id>` to `ike-scan` to fingerprint specific VPN implementations.

## Summary

- Patator's **IKE_enum module** extracts four specific cryptographic parameters from IKEv1 VPN endpoints: encryption algorithm, hash algorithm, authentication method, and Diffie-Hellman group.
- The module wraps `ike-scan` and parses the `SA=` string in responses to identify accepted **transform sets**.
- Static lookup tables in [`src/patator/patator.py`](https://github.com/lanjelot/patator/blob/main/src/patator/patator.py) (lines 4164–4175) translate numeric IDs to human-readable security policy names.
- The `generate_transforms()` function creates exhaustive test cases via Cartesian product of all possible 4-tuples.
- Results are aggregated by the `Controller_IKE` class and displayed as formatted matrices distinguishing between Main and Aggressive modes.

## Frequently Asked Questions

### What is the difference between Main Mode and Aggressive Mode in Patator's IKE enumeration?

**Main Mode** uses six message exchanges to establish the IKE SA and provides identity protection, while **Aggressive Mode** completes the exchange in three messages but transmits the initiator's identity in the clear. In Patator, enabling `aggressive=1` adds the `-A` flag to the `ike-scan` command and allows specifying a `groupname` via the `--id` parameter, which can reveal different transform sets or group-specific policies than Main Mode probes.

### How does Patator generate the list of transform sets to test?

Patator calls `generate_transforms()` (around line 4180 in [`src/patator/patator.py`](https://github.com/lanjelot/patator/blob/main/src/patator/patator.py)) to build the complete list by calculating the Cartesian product of the four static ID tables: `IKE_ENC`, `IKE_HASH`, `IKE_AUTH`, and `IKE_GROUP`. This generates every possible combination of encryption, hash, authentication, and DH group parameters, creating an exhaustive iterator of comma-separated transform strings for systematic testing.

### Can Patator retrieve VPN credentials during IKE enumeration?

**No.** According to the source code in `lanjelot/patator`, the `IKE_enum` module only parses the `SA=` string from `ike-scan` output to identify accepted cryptographic parameters. It does not implement aggressive mode credential extraction, XAUTH password cracking, or PSK recovery. The module strictly enumerates **VPN transform sets** and connection modes, not authentication secrets.

### What does the SA= string indicate in the ike-scan output?

The `SA=` string indicates that the VPN gateway has successfully negotiated a **Security Association** using the proposed transform set. When Patator's `execute()` method detects this string in the subprocess output (around lines 7474–7481 of [`patator.py`](https://github.com/lanjelot/patator/blob/main/patator.py)), it records the endpoint, mode, and specific transform combination as a valid VPN security policy offered by the target.