WireGuard Android Tunnel Library

https://github.com/wireguard/wireguard-android
Admin
WireGuard Android Tunnel Library is an embeddable tunnel library for Android that manages WireGuard...
Tokens:29,509
Snippets:368
Trust Score:9.2
License:Apache-2.0
Update:2 months ago
Show doc for...
Tokens:
Raw
### Get Mask Usage Example

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Example of retrieving the mask and checking for single host status.

```java
InetNetwork net = InetNetwork.parse("192.0.2.0/24");
int mask = net.getMask();
System.out.println("Netmask length: " + mask);  // 24

// Determine if single host
if (net.getMask() == 32) {
    System.out.println("Single IPv4 host");
}
if (net.getMask() == 128) {
    System.out.println("Single IPv6 host");
}
```

--------------------------------

### Configure DNS Servers

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Examples of specifying DNS servers and search domains.

```text
DNS = 1.1.1.1
DNS = 1.1.1.1, 8.8.8.8
DNS = 8.8.8.8, fd00::1, example.com
```

--------------------------------

### Get Address Usage Example

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Example of retrieving and identifying the IP address type.

```java
InetNetwork net = InetNetwork.parse("192.0.2.0/24");
InetAddress addr = net.getAddress();
System.out.println("Address type: " + addr.getClass().getSimpleName());
System.out.println("Address: " + addr.getHostAddress());  // "192.0.2.0"
```

--------------------------------

### Parse Network Examples

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Examples of parsing various IPv4 and IPv6 network strings.

```java
// IPv4 with netmask
InetNetwork net1 = InetNetwork.parse("192.0.2.0/24");

// IPv4 single host
InetNetwork net2 = InetNetwork.parse("192.0.2.5");  // /32

// IPv6 with netmask
InetNetwork net3 = InetNetwork.parse("2001:db8::/32");

// IPv6 single host
InetNetwork net4 = InetNetwork.parse("2001:db8::1"); // /128
```

--------------------------------

### ToString Usage Example

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Example of printing the network in CIDR notation.

```java
InetNetwork net = InetNetwork.parse("192.0.2.0/24");
System.out.println(net);  // "192.0.2.0/24"
```

--------------------------------

### Handling BadConfigException

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/errors.md

Example of catching and processing a BadConfigException to provide user feedback.

```java
try {
    Config config = Config.parse(stream);
} catch (BadConfigException e) {
    String errorMsg = String.format(
        "[%s] %s: %s (near: %s)",
        e.getSection(),
        e.getLocation().getName(),
        e.getReason(),
        e.getText()
    );
    System.err.println("Config error: " + errorMsg);
    
    // Show user-friendly message based on error type
    switch (e.getReason()) {
        case MISSING_SECTION:
            showError("Configuration missing [Interface] section");
            break;
        case INVALID_KEY:
            showError("Invalid key encoding at " + e.getLocation().getName());
            break;
        case SYNTAX_ERROR:
            showError("Syntax error: " + e.getText());
            break;
    }
}
```

--------------------------------

### Throw BackendException examples

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/errors.md

Demonstrates throwing the exception with and without format arguments.

```java
// Simple reason, no format args
throw new BackendException(BackendException.Reason.VPN_NOT_AUTHORIZED);

// Reason with format args (e.g., for error codes)
throw new BackendException(
    BackendException.Reason.GO_ACTIVATION_ERROR_CODE,
    127,  // exit code
    "Operation not permitted"
);
```

--------------------------------

### Complete WireGuard Configuration Example

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

A standard configuration file containing one Interface section and multiple Peer sections with various settings.

```ini
[Interface]
PrivateKey = cH6I...QRwAA=
Address = 10.0.0.1/24, 2001:db8::1/64
DNS = 1.1.1.1, 8.8.8.8
ListenPort = 51820
MTU = 1500

[Peer]
PublicKey = fY1...QRwAA=
AllowedIPs = 10.0.0.2/32, 192.168.1.0/24
Endpoint = vpn.example.com:51820
PersistentKeepalive = 25

[Peer]
PublicKey = aB3...QRwAA=
AllowedIPs = 10.0.0.3/32, 10.0.0.4/32
Endpoint = [2001:db8::2]:51820
PreSharedKey = gI6E...QRwAA=
PersistentKeepalive = 60

[Peer]
PublicKey = xY9...QRwAA=
AllowedIPs = 0.0.0.0/0, ::/0
Endpoint = public-vpn.example.com:51820
```

--------------------------------

### Configure Listen Port

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Examples of setting the UDP listen port, or using 0 to allow the OS to choose.

```text
ListenPort = 51820
ListenPort = 0         # OS chooses port
```

--------------------------------

### Configure MTU

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Examples of setting the Maximum Transmission Unit for the interface.

```text
MTU = 1500
MTU = 1280         # For smaller MTU paths
```

--------------------------------

### KeyFormatException Usage Example

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/errors.md

Demonstrates how to catch and handle KeyFormatException by checking the error type.

```java
try {
    Key privKey = Key.fromBase64(keyString);
} catch (KeyFormatException e) {
    if (e.getType() == KeyFormatException.Type.LENGTH) {
        System.err.println("Key format " + e.getFormat() + 
            " must be " + e.getFormat().getLength() + " chars/bytes");
    } else {
        System.err.println("Invalid " + e.getFormat() + 
            " characters in key");
    }
}
```

--------------------------------

### Configure Interface Addresses

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Examples of assigning IP addresses and networks using CIDR notation.

```text
Address = 10.0.0.1/24
Address = 10.0.0.1/24, 2001:db8::1/64, fd00::1/128
Address = 192.168.1.100
```

--------------------------------

### Load and Start Tunnel

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/INDEX.md

Initializes a configuration from an input stream and sets the tunnel state to UP.

```java
// See: api-reference/04-config-classes.md + api-reference/01-backend-interface.md
Config config = Config.parse(inputStream);
backend.setState(tunnel, Tunnel.State.UP, config);
```

--------------------------------

### Get Backend Version

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/01-backend-interface.md

Returns the version string of the backend implementation.

```java
String getVersion() throws Exception
```

```java
Backend backend = new GoBackend(context);
String version = backend.getVersion();
System.out.println("WireGuard backend: " + version);
```

--------------------------------

### Parse Network Exception Examples

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Examples of invalid inputs that trigger a ParseException.

```java
// ParseException - Invalid IP address
InetNetwork.parse("999.999.999.999/24");

// ParseException - Mask exceeds maximum
InetNetwork.parse("192.0.2.0/33");         // IPv4 max mask is 32
InetNetwork.parse("2001:db8::/129");       // IPv6 max mask is 128

// ParseException - Invalid mask value
InetNetwork.parse("192.0.2.0/abc");
```

--------------------------------

### Whitespace Handling Examples

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Demonstrates that whitespace around the assignment operator is ignored by the parser.

```ini
Address = 10.0.0.1/24
Address=10.0.0.1/24
Address  =  10.0.0.1/24
```

--------------------------------

### Configure Included Applications

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Examples of specifying Android package names that must use the tunnel.

```text
IncludedApplications = com.wireguard.android
IncludedApplications = com.example.app, org.other.app
```

--------------------------------

### Handle BackendException with switch

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/errors.md

Example of catching the exception and branching logic based on the reason code.

```java
try {
    backend.setState(tunnel, Tunnel.State.UP, config);
} catch (BackendException e) {
    switch (e.getReason()) {
        case VPN_NOT_AUTHORIZED:
            showDialog("VPN permission required");
            break;
        case UNABLE_TO_START_VPN:
            showDialog("Failed to start VPN service");
            break;
        default:
            showDialog("Unknown VPN error");
    }
}
```

--------------------------------

### Get DNS Servers

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Retrieves the configured DNS server addresses.

```java
public Set<InetAddress> getDnsServers()
```

--------------------------------

### Configure Excluded Applications

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Examples of specifying Android package names that should bypass the tunnel.

```text
ExcludedApplications = com.android.systemui
ExcludedApplications = com.android.systemui, com.android.phone, com.google.android.dialer
```

--------------------------------

### Parsing Endpoint Strings

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Examples of parsing various endpoint formats including DNS hostnames, IPv4, and IPv6 addresses.

```java
// DNS hostname
InetEndpoint ep1 = InetEndpoint.parse("vpn.example.com:51820");

// IPv4
InetEndpoint ep2 = InetEndpoint.parse("192.0.2.1:51820");

// IPv6 (must use brackets)
InetEndpoint ep3 = InetEndpoint.parse("[2001:db8::1]:51820");
```

--------------------------------

### Get Address Method Signature

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Method signature for retrieving the IP address.

```java
public InetAddress getAddress()
```

--------------------------------

### Get Included Applications

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Retrieves package names with exclusive VPN access. Cannot be used with excluded applications.

```java
public Set<String> getIncludedApplications()
```

--------------------------------

### Get Excluded Applications

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Retrieves package names excluded from VPN access. Cannot be used with included applications.

```java
public Set<String> getExcludedApplications()
```

--------------------------------

### Initialize WgQuickBackend

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/README.md

Initialize the kernel-based backend, which requires root privileges and specific tools in the system PATH.

```java
Backend backend = new WgQuickBackend();
```

--------------------------------

### Initialize GoBackend

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/README.md

Initialize the userspace backend which requires an Android Context and the native library.

```java
Backend backend = new GoBackend(context);
// Loads native library "libwg-go.so" automatically
```

--------------------------------

### Library Entry Points

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/00-START-HERE.md

Core classes for initializing the backend, parsing configurations, and generating cryptographic keys.

```java
// Start here for tunnel control
Backend backend = new GoBackend(context);

// Load configs
Config config = Config.parse(stream);

// Generate keys
KeyPair keys = new KeyPair();
```

--------------------------------

### Exporting Configuration to File

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/README.md

Converts a configuration object to a wg-quick format string and writes it to a file.

```java
Config config = ...;
String wgQuickFormat = config.toWgQuickString();
Files.write(Paths.get("output.conf"), 
    wgQuickFormat.getBytes(StandardCharsets.UTF_8));
```

--------------------------------

### Config.toWgQuickString

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Serializes the configuration to wg-quick format.

```APIDOC
## public String toWgQuickString()

### Description
Serializes the configuration to the wg-quick file format, suitable for use with `wg-quick up`.

### Returns
- **String** - The configuration in wg-quick format.
```

--------------------------------

### Loading and Managing a WireGuard Configuration

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/00-START-HERE.md

Demonstrates parsing a configuration file, accessing interface and peer details, and managing tunnel state via the GoBackend.

```java
// 1. Parse the config file
Config config = Config.parse(new FileInputStream("wg0.conf"));

// 2. Access sections
Interface iface = config.getInterface();
List<Peer> peers = config.getPeers();

// 3. Use with Backend
Backend backend = new GoBackend(context);
backend.setState(tunnel, Tunnel.State.UP, config);

// 4. Monitor
Statistics stats = backend.getStatistics(tunnel);
System.out.println("Downloaded: " + stats.totalRx() + " bytes");
```

--------------------------------

### Serialize to wg-quick Format

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Converts the configuration object into a wg-quick compatible string.

```java
public String toWgQuickString()
```

```java
Config config = Config.parse(stream);
String formatted = config.toWgQuickString();
Files.write(Paths.get("output.conf"), formatted.getBytes(StandardCharsets.UTF_8));
```

--------------------------------

### Convert between formats

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/05-crypto-classes.md

Demonstrates conversion of Key objects to and from Base64, Hex, and binary formats.

```java
Key key = Key.fromBase64("qKH9a...QA=");

// Base64
String b64 = key.toBase64();

// Hex
String hex = key.toHex();

// Binary
byte[] bytes = key.getBytes();

// Back to Key from different format
Key key2 = Key.fromHex(hex);
assert key.equals(key2);  // Same key
```

--------------------------------

### Loading Configuration from File

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/README.md

Reads a configuration file from a path and parses it into a Config object.

```java
Path configPath = Paths.get("/sdcard/Download/my-config.conf");
try (InputStream stream = Files.newInputStream(configPath)) {
    Config config = Config.parse(stream);
} catch (IOException e) {
    System.err.println("Failed to read file: " + e);
} catch (BadConfigException e) {
    System.err.println("Invalid configuration: " + e.getReason());
}
```

--------------------------------

### Get Key Pair

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Retrieves the Curve25519 key pair associated with the interface.

```java
public KeyPair getKeyPair()
```

--------------------------------

### Get Port from InetEndpoint

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Retrieves the UDP port number associated with the endpoint.

```java
InetEndpoint ep = InetEndpoint.parse("example.com:51820");
System.out.println("Port: " + ep.getPort());  // 51820
```

--------------------------------

### Build libwg-quick.so

Source: https://github.com/wireguard/wireguard-android/blob/master/tunnel/tools/CMakeLists.txt

Compiles the wg-quick tool for Android, linking against the dynamic linker library.

```cmake
add_executable(libwg-quick.so wireguard-tools/src/wg-quick/android.c ndk-compat/compat.c)
target_compile_options(libwg-quick.so PUBLIC -std=gnu11 -include ${CMAKE_CURRENT_SOURCE_DIR}/ndk-compat/compat.h -DWG_PACKAGE_NAME="${ANDROID_PACKAGE_NAME}")
target_link_libraries(libwg-quick.so -ldl)
```

--------------------------------

### Import existing keys

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/05-crypto-classes.md

Initializes Key objects from Base64 strings for use in Interface and Peer configurations.

```java
String myPrivateKeyB64 = "cH6I...AAAQ=";
String peerPublicKeyB64 = "fY1...AAAQ=";

KeyPair myKeys = new KeyPair(Key.fromBase64(myPrivateKeyB64));
Key peerPublicKey = Key.fromBase64(peerPublicKeyB64);

Interface iface = new Interface.Builder()
    .setKeyPair(myKeys)
    .build();

Peer peer = new Peer.Builder()
    .setPublicKey(peerPublicKey)
    .build();
```

--------------------------------

### Get DNS Search Domains

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Retrieves the configured DNS search domain names.

```java
public Set<String> getDnsSearchDomains()
```

--------------------------------

### Get Interface Addresses

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Retrieves the assigned IP addresses or networks as an immutable set.

```java
public Set<InetNetwork> getAddresses()
```

--------------------------------

### Get Mask Method Signature

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Method signature for retrieving the CIDR netmask length.

```java
public int getMask()
```

--------------------------------

### Get Tunnel State

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/01-backend-interface.md

Retrieves the operational state of a specific tunnel without modifying it.

```java
Tunnel.State getState(Tunnel tunnel) throws Exception
```

```java
Backend backend = new GoBackend(context);
Tunnel myTunnel = ...; // from TunnelManager
Tunnel.State state = backend.getState(myTunnel);
if (state == Tunnel.State.UP) {
    System.out.println("Tunnel is running");
}
```

--------------------------------

### Get Running Tunnel Names

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/01-backend-interface.md

Retrieves a set of currently active tunnel names.

```java
Set<String> getRunningTunnelNames()
```

```java
Backend backend = new GoBackend(context);
Set<String> running = backend.getRunningTunnelNames();
for (String name : running) {
    System.out.println("Tunnel active: " + name);
}
```

--------------------------------

### Build the WireGuard Android project

Source: https://github.com/wireguard/wireguard-android/blob/master/README.md

Commands to clone the repository and build the release APK using Gradle.

```bash
$ git clone --recurse-submodules https://git.zx2c4.com/wireguard-android
$ cd wireguard-android
$ ./gradlew assembleRelease
```

--------------------------------

### Build WireGuard configuration programmatically

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Uses builder patterns to define interface and peer settings before generating a wg-quick compatible string.

```java
KeyPair keys = new KeyPair();
Interface iface = new Interface.Builder()
    .setInterface(new Interface.Builder()
        .setPrivateKey(keys.getPrivateKey())
        .addAddress(InetNetwork.parse("10.0.0.1/24"))
        .parseListenPort("51820")
        .build());
    
Peer peer = new Peer.Builder()
    .setPublicKey(Key.fromBase64(remotePublicKey))
    .parseAllowedIPs("10.0.0.2/32")
    .parseEndpoint("example.com:51820")
    .build();

Config config = new Config.Builder()
    .setInterface(iface)
    .addPeer(peer)
    .build();

System.out.println(config.toWgQuickString());
```

--------------------------------

### Structured Error Handling in Java

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/errors.md

Demonstrates wrapping configuration parsing errors and handling specific backend tunnel state exceptions.

```java
public class ConfigManager {
    public Config loadConfiguration(InputStream stream) 
            throws ConfigException {
        try {
            return Config.parse(stream);
        } catch (IOException e) {
            throw new ConfigException("Failed to read configuration file", e);
        } catch (BadConfigException e) {
            String detail = String.format(
                "Invalid configuration in %s at %s: %s",
                e.getSection(),
                e.getLocation().getName(),
                e.getReason()
            );
            throw new ConfigException(detail, e);
        }
    }
    
    public boolean setTunnelUp(Tunnel tunnel, Config config) {
        try {
            Backend backend = getBackend();
            backend.setState(tunnel, Tunnel.State.UP, config);
            return true;
        } catch (BackendException e) {
            switch (e.getReason()) {
                case VPN_NOT_AUTHORIZED:
                    requestVpnPermission();
                    return false;
                case UNABLE_TO_START_VPN:
                    showError("VPN service failed to start");
                    return false;
                case DNS_RESOLUTION_FAILURE:
                    showError("Could not resolve peer endpoint");
                    return false;
                default:
                    showError("Tunnel activation failed: " + e.getReason());
                    return false;
            }
        } catch (Exception e) {
            showError("Unexpected error: " + e.getMessage());
            return false;
        }
    }
}
```

--------------------------------

### Project File Structure

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/README.md

Overview of the source code organization for the tunnel, configuration, and crypto packages.

```text
tunnel/src/main/java/
  ├── com/wireguard/android/backend/
  │   ├── Backend.java           # VPN control interface
  │   ├── Tunnel.java            # Tunnel representation interface
  │   ├── Statistics.java        # Traffic metrics
  │   ├── BackendException.java  # Backend errors
  │   ├── GoBackend.java         # Userspace implementation
  │   └── WgQuickBackend.java    # Kernel implementation
  ├── com/wireguard/config/
  │   ├── Config.java            # Configuration root
  │   ├── Interface.java         # Interface section
  │   ├── Peer.java              # Peer section
  │   ├── InetNetwork.java       # Network/mask
  │   ├── InetEndpoint.java      # Host:port
  │   ├── InetAddresses.java     # Address utilities
  │   ├── BadConfigException.java # Config parsing errors
  │   ├── ParseException.java    # Value parsing errors
  │   └── Attribute.java         # Line parsing
  └── com/wireguard/crypto/
      ├── Key.java               # Key container
      ├── KeyPair.java           # Public/private pair
      ├── KeyFormatException.java # Key encoding errors
      └── Curve25519.java        # Crypto operations
```

--------------------------------

### Get MTU

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Retrieves the configured Maximum Transmission Unit, or an empty Optional if the default is used.

```java
public Optional<Integer> getMtu()
```

--------------------------------

### Build libwg.so

Source: https://github.com/wireguard/wireguard-android/blob/master/tunnel/tools/CMakeLists.txt

Compiles the core WireGuard library, including necessary include directories and runtime state directory definitions.

```cmake
file(GLOB WG_SOURCES wireguard-tools/src/*.c ndk-compat/compat.c)
add_executable(libwg.so ${WG_SOURCES})
target_include_directories(libwg.so PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/wireguard-tools/src/uapi/linux/" "${CMAKE_CURRENT_SOURCE_DIR}/wireguard-tools/src/")
target_compile_options(libwg.so PUBLIC -std=gnu11 -include ${CMAKE_CURRENT_SOURCE_DIR}/ndk-compat/compat.h -DRUNSTATEDIR="/data/data/${ANDROID_PACKAGE_NAME}/cache")
```

--------------------------------

### Get Listen Port

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Retrieves the configured UDP listening port, or an empty Optional if auto-assigned.

```java
public Optional<Integer> getListenPort()
```

--------------------------------

### Peer Instance Methods

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Methods to retrieve configuration attributes from an existing Peer instance.

```APIDOC
## Peer Instance Methods

### getPublicKey()
Returns the required public key of the peer.

### getAllowedIps()
Returns an immutable set of IP addresses or networks allowed through this peer.

### getEndpoint()
Returns an Optional containing the remote endpoint (host:port) if configured.

### getPreSharedKey()
Returns an Optional containing the pre-shared symmetric key if configured.

### getPersistentKeepalive()
Returns an Optional containing the keepalive interval in seconds (1-65535) if configured.
```

--------------------------------

### Get Hostname from InetEndpoint

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Retrieves the original hostname or IP address string from an endpoint instance.

```java
InetEndpoint ep = InetEndpoint.parse("example.com:51820");
System.out.println("Host: " + ep.getHost());  // "example.com"
```

--------------------------------

### Validating Tunnel Names

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/02-tunnel-interface.md

Examples of using isNameInvalid to check if a tunnel name conforms to the required pattern.

```java
if (Tunnel.isNameInvalid("my-tunnel")) {
    System.out.println("Invalid name");
} else {
    System.out.println("Valid name");
}

// Returns true (invalid):
Tunnel.isNameInvalid("my tunnel!");      // Space and ! not allowed
Tunnel.isNameInvalid("veryverylongname"); // Exceeds 15 chars
Tunnel.isNameInvalid("");                 // Empty string

// Returns false (valid):
Tunnel.isNameInvalid("my-tunnel");
Tunnel.isNameInvalid("work-vpn_2024");
Tunnel.isNameInvalid("vpn.example");
```

--------------------------------

### View Library File Structure

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/00-START-HERE.md

Displays the directory layout of the documentation files.

```text
📁 output/
├─ 📄 README.md                    [15 KB] Overview & quick start
├─ 📄 INDEX.md                     [13 KB] Master navigation index
├─ 📄 00-START-HERE.md            [This file]
├─ 📄 types.md                     [15 KB] Type definitions
├─ 📄 configuration.md             [11 KB] Config file format
├─ 📄 errors.md                    [13 KB] Exception catalog
├─ 📄 SUMMARY.txt                  [9 KB]  Coverage summary
└─ 📁 api-reference/               [64 KB] Detailed modules
   ├─ 01-backend-interface.md     [8 KB]  Backend, Tunnel, State
   ├─ 02-tunnel-interface.md      [5 KB]  Tunnel interface
   ├─ 03-statistics.md            [7 KB]  Statistics & metrics
   ├─ 04-config-classes.md        [13 KB] Config, Interface, Peer
   ├─ 05-crypto-classes.md        [10 KB] Key, KeyPair
   └─ 06-network-classes.md       [11 KB] Networks, Endpoints
```

--------------------------------

### Constructing Immutable Configurations

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/README.md

Demonstrates the use of Builder classes to create or modify immutable configuration instances.

```java
// Immutable - cannot change after construction
Config config = Config.parse(stream);
// config.getInterface().setAddress(...) // Compile error

// Use Builder for changes
Config newConfig = new Config.Builder()
    .setInterface(config.getInterface())
    .addPeer(newPeer)
    .build();
```

--------------------------------

### Interface Instance Methods

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Methods to retrieve configuration details from an Interface instance.

```APIDOC
## Instance Methods

### getAddresses
Returns the assigned IP addresses/networks as a Set<InetNetwork>.

### getDnsServers
Returns the configured DNS server addresses as a Set<InetAddress>.

### getDnsSearchDomains
Returns the DNS search domain names as a Set<String>.

### getIncludedApplications
Returns package names with exclusive VPN access as a Set<String>.

### getExcludedApplications
Returns package names excluded from VPN as a Set<String>.

### getKeyPair
Returns the required Curve25519 KeyPair.

### getListenPort
Returns the listening UDP port (0-65535) as an Optional<Integer>.

### getMtu
Returns the configured MTU value as an Optional<Integer>.
```

--------------------------------

### Bring tunnel UP

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/01-backend-interface.md

Initializes a tunnel with a provided configuration. Requires a non-null configuration object.

```java
Backend backend = new GoBackend(context);
Tunnel myTunnel = ...;
Config config = Config.parse(configInputStream);

try {
    Tunnel.State result = backend.setState(myTunnel, Tunnel.State.UP, config);
    System.out.println("Tunnel state: " + result);
} catch (BackendException e) {
    if (e.getReason() == BackendException.Reason.VPN_NOT_AUTHORIZED) {
        System.out.println("User denied VPN permission");
    }
}
```

--------------------------------

### Create peer endpoints

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Shows how to parse endpoint strings and resolve them asynchronously using an executor service.

```java
Map<String, InetEndpoint> peerEndpoints = new HashMap<>();

try {
    peerEndpoints.put("alice", InetEndpoint.parse("alice.example.com:51820"));
    peerEndpoints.put("bob", InetEndpoint.parse("192.0.2.100:51820"));
    peerEndpoints.put("carol", InetEndpoint.parse("[2001:db8::1]:51820"));
} catch (ParseException e) {
    System.err.println("Invalid endpoint: " + e);
}

// Later, resolve endpoints asynchronously
executorService.submit(() -> {
    for (Map.Entry<String, InetEndpoint> entry : peerEndpoints.entrySet()) {
        Optional<InetEndpoint> resolved = entry.getValue().getResolved();
        resolved.ifPresent(r -> {
            System.out.println(entry.getKey() + " -> " + r.getHost());
        });
    }
});
```

--------------------------------

### Get Tunnel Statistics

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/01-backend-interface.md

Retrieves traffic and connection statistics for a tunnel, returning zero-filled data if the tunnel is not running.

```java
Statistics getStatistics(Tunnel tunnel) throws Exception
```

```java
Backend backend = new GoBackend(context);
Tunnel myTunnel = ...; 
Statistics stats = backend.getStatistics(myTunnel);
System.out.println("Total RX: " + stats.totalRx() + " bytes");
System.out.println("Total TX: " + stats.totalTx() + " bytes");

for (Key peer : stats.peers()) {
    Statistics.PeerStats ps = stats.peer(peer);
    System.out.println("Peer: RX=" + ps.rxBytes() + " TX=" + ps.txBytes());
}
```

--------------------------------

### InetNetwork Instance Methods

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Methods for retrieving information from an InetNetwork instance.

```APIDOC
## public InetAddress getAddress()

### Description
Returns the IP address of the network.

### Returns
- **InetAddress** - The underlying Inet4Address or Inet6Address.

---

## public int getMask()

### Description
Returns the CIDR netmask length.

### Returns
- **int** - The prefix length (0-32 for IPv4, 0-128 for IPv6).

---

## public String toString()

### Description
Returns the string representation of the network in CIDR notation.

### Returns
- **String** - The network in "address/mask" format.
```

--------------------------------

### Manage Tunnel State and Statistics

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/README.md

Handles tunnel lifecycle operations including starting, stopping, and retrieving traffic statistics with error handling.

```java
Backend backend = new GoBackend(context);

// Get current state
Tunnel.State state = backend.getState(tunnel);

// Start tunnel
try {
    Config config = Config.parse(stream);
    backend.setState(tunnel, Tunnel.State.UP, config);
} catch (BackendException e) {
    switch (e.getReason()) {
        case VPN_NOT_AUTHORIZED:
            // Prompt user for permission
            break;
        case DNS_RESOLUTION_FAILURE:
            // Peer endpoint couldn't be resolved
            break;
    }
}

// Stop tunnel
backend.setState(tunnel, Tunnel.State.DOWN, null);

// Get statistics
Statistics stats = backend.getStatistics(tunnel);
System.out.println("Downloaded: " + stats.totalRx() + " bytes");
System.out.println("Uploaded: " + stats.totalTx() + " bytes");
```

--------------------------------

### Build libwg-go.so

Source: https://github.com/wireguard/wireguard-android/blob/master/tunnel/tools/CMakeLists.txt

Defines a custom target to build the Go-based WireGuard library using an external make process.

```cmake
add_custom_target(libwg-go.so WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/libwg-go" COMMENT "Building wireguard-go" VERBATIM COMMAND "${ANDROID_HOST_PREBUILTS}/bin/make"
    ANDROID_ARCH_NAME=${ANDROID_ARCH_NAME}
    ANDROID_PACKAGE_NAME=${ANDROID_PACKAGE_NAME}
    GRADLE_USER_HOME=${GRADLE_USER_HOME}
    CC=${CMAKE_C_COMPILER}
    CFLAGS=${CMAKE_C_FLAGS}
    LDFLAGS=${CMAKE_SHARED_LINKER_FLAGS}
    SYSROOT=${CMAKE_SYSROOT}
    TARGET=${CMAKE_C_COMPILER_TARGET}
    DESTDIR=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}
    BUILDDIR=${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/../generated-src
)
```

--------------------------------

### Create KeyPair from Existing Private Key

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/05-crypto-classes.md

Constructs a KeyPair using a provided 32-byte private key.

```java
public KeyPair(Key privateKey)
```

```java
Key privKey = Key.fromBase64(existingPrivateKeyB64);
KeyPair pair = new KeyPair(privKey);
Key pubKey = pair.getPublicKey();
System.out.println("Derived public: " + pubKey.toBase64());
```

--------------------------------

### Load and inspect WireGuard configuration

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Parses a configuration file from a stream and iterates through interface and peer settings.

```java
Config config = Config.parse(new FileInputStream("wg0.conf"));
Interface iface = config.getInterface();

System.out.println("Address: " + iface.getAddresses());
System.out.println("Private key: " + iface.getKeyPair().getPrivateKey().toBase64());

for (Peer peer : config.getPeers()) {
    System.out.println("Peer: " + peer.getPublicKey().toBase64());
    peer.getEndpoint().ifPresent(ep -> System.out.println("  Endpoint: " + ep));
    System.out.println("  Allowed: " + peer.getAllowedIps());
}
```

--------------------------------

### Serialize to Userspace API Format

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Converts the configuration object into the wireguard-go UAPI format.

```java
public String toWgUserspaceString()
```

--------------------------------

### Use keys in collections

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/05-crypto-classes.md

Shows how Key objects can be used as keys in a Map for lookups.

```java
Map<Key, String> peerNames = new HashMap<>();
Key peerKey1 = Key.fromBase64("qKH9...QA=");
Key peerKey2 = Key.fromBase64("fY1...QA=");

peerNames.put(peerKey1, "Alice");
peerNames.put(peerKey2, "Bob");

// Lookup by key
String name = peerNames.get(peerKey1);  // "Alice"
```

--------------------------------

### Generate and Import Keys

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/README.md

Creates new key pairs or imports existing private keys from Base64 strings.

```java
// Generate new key pair
KeyPair keys = new KeyPair();
String privateKeyB64 = keys.getPrivateKey().toBase64();
String publicKeyB64 = keys.getPublicKey().toBase64();

// Or import existing
Key existingPrivate = Key.fromBase64(privateKeyString);
KeyPair pair = new KeyPair(existingPrivate);
```

--------------------------------

### Interface.parse

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Parses a collection of configuration lines into an Interface instance. The PrivateKey attribute is required.

```APIDOC
## public static Interface parse(Iterable<? extends CharSequence> lines)

### Description
Parses "KEY = VALUE" lines into an Interface instance. PrivateKey is required for successful parsing.

### Parameters
- **lines** (Iterable<CharSequence>) - Required - Configuration lines (no section header)

### Returns
- **Interface** - The parsed interface instance

### Throws
- **BadConfigException** - Thrown if attributes are missing or invalid
```

--------------------------------

### getVersion

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/01-backend-interface.md

Returns the version string of the backend implementation.

```APIDOC
## String getVersion()

### Description
Returns the backend version string (e.g., "1.0.20211016" for wireguard-go, or kernel module version).

### Parameters
- None

### Return Type
- String

### Throws
- Exception - When version cannot be determined

### Example
```java
Backend backend = new GoBackend(context);
String version = backend.getVersion();
System.out.println("WireGuard backend: " + version);
```
```

--------------------------------

### Generate Private Key

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Command to generate a valid 44-character Base64 private key.

```bash
wg genkey  # Outputs 44-character Base64 string
```

--------------------------------

### Parse AllowedIPs from config

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Demonstrates parsing an array of CIDR strings into a set of InetNetwork objects with error handling.

```java
String[] allowedIpStrings = {"10.0.0.2/32", "192.168.1.0/24", "2001:db8::/32"};
Set<InetNetwork> allowedIps = new HashSet<>();

for (String network : allowedIpStrings) {
    try {
        allowedIps.add(InetNetwork.parse(network));
    } catch (ParseException e) {
        System.err.println("Invalid network: " + network);
    }
}

System.out.println("Allowed networks: " + allowedIps);
```

--------------------------------

### Parse Peer Configuration

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Parses configuration lines into a Peer instance.

```java
public static Peer parse(Iterable<? extends CharSequence> lines)
    throws BadConfigException
```

```java
Peer peer = Peer.parse(Arrays.asList(
    "PublicKey = fY...",
    "AllowedIPs = 10.0.0.2/32",
    "Endpoint = example.com:51820",
    "PersistentKeepalive = 25"
));
```

--------------------------------

### Key.fromBytes(byte[] bytes)

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/05-crypto-classes.md

Wraps raw binary key data in a Key container with length validation.

```APIDOC
## Key.fromBytes(byte[] bytes)

### Description
Wraps raw binary key data in a Key container. Performs a defensive copy to prevent external modification.

### Parameters
- **bytes** (byte[]) - Required - Raw key data (must be exactly 32 bytes)

### Returns
- **Key** - An immutable key container.

### Throws
- **KeyFormatException** - Thrown when the length is not 32 bytes.
```

--------------------------------

### Comment Syntax

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Shows how to use the hash symbol for comments, which can be placed on their own lines or at the end of a line.

```ini
# This is a comment
PrivateKey = xyz...      # This is also a comment
```

--------------------------------

### Configure Endpoint

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Specify the remote address and port for the peer connection.

```text
Endpoint = vpn.example.com:51820
Endpoint = 203.0.113.1:51820
Endpoint = [2001:db8::1]:51820
```

```text
# Correct
Endpoint = [2001:db8::1]:51820

# Wrong (will fail to parse)
Endpoint = 2001:db8::1:51820
```

--------------------------------

### Generate Public Key from Private Key

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Use the wg utility to derive a public key from a base64-encoded private key.

```bash
echo "private_key_base64" | wg pubkey  # Outputs corresponding public key
```

--------------------------------

### Peer.Builder

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/types.md

Methods for constructing Peer instances using the Builder pattern.

```APIDOC
## Peer.Builder

### Description
Utility class for constructing immutable Peer instances.

### Builder Methods
- **parsePublicKey(CharSequence)**: Parses Base64 public key.
- **parseAllowedIPs(CharSequence)**: Parses comma-separated IP list.
- **parseEndpoint(CharSequence)**: Parses "host:port".
- **parsePreSharedKey(CharSequence)**: Parses Base64 pre-shared key.
- **parsePersistentKeepalive(CharSequence)**: Parses keepalive interval.
- **addAllowedIp(InetNetwork) / addAllowedIps(Collection)**: Adds allowed IP networks.
- **setEndpoint(InetEndpoint)**: Sets the remote endpoint.
- **setPreSharedKey(Key)**: Sets the pre-shared key.
- **setPersistentKeepalive(Integer)**: Sets the keepalive interval.
- **setPublicKey(Key)**: Sets the public key.
- **build()**: Returns a new immutable Peer instance.
```

--------------------------------

### Construct BackendException

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/errors.md

Constructor signature for creating a new exception instance.

```java
public BackendException(Reason reason, Object... format)
```

--------------------------------

### Generate Keys

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/INDEX.md

Creates a new KeyPair and retrieves the private key in Base64 format.

```java
// See: api-reference/05-crypto-classes.md
KeyPair keys = new KeyPair();
String privateB64 = keys.getPrivateKey().toBase64();
```

--------------------------------

### Configure AllowedIPs

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

Define comma-separated CIDR networks for routing traffic through the peer.

```text
AllowedIPs = 10.0.0.2/32
AllowedIPs = 192.168.1.0/24, 10.0.0.2/32, 2001:db8::/32
AllowedIPs = 0.0.0.0/0, ::/0                    # All traffic (default route)
```

--------------------------------

### Config.parse(BufferedReader)

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Parses a WireGuard configuration from a BufferedReader.

```APIDOC
## public static Config parse(BufferedReader reader)

### Description
Parses a WireGuard configuration from a BufferedReader.

### Parameters
- **reader** (BufferedReader) - Required - UTF-8 configuration reader.

### Returns
- **Config** - The parsed configuration object.

### Throws
- **IOException** - If the read fails.
- **BadConfigException** - If the configuration format is invalid.
```

--------------------------------

### WireGuard Configuration File Structure

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/configuration.md

The basic layout of a WireGuard configuration file, requiring one [Interface] section and optional [Peer] sections.

```ini
[Interface]
Key1 = Value1
Key2 = Value2
...

[Peer]
Key1 = Value1
Key2 = Value2
...

[Peer]
Key1 = Value1
...
```

--------------------------------

### Config.parse(InputStream)

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Parses a WireGuard configuration from a UTF-8 input stream.

```APIDOC
## public static Config parse(InputStream stream)

### Description
Parses a WireGuard configuration from a UTF-8 input stream. Comments are stripped and the configuration must contain exactly one [Interface] section.

### Parameters
- **stream** (InputStream) - Required - UTF-8 encoded configuration stream.

### Returns
- **Config** - The parsed configuration object.

### Throws
- **IOException** - If the stream read fails.
- **BadConfigException** - If the configuration format is invalid.
```

--------------------------------

### Config.toWgUserspaceString

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Serializes the configuration for the userspace API.

```APIDOC
## public String toWgUserspaceString()

### Description
Serializes the configuration for the wireguard-go userspace API (UAPI) using key=value format.

### Returns
- **String** - The configuration in userspace API format.
```

--------------------------------

### Configure Gradle Dependencies

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/README.md

Add the tunnel library dependency and enable Java 8 desugaring in your build.gradle.kts file.

```kotlin
dependencies {
    implementation("com.wireguard.android:tunnel:1.0.23")
    
    // Required: Java 8 desugaring
    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.0.3")
}

android {
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
        coreLibraryDesugaringEnabled = true
    }
}
```

--------------------------------

### Key.toBase64()

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/05-crypto-classes.md

Encodes the key to a Base64 string using constant-time encoding.

```APIDOC
## public String toBase64()

### Description
Encodes the key to a Base64 string. The operation uses constant-time encoding to resist timing attacks.

### Return Type
`String` - Base64 string (44 characters, ends with '=')
```

--------------------------------

### Parse Configuration from InputStream

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Parses a UTF-8 encoded configuration stream.

```java
public static Config parse(InputStream stream) 
    throws IOException, BadConfigException
```

```java
InputStream configStream = new FileInputStream("my-config.conf");
Config config = Config.parse(configStream);
System.out.println("Config: " + config);
```

--------------------------------

### Config Builder Class

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Provides a builder pattern for constructing Config instances.

```java
public static final class Builder {
    public Builder setInterface(Interface interfaze);
    public Builder parseInterface(Iterable<? extends CharSequence> lines)
        throws BadConfigException;
    public Builder addPeer(Peer peer);
    public Builder addPeers(Collection<Peer> peers);
    public Builder parsePeer(Iterable<? extends CharSequence> lines)
        throws BadConfigException;
    public Config build();
}
```

```java
Config config = new Config.Builder()
    .setInterface(interfaceObj)
    .addPeer(peer1)
    .addPeer(peer2)
    .build();
```

--------------------------------

### Wrap Raw Bytes into Key

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/05-crypto-classes.md

Method for creating a Key instance from a raw byte array.

```java
public static Key fromBytes(byte[] bytes) throws KeyFormatException
```

```java
byte[] rawKey = new byte[32];
SecureRandom.nextBytes(rawKey);
Key key = Key.fromBytes(rawKey);
```

--------------------------------

### Key.getBytes()

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/05-crypto-classes.md

Returns the raw binary key data as a defensive copy.

```APIDOC
## public byte[] getBytes()

### Description
Returns the raw binary key data as a defensive copy. The returned array is a copy, so modifications do not affect the original Key instance.

### Return Type
`byte[]` - Defensive copy of 32-byte key (never null)
```

--------------------------------

### Parse Configuration from BufferedReader

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Parses a configuration from a BufferedReader.

```java
public static Config parse(BufferedReader reader) 
    throws IOException, BadConfigException
```

```java
BufferedReader reader = new BufferedReader(new FileReader("my-config.conf"));
Config config = Config.parse(reader);
```

--------------------------------

### Config Class Methods

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/types.md

Methods for parsing, retrieving, and serializing WireGuard configuration data.

```APIDOC
## Config.parse(InputStream stream)

### Description
Parses a UTF-8 configuration from an InputStream.

### Parameters
- **stream** (InputStream) - Required - The input stream containing the configuration.

### Returns
- **Config** - The parsed configuration object.

## Config.getInterface()

### Description
Returns the Interface section of the configuration.

### Returns
- **Interface** - The interface section.

## Config.toWgQuickString()

### Description
Serializes the configuration to the wg-quick file format.

### Returns
- **String** - The serialized configuration string.
```

--------------------------------

### Config.getInterface

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Retrieves the Interface section of the configuration.

```APIDOC
## public Interface getInterface()

### Description
Returns the local tunnel interface configuration.

### Returns
- **Interface** - The interface configuration object (never null).
```

--------------------------------

### Peer.parse(Iterable<? extends CharSequence> lines)

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Parses a collection of configuration lines into a Peer instance. The lines should be in 'KEY = VALUE' format without the section header.

```APIDOC
## Peer.parse

### Description
Parses a list of configuration strings into a Peer object. Recognized attributes include PublicKey, AllowedIPs, Endpoint, PreSharedKey, and PersistentKeepalive.

### Signature
`public static Peer parse(Iterable<? extends CharSequence> lines) throws BadConfigException`

### Parameters
- **lines** (Iterable<CharSequence>) - Required - Configuration lines representing peer attributes.

### Returns
- **Peer** - A new Peer instance populated with the parsed values.

### Throws
- **BadConfigException** - Thrown if the configuration lines are missing required attributes or contain invalid values.
```

--------------------------------

### KeyPair()

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/05-crypto-classes.md

Generates a new random private key and derives the corresponding public key.

```APIDOC
## KeyPair()

### Description
Generates a new random private key using SecureRandom and derives the public key using Curve25519 scalar multiplication.

### Signature
`public KeyPair()`

### Parameters
- None

### Example
```java
KeyPair pair = new KeyPair();
System.out.println("Private: " + pair.getPrivateKey().toBase64());
System.out.println("Public: " + pair.getPublicKey().toBase64());
```
```

--------------------------------

### ToString Method Signature

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Method signature for converting the network to a string.

```java
public String toString()
```

--------------------------------

### KeyPair(Key)

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/05-crypto-classes.md

Creates a key pair from an existing private key and derives the public key.

```APIDOC
## KeyPair(Key privateKey)

### Description
Creates a key pair from an existing 32-byte private key and derives the public key using constant-time Curve25519 scalar multiplication.

### Signature
`public KeyPair(Key privateKey)`

### Parameters
- **privateKey** (Key) - Required - Existing 32-byte private key.

### Example
```java
Key privKey = Key.fromBase64(existingPrivateKeyB64);
KeyPair pair = new KeyPair(privKey);
Key pubKey = pair.getPublicKey();
```
```

--------------------------------

### Configure WireGuard Build Environment

Source: https://github.com/wireguard/wireguard-android/blob/master/tunnel/tools/CMakeLists.txt

Sets the minimum CMake version, project name, and global compiler/linker flags for the Android build.

```cmake
cmake_minimum_required(VERSION 3.4.1)
project("WireGuard")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}")
add_link_options(LINKER:--build-id=none)
add_compile_options(-Wall -Werror)
```

--------------------------------

### Parse Configuration Safely

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/INDEX.md

Parses a configuration stream while handling potential BadConfigException errors.

```java
// See: api-reference/04-config-classes.md + errors.md
try {
    Config config = Config.parse(stream);
} catch (BadConfigException e) {
    System.err.println(e.getReason() + " at " + e.getLocation());
}
```

--------------------------------

### Parse Interface Configuration

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/04-config-classes.md

Parses a collection of configuration lines into an Interface instance. Requires a PrivateKey attribute.

```java
public static Interface parse(Iterable<? extends CharSequence> lines)
    throws BadConfigException
```

```java
List<String> lines = Arrays.asList(
    "PrivateKey = qKH...",
    "Address = 10.0.0.1/24",
    "ListenPort = 51820"
);
Interface iface = Interface.parse(lines);
```

--------------------------------

### KeyPair

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/README.md

Handles generation and import of WireGuard cryptographic key pairs.

```APIDOC
## KeyPair()

### Description
Generates a new random WireGuard key pair.

## Key.fromBase64(String)

### Description
Imports an existing key from a Base64 encoded string.
```

--------------------------------

### Access format arguments in catch block

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/errors.md

Demonstrates extracting and using format arguments from a caught exception.

```java
catch (BackendException e) {
    if (e.getReason() == BackendException.Reason.GO_ACTIVATION_ERROR_CODE) {
        Object[] args = e.getFormat();
        String errorCode = String.valueOf(args[0]);
        System.err.println("wireguard-go error: " + errorCode);
    }
}
```

--------------------------------

### toString()

Source: https://github.com/wireguard/wireguard-android/blob/master/_autodocs/api-reference/06-network-classes.md

Returns the endpoint formatted as a string.

```APIDOC
## toString()

### Description
Returns the endpoint in "host:port" or "[host]:port" format. Automatically brackets bare IPv6 addresses.

### Signature
`public String toString()`

### Returns
- **String** - Formatted endpoint string.
```
Tokens:
Raw