ZTTP — Proxy Transparent Zero-Trust

Un bastion SSH auto-hébergé et durci avec gestion des clés basée sur Vault, application de politiques RBAC, enregistrement complet des sessions et une TUI d'administration interactive — conçu pour les équipes ayant besoin d'un accès auditable et zero-trust à l'infrastructure de production.

Table des matières

• Pourquoi ZTTP
• Vue d'ensemble de l'architecture
• Points forts des fonctionnalités
• Prérequis
• Démarrage rapide — Serveur
• Démarrage rapide — Client
• Configuration
• Rôles et politique RBAC
• Console d'administration
• Journaux d'audit et enregistrements de sessions
• Compilation depuis les sources
• Référence Makefile
• Captures d'écran et démo
• Structure du projet
• Modèle de sécurité
• Contribuer
• Licence

Pourquoi ZTTP

Les équipes d'ingénierie modernes ont besoin d'un moyen de donner aux développeurs l'accès minimum requis pour faire leur travail — ni plus, ni moins. La distribution traditionnelle des clés SSH est sujette aux erreurs : les clés sont partagées, oubliées sur les ordinateurs portables et révoquées des jours trop tard.

ZTTP résout ce problème en agissant comme la porte unique vers votre infrastructure :

Vue d'ensemble de l'architecture

Ordinateur portable du développeur
      │
      │  zttp
      │  (Sous le capot : SSH sur le port 2224)
      ▼
┌─────────────────────────────────────────────────────────┐
│                     Proxy ZTTP                          │
│                                                         │
│  ① Porte d'authentification — TUI de connexion bcrypt/Argon2id │
│  ② Moteur RBAC — vérification de politique sensible à l'environnement │
│  ③ Récupération Vault — récupération éphémère de clé SSH │
│  ④ Pont — tunnel TCP transparent                        │
│  ⑤ Écrivain d'audit — enregistreur de trames ttyrec     │
└──────────┬──────────────────────────────────────────────┘
           │  ssh (IP privée, clé éphémère)
           ▼
     Serveur cible

Services d'infrastructure (Docker Compose) :

Points forts des fonctionnalités

• 🔐 Authentification zero-trust — TUI de connexion SSH interactive avec hachage de mot de passe bcrypt, limitation de débit et verrouillage de compte après 5 tentatives échouées
• 🛡️ Moteur de politique RBAC — Contrôle d'accès par rôle et par environnement avec un seul JOIN PostgreSQL optimisé (aucun aller-retour)
• 🗝️ Clés SSH basées sur Vault — Les clés privées ne touchent jamais le disque ; récupérées de manière éphémère par session depuis HashiCorp Vault
• 📹 Enregistrement complet des sessions — Toutes les sessions sont enregistrées au format .ttyrec avec des trames horodatées
• 🖥️ TUI d'administration interactive — Interface terminal complète pour la gestion des utilisateurs, l'enregistrement des serveurs, les octrois d'accès et la revue des journaux
• 🔍 Visionneuse de journaux d'audit — Parcourez les sessions par serveur, rejouez les enregistrements ou lisez des journaux texte propres directement depuis la console d'administration
• ⚡ Kill Switch — Point de terminaison gRPC pour terminer instantanément toute session en direct
• 📋 Journal des actions administratives — Chaque action administrative (création d'utilisateur, octroi d'accès, consultation de journaux) est consignée dans une piste d'audit persistante
• 🌍 Client multiplateforme — CLI à binaire unique pour Linux, macOS (amd64/arm64) et Windows

Prérequis

Serveur (hôte proxy) :

• Docker ≥ 24 et Docker Compose ≥ 2.20
• Une IP publique ou accessible sur le LAN sur le port 2224
• make (optionnel, mais recommandé)

Développeur (client) :

• Tout client SSH (commande ssh)
• Machine Linux, macOS ou Windows

Démarrage rapide — Serveur

1. Cloner le dépôt

git clone https://gitlab.com/Nihal799/zttp.git
cd zttp

2. Configurer votre environnement

cp .env.example .env

Modifiez .env et définissez au minimum :

PROXY_NODE_IP=<ip-publique-de-votre-serveur>
POSTGRES_PASSWORD=<un-mot-de-passe-fort>
VAULT_TOKEN=<un-jeton-vault-fort>

⚠️ Ne committez jamais votre fichier .env. Il est listé dans .gitignore.

3. Démarrer tous les services

make docker-up
# ou directement :
docker compose -f deploy/docker-compose.yml up -d --build

4. Vérifier que les services sont sains

make docker-ps
curl http://localhost:8080/healthz

5. Compiler et publier les installateurs CLI

make release PROXY_ADDR=<ip-de-votre-serveur>:2224

Cela compile en croisé les clients pour toutes les plateformes et met automatiquement à jour dist/install.sh et dist/install.ps1 avec l'URL correcte du serveur. Le conteneur Nginx les sert à http://<ip-de-votre-serveur>:8555/.

Démarrage rapide — Client

Linux / macOS

curl -fsSL http://<ip-du-proxy>:8555/install.sh | bash

Windows (PowerShell, exécuté en tant qu'administrateur)

irm http://<ip-du-proxy>:8555/install.ps1 | iex

Se connecter

Une fois installé, connectez-vous à la passerelle ZTTP :

zttp
# ou directement :
ssh -p 2224 <votre-nom-dutilisateur>@<ip-du-proxy>

Un écran de connexion terminal s'affichera. Après authentification, vous verrez une liste des serveurs auxquels vous êtes autorisé à accéder.

Configuration

Toute la configuration se fait via des variables d'environnement (ou le fichier .env). Voir .env.example pour la référence complète.

Rôles et politique RBAC

ZTTP utilise un modèle basé sur les rôles. Chaque utilisateur se voit attribuer un rôle ; chaque rôle a une politique qui définit à quels environnements de serveurs il peut accéder.

Les rôles et les affectations de serveurs sont gérés via la console d'administration (voir ci-dessous). Le moteur RBAC effectue toutes les vérifications dans une seule requête PostgreSQL — il n'expose jamais pourquoi l'accès a été refusé au client (protection contre l'énumération).

Console d'administration

Connectez-vous au serveur zttp-admin depuis le menu de la passerelle, ou connectez-vous avec un compte ayant le rôle security-admin.

La console d'administration fournit :

Toutes les actions administratives sont consignées dans admin-actions.log dans le volume d'audit.

Journaux d'audit et enregistrements de sessions

Toutes les sessions sont stockées dans le volume Docker zttp-audit-logs (/var/log/zttp/audit/ dans le conteneur).

Consultation depuis la console d'administration

1. Connectez-vous en tant que security-admin
2. Sélectionnez Voir les journaux d'audit
3. Sélectionnez un serveur dans la liste
4. Sélectionnez une session
5. Choisissez Voir le journal texte (sans ANSI, lisible) ou Lire l'enregistrement (lecture en temps réel)
6. Appuyez sur Ctrl+C pour revenir en arrière

Consultation depuis l'hôte (brut)

# Lister les enregistrements
sudo ls /var/lib/docker/volumes/zttp-audit-logs/_data/

# Lire un enregistrement avec ttyplay
sudo ttyplay /var/lib/docker/volumes/zttp-audit-logs/_data/<id-de-session>.ttyrec

# Lire le journal des actions administratives
sudo cat /var/lib/docker/volumes/zttp-audit-logs/_data/admin-actions.log

Compilation depuis les sources

Prérequis : Go 1.25+, Docker (pour la compilation croisée)

# Compiler le proxy + CLI pour la plateforme actuelle
make build

# Compiler en croisé la CLI pour toutes les plateformes (Linux, macOS, Windows)
make release PROXY_ADDR=<ip-du-proxy>:2224

# Exécuter les tests
make test

# Exécuter le proxy localement (nécessite Postgres + Vault déjà en cours d'exécution)
make run-proxy

Référence Makefile

Captures d'écran et démo

1. Installation

(Cliquez pour lire la démo)

2. Connexion sécurisée

(Cliquez pour lire la démo)

3. Ajouter un serveur (console d'administration)

(Cliquez pour lire la démo)

4. Se connecter au serveur (passerelle)

(Cliquez pour lire la démo)

5. Kill Switch (éjection administrative)

(Cliquez pour lire la démo)

Structure du projet

zttp/
├── cmd/
│   ├── proxy/          # Point d'entrée du serveur proxy
│   └── zttp/           # Point d'entrée du client CLI
├── db/
│   └── migrations/     # Migrations de schéma PostgreSQL
├── deploy/
│   ├── docker-compose.yml
│   ├── Dockerfile.proxy
│   └── vault-seed.sh   # Remplit les clés SSH de test dans Vault
├── dist/
│   ├── install.sh      # Script d'installation Linux/macOS
│   └── install.ps1     # Script d'installation Windows
├── internal/
│   ├── audit/          # Journalisation des actions administratives
│   ├── auth/           # Authentification utilisateur (bcrypt, verrouillage)
│   ├── cli/            # TUI du client CLI et logique de connexion
│   ├── config/         # Configuration basée sur l'environnement
│   ├── killswitch/     # Service gRPC kill-switch
│   ├── proxy/          # Proxy SSH, TUI de passerelle, TUI d'administration, pont
│   ├── rbac/           # Moteur de contrôle d'accès basé sur les rôles
│   ├── ratelimit/      # Limitation de débit par IP
│   ├── session/        # Suivi des sessions et stockage en base de données
│   └── vault/          # Client de clés SSH HashiCorp Vault
├── proto/              # Définitions de protocole gRPC
├── tools/
│   └── hashpw/         # Outil CLI : générer un hachage de mot de passe bcrypt
├── .env.example        # Modèle de configuration
├── go.mod
└── Makefile

Modèle de sécurité

Contribuer

1. Forkez le dépôt
2. Créez une branche de fonctionnalité : git checkout -b feat/votre-fonctionnalité
3. Apportez vos modifications, en veillant à ce que chaque fichier ait son propre commit
4. Exécutez les tests : make test
5. Ouvrez une demande de fusion

Veuillez ne pas committer :

• .env ou tout fichier contenant des secrets
• De vraies adresses IP ou noms d'hôtes de serveurs de production
• Des binaires compilés (le binaire zttp à la racine est .gitignored)

Licence

Ce projet est propriétaire. Tous droits réservés.

Conçu avec Go, PostgreSQL, HashiCorp Vault et Docker.