# Vaultwarden Docker Deployment

Déploiement sécurisé de [Vaultwarden](https://github.com/dani-garcia/vaultwarden) (serveur Bitwarden open-source) avec Docker Compose et Traefik.

## Caractéristiques

- **Sécurité renforcée** : Capabilities Linux limitées, rate limiting, inscriptions désactivées
- **HTTPS automatique** : Certificats Let's Encrypt via Traefik
- **Limites de ressources** : Protection contre les fuites mémoire
- **Health checks** : Surveillance automatique de l'état du service
- **Configuration SMTP** : Récupération de mot de passe par email

## Prérequis

- Docker et Docker Compose installés
- Traefik configuré avec le réseau `traefik-net`
- Nom de domaine pointant vers votre serveur
- Serveur SMTP (optionnel, pour les emails)

## Installation

### 1. Cloner le projet

```bash
git clone <votre-repo>
cd agence66-vaultwarden
```

### 2. Configuration

Copier et éditer le fichier d'environnement :

```bash
cp .env.example .env
nano .env
```

### 3. Variables d'environnement

Configurer les variables dans `.env` :

```env
# Domaine public de votre instance
DOMAIN=vault.example.com

# Token admin (IMPORTANT : générer un token fort)
ADMIN_TOKEN=<généré-avec-openssl-rand-base64-48>

# Configuration SMTP (optionnel)
SMTP_HOST=smtp.example.com
SMTP_PORT=587
SMTP_FROM=vaultwarden@example.com
SMTP_USER=votre-utilisateur
SMTP_PASSWORD=votre-mot-de-passe
```

#### Générer un token admin sécurisé

**Étape 1 : Générer un token aléatoire**

```bash
openssl rand -base64 48
```

**Étape 2 : Hasher le token (RECOMMANDÉ)**

Pour une sécurité maximale, il est **fortement recommandé** de hasher le token avec Argon2 avant de le mettre dans `.env`.

**Option A : Avec Docker (pas besoin d'installer argon2)**

```bash
# Remplacer YOUR_TOKEN par le token généré à l'étape 1
echo -n "YOUR_TOKEN" | docker run --rm -i vaultwarden/server:latest \
  /vaultwarden hash --preset owasp
```

**Option B : Avec argon2 installé localement**

```bash
# Installation (Debian/Ubuntu)
sudo apt install argon2

# Hasher le token
echo -n "YOUR_TOKEN" | argon2 "$(openssl rand -base64 32)" -e -id -k 65540 -t 3 -p 4
```

**Utilisation du hash**

1. Copiez le hash généré (commence par `$argon2id$...`)
2. Mettez-le dans `.env` comme ceci :

```env
ADMIN_TOKEN=$argon2id$v=19$m=65540,t=3,p=4$base64hash...
```

3. Pour vous connecter au panel admin, utilisez le **token en clair** (celui de l'étape 1), pas le hash

**Pourquoi hasher ?**

- ✅ **Sécurité** : Si quelqu'un accède à votre `.env`, il ne peut pas utiliser le hash directement
- ✅ **Protection** : Le hash ne peut pas être inversé pour retrouver le token
- ✅ **Best practice** : Recommandé par la documentation officielle Vaultwarden

**Documentation officielle** : [Securing the admin token](https://github.com/dani-garcia/vaultwarden/wiki/Enabling-admin-page#secure-the-admin_token)

### 4. Créer le répertoire de données

```bash
mkdir -p data
chmod 700 data
```

### 5. Démarrer le service

```bash
docker compose up -d
```

### 6. Vérifier le statut

```bash
docker compose ps
docker compose logs -f vaultwarden
```

## Accès

- **Interface utilisateur** : `https://votre-domaine.com`
- **Panel admin** : `https://votre-domaine.com/admin`
  - Token requis (celui dans `.env`)

## Configuration de sécurité

### Capabilities Linux

Le container utilise le principe du moindre privilège :
- Toutes les capabilities sont supprimées (`cap_drop: ALL`)
- Seules les capabilities nécessaires sont ajoutées :
  - `CHOWN` : Changer propriétaire des fichiers
  - `SETGID` : Changer group ID
  - `SETUID` : Changer user ID

### Rate Limiting

Protection contre le brute-force :
- **Connexions** : 10 tentatives max par 60 secondes
- **Emails** : 3 tentatives max, expiration 10 minutes

### Limites de ressources

- **Mémoire max** : 256 MB
- **CPU max** : 50% d'un core
- **Mémoire réservée** : 128 MB

## Backup

### Backup manuel

```bash
# Arrêter le service
docker compose down

# Créer une archive datée
tar -czf backup-vaultwarden-$(date +%Y%m%d-%H%M%S).tar.gz data/

# Redémarrer le service
docker compose up -d
```

### Backup automatique (cron)

Créer un script `/usr/local/bin/backup-vaultwarden.sh` :

```bash
#!/bin/bash
BACKUP_DIR="/path/to/backups"
cd /path/to/agence66-vaultwarden

docker compose exec vaultwarden sqlite3 /data/db.sqlite3 ".backup /data/db-backup.sqlite3"
tar -czf "${BACKUP_DIR}/vaultwarden-$(date +%Y%m%d-%H%M%S).tar.gz" data/
find "${BACKUP_DIR}" -name "vaultwarden-*.tar.gz" -mtime +30 -delete
```

Ajouter au crontab :

```bash
0 2 * * * /usr/local/bin/backup-vaultwarden.sh
```

## Restore

```bash
# Arrêter le service
docker compose down

# Supprimer les données actuelles
rm -rf data/*

# Extraire le backup
tar -xzf backup-vaultwarden-YYYYMMDD-HHMMSS.tar.gz

# Redémarrer
docker compose up -d
```

## Maintenance

### Mise à jour

```bash
# 1. Backup (voir section Backup)

# 2. Mettre à jour l'image dans docker-compose.yml
# Remplacer : image: vaultwarden/server:latest
# Par : image: vaultwarden/server:1.31.0  (version désirée)

# 3. Télécharger la nouvelle image
docker compose pull

# 4. Recréer le container
docker compose up -d

# 5. Vérifier les logs
docker compose logs -f vaultwarden
```

### Logs

```bash
# Temps réel
docker compose logs -f vaultwarden

# 100 dernières lignes
docker compose logs --tail=100 vaultwarden
```

### Healthcheck

```bash
# Vérifier l'état
docker inspect vaultwarden --format='{{.State.Health.Status}}'

# Doit retourner : healthy
```

## Dépannage

### Le service ne démarre pas

```bash
# Vérifier les logs
docker compose logs vaultwarden

# Vérifier le réseau Traefik
docker network ls | grep traefik-net

# Créer le réseau si nécessaire
docker network create traefik-net
```

### Erreur certificat SSL

Vérifier que :
- Le domaine pointe bien vers le serveur (DNS)
- Le port 80 est ouvert (Let's Encrypt challenge)
- Traefik est correctement configuré

### Impossible de se connecter

```bash
# Vérifier que le service répond
curl -I http://localhost:80/alive

# Vérifier les labels Traefik
docker inspect vaultwarden | grep traefik
```

### Problème de performance

Ajuster les limites dans `docker-compose.yml` :

```yaml
deploy:
  resources:
    limits:
      memory: 512M  # Augmenter si nécessaire
      cpus: '1.0'
```

## Sécurité additionnelle (recommandé)

### Fail2Ban

Installer Fail2Ban pour bloquer les IPs suspectes :

```bash
# /etc/fail2ban/filter.d/vaultwarden.conf
[Definition]
failregex = ^.*Username or password is incorrect\. Try again\. IP: <ADDR>\. Username:.*$
ignoreregex =
```

### Authentification 2FA

Configurer 2FA pour tous les utilisateurs via l'interface web.

### Audit régulier

Vérifier régulièrement :
- Panel admin → View logs
- Utilisateurs actifs
- Appareils connectés

## Architecture

```
Internet
   ↓
Traefik (reverse proxy)
   ↓ HTTPS
Vaultwarden (Docker)
   ↓
./data (SQLite + attachments)
```

## Ressources

- [Vaultwarden Wiki](https://github.com/dani-garcia/vaultwarden/wiki)
- [Vaultwarden GitHub](https://github.com/dani-garcia/vaultwarden)
- [Configuration SMTP](https://github.com/dani-garcia/vaultwarden/wiki/SMTP-Configuration)
- [Sécurité Admin Panel](https://github.com/dani-garcia/vaultwarden/wiki/Enabling-admin-page#secure-the-admin_token)

## Licence

Ce projet de déploiement est libre d'utilisation. Vaultwarden est sous licence GPL-3.0.