TOC

Comment chiffrer le trafic sur Redis avec Stunnel 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, les recommandées étant présentées surtheir website.

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 crypter le trafic Redis à l'aide d'un programme de tunneling sécurisé appeléstunnel. Le trafic entre les clients Redis et les serveurs sera acheminé via un tunnel crypté SSL dédié. Nous allons utiliser deux serveurs Ubuntu 16.04 pour démontrer.

Conditions préalables

Pour commencer, vous devez avoir un utilisateur non root avec les privilègessudo 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 nosUbuntu 16.04 initial server setup guide pour remplir ces conditions.

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

Qu'est-ce que Stunnel?

Pour les communications chiffrées de base, l'utilitairestunnel est simple à installer et à configurer. Il permet le transfert crypté entre deux machines. Le client se connecte à un port local etstunnel l'enveloppe dans le chiffrement avant de le transmettre au serveur distant. Côté serveur,stunnel écoute sur le port configuré et décrypte le trafic avant de le rediriger vers un port local (dans notre cas, le port sur lequel le serveur Redis écoute).

Certains avantages de l'utilisation destunnel sont:

  • Ubuntu maintient les packages pourstunnel dans ses référentiels par défaut

  • Ubuntu comprend un script init pour démarrer automatiquement le processus au démarrage

  • La configuration est simple et intuitive

  • Un nouveau tunnel est utilisé à chaque fin. 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).

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.

[.note] #Note: Les instructions du serveur Redis définissent une clé de test qui sera utilisée pour tester la connexion ultérieurement. Si vous avez déjà installé le serveur Redis, vous pouvez continuer et définir cette clé ou utiliser toute autre clé connue lorsque nous testons la connexion.
#

Installer le serveur Redis

Nous utiliseronsChris Lea’s Redis server PPA 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

TapezEnter pour accepter les invites pendant 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 valeursuccess. Nous essaierons d'accéder à cette clé depuis notre machine cliente après avoir configuréstunnel.

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 packageredis-tools dans le 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 et activer Stunnel sur chaque ordinateur

Ensuite, vous devrez installerstunnel sur chacun des serveurs et clients. Ubuntu inclut la version quatre de l'utilitaire, appeléestunnel4 dans ses référentiels par défaut. Si vous n'avez rien besoin d'installer dans la section précédente, assurez-vous d'inclure la commandesudo apt-get update pour actualiser l'index de votre package avant d'installer: 

# sudo apt-get update
sudo apt-get install stunnel4

Le servicestunnel sur Ubuntu utilise un ancien script SysVinit pour le démarrage, qui peut être géré par systemd. Plutôt que d'utiliser des méthodes systemd natives, pour configurer le service pour qu'il démarre au démarrage, vous devez modifier le fichier/etc/default/stunnel4: 

sudo nano /etc/default/stunnel4

Autorisez le service à démarrer au démarrage en définissant l'optionENABLED sur «1»:

/etc/default/stunnel4

. . .
ENABLED=1
. . .

Enregistrez et fermez le fichier sur chaque serveur.

Ensuite, nous allons créer un certificat SSL auto-signé et une clé qui sera utilisée pour chiffrer la communication.

Créer un certificat SSL auto-signé et une clé sur le serveur Redis

Sur votre serveur Redis, créez un certificat SSL auto-signé et une clé dans le répertoire/etc/stunnel. Ceci sera utilisé pour crypter la connexion entre les deux instances destunnel. Nous utiliserons le nomredis-server pour faire référence au certificat et aux fichiers de clés: 

sudo openssl req -x509 -nodes -days 3650 -newkey rsa:2048 -keyout /etc/stunnel/redis-server.key -out /etc/stunnel/redis-server.crt

Vous serez invité à fournir des informations sur le certificat que vous créez. Etant donné que cela ne sera utilisé qu’en interne, les valeurs n’ont pas beaucoup d’importance, alors indiquez ce que vous voulez. Vous pouvez voir un exemple ci-dessous: 

Redis server output. . .
-----
Country Name (2 letter code) [AU]:US
State or Province Name (full name) [Some-State]:New York
Locality Name (eg, city) []:New York City
Organization Name (eg, company) [Internet Widgits Pty Ltd]:DigitalOcean
Organizational Unit Name (eg, section) []:Community
Common Name (e.g. server FQDN or YOUR name) []:redis-server
Email Address []:[email protected]

Restreignez l'accès au fichier.key généré en tapant: 

sudo chmod 600 /etc/stunnel/redis-server.key

Maintenant que nous avons un certificat SSL et une clé, nous pouvons créer le fichier de configurationstunnel de notre serveur Redis.

Créer le fichier de configuration stunnel du serveur Redis

Ouvrez un fichier se terminant par.conf dans le répertoire/etc/stunnel sur le serveur Redis pour commencer: 

sudo nano /etc/stunnel/redis.conf

À l'intérieur, spécifiez un emplacement pour écrire le fichier PID dans la section principale. Le répertoire/run est conçu pour stocker ces types de fichiers, nous allons donc l'utiliser:

/etc/stunnel/redis.conf

pid = /run/stunnel-redis.pid

Ensuite, créez une section pour configurer l’accès au service Redis. Vous pouvez l'appeler comme vous le souhaitez (nous l'appelleronsredis-server). La section sépare cette configuration de tous les autres tunnels que vous devrez peut-être configurer sur cette machine ultérieurement.

Nous devons spécifier les emplacements du propre certificat et de la clé du serveur Redis en utilisant respectivement les directivescert etkey.

Nous définirons également le tunnel pour les données entrantes ici. Nous voulonsacceptle trafic chiffré vers le port Redis par défaut (port 6379) sur l’adresse IP externe du serveur Redis. Nous voulons ensuiteconnect ce trafic vers le port Redis par défaut sur l'interfacelocal pour déposer le trafic décrypté. C'est ici que le service Redis écoute réellement:

/etc/stunnel/redis.conf

pid = /run/stunnel-redis.pid

[redis-server]
cert = /etc/stunnel/redis-server.crt
key = /etc/stunnel/redis-server.key
accept = redis_servers_public_IP:6379
connect = 127.0.0.1:6379

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

Redémarrez Stunnel et configurez le pare-feu

Maintenant questunnel est configuré sur le serveur Redis, nous pouvons redémarrer le service en tapant: 

sudo systemctl restart stunnel4.service

Si vous vérifiez les services à l'écoute des connexions sur votre serveur Redis, vous devriez voirstunnel en écoute 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 public_IP:6379          0.0.0.0:*               LISTEN      4292/stunnel4
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 questunnel écoute sur l'interface publique, le pare-feu n'est probablement pas encore 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ùstunnel écoute. Le portstunnel n'accepte que le trafic chiffré.

Distribuer le certificat au client

Chaque client Redis aura besoin d’une copie du fichier de certificat du serveur Redis. La manière la plus simple de distribuer les fichiers.crt est simplement de sortir le contenu du fichier sur le serveur, puis de copier le contenu dans un fichier correspondant sur les machines connectées.

Sortez le contenu du fichier.crt sur votre serveur Redis en tapant: 

cat /etc/stunnel/redis-server.crt
Redis server output-----BEGIN CERTIFICATE-----
MIIEGTCCAwGgAwIBAgIJALUdz8P8q8UPMA0GCSqGSIb3DQEBCwUAMIGiMQswCQYD
VQQGEwJVUzERMA8GA1UECAwITmV3IFlvcmsxFjAUBgNVBAcMDU5ldyBZb3JrIENp

. . .

Tq7WJk77tk4nPI8iGv1WuK8xTAm5aOncxP16VoMpsDMV+GB1p3nBkMQ/GKF8pPXU
fn6BnDWKmeZqAlBM+MGYAfkbZWdBslrWasCJzs+tehTqL0LLJ6d3Gi9biBPb
-----END CERTIFICATE-----

Copiez le certificat affiché,including the lines marked BEGIN CERTIFICATE and END CERTIFICATE dans votre presse-papiers.

Sur la machine cliente, ouvrez un fichier du même nom dans le répertoire/etc/stunnel: 

sudo nano /etc/stunnel/redis-server.crt

Collez le contenu que vous avez copié à partir du serveur Redis. Enregistrez et fermez le fichier lorsque vous avez terminé.

Créer le fichier de configuration stunnel du client Redis

Maintenant que le client a une copie du certificat du serveur, nous pouvons configurer le côté client de la configuration destunnel.

Ouvrez un fichier se terminant par.conf dans le répertoire/etc/stunnel sur l'ordinateur client. Nous appellerons à nouveau le fichierredis.conf: 

sudo nano /etc/stunnel/redis.conf

À l'intérieur, spécifiez un fichier PID dans lequel le service stockera à nouveau son ID de processus:

/etc/stunnel/redis.conf

pid = /run/stunnel-redis.pid

Ensuite, ajoutez une section pour configurer le tunnel pour les données sortantes. Vous pouvez le nommer comme vous le souhaitez (nous l'appelleronsredis-client). La section sépare cette configuration de tous les autres tunnels que vous devrez peut-être configurer sur cette machine ultérieurement.

Nous devons marquer explicitement cette section comme une configuration client en utilisant la directiveclient. Définissez la directiveaccept pour écouter sur un port inutilisé sur l'interface locale pour gérer les connexions de votre client Redis local (nous utiliserons le port 8000 dans cet exemple). Définissez la directiveconnect sur l'adresse IP publique du serveur Redis et le port que nous avons ouvert.

Utilisez ensuiteCAfile pour pointer vers la copie du certificat du serveur Redis. Nous devons également mettreverify à 4, ce qui fait questunnel ne vérifie que le certificat sans égard à une chaîne de certificats (puisque nous avons auto-signé notre certificat):

/etc/stunnel/redis.conf

pid = /run/stunnel-redis.pid

[redis-client]
client = yes
accept = 127.0.0.1:8000
connect = remote_server_IP_address:6379
CAfile = /etc/stunnel/redis-server.crt
verify = 4

Enregistrez et fermez le fichier lorsque vous avez terminé.

Redémarrage du service client et test de la connexion

Redémarrez le servicestunnel sur le client pour implémenter les modifications: 

sudo systemctl restart stunnel4.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      3809/stunnel4
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      1714/sshd
tcp6       0      0 :::22                   :::*                    LISTEN      1714/sshd

Comme vous pouvez le voir,stunnel écoute sur le port local 8000 pour les connexions.

Maintenant, vous devriez 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 sommesunable pour communiquer avec le serveur Redis distant sans utiliser le tunnel, nous pouvons essayer de nous connecter directement au port distant: 

redis-cli -h redis_server_public_IP -p 6379 ping
Redis client outputError: Connection reset by peer

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.

  • Installez le logiciel client Redis et le packagestunnel sur le nouveau client

  • Permettre au logicielstunnel de démarrer au démarrage

  • Copiez le fichier de certificat du serveur dans le répertoire/etc/stunnel

  • Copiez le fichier de configuration client destunnelur le nouvel ordinateur client

  • Redémarrez le servicestunnel

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 package du serveur Redis etstunnel

  • Permettre au logicielstunnel de démarrer au démarrage

  • Générez un nouveau certificat et un fichier de clé pour le nouveau serveur Redis (utilisez un nom unique pour les fichiers)

  • Copiez chacun des fichiers de certificat d'un serveur à l'autre dans le répertoire/etc/stunnel

  • Modifiez ou créez le fichier de configuration destunnelur chaque serveur (y compris les serveurs existants) afin qu'il contienne:

    • Une section de serveur mappant un port externe sur le Redis local

    • Une section client 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).

Les fichiers de configuration destunnel pour les deux serveurs ressembleraient à ceci:

fichier de configuration stunnel pour la communication serveur à serveur 

pid = /run/stunnel-redis.pid

[redis-server]
cert = /etc/stunnel/this_servers_certificate.crt
key = /etc/stunnel/this_servers_key.key
accept = this_servers_public_IP:6379
connect = 127.0.0.1:6379

[redis-client]
client = yes
accept = 127.0.0.1:arbitrary_local_port
connect = remote_servers_public_IP:6379
CAfile = /etc/stunnel/remote_servers_certificate.crt
verify = 4

Si nécessaire, plusieurs sections de client peuvent être configurées sur chaque ordinateur pour mapper les ports locaux aux serveurs distants. Dans ces cas, veillez à choisir un port local inutilisé différent avec la directiveaccept pour chaque serveur distant.

Conclusion

Redis est un outil puissant et flexible, d’une valeur inestimable 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. Les autres options incluenttunneling with spiped ousetting up a VPN.

Related