Windows Packet Filter

using System;
using System.Linq;
using System.Threading;
using NdisApiDotNet;
using NativeApi = NdisApiDotNet.Native.NdisApi;

// Open WinpkFilter driver instance
using var filter = NdisApi.Open();
if (!filter.IsDriverLoaded())
{
    Console.WriteLine("WinpkFilter driver is not loaded.");
    return;
}

// Select the first valid TCP/IP bound network adapter
var adapter = filter.GetNetworkAdapters().FirstOrDefault(a => a.IsValid);
if (adapter == null)
{
    Console.WriteLine("No valid network adapter found.");
    return;
}

using var waitEvent = new AutoResetEvent(false);
filter.SetPacketEvent(adapter, waitEvent);

// Enter bidirectional tunnel mode
filter.SetAdapterMode(adapter,
    NativeApi.MSTCP_FLAGS.MSTCP_FLAG_SENT_TUNNEL |
    NativeApi.MSTCP_FLAGS.MSTCP_FLAG_RECV_TUNNEL);

unsafe
{
    NativeApi.ETH_REQUEST* request = filter.CreateEthRequest();
    request->hAdapterHandle = adapter.Handle;

    // Process a bounded number of notification cycles for this minimal example
    const int DemoWakeups = 100;
    for (int i = 0; i < DemoWakeups; i++)
    {
        waitEvent.WaitOne();

        while (filter.ReadPacket(ref *request))
        {
            var buffer = (NativeApi.INTERMEDIATE_BUFFER*)request->EthPacket.Buffer;
            if (buffer->m_dwDeviceFlags == NativeApi.PACKET_FLAG.PACKET_FLAG_ON_SEND)
            {
                // Outgoing from TCP/IP: reinject downward to network adapter
                filter.SendPacketToAdapter(ref *request);
            }
            else
            {
                // Incoming from network: reinject upward to TCP/IP stack
                filter.SendPacketToMstcp(ref *request);
            }
        }
    }

    filter.DisposeObject(request);
}

// Restore normal adapter mode and release event
filter.ResetAdapterMode(adapter);
filter.ResetPacketEvent(adapter);

use ndisapi::{
    DirectionFlags, EthRequest, EthRequestMut, FilterFlags, IntermediateBuffer, Ndisapi,
};
use windows::Win32::Foundation::CloseHandle;
use windows::Win32::System::Threading::{CreateEventW, ResetEvent, WaitForSingleObject};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Open WinpkFilter driver instance via native driver handle
    let driver = Ndisapi::new("NDISRD")
        .map_err(|e| format!("Failed to connect to driver: {e:?}"))?;

    // Query TCP/IP bound network adapters
    let adapters = driver.get_tcpip_bound_adapters_info()?;
    let adapter = adapters.first().ok_or("No TCP/IP bound adapters found")?;

    let event = unsafe { CreateEventW(None, true, false, None)? };
    driver.set_packet_event(adapter.get_handle(), event)?;

    // Enter bidirectional tunnel mode
    driver.set_adapter_mode(
        adapter.get_handle(),
        FilterFlags::MSTCP_FLAG_SENT_TUNNEL | FilterFlags::MSTCP_FLAG_RECV_TUNNEL,
    )?;

    let mut packet = IntermediateBuffer::default();

    // Process a bounded number of notification cycles for this minimal example
    const DEMO_WAKEUPS: usize = 100;
    for _ in 0..DEMO_WAKEUPS {
        unsafe { WaitForSingleObject(event, u32::MAX); }

        loop {
            let mut read_request = EthRequestMut::new(adapter.get_handle());
            read_request.set_packet(&mut packet);
            if driver.read_packet(&mut read_request).is_err() {
                break;
            }

            let mut write_request = EthRequest::new(adapter.get_handle());
            write_request.set_packet(&packet);

            if packet.get_device_flags() == DirectionFlags::PACKET_FLAG_ON_SEND {
                // Outgoing from TCP/IP: reinject downward to network adapter
                driver.send_packet_to_adapter(&write_request)?;
            } else {
                // Incoming from network: reinject upward to TCP/IP stack
                driver.send_packet_to_mstcp(&write_request)?;
            }
        }

        unsafe { let _ = ResetEvent(event); }
    }

    // Restore normal adapter mode and release event
    driver.set_adapter_mode(adapter.get_handle(), FilterFlags::default())?;
    unsafe { let _ = CloseHandle(event); }
    Ok(())
}

package main

import (
    "log"

    "github.com/wiresock/ndisapi-go"
    "golang.org/x/sys/windows"
)

func main() {
    // Open WinpkFilter driver instance
    api, err := ndisapi.NewNdisApi()
    if err != nil {
        log.Fatalf("Failed to open NDIS API: %v", err)
    }
    defer api.Close()

    if !api.IsDriverLoaded() {
        log.Fatal("WinpkFilter driver is not loaded.")
    }

    // Query TCP/IP bound network adapters
    adapters, err := api.GetTcpipBoundAdaptersInfo()
    if err != nil || adapters.AdapterCount == 0 {
        log.Fatal("No TCP/IP bound adapters found.")
    }

    adapter := adapters.AdapterHandle[0]

    event, err := windows.CreateEvent(nil, 0, 0, nil)
    if err != nil {
        log.Fatalf("Failed to create event: %v", err)
    }
    defer windows.CloseHandle(event)

    if err := api.SetPacketEvent(adapter, event); err != nil {
        log.Fatalf("Failed to set packet event: %v", err)
    }

    // Enter bidirectional tunnel mode
    mode := &ndisapi.AdapterMode{
        AdapterHandle: adapter,
        Flags:         ndisapi.MSTCP_FLAG_SENT_TUNNEL | ndisapi.MSTCP_FLAG_RECV_TUNNEL,
    }
    if err := api.SetAdapterMode(mode); err != nil {
        log.Fatalf("Failed to set adapter mode: %v", err)
    }

    var buffer ndisapi.IntermediateBuffer
    request := &ndisapi.EtherRequest{
        AdapterHandle: adapter,
        EthernetPacket: ndisapi.EthernetPacket{
            Buffer: &buffer,
        },
    }

    // Process a bounded number of notification cycles for this minimal example
    const demoWakeups = 100
    for i := 0; i < demoWakeups; i++ {
        _, _ = windows.WaitForSingleObject(event, windows.INFINITE)
        _ = windows.ResetEvent(event)

        for api.ReadPacket(request) {
            if buffer.DeviceFlags == ndisapi.PACKET_FLAG_ON_SEND {
                // Outgoing from TCP/IP: reinject downward to network adapter
                _ = api.SendPacketToAdapter(request)
            } else {
                // Incoming from network: reinject upward to TCP/IP stack
                _ = api.SendPacketToMstcp(request)
            }
        }
    }

    // Restore normal adapter mode and release event
    mode.Flags = 0
    _ = api.SetAdapterMode(mode)
    _ = api.SetPacketEvent(adapter, 0)
}