WireGuard

struct message_handshake_initiation {
    struct message_header header;
    __le32 sender_index;
    u8 unencrypted_ephemeral[NOISE_PUBLIC_KEY_LEN];
    u8 encrypted_static[noise_encrypted_len(NOISE_PUBLIC_KEY_LEN)];
    u8 encrypted_timestamp[noise_encrypted_len(NOISE_TIMESTAMP_LEN)];
    struct message_macs macs;
};

struct message_handshake_response {
    struct message_header header;
    __le32 sender_index;
    __le32 receiver_index;
    u8 unencrypted_ephemeral[NOISE_PUBLIC_KEY_LEN];
    u8 encrypted_nothing[noise_encrypted_len(0)];
    struct message_macs macs;
};

struct message_data {
    struct message_header header;
    __le32 key_idx;
    __le64 counter;
    u8 encrypted_data[];
};

static const struct net_device_ops netdev_ops = {
    .ndo_open = wg_open,
    .ndo_stop = wg_stop,
    .ndo_start_xmit = wg_xmit,
    .ndo_get_stats64 = wg_get_stats64,
};

static void wg_setup(struct net_device *dev)
{
    dev->type = ARPHRD_NONE;
    dev->flags = IFF_POINTOPOINT | IFF_NOARP;
    dev->needed_headroom = DATA_PACKET_HEAD_ROOM;
}

[Interface]
Address = 10.70.0.1/24
ListenPort = 51820
PrivateKey = SERVER_PRIVATE_KEY

[Peer]
PublicKey = CLIENT_PUBLIC_KEY
AllowedIPs = 10.70.0.2/32

# ------------------------------

[Interface]
Address = 10.70.0.2/32
PrivateKey = CLIENT_PRIVATE_KEY
DNS = 10.70.0.1

[Peer]
PublicKey = SERVER_PUBLIC_KEY
Endpoint = vpn.example.com:51820
AllowedIPs = 0.0.0.0/0, ::/0
PersistentKeepalive = 25

# 순수 wg + ip 명령만으로 최소 구성
ip link add wg0 type wireguard
ip address add 10.70.0.1/24 dev wg0
wg set wg0 private-key ./server.key listen-port 51820 \
    peer CLIENT_PUBLIC_KEY allowed-ips 10.70.0.2/32
ip link set wg0 up

# 전체 터널의 핵심 정책 라우팅 아이디어
wg set wg0 fwmark 51820
ip route add default dev wg0 table 51820
ip rule add not fwmark 51820 table 51820
ip rule add table main suppress_prefixlength 0

# 무중단 재적용
wg syncconf wg0 <(wg-quick strip wg0)

# init namespace에서 생성
ip netns add container
ip link add wg0 type wireguard

# 인터페이스만 다른 namespace로 이동
ip link set wg0 netns container
ip -n container address add 10.70.0.2/32 dev wg0
ip netns exec container wg set wg0 private-key ./client.key \
    peer SERVER_PUBLIC_KEY endpoint 203.0.113.10:51820 \
    allowed-ips 0.0.0.0/0,::/0
ip -n container link set wg0 up

# PMTU / 단편화 점검
tracepath 10.70.0.1
ping -M do -s 1372 10.70.0.1

# 대역폭과 멀티스트림 점검
iperf3 -c 10.70.0.1 -P 4

# CPU 핫스팟 확인
perf top -g

# 바깥쪽 암호문 / 안쪽 평문 비교
tcpdump -ni eth0 udp port 51820
tcpdump -ni wg0

# 장치 / peer 상태
wg show wg0
wg show wg0 latest-handshakes transfer endpoints allowed-ips
wg showconf wg0

# 링크 / 주소 / 라우팅 / 정책 라우팅
ip -d link show wg0
ip addr show dev wg0
ip route get 10.70.0.1
ip rule show

# 소켓 / UDP / 패킷
ss -ulpn
tcpdump -ni eth0 udp port 51820
tcpdump -ni wg0

# 커널 런타임 디버그
modprobe wireguard
echo module wireguard +p > /sys/kernel/debug/dynamic_debug/control
dmesg | tail -n 100

/* noise.c — Initiator 측 핸드셰이크 생성 핵심 흐름 (단순화) */
bool wg_noise_handshake_create_initiation(
    struct message_handshake_initiation *dst,
    struct noise_handshake *handshake)
{
    struct noise_symmetric_key key;
    u8 timestamp[NOISE_TIMESTAMP_LEN];

    /* 1. 임시 키 쌍 생성 */
    curve25519_generate_secret(handshake->ephemeral_private);
    curve25519_generate_public(
        dst->unencrypted_ephemeral,
        handshake->ephemeral_private);

    /* 2. DH(e_i, S_r) → 체인 키 갱신 */
    mix_dh(handshake, handshake->ephemeral_private,
           handshake->remote_static);

    /* 3. 정적 공개키 암호화 */
    message_encrypt(dst->encrypted_static,
        handshake->static_identity->static_public,
        NOISE_PUBLIC_KEY_LEN, key);

    /* 4. DH(s_i, S_r) → 체인 키 갱신 */
    mix_dh(handshake,
           handshake->static_identity->static_private,
           handshake->remote_static);

    /* 5. 타임스탬프 암호화 (리플레이 방어) */
    tai64n_now(timestamp);
    message_encrypt(dst->encrypted_timestamp,
        timestamp, NOISE_TIMESTAMP_LEN, key);

    /* 6. mac1, mac2 계산 */
    message_macs(dst, handshake);
    return true;
}

/* noise.h — 핸드셰이크 상태 열거 */
enum noise_handshake_state {
    HANDSHAKE_ZEROED,        /* 초기화 전 */
    HANDSHAKE_CREATED_INITIATION, /* Initiation 전송 완료 */
    HANDSHAKE_CONSUMED_INITIATION, /* Initiation 수신/처리 완료 */
    HANDSHAKE_CREATED_RESPONSE,  /* Response 전송 완료 */
    HANDSHAKE_CONSUMED_RESPONSE, /* Response 수신/처리 → 키 활성화 */
};

/* Responder 측 핸드셰이크 소비 (단순화) */
struct wg_peer *wg_noise_handshake_consume_initiation(
    struct message_handshake_initiation *src,
    struct wg_device *wg)
{
    struct noise_handshake *handshake;
    u8 s[NOISE_PUBLIC_KEY_LEN];
    u8 timestamp[NOISE_TIMESTAMP_LEN];

    /* 1. Initiator의 임시 공개키로 DH */
    mix_hash(&handshake_hash, src->unencrypted_ephemeral,
             NOISE_PUBLIC_KEY_LEN);
    mix_dh(&chaining_key, wg->static_identity.static_private,
           src->unencrypted_ephemeral);

    /* 2. Initiator의 정적 공개키 복호화 → peer 식별 */
    message_decrypt(s, src->encrypted_static,
        NOISE_PUBLIC_KEY_LEN + NOISE_AUTHTAG_LEN,
        key, handshake_hash);

    /* 3. peer 조회 (정적 공개키 기반) */
    handshake = lookup_peer(wg, s);

    /* 4. 타임스탬프 검증 (리플레이 방어) */
    message_decrypt(timestamp, src->encrypted_timestamp,
        NOISE_TIMESTAMP_LEN + NOISE_AUTHTAG_LEN,
        key, handshake_hash);

    if (!timestamp_is_newer(timestamp, handshake))
        goto fail; /* 리플레이 거부 */

    handshake->state = HANDSHAKE_CONSUMED_INITIATION;
    return handshake->peer;
}

/* allowedips.c — 트라이 조회 핵심 구조 */
struct allowedips_node {
    struct wg_peer __rcu *peer;
    struct allowedips_node __rcu *bit[2];
    u8 cidr, bit_at_a, bit_at_b, bitlen;

    /* 노드 메모리는 RCU로 보호 */
};

/* 송신 시 목적지 IP로 peer 조회 */
struct wg_peer *wg_allowedips_lookup_dst(
    struct allowedips *table,
    struct sk_buff *skb)
{
    if (skb->protocol == htons(ETH_P_IP))
        return lookup(table->root4,
            32, &ip_hdr(skb)->daddr);
    else if (skb->protocol == htons(ETH_P_IPV6))
        return lookup(table->root6,
            128, &ipv6_hdr(skb)->daddr);
    return NULL;
}

/* 수신 시 소스 IP 검증 */
struct wg_peer *wg_allowedips_lookup_src(
    struct allowedips *table,
    struct sk_buff *skb)
{
    if (skb->protocol == htons(ETH_P_IP))
        return lookup(table->root4,
            32, &ip_hdr(skb)->saddr);
    else if (skb->protocol == htons(ETH_P_IPV6))
        return lookup(table->root6,
            128, &ipv6_hdr(skb)->saddr);
    return NULL;
}

/* allowedips.c — RCU 보호 트라이 조회 (단순화) */
static struct wg_peer *lookup(
    struct allowedips_node __rcu *top,
    u8 bits, const void *be_ip)
{
    struct allowedips_node *node;
    struct wg_peer *peer = NULL;
    u8 cidr;

    /* RCU 읽기 영역 — 잠금 없이 안전한 탐색 */
    rcu_read_lock();

    node = rcu_dereference(top);
    while (node) {
        /* 현재 노드의 CIDR 비트까지 IP가 일치하면 */
        if (prefix_matches(node, be_ip, bits)) {
            /* peer가 있으면 후보로 기록 (마지막 매칭이 승자) */
            struct wg_peer *p =
                rcu_dereference(node->peer);
            if (p)
                peer = p;
            /* 다음 비트 방향으로 하강 */
            node = rcu_dereference(
                node->bit[choose_bit(be_ip, node)]);
        } else {
            break;
        }
    }

    rcu_read_unlock();
    return peer;
}

/* noise.c — HKDF-BLAKE2s 기반 키 유도 (단순화) */
static void kdf(u8 *first_dst, u8 *second_dst,
    u8 *third_dst,
    const u8 *data, size_t dlen,
    const u8 chaining_key[NOISE_HASH_LEN])
{
    u8 output[BLAKE2S_HASH_SIZE + 1];
    u8 secret[BLAKE2S_HASH_SIZE];

    /* Extract: HMAC-BLAKE2s(chaining_key, data) */
    blake2s256_hmac(secret, data, chaining_key,
        dlen, NOISE_HASH_LEN);

    /* Expand 1: T1 = HMAC-BLAKE2s(secret, 0x01) */
    output[0] = 1;
    blake2s256_hmac(first_dst, output, secret,
        1, BLAKE2S_HASH_SIZE);

    if (!second_dst)
        goto out;

    /* Expand 2: T2 = HMAC-BLAKE2s(secret, T1 || 0x02) */
    memcpy(output, first_dst, BLAKE2S_HASH_SIZE);
    output[BLAKE2S_HASH_SIZE] = 2;
    blake2s256_hmac(second_dst, output, secret,
        BLAKE2S_HASH_SIZE + 1,
        BLAKE2S_HASH_SIZE);

    /* 필요하면 T3도 유사하게 유도 */
out:
    memzero_explicit(secret, BLAKE2S_HASH_SIZE);
    memzero_explicit(output, sizeof(output));
}

/* 데이터 패킷 암호화 핵심 (send.c 기반, 단순화) */
static bool encrypt_packet(
    struct sk_buff *skb,
    struct noise_keypair *keypair)
{
    struct message_data *header;
    u64 nonce;
    unsigned int padding_len, plaintext_len;

    /* nonce = 원자적으로 증가하는 64비트 카운터 */
    nonce = atomic64_inc_return(
        &keypair->sending_counter) - 1;

    /* REKEY_AFTER_MESSAGES 도달 시 재핸드셰이크 유도 */
    if (unlikely(nonce >= REKEY_AFTER_MESSAGES))
        goto rekey;

    /* 헤더 세팅 */
    header = (struct message_data *)skb_push(
        skb, sizeof(*header));
    header->header.type = cpu_to_le32(
        MESSAGE_DATA);
    header->key_idx = keypair->remote_index;
    header->counter = cpu_to_le64(nonce);

    /* ChaCha20-Poly1305 AEAD 암호화 */
    chacha20poly1305_encrypt(
        skb->data + sizeof(*header),
        skb->data + sizeof(*header),
        plaintext_len,
        header, sizeof(*header),  /* AAD */
        nonce, keypair->sending.key);

    return true;
}

/* device.c — WireGuard 장치의 핵심 구조체 */
struct wg_device {
    struct net_device *dev;

    /* 암호 식별자 */
    struct noise_static_identity static_identity;

    /* peer 관리 */
    struct list_head peer_list;
    struct allowedips peer_allowedips;
    u32 num_peers;

    /* UDP 소켓 (birth namespace에 고정) */
    struct wg_socket __rcu *sock4, *sock6;
    u16 incoming_port;

    /* 암복호화 병렬 큐 */
    struct wg_queue encrypt_queue, decrypt_queue;
    struct workqueue_struct *handshake_send_wq;
    struct workqueue_struct *handshake_receive_wq;

    /* 네트워크 네임스페이스 */
    struct net *creating_net;  /* birth ns */

    /* DoS 완화 */
    struct cookie_checker cookie_checker;

    /* 인덱스 해시테이블: key_idx → keypair 빠른 조회 */
    struct index_hashtable index_hashtable;
};

/* peer.c — 피어별 상태 */
struct wg_peer {
    struct wg_device *device;
    struct noise_handshake handshake;
    struct noise_keypairs keypairs;

    /* endpoint 정보 (로밍 시 갱신) */
    struct endpoint endpoint;

    /* 송신 대기 큐 */
    struct sk_buff_head staged_packet_queue;

    /* per-peer NAPI (수신 GRO 경로) */
    struct napi_struct napi;

    /* 타이머 */
    struct timer_list timer_retransmit_handshake;
    struct timer_list timer_send_keepalive;
    struct timer_list timer_new_handshake;
    struct timer_list timer_zero_key_material;
    struct timer_list timer_persistent_keepalive;

    /* 통계 */
    u64 last_sent_handshake;
    u64 rx_bytes, tx_bytes;
};

/* queueing.h — per-CPU 큐 구조 */
struct wg_queue {
    struct ptr_ring ring;
    struct work_struct work;
    int last_cpu;
};

/* 패킷을 큐에 넣고 워커를 깨우는 핵심 로직 */
static inline int wg_queue_enqueue_per_device_and_peer(
    struct wg_queue *device_queue,
    struct wg_queue *peer_queue,
    struct sk_buff *skb,
    struct workqueue_struct *wq)
{
    int cpu;

    /* peer 큐에 삽입 (순서 보장용) */
    ptr_ring_produce(&peer_queue->ring, skb);

    /* device 큐에도 삽입 (CPU 분산용) */
    cpu = wg_cpumask_next_online(
        &device_queue->last_cpu);
    ptr_ring_produce_bh(&device_queue->ring, skb);

    /* 해당 CPU의 워커 깨우기 */
    queue_work_on(cpu, wq, &device_queue->work);
    return 0;
}

/* peerlookup.h — 리플레이 카운터 구조 */
struct noise_replay_counter {
    u64 counter;             /* 수신된 최대 카운터 */
    unsigned long backtrack[  /* 비트맵: 윈도우 내 수신 기록 */
        COUNTER_BITS_TOTAL /
        BITS_PER_LONG];
    spinlock_t lock;
};

/* COUNTER_WINDOW_SIZE 계산:
 *   COUNTER_BITS_TOTAL = 8192 (비트)
 *   COUNTER_REDUNDANT_BITS = sizeof(unsigned long) * 8 = 64
 *   COUNTER_WINDOW_SIZE = 8192 - 64 = 8128
 *
 * 즉, 최대 카운터 값으로부터 8128개 이전 nonce까지 추적 */

static bool counter_validate(
    struct noise_replay_counter *counter,
    u64 their_counter)
{
    u64 index;
    bool ret = false;

    spin_lock_bh(&counter->lock);

    /* 새 최대값이면 윈도우 확장 */
    if (likely(their_counter > counter->counter)) {
        index = their_counter >> ilog2(BITS_PER_LONG);
        /* 비트맵에서 해당 위치 표시 */
        bitmap_set(counter->backtrack, index, 1);
        counter->counter = their_counter;
        ret = true;
    }
    /* 윈도우 안에 있고 아직 안 본 nonce면 허용 */
    else if (counter->counter - their_counter
             < COUNTER_WINDOW_SIZE) {
        index = their_counter >> ilog2(BITS_PER_LONG);
        if (!test_and_set_bit(
                their_counter & (BITS_PER_LONG - 1),
                &counter->backtrack[index
                    % (COUNTER_BITS_TOTAL
                       / BITS_PER_LONG)]))
            ret = true; /* 새로운 nonce */
        /* 이미 본 nonce면 ret = false (리플레이) */
    }
    /* 윈도우 밖이면 ret = false (너무 오래된 패킷) */

    spin_unlock_bh(&counter->lock);
    return ret;
}

/* noise.c — keypair 승격 로직 (단순화) */
void wg_noise_keypair_begin_session(
    struct noise_keypairs *keypairs,
    struct noise_keypair *new_keypair,
    bool is_initiator)
{
    struct noise_keypair *previous, *next, *current;

    spin_lock_bh(&keypairs->keypair_update_lock);

    /* next 슬롯에 새 keypair 배치 */
    next = rcu_dereference_protected(
        keypairs->next_keypair,
        lockdep_is_held(&keypairs->keypair_update_lock));

    if (is_initiator) {
        /* Initiator: 즉시 current로 승격 */
        current = rcu_dereference_protected(
            keypairs->current_keypair, 1);
        previous = rcu_dereference_protected(
            keypairs->previous_keypair, 1);

        /* previous → 해제 */
        rcu_assign_pointer(
            keypairs->previous_keypair, current);
        rcu_assign_pointer(
            keypairs->current_keypair, new_keypair);
        rcu_assign_pointer(
            keypairs->next_keypair, NULL);

        if (previous)
            wg_noise_keypair_put(previous, true);
    } else {
        /* Responder: next에 대기, 첫 데이터 수신 시 승격 */
        rcu_assign_pointer(
            keypairs->next_keypair, new_keypair);
    }

    spin_unlock_bh(&keypairs->keypair_update_lock);
}

# 1. SIMD 최적화 확인 (x86_64)
grep -r "chacha20" /proc/crypto
grep -r "curve25519" /proc/crypto

# 2. NIC offload 상태 확인
ethtool -k eth0 | grep -E "gso|gro|tso"

# 3. IRQ 분산 확인 (멀티코어)
cat /proc/interrupts | grep eth0
cat /proc/irq/*/smp_affinity_list

# 4. CPU별 암복호화 워커 분포
perf top -g -p $(pgrep -f wireguard)

# 5. UDP 소켓 버퍼 크기 조정
sysctl net.core.rmem_max
sysctl net.core.wmem_max
sysctl -w net.core.rmem_max=26214400
sysctl -w net.core.wmem_max=26214400

# 6. 대역폭 측정 (다중 스트림)
iperf3 -c 10.70.0.1 -P 8 -t 30

# 7. 단일 스트림 지연 시간 측정
iperf3 -c 10.70.0.1 -u -b 1G -l 1400

# 1. 네임스페이스 생성
ip netns add vpn-container

# 2. 호스트에서 WireGuard 인터페이스 생성 (birth ns = 호스트)
ip link add wg-vpn type wireguard
wg set wg-vpn private-key /etc/wireguard/container.key \
    peer SERVER_PUB_KEY endpoint vpn.example.com:51820 \
    allowed-ips 0.0.0.0/0,::/0 \
    persistent-keepalive 25

# 3. 인터페이스를 컨테이너 namespace로 이동
ip link set wg-vpn netns vpn-container

# 4. 컨테이너 내부에서 주소와 라우팅 설정
ip -n vpn-container addr add 10.70.0.2/32 dev wg-vpn
ip -n vpn-container link set wg-vpn up
ip -n vpn-container link set lo up
ip -n vpn-container route add default dev wg-vpn

# 5. 컨테이너 namespace에서 프로세스 실행
ip netns exec vpn-container /usr/bin/my-app

# 1. 물리 NIC를 담을 namespace 생성
ip netns add physical

# 2. WireGuard를 physical namespace에서 생성 (birth ns = physical)
ip -n physical link add wg0 type wireguard

# 3. 물리 NIC를 physical namespace로 이동
ip link set eth0 netns physical
ip -n physical addr add 203.0.113.5/24 dev eth0
ip -n physical link set eth0 up
ip -n physical route add default via 203.0.113.1

# 4. physical namespace에서 WireGuard 설정
ip netns exec physical wg set wg0 \
    private-key /etc/wireguard/host.key \
    listen-port 51820 \
    peer CLIENT_PUB_KEY allowed-ips 10.70.0.0/24

# 5. WireGuard 인터페이스를 init namespace로 이동
ip -n physical link set wg0 netns 1

# 6. init namespace에서 주소와 라우팅
ip addr add 10.70.0.1/24 dev wg0
ip link set wg0 up

# 결과: init namespace에서는 평문 트래픽만 보임
# 물리 NIC와 암호문 UDP는 physical namespace에 격리

# 터널 A: 업무용 VPN
ip netns add work-vpn
ip link add wg-work type wireguard
wg set wg-work private-key /etc/wireguard/work.key \
    peer WORK_PUB_KEY endpoint work-vpn.corp.com:51820 \
    allowed-ips 10.0.0.0/8
ip link set wg-work netns work-vpn
ip -n work-vpn addr add 10.70.0.2/32 dev wg-work
ip -n work-vpn link set wg-work up
ip -n work-vpn route add 10.0.0.0/8 dev wg-work

# 터널 B: 개인용 VPN
ip netns add personal-vpn
ip link add wg-personal type wireguard
wg set wg-personal private-key /etc/wireguard/personal.key \
    peer PERSONAL_PUB_KEY endpoint personal.vpn.com:51820 \
    allowed-ips 0.0.0.0/0,::/0
ip link set wg-personal netns personal-vpn
ip -n personal-vpn addr add 10.80.0.2/32 dev wg-personal
ip -n personal-vpn link set wg-personal up
ip -n personal-vpn route add default dev wg-personal

# 특정 앱을 특정 터널로 실행
ip netns exec work-vpn curl https://internal.corp.com
ip netns exec personal-vpn firefox

# /etc/systemd/network/99-wg0.netdev
[NetDev]
Name=wg0
Kind=wireguard
Description=WireGuard VPN

[WireGuard]
PrivateKey=SERVER_PRIVATE_KEY
ListenPort=51820

[WireGuardPeer]
PublicKey=CLIENT_PUBLIC_KEY
AllowedIPs=10.70.0.2/32
PersistentKeepalive=25

# /etc/systemd/network/99-wg0.network
[Match]
Name=wg0

[Network]
Address=10.70.0.1/24

[Route]
Destination=10.70.0.0/24
Scope=link

# systemd-networkd로 WireGuard 관리
systemctl enable --now systemd-networkd
networkctl status wg0
networkctl list

# 로그 확인
journalctl -u systemd-networkd -f --grep wireguard

# WireGuard 모듈의 모든 dynamic debug 메시지 활성화
echo module wireguard +p > /sys/kernel/debug/dynamic_debug/control

# 핸드셰이크 관련 메시지만 필터링
echo 'module wireguard func wg_noise_handshake* +p' \
    > /sys/kernel/debug/dynamic_debug/control

# 결과 확인
dmesg -w | grep wireguard

# 1. WireGuard 송신 경로 함수 그래프 추적
cd /sys/kernel/debug/tracing
echo function_graph > current_tracer
echo 'wg_xmit' > set_graph_function
echo 1 > tracing_on

# 패킷 전송 후 결과 확인
cat trace | head -100

# 2. 특정 함수의 지연 시간 측정
echo 'wg_noise_handshake_create_initiation' > set_ftrace_filter
echo function > current_tracer
echo 1 > tracing_on
cat trace_pipe

# 3. 추적 중지
echo 0 > tracing_on
echo nop > current_tracer

# 1. 핸드셰이크 빈도 모니터링
bpftrace -e '
kprobe:wg_noise_handshake_create_initiation {
    @handshakes[comm] = count();
}
interval:s:10 { print(@handshakes); clear(@handshakes); }
'

# 2. 패킷 암호화 지연 시간 히스토그램
bpftrace -e '
kprobe:wg_packet_encrypt_worker { @start[tid] = nsecs; }
kretprobe:wg_packet_encrypt_worker /@start[tid]/ {
    @encrypt_ns = hist(nsecs - @start[tid]);
    delete(@start[tid]);
}
'

# 3. peer별 송수신 바이트 추적
bpftrace -e '
kprobe:wg_xmit {
    @tx_bytes = sum(((struct sk_buff *)arg0)->len);
}
kprobe:wg_packet_receive {
    @rx_bytes = sum(((struct sk_buff *)arg0)->len);
}
interval:s:5 { print(@tx_bytes); print(@rx_bytes); }
'

# 4. AllowedIPs 조회 실패 (peer 없음) 추적
bpftrace -e '
kretprobe:wg_allowedips_lookup_dst /retval == 0/ {
    @lookup_miss = count();
    printf("AllowedIPs miss at %s\n", kstack);
}
'

# 1. WireGuard 관련 CPU 핫스팟 확인
perf top -g --kallsyms=/proc/kallsyms -d 5

# 2. 암호화 연산의 CPU 사이클 분포
perf record -g -a -- sleep 10
perf report --symbol-filter=chacha20

# 3. 특정 WireGuard 함수의 flamegraph 생성
perf record -g -a -F 99 -- sleep 30
perf script | stackcollapse-perf.pl | flamegraph.pl > wg-flame.svg

# 4. 캐시 미스 분석 (대용량 트래픽 시)
perf stat -e cache-misses,cache-references,instructions \
    -a -- sleep 10

# 터미널 1: 바깥쪽 암호문 패킷 캡처
tcpdump -ni eth0 udp port 51820 -X -c 20

# 터미널 2: 안쪽 평문 패킷 캡처
tcpdump -ni wg0 -c 20

# 양쪽을 동시에 파일로 저장하여 비교
tcpdump -ni eth0 udp port 51820 -w /tmp/outer.pcap &
tcpdump -ni wg0 -w /tmp/inner.pcap &

# 패킷 캡처 후 분석
# 바깥쪽에서 패킷이 보이지만 안쪽에서 안 보이면:
#   → 복호화 실패 또는 AllowedIPs 소스 검증 실패
# 안쪽에서 패킷이 보이지만 바깥쪽에서 안 보이면:
#   → 암호화 전 단계 문제 (peer 없음, endpoint 미설정)

# WireGuard 패킷 타입 확인 (첫 바이트)
# 0x01 = Handshake Initiation
# 0x02 = Handshake Response
# 0x03 = Cookie Reply
# 0x04 = Transport Data
tcpdump -ni eth0 udp port 51820 -X | head -40

/* BPF 프로그램 예시: WireGuard 핸드셰이크 모니터링 (개념) */
SEC("kprobe/wg_noise_handshake_consume_initiation")
int trace_handshake_init(struct pt_regs *ctx)
{
    struct event *e;
    u64 ts = bpf_ktime_get_ns();

    e = bpf_ringbuf_reserve(&events,
        sizeof(*e), 0);
    if (!e)
        return 0;

    e->type = EVENT_HANDSHAKE_INIT;
    e->timestamp = ts;
    e->pid = bpf_get_current_pid_tgid() >> 32;
    bpf_get_current_comm(e->comm, sizeof(e->comm));

    bpf_ringbuf_submit(e, 0);
    return 0;
}

SEC("kretprobe/wg_allowedips_lookup_dst")
int trace_lookup_result(struct pt_regs *ctx)
{
    void *ret = (void *)PT_REGS_RC(ctx);

    if (!ret) {
        /* peer 못 찾음 → AllowedIPs miss 카운트 */
        bpf_map_update_elem(&miss_count,
            &zero, &one, BPF_ANY);
    }
    return 0;
}

# === 1단계: 기본 상태 확인 ===
wg show wg0
ip -d link show wg0
ip addr show dev wg0
ip route show table all | grep wg0
ip rule show

# === 2단계: 외부 연결성 확인 ===
# endpoint에 UDP 도달 가능한가?
ss -ulpn | grep 51820
# 바깥쪽 패킷이 나가는가?
tcpdump -ni eth0 udp port 51820 -c 10

# === 3단계: 핸드셰이크 확인 ===
wg show wg0 latest-handshakes
# dynamic debug 활성화
echo module wireguard +p > /sys/kernel/debug/dynamic_debug/control
dmesg -w | grep wireguard

# === 4단계: 데이터 경로 확인 ===
# 안쪽 평문 패킷이 보이는가?
tcpdump -ni wg0 -c 10
# AllowedIPs와 라우팅 교차 검증
wg show wg0 allowed-ips
ip route get 10.70.0.2 fibmatch

# === 5단계: MTU / 단편화 확인 ===
tracepath 10.70.0.1
ping -M do -s 1372 10.70.0.1

# === 6단계: 카운터 / 통계 확인 ===
wg show wg0 transfer
ip -s link show wg0
cat /proc/net/udp | grep $(printf '%04X' 51820)

#!/bin/bash
# wg-monitor.sh — WireGuard 상태 모니터링
# cron: */5 * * * * /usr/local/bin/wg-monitor.sh

INTERFACE="wg0"
ALERT_THRESHOLD=300  # 5분 이상 핸드셰이크 없으면 경고

check_peer() {
    local pubkey="$1"
    local last_hs

    last_hs=$(wg show "$INTERFACE" latest-handshakes \
        | grep "$pubkey" | awk '{print $2}')

    if [ -z "$last_hs" ] || [ "$last_hs" -eq 0 ]; then
        echo "CRITICAL: peer $pubkey - 핸드셰이크 기록 없음"
        return 1
    fi

    local now
    now=$(date +%s)
    local age=$((now - last_hs))

    if [ "$age" -gt "$ALERT_THRESHOLD" ]; then
        echo "WARNING: peer $pubkey - 마지막 핸드셰이크 ${age}초 전"
        return 1
    fi

    # 전송량 확인
    local transfer
    transfer=$(wg show "$INTERFACE" transfer \
        | grep "$pubkey")
    local rx=$(echo "$transfer" | awk '{print $2}')
    local tx=$(echo "$transfer" | awk '{print $3}')

    echo "OK: peer ${pubkey:0:8}... hs=${age}s rx=$rx tx=$tx"
    return 0
}

# 인터페이스 존재 확인
if ! ip link show "$INTERFACE" > /dev/null 2>&1; then
    echo "CRITICAL: $INTERFACE 인터페이스 없음"
    exit 2
fi

# 모든 peer 확인
wg show "$INTERFACE" peers | while read -r pubkey; do
    check_peer "$pubkey"
done

# 시스템 리소스 확인
echo "--- 시스템 상태 ---"
echo "UDP 드롭: $(cat /proc/net/snmp \
    | grep Udp: | tail -1 | awk '{print $4}')"
echo "소프트IRQ 시간: $(cat /proc/softirqs \
    | grep NET_RX)"

# dynamic debug 활성화 후 핵심 로그 패턴

# 정상: 핸드셰이크 완료
# wireguard: wg0: Receiving handshake initiation from peer N
# wireguard: wg0: Sending handshake response to peer N
# → 양쪽이 정상적으로 Initiation/Response를 교환함

# 문제: 리플레이 타임스탬프 거부
# wireguard: wg0: Invalid timestamp (대략적 표현)
# → 시스템 시간이 틀려 TAI64N 검증 실패
# 해결: timedatectl set-ntp true

# 문제: peer를 찾을 수 없음
# wireguard: wg0: No peer found for given public key
# → Initiation에 포함된 정적 공개키가 등록된 peer와 불일치
# 해결: 양쪽 공개키 설정 교차 확인

# 문제: mac1 검증 실패
# → 패킷이 변조되었거나 잘못된 키로 계산됨
# 해결: 네트워크 경로에서 패킷 변조 요소 확인

# 문제: 과부하 모드 진입
# wireguard: wg0: Under load, rate limiting...
# → cookie 기반 DoS 완화가 활성화됨
# 해결: 정상 동작이며, 부하가 줄면 자동 해제