Comment chiffrer le trafic sur Redis avec Spiped sur Ubuntu 16.04

introduction

Redis est un magasin de données clé-valeur open source, utilisant un modèle de stockage en mémoire avec des écritures de disque optionnelles pour la persistance. Il comporte des transactions, un modèle de messagerie pub / secondaire et un basculement automatique, entre autres fonctionnalités. Redis a des clients écrits dans la plupart des langues et ceux recommandés sont affichés sur their leur site Web.

Redis ne fournit aucune fonctionnalité de cryptage propre. Il fonctionne en supposant qu’il a été déployé sur un réseau privé isolé, accessible uniquement aux parties de confiance. Si votre environnement ne correspond pas à cette hypothèse, vous devrez encapsuler le trafic Redis dans un chiffrement séparé.

Dans ce guide, nous montrerons comment chiffrer le trafic Redis à l’aide d’un programme de tuyauterie sécurisé appelé + spiped +. Le trafic entre les clients Redis et les serveurs sera acheminé via un tunnel crypté dédié, similaire à un tunnel SSH dédié. Nous allons utiliser deux serveurs Ubuntu 16.04 à des fins de démonstration.

Conditions préalables

Pour commencer, vous devez avoir un utilisateur non root avec les privilèges sudo + configurés sur chacune de vos machines. De plus, ce guide supposera que vous avez un pare-feu de base en place. Vous pouvez suivre notre Ubuntu 16.04 guide de configuration du serveur pour remplir ces conditions.

Lorsque vous êtes prêt à continuer, suivez les instructions ci-dessous.

Qu’est-ce qui est spipé?

L’utilitaire + spiped + est simple à installer et à configurer pour une communication sécurisée entre deux sockets réseau (ports réseau ordinaires ou sockets Unix). Il peut être utilisé pour configurer une communication cryptée entre deux serveurs distants. Le client se connecte à un port local et + spiped + l’encapsule avant d’être transféré au serveur distant. Sur le serveur, + spiped + écoute sur le port configuré et décrypte le trafic avant de le transférer sur un port local (dans notre cas, le port sur lequel le serveur Redis écoute).

Certains avantages de l’utilisation de + spiped + sont les suivants:

  • Ubuntu conserve des paquets pour + spiped + `dans ses dépôts par défaut.

  • Le projet Redis suggère actuellement d’utiliser + spiped + pour chiffrer le trafic.

  • La configuration est simple et intuitive.

  • Un nouveau tuyau est utilisé pour chaque objectif. Cela peut constituer un inconvénient dans certaines situations, mais cela permet un contrôle granulaire de l’accès.

Certains inconvénients sont:

  • Les clients se connectent à la machine distante en se connectant à un port local autre que celui par défaut, ce qui peut être peu intuitif au début.

  • Si vous connectez deux serveurs Redis pour la réplication ou la mise en cluster, deux tunnels doivent être configurés sur chaque ordinateur pour la communication serveur à serveur (un pour le trafic sortant et un pour le trafic entrant).

  • Il n’y a pas de script init inclus, vous devez donc en créer un pour créer automatiquement les connexions nécessaires au démarrage.

Avec ces caractéristiques à l’esprit, commençons.

Installer les packages serveur et client Redis

Avant de commencer, le serveur Redis doit être installé sur une machine et les packages client disponibles sur l’autre. Si vous avez déjà configuré l’un ou les deux, n’hésitez pas à passer à l’avant.

Installer le serveur Redis

Nous utiliserons Chris du serveur Redis de Chris de Lea pour installer une version à jour de Redis. Soyez toujours prudent lorsque vous utilisez un référentiel tiers. Dans ce cas, Chris Lea est un emballeur de confiance qui gère des packages de haute qualité et mis à jour pour plusieurs projets open source populaires.

Ajoutez le PPA et installez le logiciel serveur Redis sur votre première machine en tapant:

sudo apt-add-repository ppa:chris-lea/redis-server
sudo apt-get update
sudo apt-get install redis-server

Tapez * Entrée * pour accepter les invites au cours de ce processus.

Une fois l’installation terminée, vérifiez que vous pouvez vous connecter au service Redis localement en tapant:

redis-cli ping

Si le logiciel est installé et en cours d’exécution, vous devriez voir:

Redis server outputPONG

Définissons une clé que nous pourrons utiliser plus tard:

redis-cli set test 'success'

Nous avons défini la clé * test * sur la valeur + success +. Nous allons essayer d’accéder à cette clé à partir de notre ordinateur client après la configuration de + spiped +.

Installation du client Redis

L’autre machine Ubuntu 16.04 fonctionnera en tant que client. Tous les logiciels dont nous avons besoin sont disponibles dans le package + redis-tools + du référentiel par défaut:

sudo apt-get update
sudo apt-get install redis-tools

Avec la configuration par défaut du serveur Redis distant et un pare-feu actif, nous ne pouvons pas actuellement nous connecter à l’instance Redis distante à tester.

Installer spiped sur chaque ordinateur

Ensuite, vous devrez installer + spiped + sur chacun des serveurs et des clients. Si vous n’avez rien eu à installer dans la section précédente, veillez à inclure la commande sudo apt-get update + pour actualiser l’index de votre paquet avant l’installation:

sudo apt-get install spiped

Maintenant que le logiciel nécessaire est installé, nous pouvons générer une clé sécurisée que + spiped + peut utiliser pour chiffrer le trafic entre nos deux machines.

Générer une clé de cryptage sur le serveur Redis

Créez ensuite un répertoire de configuration + spiped + dans + / etc + sur votre serveur Redis pour stocker la clé que nous allons générer pour le cryptage:

sudo mkdir /etc/spiped

Générez une clé sécurisée en tapant:

sudo dd if=/dev/urandom of=/etc/spiped/redis.key bs=32 count=1

Limitez l’accès au fichier de clé généré en ajustant les autorisations:

sudo chmod 600 /etc/spiped/redis.key

Maintenant que la clé est disponible sur le serveur Redis, nous pouvons configurer + spiped + sur le serveur à l’aide d’un fichier unité systemd.

Créer un fichier unité systemd pour les serveurs Redis

L’utilitaire + spiped + est très simple et ne prend pas en charge la lecture d’un fichier de configuration. Étant donné que chaque canal doit être configuré manuellement, le paquet Ubuntu n’est pas accompagné d’un script init permettant de démarrer un canal automatiquement au démarrage.

Pour résoudre ces problèmes, nous allons créer un simple fichier unité systemd. Ouvrez un nouveau fichier d’unité dans le répertoire + / etc / systemd / system pour commencer:

sudo nano /etc/systemd/system/spiped-receive.service

À l’intérieur, créez une section + [Unit] + pour décrire l’unité et établissez un ordre pour que cette unité soit démarrée une fois que la mise en réseau est disponible:

/etc/systemd/system/spiped-receive.service

[Unit]
Description=spiped receive for Redis
Wants=network-online.target
After=network-online.target

Ensuite, ouvrez une section + [Service] + pour définir la commande à exécuter. Nous allons utiliser les options suivantes avec + spiped +:

  • + -F +: Exécuter au premier plan. Le système systemd init est conçu pour gérer les services exécutés au premier plan lorsque cela est possible. L’exécution au premier plan simplifie la configuration requise.

  • + -d +: Décrypte le trafic du socket source. Ceci indique + spiped + la direction du chiffrement afin qu’il sache déchiffrer le trafic de la source et chiffrer le trafic de la cible.

  • + -s +: Ceci définit le socket source. Les adresses IP doivent être entre crochets, suivies de deux points, puis du port. Pour le serveur Redis, il convient de définir l’adresse IP publique et le port Redis.

  • + -t +: le socket cible. C’est à cet endroit que le trafic sera transféré après le déchiffrement. Redis écoute par défaut le port 6379 sur l’hôte local, c’est donc ce que nous devons utiliser.

  • + -k +: spécifie le fichier de clé à utiliser. Cela devrait indiquer la clé de cryptage que nous avons générée précédemment.

Toutes ces options iront dans une seule directive + ExecStart +, qui est le seul élément dont nous avons besoin dans cette section:

/etc/systemd/system/spiped-receive.service

[Unit]
Description=spiped receive for Redis
Wants=network-online.target
After=network-online.target

[Service]
ExecStart=/usr/bin/spiped -F -d -s []:6379 -t [127.0.0.1]:6379 -k /etc/spiped/redis.key

Enfin, nous allons inclure une section + [Install] + pour indiquer à systemd quand démarrer automatiquement l’unité si elle est activée:

/etc/systemd/system/spiped-receive.service

[Unit]
Description=spiped receive for Redis
Wants=network-online.target
After=network-online.target

[Service]
ExecStart=/usr/bin/spiped -F -d -s []:6379 -t [127.0.0.1]:6379 -k /etc/spiped/redis.key

[Install]
WantedBy=multi-user.target

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Démarrer le service spiped et ajuster le pare-feu sur le serveur Redis

Démarrez et activez la nouvelle unité + spiped + en tapant:

sudo systemctl start spiped-receive.service
sudo systemctl enable spiped-receive.service

Si vous vérifiez que les services écoutent les connexions sur votre serveur Redis, vous devriez voir l’écoute + spiped + sur le port 6379 sur l’interface publique. Vous devriez également voir que Redis écoute ce même port sur l’interface locale:

sudo netstat -plunt
Redis server outputActive Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 :6379          0.0.0.0:*               LISTEN      4292/spiped
tcp        0      0 127.0.0.1:6379          0.0.0.0:*               LISTEN      2679/redis-server 1
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      1720/sshd
tcp6       0      0 :::22                   :::*                    LISTEN      1720/sshd

Bien que + spiped + écoute sur l’interface publique, le pare-feu n’est probablement pas configuré pour laisser passer le trafic.

Pour autoriser tout le trafic sur le port 6379, tapez:

sudo ufw allow 6379

Cela ouvrira l’accès au port 6379 sur votre interface publique où + spiped + est à l’écoute. Le port + spiped + accepte uniquement le trafic chiffré.

Transférer la clé de cryptage sur le client

Pour transférer la clé de cryptage sur le client, nous devons établir une connexion sécurisée entre nos deux serveurs. Nous allons utiliser + ssh + car cela nous permet de tirer parti de notre configuration existante.

Si vous utilisez une authentification basée sur une clé, vous devrez transférer votre clé SSH sur le serveur Redis pour établir la connexion. Cela n’est pas nécessaire pour les systèmes basés sur un mot de passe.

Étapes supplémentaires pour l’authentification par clé

Déconnectez-vous de votre serveur Redis:

exit

Maintenant, sur votre ordinateur local, assurez-vous qu’un agent SSH est en cours d’exécution et que votre clé privée y a été ajoutée:

eval `ssh-agent`
ssh-add

Maintenant, reconnectez-vous à votre serveur Redis et ajoutez l’indicateur + -A + pour transférer vos clés:

ssh -A @

Vous pouvez maintenant continuer avec les étapes ci-dessous.

Transférer la clé

Nous nous connecterons depuis le serveur Redis au client car notre fichier de clé nécessite des privilèges locaux + sudo +. Nous pouvons maintenant transférer le fichier en prenant soin d’inclure les deux points à la fin de la commande ci-dessous:

sudo -E scp /etc/spiped/redis.key @:

+ scp + pour écrire dans le répertoire de base de votre utilisateur sur la machine cliente.

Après avoir transféré la clé, créez le répertoire + / etc / spiped + sur la machine cliente:

sudo mkdir /etc/spiped

Déplacez la clé de cryptage dans le nouveau répertoire:

sudo mv ~/redis.key /etc/spiped

Verrouillez les autorisations pour restreindre l’accès:

sudo chmod 600 /etc/spiped/redis.key

Maintenant que le client dispose d’une copie de la clé de chiffrement du serveur, nous pouvons configurer le côté client de la configuration + spiped +.

Créer un fichier unité systemd pour les clients Redis

Nous devrons créer un fichier unité systemd pour + spiped + côté client, comme nous l’avons fait sur le serveur Redis.

Ouvrez un nouveau fichier d’unité systemd en tapant:

sudo nano /etc/systemd/system/spiped-send.service

A l’intérieur, ouvrez une section + [Unit] + pour décrire le service et établir que cela dépend de la disponibilité du réseau:

/etc/systemd/system/spiped-send.service

[Unit]
Description=spiped sending for Redis
Wants=network-online.target
After=network-online.target

Ensuite, ouvrez une section + [Service] + pour exécuter le processus + spiped +. Les options utilisées ici sont très similaires à celles utilisées sur le serveur Redis, avec les différences suivantes:

  • + -e +: Spécifie que le trafic entrant dans le socket source devra être chiffré. Ceci établit la relation entre les sockets source et cible.

  • + -s +: Définit le socket source, comme avant. Dans ce cas, toutefois, la source est un port disponible arbitraire sur l’interface locale à laquelle le client Redis local peut se connecter.

  • + -t +: Définit le socket cible, comme avant. Pour le client, il s’agira de l’adresse IP publique du serveur Redis distant et du port ouvert.

Ceux-ci seront définis à l’aide de la directive + ExecStart + à nouveau:

/etc/systemd/system/spiped-send.service

[Unit]
Description=spiped sending for Redis
Wants=network-online.target
After=network-online.target

[Service]
ExecStart=/usr/bin/spiped -F -e -s [127.0.0.1]:8000 -t []:6379 -k /etc/spiped/redis.key

Enfin, incluez une section + [Install] + pour définir quand l’unité sera démarrée si elle est activée:

/etc/systemd/system/spiped-send.service

[Unit]
Description=spiped sending for Redis
Wants=network-online.target
After=network-online.target

[Service]
ExecStart=/usr/bin/spiped -F -e -s [127.0.0.1]:8000 -t []:6379 -k /etc/spiped/redis.key

[Install]
WantedBy=multi-user.target

Lorsque vous avez terminé, enregistrez et fermez le fichier.

Démarrer le service spiped sur le client et tester la connexion

Maintenant, nous pouvons démarrer notre service + spiped + sur le client et lui permettre de démarrer automatiquement au démarrage:

sudo systemctl start spiped-send.service
sudo systemctl enable spiped-send.service

Vérifiez que le tunnel sur le client a été configuré correctement:

sudo netstat -plunt
Redis client outputActive Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 127.0.0.1:8000          0.0.0.0:*               LISTEN      3264/spiped
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      1705/sshd
tcp6       0      0 :::22                   :::*                    LISTEN      1705/sshd

Comme vous pouvez le constater, + spiped + écoute sur le port local 8000 pour les connexions.

Vous devriez maintenant pouvoir vous connecter à l’instance Redis distante en pointant votre client sur le port 8000 de votre interface locale:

redis-cli -p 8000 ping
Redis client outputPONG

Requête pour la clé de test que nous avons définie au début de ce guide:

redis-cli -p 8000 get test
Redis client output"success"

Cela confirme que nous sommes en mesure d’atteindre la base de données distante avec succès.

Pour confirmer que nous sommes unables à communiquer avec le serveur Redis distant sans utiliser le tunnel, nous pouvons essayer de nous connecter directement au port distant:

redis-cli -h  -p 6379 ping
Redis client outputError: Protocol error, got "\xac" as reply type byte

Comme vous pouvez le constater, le trafic sur le port Redis distant n’est accepté que s’il est correctement chiffré via le tunnel.

Extension de l’exemple ci-dessus pour la communication multi-client et serveur à serveur

L’exemple décrit ci-dessus utilise un exemple simple d’un serveur Redis et d’un client. Cependant, ces mêmes méthodes peuvent être appliquées à des interactions plus complexes.

Étendre cet exemple pour gérer plusieurs clients est simple. Vous devrez effectuer les actions suivantes décrites ci-dessus.

  • Installer le logiciel client Redis et le package + spiped + sur le nouveau client

  • Transférer la clé de cryptage sur le nouveau client

  • Copiez le fichier unité systemd + spiped + sur le nouvel ordinateur client.

  • Démarrer le service + spiped + et lui permettre de démarrer au démarrage

Pour configurer une communication sécurisée entre serveurs (par exemple, pour la réplication ou la mise en cluster), vous devez configurer deux tunnels parallèles:

  • Sur le nouveau serveur, installez le paquet du serveur Redis et + spiped +

  • Générez une nouvelle clé de chiffrement pour le nouveau serveur Redis (utilisez un nom unique pour le fichier)

  • Copiez la clé de cryptage d’un serveur à l’autre dans le répertoire + / etc / spiped +

  • Créez un fichier d’unité systemd + spiped + sur chaque serveur (y compris les serveurs existants) de sorte que chaque serveur dispose d’un fichier servant à chaque rôle:

  • Un fichier d’unité réceptrice mappant un port externe sur le Redis local

  • Un fichier d’unité d’envoi mappant un port local sur le port exposé du serveur distant

  • Ouvrez le port externe dans le pare-feu sur le nouveau serveur Redis

  • Configurez chaque instance Redis pour qu’elle se connecte au port mappé localement afin d’accéder au serveur distant en ajustant le fichier de configuration Redis (les directives requises dépendent de la relation entre les serveurs. Voir la documentation Redis pour plus de détails).

Si nécessaire, plusieurs fichiers d’unité client peuvent être configurés sur chaque ordinateur pour mapper les ports locaux aux serveurs distants. Dans ces cas, veillez à choisir un autre port local inutilisé dans la spécification du socket source dans le fichier d’unité d’envoi.

Conclusion

Redis est un outil puissant et flexible qui est précieux pour de nombreux déploiements. Toutefois, l’utilisation de Redis dans un environnement non sécurisé est une lourde responsabilité qui rend vos serveurs et vos données vulnérables aux attaques et au vol. Il est essentiel de sécuriser le trafic par d’autres moyens si vous ne disposez pas d’un réseau isolé peuplé uniquement de parties de confiance. La méthode décrite dans ce guide n’est qu’un moyen de sécuriser la communication entre les parties Redis. D’autres options incluent https://www.digitalocean.com/community/tutorials/how-to-encrypt-traffic-to-redis-with-stunnel-on-ubuntu-16-04 tunnelling avec stunnel] ou https: // www.digitalocean.com/community/tutorials/how-to-encrypt-traffic-to-redis-with-peervpn-on-ubuntu-16-04 (établissement d’un réseau privé virtuel)].