# Step 001: WireGuard + UFW + SSH tylko po WG (Ubuntu 24.04, 1 NIC)

Cel: na świeżym Ubuntu 24.04 na bare metalu ustawić:

- **WireGuard** jako prywatny kanał administracyjny,
- **SSH dostępne tylko przez WireGuard**,
- przygotować grunt pod **Agave RPC dostępne tylko przez WireGuard** (8899/8900 prywatnie),
- zostawić porty klastra Agave na publicznym NIC, żeby node mógł się zsynchronizować.

Kolejność jest krytyczna: najpierw uruchom WireGuard i sprawdź, że działa, dopiero potem ograniczaj SSH/firewall.

## Założenia

- Host ma **1 publiczny interfejs** (np. `enp1s0`).
- WireGuard interfejs to `wg0`.
- Masz dostęp awaryjny do konsoli (IPMI/KVM) na wypadek pomyłki.

## Parametry (dostosuj)

```bash
export PUBLIC_IFACE="enp1s0"
export WG_IFACE="wg0"

export WG_SERVER_IP="10.66.66.1/24"
export WG_SERVER_IP_ONLY="10.66.66.1"
export WG_PORT="51820"

export WG_CLIENT_IP="10.66.66.2/32"
export WG_CLIENT_PUBKEY="<PASTE_CLIENT_PUBLIC_KEY>"

# Agave/validator ports
export RPC_PORT="8899"
export WS_PORT="8900"
export DYNAMIC_PORT_RANGE="8000:8020"
```

## 1) WireGuard (nie ruszaj jeszcze SSH)

### Instalacja

```bash
apt-get update
apt-get install -y wireguard
```

### Klucze serwera

```bash
umask 077
wg genkey | tee /etc/wireguard/server.key >/dev/null
cat /etc/wireguard/server.key | wg pubkey | tee /etc/wireguard/server.pub >/dev/null
cat /etc/wireguard/server.pub
```

### Konfiguracja `/etc/wireguard/wg0.conf`

```bash
cat >/etc/wireguard/${WG_IFACE}.conf <<EOF
[Interface]
Address = ${WG_SERVER_IP}
ListenPort = ${WG_PORT}
PrivateKey = $(cat /etc/wireguard/server.key)

[Peer]
PublicKey = ${WG_CLIENT_PUBKEY}
AllowedIPs = ${WG_CLIENT_IP}
EOF
```

Start:

```bash
systemctl enable --now wg-quick@${WG_IFACE}
wg show
ip a show ${WG_IFACE}
```

Test z klienta (po zestawieniu tunelu): `ping 10.66.66.1`.

## 2) UFW: public tylko WG + porty klastra; prywatnie RPC/SSH po wg0

Instalacja:

```bash
apt-get install -y ufw
```

Public: pozwól na WireGuard:

```bash
ufw allow ${WG_PORT}/udp
```

Public: pozwól na porty klastra Agave (żeby node mógł syncować).

Uwaga: Solana/Agave używa głównie **UDP** w tym zakresie; jeśli będziesz miał problemy z reachability, rozważ dopuszczenie też TCP w tym samym zakresie.

```bash
ufw allow in on "${PUBLIC_IFACE}" to any port ${DYNAMIC_PORT_RANGE}/udp
```

Prywatnie (wg0): RPC/WS:

```bash
ufw allow in on "${WG_IFACE}" to any port ${RPC_PORT} proto tcp
ufw allow in on "${WG_IFACE}" to any port ${WS_PORT} proto tcp
```

Na tym etapie NIE blokuj jeszcze publicznego SSH (żeby się nie zablokować).

Włącz UFW:

```bash
ufw enable
ufw status verbose
```

## 3) SSH tylko po WireGuard (dopiero gdy WG działa)

### 3.1) UFW: pozwól na SSH po wg0

```bash
ufw allow in on "${WG_IFACE}" to any port 22 proto tcp
```

### 3.2) sshd: nasłuch tylko na WG IP

Edytuj `sshd_config`:

```bash
sed -n '1,220p' /etc/ssh/sshd_config
```

Dodaj (lub ustaw) na końcu pliku:

```conf
PasswordAuthentication no
PermitRootLogin no
ListenAddress 10.66.66.1
```

Zanim zrestartujesz SSH:

- miej otwartą obecną sesję SSH,
- zestaw WG na kliencie,
- przygotuj drugi terminal do testu po `10.66.66.1`.

Restart:

```bash
systemctl restart ssh
ss -lntp | grep -E ':22\\b' || true
```

Test z klienta po WG:

```bash
ssh <user>@10.66.66.1
```

Jeśli działa: zablokuj publiczny SSH:

```bash
ufw deny 22/tcp
ufw status verbose
```

## 4) Kernel/sysctl baseline pod Agave (na tym etapie bez uruchamiania Agave)

Minimalne wartości, które już mamy w Ansible (i kilka dodatkowych bezpiecznych):

```bash
cat >/etc/sysctl.d/90-agave.conf <<'EOF'
fs.file-max = 2000000
vm.max_map_count = 1000000
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 250000
net.core.rmem_max = 134217728
net.core.wmem_max = 134217728
EOF

sysctl --system
```

Limity `nofile`:

```bash
cat >/etc/security/limits.d/90-solana.conf <<'EOF'
* soft nofile 1000000
* hard nofile 1000000
EOF
```

## 5) Co dalej

- Instalacja i uruchomienie Agave: patrz `doc/etap-007-manual-baremetal-rpc-commands.md`.
- Narzedzia do generowania konfiguracji WireGuard (server/client) + reset wg0: patrz `doc/step-001-wireguard-tools.md`.
- Docelowo: bind RPC/WS do WG IP (zamiast `0.0.0.0`) i spójne, minimalne reguły firewall.