# Configuration bureau & routeur

SecurQbit propose un client en ligne de commande pour les machines qui n'ont pas d'application : serveurs et postes Linux, Windows, FreeBSD et routeurs OpenWrt. C'est le même VPN et le même compte que les applications mobiles — voir [Installer SecurQbit](/installation) pour iOS et Android.

Deux programmes sont installés :

| Programme | Ce que c'est |
| --- | --- |
| `securqbitd` | Le service en arrière-plan. Il détient votre session, construit le tunnel et programme le routage du système. Il s'exécute avec les privilèges système parce que créer un périphérique tunnel les exige. |
| `sqctl` | La commande que vous tapez. Elle demande au service d'agir et vous montre ce qu'il fait. Elle ne détient aucun identifiant et n'a besoin d'aucun privilège. |

Vous interagissez avec `sqctl`. Voir la [Référence CLI](/cli-reference) pour toutes les commandes.

## Installer en une commande

Sur Linux, macOS, FreeBSD et OpenWrt :

```bash
curl -fsSL https://cdn.securqbit.com/securqbitd/install.sh | sudo sh
```

C'est toute l'installation. Le script détermine le paquet dont cette machine a besoin, le télécharge, le compare aux sommes de contrôle SHA-256 publiées, met les deux programmes en place et enregistre le service auprès de ce qui supervise les processus longs ici — systemd, OpenRC, runit, SysV init, procd, rc.d ou launchd. Rien d'autre n'a besoin d'être configuré.

Une fois terminé :

```bash
sqctl login              # ouvre un lien à approuver dans votre navigateur
sqctl connect --fastest
sqctl status
```

> **Il vous faut déjà un compte.** Le client bureau se connecte par approbation dans le navigateur et ne peut pas créer de compte. Créez-en un d'abord dans l'[application iOS ou Android](/installation) — y compris un [compte invité](/anonymous-accounts), qui se connecte sur accounts.securqbit.com avec son code de récupération et approuve depuis là.

### Options

L'installateur accepte quelques options. Passez-les après `sh -s --` :

```bash
curl -fsSL https://cdn.securqbit.com/securqbitd/install.sh | sudo sh -s -- --no-start
```

| Option | Ce qu'elle fait |
| --- | --- |
| `--version <v>` | Installe une version précise plutôt que l'actuelle. |
| `--from <path>` | Installe depuis une archive déjà téléchargée, sans réseau. |
| `--prefix <dir>` | Installe ailleurs que dans `/usr/local` (`/usr` sur OpenWrt). |
| `--no-start` | Enregistre le service mais le laisse arrêté. |
| `--no-router` | Sur OpenWrt, installe sans placer le LAN derrière le tunnel. |
| `--uninstall` | Supprime le service et les programmes. |

## Plateformes prises en charge

| Système | Architectures |
| --- | --- |
| Linux | x86-64, arm64, armv7 |
| Windows | x86-64, arm64 |
| FreeBSD | x86-64, arm64 |
| OpenWrt | x86-64, arm64, armv7 |
| macOS | Apple silicon, Intel |

Une compilation statique : un seul paquet Linux couvre glibc comme musl — Debian, Ubuntu, Fedora, Arch, Alpine et Void prennent le même fichier.

> **Il n'y a pas de version MIPS, et il n'y en aura pas.** Ces routeurs disposent de 8 à 16 Mo de flash et SecurQbit en réclame environ 40, donc un paquet pour eux ne pourrait qu'échouer après l'attente du téléchargement. Un routeur ARM ou x86-64 fonctionne.

> **Sur macOS, préférez l'application.** Le produit Mac est l'application SecurQbit native de l'App Store. Le client en ligne de commande se compile et s'exécute sur macOS pour pouvoir y être développé ; ce n'est pas ce qu'un utilisateur Mac devrait installer.

## Vérifier le téléchargement

L'installateur compare déjà l'archive aux sommes de contrôle publiées à côté d'elle et refuse de continuer si elles divergent. Pour vérifier à la main, ou installer hors ligne :

```bash
V=$(curl -fsSL https://cdn.securqbit.com/securqbitd/latest)
BASE=https://cdn.securqbit.com/securqbitd/$V

curl -fsSLO $BASE/securqbit-$V-linux-amd64.tar.gz
curl -fsSLO $BASE/SHA256SUMS

sha256sum --check --ignore-missing SHA256SUMS
```

Installez ensuite depuis le fichier que vous venez de vérifier :

```bash
tar -xzf securqbit-$V-linux-amd64.tar.gz
sudo ./securqbit-$V-linux-amd64/install.sh
```

Lancer `install.sh` depuis une archive extraite installe *cette* archive et ne touche jamais au réseau — c'est ainsi que l'on installe sur une machine qui n'a pas encore de route vers internet.

> Les sommes de contrôle empruntent la même connexion HTTPS que le paquet : elles prouvent que le fichier est arrivé intact, pas que le serveur était honnête. C'est TLS qui rend la connexion digne de confiance. N'installez pas via du `http` en clair.

## L'utiliser sans `sudo`

Le service s'exécute en root. Le socket sur lequel il écoute appartient à un groupe `securqbit` créé par l'installateur : ses membres peuvent piloter le VPN sans mot de passe.

```bash
sudo usermod -aG securqbit "$USER"    # Linux
sudo pw groupmod securqbit -m "$USER" # FreeBSD
```

Déconnectez-vous et reconnectez-vous pour que le nouveau groupe s'applique. Sur macOS le groupe est `admin`, dont les administrateurs font déjà partie. Sur Windows l'équivalent est le groupe `SecurQbit Users`, aux côtés de SYSTEM et Administrateurs.

En attendant, `sqctl` vous dira qu'il n'a pas la permission et affichera la commande ci-dessus.

## Windows

Windows s'installe depuis l'archive plutôt qu'avec la commande unique.

1. Téléchargez `securqbit-<version>-windows-amd64.tar.gz` depuis [cdn.securqbit.com/securqbitd](https://cdn.securqbit.com/securqbitd/) et extrayez-la.
2. Placez `wintun.dll` — le pilote de l'adaptateur tunnel, correspondant à votre architecture — à côté de `securqbitd.exe`. Il n'est pas redistribué avec SecurQbit ; téléchargez-le sur [wintun.net](https://www.wintun.net).
3. Depuis une invite PowerShell **avec élévation**, dans le dossier extrait :

```powershell
.\install.ps1
```

Cela copie les deux programmes dans `%ProgramFiles%\SecurQbit`, enregistre le service et ajoute le dossier au `PATH` machine pour que `sqctl` fonctionne depuis n'importe quel terminal. Ouvrez ensuite un nouveau terminal pour qu'il prenne le nouveau `PATH`.

Pour le retirer, lancez `.\uninstall.ps1` depuis la même invite avec élévation.

## OpenWrt : placer tout un réseau derrière le VPN

Sur un routeur, SecurQbit protège tout ce qui est sur le réseau — téléphones, portables, consoles, une télévision connectée — sans rien installer sur aucun d'eux.

```bash
curl -fsSL https://cdn.securqbit.com/securqbitd/install.sh | sh
sqctl login
sqctl connect --fastest
```

L'installation programme aussi le pare-feu : une zone au-dessus du tunnel avec NAT, le trafic LAN redirigé dedans, et l'IPv6 du LAN vers le WAN rejeté. C'est le comportement par défaut sur un routeur, parce qu'un VPN sur un routeur qui ne protégerait que le trafic du routeur lui-même n'est pas ce pour quoi on en installe un. Utilisez `--no-router` si c'est vraiment ce que vous voulez.

**Avant de commencer, vérifiez trois choses.**

- **La flash.** Il faut environ 90 Mo libres. La plupart des routeurs grand public ne les ont pas, et l'installateur refuse plutôt que de remplir l'overlay — un routeur dont l'overlay est plein ne peut pas être réparé à distance. La solution est un [extroot](https://openwrt.org/docs/guide-user/additional-software/extroot_configuration) sur une clé USB ou une carte SD.
- **Le module tun.** OpenWrt l'omet de l'image par défaut : `opkg update && opkg install kmod-tun` (ou `apk add kmod-tun`). Sans lui, c'est la première connexion qui échoue, pas l'installation.
- **curl.** Certaines images ne fournissent ni curl ni un wget capable de faire du HTTPS correctement : `opkg install curl`.

Lisez les journaux avec `logread -f -e securqbitd`. Ils restent en RAM à dessein — faire tourner des mégaoctets par jour sur la flash d'un routeur, c'est ainsi que la flash meurt.

> **L'IPv6 est rejeté, pas ignoré, et c'est voulu.** Le tunnel transporte de l'IPv4 ; laisser l'IPv6 du LAN sur le WAN ferait passer la moitié du trafic de chaque appareil à côté du VPN. Le rejet fait basculer les clients immédiatement en IPv4 au lieu d'attendre l'expiration d'un délai à chaque requête. `--allow-ipv6` désactive cette protection et accepte la fuite.

## Se connecter au démarrage

```bash
sqctl set autoconnect on
```

Le service démarre avec la machine et monte le tunnel dès qu'il a un réseau. Combiné à `sqctl set country`, un routeur ou un serveur revient d'un redémarrage déjà protégé, sans que personne ne se connecte.

## Rester à jour

```bash
sqctl update
```

Cela télécharge la version actuelle, la vérifie, remplace les deux programmes et redémarre le service. SecurQbit vérifie aussi une fois par jour de lui-même et vous signale les nouveautés — sous `sqctl status` :

```text
    Update         v1.1.0 available — run: sqctl update
```

Il se contente toujours de vous le dire. Il n'installe jamais seul, parce que terminer une mise à jour implique un redémarrage, et un redémarrage coupe le tunnel en cours. `sqctl set updates off` arrête la recherche ; `sqctl update` continue de fonctionner.

## Le désinstaller

```bash
curl -fsSL https://cdn.securqbit.com/securqbitd/install.sh | sudo sh -s -- --uninstall
```

Cela coupe d'abord le tunnel, pour que votre routage et votre DNS soient remis en état, puis retire le service et les deux programmes. Sur un routeur, la configuration de pare-feu ajoutée est également retirée. Votre fichier de configuration et vos journaux restent en place.

## Étapes suivantes

- [Référence CLI](/cli-reference) — chaque commande et ce qu'elle fait.
- [Se connecter à un serveur](/connecting) — choisir où vous apparaissez.
- [Dépannage](/troubleshooting) — quand quelque chose ne marche pas.
