WireGuard

// Noise_IK 메시지 흐름 (단순화):

// 개시자(A) → 응답자(B) 첫 메시지:
A → B:  e, es, s, ss
        // e:  A의 임시 공개키(ephemeral)
        // es: A_ephemeral과 B_static으로 DH (B의 정적키는 이미 알고 있음)
        // s:  A의 정적 공개키 (암호화됨)
        // ss: A_static과 B_static으로 DH

// 응답자(B) → 개시자(A) 응답:
B → A:  e, ee, se
        // e:  B의 임시 공개키
        // ee: A_ephemeral과 B_ephemeral로 DH
        // se: B_static과 A_ephemeral로 DH

// drivers/net/wireguard/noise.c

struct noise_handshake {
    enum {
        HANDSHAKE_ZEROED,
        HANDSHAKE_CREATED_INITIATION,
        HANDSHAKE_CONSUMED_INITIATION,
        HANDSHAKE_CREATED_RESPONSE,
        HANDSHAKE_CONSUMED_RESPONSE
    } state;

    u8 hash[NOISE_HASH_LEN];        // 누적 해시 (프로토콜 바인딩)
    u8 chaining_key[NOISE_HASH_LEN]; // HKDF 체이닝 키
    u8 remote_static[NOISE_PUBLIC_KEY_LEN];
    u8 local_ephemeral[NOISE_PUBLIC_KEY_LEN];
    u8 remote_ephemeral[NOISE_PUBLIC_KEY_LEN];
};

// 핸드셰이크 개시 (A → B):
bool wg_noise_handshake_create_initiation(
    struct message_handshake_initiation *dst,
    struct noise_handshake *handshake)
{
    // 1. 새 임시 키 쌍 생성
    curve25519_generate_secret(handshake->ephemeral_private);
    curve25519_generate_public(key, handshake->ephemeral_private);

    // 2. DH(ephemeral, remote_static) — es
    // 3. 정적 공개키 암호화하여 전송 (s)
    // 4. DH(local_static, remote_static) — ss
    // 5. 타임스탬프 암호화 (리플레이 방지)
    // 6. MAC 태그 추가

    dst->message_type = cpu_to_le32(MESSAGE_HANDSHAKE_INITIATION);
    dst->sender_index = wg_index_hashtable_insert(&handshake->entry);
    return true;
}

// 핸드셰이크 응답 (B → A):
bool wg_noise_handshake_consume_initiation(
    struct message_handshake_initiation *src,
    struct wg_peer *peer)
{
    // 1. 타임스탬프 검증 (리플레이 방지)
    // 2. MAC 검증
    // 3. DH 연산으로 공유 비밀 재구성
    // 4. 전송 키(TX/RX 대칭키) 유도

    return handshake->state == HANDSHAKE_CONSUMED_INITIATION;
}

// message_handshake_initiation 구조체 (148 bytes):
struct message_handshake_initiation {
    __le32 message_type;          // 1
    __le32 sender_index;          // 로컬 피어 인덱스
    u8 unencrypted_ephemeral[32]; // e: 임시 공개키
    u8 encrypted_static[NOISE_ENCRYPTED_LEN]; // s: 정적키 (암호화됨)
    u8 encrypted_timestamp[NOISE_TIMESTAMP_LEN]; // 리플레이 방지
    u8 mac1[COOKIE_LEN];          // 피어 인증 MAC
    u8 mac2[COOKIE_LEN];          // 쿠키 (DoS 방어, 선택적)
};

// message_handshake_response 구조체 (92 bytes):
struct message_handshake_response {
    __le32 message_type;          // 2
    __le32 sender_index;          // 응답자 인덱스
    __le32 receiver_index;        // 개시자 인덱스 (상대방이 보낸 sender_index)
    u8 unencrypted_ephemeral[32]; // e: 응답자 임시 공개키
    u8 encrypted_nothing[16];     // 빈 페이로드 (인증 태그만)
    u8 mac1[COOKIE_LEN];
    u8 mac2[COOKIE_LEN];
};

struct noise_keypair {
    u8 sending_key[NOISE_SYMMETRIC_KEY_LEN];   // TX 키
    u8 receiving_key[NOISE_SYMMETRIC_KEY_LEN]; // RX 키
    __le64 sending_counter;    // 리플레이 카운터 (송신)
    __le64 receiving_counter;  // 리플레이 카운터 (수신)
    struct kref refcount;
    u64 birthdate;             // 키 생성 시각 (rekeying 판단)
};

// message_data 구조체 (가변 길이):
struct message_data {
    __le32 message_type;    // 4
    __le32 receiver_index;  // 수신자 피어 인덱스
    __le64 counter;         // Nonce (단조 증가)
    u8 encrypted_data[];   // ChaCha20-Poly1305로 암호화된 IP 패킷
};

// 암호화 과정:
chacha20poly1305_encrypt(
    encrypted_data,           // 출력 버퍼
    plaintext,                // 원본 IP 패킷
    plaintext_len,
    NULL,                     // AAD (추가 인증 데이터, 여기선 없음)
    0,
    counter,                  // Nonce
    keypair->sending_key      // 대칭 키
);

// message_handshake_cookie (64 bytes):
struct message_handshake_cookie {
    __le32 message_type;        // 3
    __le32 receiver_index;      // 개시자 인덱스
    u8 nonce[COOKIE_NONCE_LEN];
    u8 encrypted_cookie[COOKIE_ENCRYPTED_SIZE];
};

// 쿠키 계산:
cookie = BLAKE2s(label || peer_public_key || src_ip_port)
// 응답자는 이 쿠키를 암호화하여 전송.
// 개시자는 다음 핸드셰이크 시 mac2 필드에 이 쿠키를 포함해야 함.

// drivers/net/wireguard/cookie.c

void wg_cookie_checker_precompute_peer_keys(struct wg_peer *peer)
{
    // 피어별 BLAKE2s 키 사전 계산 (성능 최적화)
    blake2s(peer->latest_cookie.cookie,
            peer->handshake.remote_static,
            NULL, COOKIE_LEN, NOISE_PUBLIC_KEY_LEN, 0);
}

bool wg_cookie_validate_packet(struct wg_device *wg,
                                struct sk_buff *skb)
{
    if (!ratelimit_allow(&peer->handshake_ratelimit))
        return false; // 속도 제한 초과 시 쿠키 요구
    return true;
}

// drivers/net/wireguard/device.c

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->netdev_ops = &netdev_ops;
    dev->type = ARPHRD_NONE;            // L3 장치 (ARP 없음)
    dev->flags = IFF_POINTOPOINT | IFF_NOARP;
    dev->mtu = ETH_DATA_LEN - MESSAGE_DATA_OVERHEAD; // 기본 MTU
    dev->needed_headroom = DATA_PACKET_HEAD_ROOM;
}

// drivers/net/wireguard/device.h

struct wg_device {
    struct net_device *dev;
    struct crypt_queue encrypt_queue;     // 암호화 워크큐
    struct crypt_queue decrypt_queue;     // 복호화 워크큐
    struct sock __rcu *sock4;             // UDP 소켓 (IPv4)
    struct sock __rcu *sock6;             // UDP 소켓 (IPv6)
    u16 incoming_port;                    // 리슨 포트
    struct noise_static_identity static_identity; // 로컬 정적키
    struct hlist_head peer_hashtable[PEER_HASHTABLE_SIZE];
    struct allowedips peer_allowedips;    // IP → 피어 매핑
    struct mutex device_update_lock;
};

struct wg_peer {
    struct wg_device *device;
    struct noise_handshake handshake;
    struct noise_keypair *keypairs[3];    // current, previous, next
    struct endpoint endpoint;               // 원격 주소 (동적)
    struct list_head allowedips_list;      // 허용 IP 대역

    // 통계 및 타이머
    u64 rx_bytes, tx_bytes;
    struct timer_list timer_retransmit_handshake;
    struct timer_list timer_new_handshake;
    struct timer_list timer_zero_key_material;
    struct timer_list timer_persistent_keepalive;
};

// drivers/net/wireguard/allowedips.h

struct allowedips {
    struct allowedips_node __rcu *root4;  // IPv4 트라이
    struct allowedips_node __rcu *root6;  // IPv6 트라이
};

struct allowedips_node {
    struct wg_peer *peer;
    struct allowedips_node __rcu *bit[2]; // 이진 트라이
    u8 cidr, bit_at_a, bit_at_b;
    u8 bits[] __aligned(__alignof(u64));    // IP 주소
};

// 검색 함수 (최장 prefix 매칭):
struct wg_peer *wg_allowedips_lookup_dst(
    struct allowedips *table,
    struct sk_buff *skb)
{
    // IP 헤더에서 목적지 주소 추출
    if (skb->protocol == htons(ETH_P_IP)) {
        struct iphdr *ip = ip_hdr(skb);
        return lookup_ip4(table->root4, &ip->daddr);
    } else if (skb->protocol == htons(ETH_P_IPV6)) {
        struct ipv6hdr *ip = ipv6_hdr(skb);
        return lookup_ip6(table->root6, &ip->daddr);
    }
    return NULL;
}

// 1. 유저스페이스 → wg0 인터페이스 (IP 패킷):
wg_xmit(struct sk_buff *skb, struct net_device *dev)
{
    struct wg_device *wg = netdev_priv(dev);

    // 2. 목적지 IP로 피어 검색 (AllowedIPs):
    peer = wg_allowedips_lookup_dst(&wg->peer_allowedips, skb);
    if (!peer) {
        kfree_skb(skb);
        return NETDEV_TX_OK; // 라우팅 실패
    }

    // 3. 활성 keypair 확인:
    keypair = READ_ONCE(peer->keypairs[KEYPAIR_CURRENT]);
    if (!keypair || !READ_ONCE(keypair->sending.is_valid)) {
        // 핸드셰이크 필요
        wg_packet_send_queued_handshake_initiation(peer);
        goto err;
    }

    // 4. 암호화 워크큐에 추가:
    wg_packet_encrypt_worker(skb, peer, keypair);

    return NETDEV_TX_OK;
}

// 5. 암호화 워커 (별도 스레드/CPU 코어):
void wg_packet_encrypt_worker(struct work_struct *work)
{
    struct crypt_queue *queue = container_of(work, struct crypt_queue, work);
    struct sk_buff *skb;

    while ((skb = __ptr_ring_consume(&queue->ring)) != NULL) {
        // ChaCha20-Poly1305 암호화
        chacha20poly1305_encrypt(
            message->encrypted_data, skb->data, skb->len,
            NULL, 0, counter, keypair->sending_key
        );

        // 6. UDP 소켓으로 전송:
        udp_tunnel_xmit_skb(peer->endpoint.sock4, skb, ...);
    }
}

// 1. UDP 소켓 수신 핸들러:
static int wg_receive(struct sock *sk, struct sk_buff *skb)
{
    struct wg_device *wg = sk->sk_user_data;
    struct message_header *header = (struct message_header *)skb->data;

    switch (header->type) {
    case MESSAGE_HANDSHAKE_INITIATION:
        wg_packet_handshake_receive_worker(wg, skb);
        break;
    case MESSAGE_HANDSHAKE_RESPONSE:
        wg_packet_handshake_receive_worker(wg, skb);
        break;
    case MESSAGE_DATA:
        // 2. receiver_index로 피어 검색:
        struct message_data *msg = (struct message_data *)skb->data;
        struct wg_peer *peer = wg_index_hashtable_lookup(
            wg->index_hashtable, msg->receiver_index
        );

        if (!peer) {
            kfree_skb(skb);
            return 0;
        }

        // 3. 복호화 워크큐에 추가:
        wg_packet_decrypt_worker(skb, peer);
        break;
    }
    return 0;
}

// 4. 복호화 워커:
void wg_packet_decrypt_worker(struct work_struct *work)
{
    struct sk_buff *skb;

    while ((skb = dequeue(&decrypt_queue)) != NULL) {
        // ChaCha20-Poly1305 복호화
        if (!chacha20poly1305_decrypt(
                plaintext, message->encrypted_data, len,
                NULL, 0, counter, keypair->receiving_key))
        {
            kfree_skb(skb);
            continue; // 복호화 실패 (인증 실패)
        }

        // 5. 리플레이 검증:
        if (!wg_replay_counter_validate(&keypair->receiving, counter)) {
            kfree_skb(skb);
            continue;
        }

        // 6. AllowedIPs 검증 (소스 IP 검사):
        struct iphdr *ip = (struct iphdr *)plaintext;
        if (!wg_allowedips_lookup_src(&peer->device->peer_allowedips,
                                         &ip->saddr, peer)) {
            kfree_skb(skb);
            continue; // IP 스푸핑 시도
        }

        // 7. 네트워크 스택으로 전달 (wg0 인터페이스 수신):
        skb->dev = wg->dev;
        skb->protocol = htons(ETH_P_IP); // 또는 ETH_P_IPV6
        netif_rx(skb);
    }
}

// drivers/net/wireguard/queueing.c

int wg_queue_init(void)
{
    wg_packet_queue_encrypt = alloc_percpu(struct crypt_queue);
    wg_packet_queue_decrypt = alloc_percpu(struct crypt_queue);

    // CPU별 워커 스레드 생성
    for_each_possible_cpu(cpu) {
        struct crypt_queue *queue = per_cpu_ptr(wg_packet_queue_encrypt, cpu);
        INIT_WORK(&queue->work, wg_packet_encrypt_worker);
        ptr_ring_init(&queue->ring, ENCRYPT_QUEUE_SIZE, GFP_KERNEL);
    }

    return 0;
}

// 패킷을 현재 CPU의 워크큐에 추가:
void wg_packet_encrypt_queue(struct sk_buff *skb, struct wg_peer *peer)
{
    int cpu = get_cpu();
    struct crypt_queue *queue = per_cpu_ptr(wg_packet_queue_encrypt, cpu);

    if (ptr_ring_produce_bh(&queue->ring, skb))
        queue_work_on(cpu, system_wq, &queue->work);

    put_cpu();
}

// 1. RETRANSMIT_HANDSHAKE_TIMER: 핸드셰이크 응답 대기 (5초)
// 초기 핸드셰이크 후 응답이 없으면 재전송
static void wg_expired_retransmit_handshake(struct timer_list *timer)
{
    struct wg_peer *peer = from_timer(peer, timer, timer_retransmit_handshake);

    if (peer->timer_handshake_attempts > MAX_TIMER_HANDSHAKES) {
        // 최대 재시도 초과, 연결 종료로 간주
        wg_peer_timers_data_sent(peer);
        return;
    }

    peer->timer_handshake_attempts++;
    wg_packet_send_queued_handshake_initiation(peer);
}

// 2. NEW_HANDSHAKE_TIMER: 주기적 키 갱신 (120초)
// 키가 생성된 후 2분 경과 시 새 핸드셰이크 시작
static void wg_expired_new_handshake(struct timer_list *timer)
{
    struct wg_peer *peer = from_timer(peer, timer, timer_new_handshake);

    if (READ_ONCE(peer->keypairs[KEYPAIR_CURRENT])->is_valid)
        wg_packet_send_queued_handshake_initiation(peer);
}

// 3. ZERO_KEY_MATERIAL_TIMER: 키 만료 (180초)
// 키가 생성된 후 3분 경과 시 완전히 무효화
static void wg_expired_zero_key_material(struct timer_list *timer)
{
    struct wg_peer *peer = from_timer(peer, timer, timer_zero_key_material);

    wg_noise_keypair_put(peer->keypairs[KEYPAIR_CURRENT]);
    peer->keypairs[KEYPAIR_CURRENT] = NULL;
}

// 4. PERSISTENT_KEEPALIVE_TIMER: keepalive 패킷 전송 (설정 가능)
// NAT/방화벽 매핑 유지 목적 (기본값: 25초)
static void wg_expired_send_persistent_keepalive(struct timer_list *timer)
{
    struct wg_peer *peer = from_timer(peer, timer, timer_persistent_keepalive);

    if (peer->persistent_keepalive_interval)
        wg_packet_send_keepalive(peer);
}

// drivers/net/wireguard/receive.c

#define COUNTER_WINDOW_SIZE 2048 // 비트맵 크기

struct noise_replay_counter {
    u64 counter;
    unsigned long backtrack[COUNTER_BITS_TOTAL / BITS_PER_LONG];
    spinlock_t lock;
};

bool wg_replay_counter_validate(struct noise_replay_counter *counter, u64 their_counter)
{
    u64 index, index_current, top, i;
    unsigned long *bitmap;

    spin_lock_bh(&counter->lock);

    if (their_counter >= counter->counter) {
        // 새로운 카운터 (정상)
        index = their_counter - counter->counter;
        if (index > COUNTER_WINDOW_SIZE) {
            // 윈도우 크기 초과 → 비트맵 리셋
            memset(counter->backtrack, 0, sizeof(counter->backtrack));
        } else {
            // 비트맵 시프트
            for (i = 1; i <= index; ++i)
                counter->backtrack[(i / BITS_PER_LONG)] >>= 1;
        }
        counter->counter = their_counter;
        set_bit(0, counter->backtrack); // 현재 카운터 마킹
        spin_unlock_bh(&counter->lock);
        return true;
    }

    // 오래된 카운터 (재전송 또는 리플레이)
    index = counter->counter - their_counter;
    if (index >= COUNTER_WINDOW_SIZE) {
        spin_unlock_bh(&counter->lock);
        return false; // 윈도우 밖, 거부
    }

    if (test_and_set_bit(index, counter->backtrack)) {
        spin_unlock_bh(&counter->lock);
        return false; // 이미 수신한 패킷, 리플레이 공격
    }

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

// drivers/net/wireguard/receive.c

void wg_socket_set_peer_endpoint(struct wg_peer *peer, const struct endpoint *endpoint)
{
    // 수신 패킷의 소스 주소를 피어의 엔드포인트로 업데이트
    write_lock_bh(&peer->endpoint_lock);
    if (endpoint->addr.sa_family == AF_INET)
        peer->endpoint.addr4 = endpoint->addr4;
    else
        peer->endpoint.addr6 = endpoint->addr6;
    write_unlock_bh(&peer->endpoint_lock);

    // 다음 송신 패킷부터 새 주소 사용
}

// drivers/net/wireguard/netlink.c

static const struct genl_ops wg_genl_ops[] = {
    {
        .cmd = WG_CMD_GET_DEVICE,
        .doit = wg_get_device,
        .flags = GENL_ADMIN_PERM, // CAP_NET_ADMIN 필요
    },
    {
        .cmd = WG_CMD_SET_DEVICE,
        .doit = wg_set_device,
        .flags = GENL_ADMIN_PERM,
    },
};

static struct genl_family wg_genl_family = {
    .name = WG_GENL_NAME,          // "wireguard"
    .version = WG_GENL_VERSION,
    .maxattr = WGDEVICE_A_MAX,
    .ops = wg_genl_ops,
    .n_ops = ARRAY_SIZE(wg_genl_ops),
};

// wg set wg0 listen-port 51820 → SET_DEVICE 메시지:
int wg_set_device(struct sk_buff *skb, struct genl_info *info)
{
    struct wg_device *wg = lookup_interface(info->attrs[WGDEVICE_A_IFNAME]);

    if (info->attrs[WGDEVICE_A_LISTEN_PORT]) {
        u16 port = nla_get_u16(info->attrs[WGDEVICE_A_LISTEN_PORT]);
        wg_socket_reinit(wg, NULL, port); // UDP 소켓 재생성
    }

    if (info->attrs[WGDEVICE_A_PEERS]) {
        // 피어 추가/수정
        wg_set_device_peers(wg, info->attrs[WGDEVICE_A_PEERS]);
    }

    return 0;
}

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

[Peer]
PublicKey = CLIENT_PUBLIC_KEY
AllowedIPs = 10.0.0.2/32

// 1. wg0 네트워크 장치 생성
ip link add dev wg0 type wireguard

// 2. 로컬 주소 할당
ip address add 10.0.0.1/24 dev wg0

// 3. Private Key 설정 (Netlink):
wg set wg0 private-key /tmp/privatekey

// 4. Listen Port 설정:
wg set wg0 listen-port 51820
// → wg_socket_init(): UDP 소켓 생성, bind(0.0.0.0:51820)

// 5. 피어 추가:
wg set wg0 peer CLIENT_PUBLIC_KEY allowed-ips 10.0.0.2/32
// → wg_peer_create(): struct wg_peer 할당
// → wg_allowedips_insert(): 10.0.0.2/32를 AllowedIPs 트라이에 추가

// 6. 인터페이스 활성화
ip link set wg0 up

[Interface]
Address = 10.0.0.2/32
PrivateKey = CLIENT_PRIVATE_KEY

[Peer]
PublicKey = SERVER_PUBLIC_KEY
Endpoint = server.example.com:51820
AllowedIPs = 0.0.0.0/0             # 모든 트래픽 라우팅
PersistentKeepalive = 25         # NAT 유지

# wg-quick이 자동으로 실행:
ip route add 0.0.0.0/0 dev wg0 table 51820
ip rule add not fwmark 51820 table 51820
ip rule add table main suppress_prefixlength 0

# 결과: 기본 게이트웨이를 제외한 모든 트래픽이 wg0로 전송됨

# 네임스페이스 생성
ip netns add ns_client
ip netns add ns_server

# 서버 (ns_server):
ip link add wg_srv type wireguard
ip link set wg_srv netns ns_server
ip netns exec ns_server wg set wg_srv private-key /tmp/srv_priv listen-port 51820
ip netns exec ns_server ip addr add 10.0.0.1/24 dev wg_srv
ip netns exec ns_server ip link set wg_srv up

# 클라이언트 (ns_client):
ip link add wg_cli type wireguard
ip link set wg_cli netns ns_client
ip netns exec ns_client wg set wg_cli private-key /tmp/cli_priv peer <srv_pubkey> \
    endpoint 127.0.0.1:51820 allowed-ips 10.0.0.0/24
ip netns exec ns_client ip addr add 10.0.0.2/32 dev wg_cli
ip netns exec ns_client ip link set wg_cli up

# 테스트:
ip netns exec ns_client ping 10.0.0.1

# iperf3 테스트 (멀티스트림):
iperf3 -c 10.0.0.1 -P 8  # 8개 병렬 스트림
# → 각 스트림이 다른 CPU 코어에서 암호화 처리됨

# WireGuard 디버그 로그 활성화 (커널 빌드 옵션):
CONFIG_WIREGUARD_DEBUG=y

# 런타임 로그 확인:
dmesg | grep wireguard
# 예: "wireguard: wg0: Receiving handshake initiation from peer 1 (192.168.1.100:12345)"

# 모든 인터페이스 상태:
wg show all

# 특정 인터페이스:
wg show wg0
# 출력 예:
interface: wg0
  public key: SERVER_PUBLIC_KEY
  private key: (hidden)
  listening port: 51820

peer: CLIENT_PUBLIC_KEY
  endpoint: 192.168.1.100:54321
  allowed ips: 10.0.0.2/32
  latest handshake: 1 minute, 23 seconds ago
  transfer: 1.23 GiB received, 456 MiB sent

# 외부 트래픽 (암호화된 UDP 패킷):
tcpdump -i eth0 udp port 51820 -w wireguard_encrypted.pcap

# 내부 트래픽 (복호화된 IP 패킷):
tcpdump -i wg0 -w wireguard_decrypted.pcap

# Wireshark 분석 시, WireGuard 프로토콜 디섹터는 핸드셰이크만 파싱 가능.
# 데이터 패킷은 암호화되어 있어 내용 확인 불가.

# perf로 암호화 핫스팟 분석:
perf record -a -g -- sleep 10  # 10초간 샘플링
perf report

# 주요 함수:
# - chacha20_simd() — SIMD 최적화 암호화
# - poly1305_simd_blocks() — MAC 계산
# - curve25519_generic() — DH 연산 (핸드셰이크)

# 피어 통계 (커널 5.12+):
cat /sys/class/net/wg0/statistics/rx_bytes
cat /sys/class/net/wg0/statistics/tx_bytes

# 핸드셰이크 카운터 (디버그 빌드):
cat /sys/kernel/debug/wireguard/wg0/peers/<peer_pubkey>/handshakes