Tout ce qui est décrit dans l'article est implémenté comme un outil Toroxy disponible sur GitHub
Récemment, l'anonymat en ligne a fait l'objet de vifs débats. Ce n'est un secret pour personne que les données sur les visites des ressources Internet à partir d'un appareil local peuvent être collectées à différents niveaux afin de construire un «modèle» de l'utilisateur, qui pourra ensuite être utilisé contre lui (ou
pourrait ). Par conséquent, il n'est pas surprenant qu'un nombre croissant d'utilisateurs actifs d'Internet soient convaincus de la nécessité de mécanismes de proxy et d'anonymisation. À cet égard, il y a de plus en plus de nouveaux clients VPN, mais, comme le montre la pratique, tous ne peuvent pas vraiment faire confiance: soit tout ne fonctionne pas prêt à l'emploi, alors seul le trafic HTTP est anonymisé, puis la qualité de la mise en œuvre est boiteuse, ou et les développeurs pèchent en fusionnant les données sur leurs utilisateurs.
Dans cet article, nous allons essayer d'assembler notre propre outil avec une interface utilisateur à partir d'un certain nombre de composants logiciels, ce qui nous permettrait d'anonymiser complètement le trafic du système local et d'éviter les fuites sur les canaux «d'écoute» à n'importe quelle étape du travail.
Notre objectif principal sera de «construire» un utilitaire fiable à partir d'outils prêts à l'emploi. De toute évidence, l'idée de créer un outil de qualité à partir de zéro dans un délai raisonnable est semée d'erreurs, et il sera donc plus rapide et plus fiable de choisir des composants prêts à l'emploi, puis de les connecter correctement!
Que devrait faire un outil?
- Rediriger tout le trafic du système cible vers les nœuds intermédiaires (de préférence plusieurs) pour masquer de manière fiable la source
- Suivez les violations possibles de l'anonymat, corrigez-les et signalez-les à l'aide des notifications de l'interface utilisateur
Composants sélectionnés pour la création de l'outil:
- tor
- iptables
- python3
- systemd
En mélangeant tous les composants dans un shell appelé «Linux», nous pouvons certainement obtenir quelque chose de valable qui aidera à atteindre l'objectif final.
Composant # 1: Tor
C'est autour de cette composante que sera construit le reste de l'infrastructure d'outils. Tor fournit un mécanisme qui fait partie de tout client VPN - un mécanisme pour envelopper le trafic via des nœuds intermédiaires de manière anonyme pour un observateur externe (dans la configuration standard de ces nœuds 3).
Par défaut, le client Tor des référentiels par lots standard après l'installation commence à écouter le port 9050, qui accepte tout client pouvant se chausser. Le problème est qu'en plus du trafic de chaussettes dans notre système, il peut y avoir un tas d'autres trafics d'applications qui ne fonctionnent pas sur ce protocole. À cet égard, tout d'abord, au sein du système local, vous devrez couper une fenêtre dans le réseau Tor pour toute nouvelle connexion réseau. Cela se fait tout simplement en augmentant le
proxy transparent dans la configuration
torrc :
/etc/tor/torrc ... TransPort 9040 # python ControlPort 9051 ...
Une attention particulière doit être accordée au trafic UDP. Le fait est que le principe de routage de l'oignon est basé sur le concept de «flux», qui, comme vous le savez, n'existe que dans TCP. En envoyant un paquet UDP via Tor, le système cible ne pourra pas recevoir de réponse, car le paquet de réponse ne trouvera pas le chemin de retour. Mais malgré cette particularité, nous avons toujours la possibilité d'anonymiser les requêtes DNS, qui sont connues pour être effectuées sur UDP, et en même temps inclure la résolution .onion:
/etc/tor/torrc ... AutomapHostsOnResolve 1 DNSPort 53 ...
Sur cela, l'accès à Tor est ouvert dans le bouclage.
Composante # 2: Iptables
Puisque notre tâche est de cacher la véritable source de trafic à un observateur externe dans tout le système, et que la fenêtre de Tor est déjà ouverte, il ne reste plus qu'à envelopper tout le trafic dans cette fenêtre. Le pare-feu système fourni avec le noyau Linux nous aidera à cela:
# tcp iptables -t nat -A OUTPUT -p tcp --syn -j REDIRECT --to-ports $TRANS_PORT # udp (dns only) iptables -t nat -A OUTPUT -p udp --dport 53 -j REDIRECT --to-ports 53 iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT # iptables -A OUTPUT -j REJECT ip6tables -A OUTPUT -j REJECT
À ce stade, nous obtenons un utilitaire fonctionnel qui masque de manière fiable tout le trafic sortant, mais ce n'est que la moitié du travail.
Composant n ° 3: interface utilisateur python + Desktop Evironment
Chaque fois, la configuration manuelle à partir de la console (même si ce sera le lancement d'un script bash) sera assez fatigante, il est donc temps de commencer à écrire un petit utilitaire qui nous aide spécifiquement dans ce qui suit:
- Configuration automatique
- Modifiez votre identité au sein de Tor à tout moment
- Surveillance de l'intégrité des règles iptables et réécriture en cas de violation
- Suivi de votre identité actuelle (IP)
- Notification des deux paragraphes précédents avec notifications graphiques
Au premier démarrage, l'utilitaire téléchargera tous les
composants nécessaires par lui-même, et lors des lancements suivants, il configurera Tor en conjonction avec iptables, comme décrit ci-dessus.
Si vous souhaitez modifier votre adresse IP externe, vous interagirez avec le port de service Tor-9051, qui était ouvert au tout début pour automatiser le changement IP:
with Controller.from_port(port = 9051) as controller: controller.authenticate() controller.signal(Signal.NEWNYM)
Le suivi d'intégrité peut être implémenté de manière assez banale (nous le faisons à genoux) en lisant périodiquement la structure des règles iptables et en vérifiant leur somme SHA256:
def rulesOk(self): RULES_CHECKSUM_CMD = "{ iptables-save && ip6tables-save; } | sed s/\-\-uid\-owner\\\\s[0-9]\\\\+\\\\s//g | grep -viE '^#' | grep -viE '^\:' | sort | uniq | sha256sum | cut -d' ' -f 1" checkSum = getoutput(RULES_CHECKSUM_CMD).strip() alright = checkSum == Strings.RULES_CHECKSUM_CORRECT_HASH if not alright: rules = getoutput('iptables-save && ip6tables-save') self.lastSnapshotFileName = "/tmp/broken-rules-%s.log" % time.strftime("%d-%m-%Y_%I-%M-%S") open(self.lastSnapshotFileName, "w").write(rules) return False else: return True
En outre, s'il existe des incohérences avec la somme de contrôle attendue, vous pouvez enregistrer le vidage des règles iptables dans
/tmp/broken-rules-%d-%m-%Y_%I-%M-%S.log pour d'autres procédures. S'il s'avère que
rulesOk() == False
cela lancera une réécriture de la table des règles iptables.
La surveillance de l'adresse IP actuelle se fera en accédant en permanence à une ressource externe qui fournit le client IP - par exemple,
ident.me .
Enfin, nous utiliserons DE UI pour signaler des problèmes avec les règles ou le changement d'IP. Chaque environnement graphique est unique d'une manière ou d'une autre, en particulier lorsqu'il s'agit d'utiliser l'interface utilisateur du processus démon, mais sur la plupart des systèmes Linux, un tel code bash appelé à partir de Python affichera avec succès des notifications:
En combinant tout cela dans un script Python de 200 lignes, nous obtenons ce que nous avons accompli. Voici, par exemple, à quoi ressemblera une notification que notre identité a été mise à jour:
Et voici à quoi ressemblera la notification: l'intégrité des règles Iptables a été violée, indiquant le vidage contenant la violation:
Composant # 4: systemd
Et enfin, nous aimerions certainement faire une configuration unique et ne pas penser à notre sécurité à l'avenir, et donc l'exécution automatique et les services viennent à la rescousse. Linux possède plusieurs sous-systèmes de gestion de démons standard: systemd, sysV, init. Dans notre cas, le choix s'est porté sur systemd en raison de la flexibilité de sa configuration.
Supposons que le script python écrit à l'étape précédente s'appelle «toroxy» et se trouve dans
/usr/bin/ , puis son exécution automatique et sa surveillance ultérieure avec une certaine flexibilité pour contrôler le démon seront comme ceci:
[Unit] Description=Toroxy After=network.target StartLimitIntervalSec=0 [Service] Type=simple Restart=always RestartSec=1 User=root # service toroxy start ExecStart=/usr/bin/toroxy service # service toroxy stop ExecStop=/usr/bin/toroxy stop # service toroxy reload ExecReload=/usr/bin/toroxy switch [Install] # init 3, UI Tor WantedBy=multi-user.target
Presque tout est prêt pour un fonctionnement "industriel". La touche finale que je voudrais ajouter à l'outil pour plus de fiabilité est l'initialisation automatique des règles iptables au démarrage du système (comme vous le savez, les règles iptables sont réinitialisées lors du redémarrage) en utilisant iptables-persistent:
iptables-save > /etc/iptables/rules.v4 ip6tables-save > /etc/iptables/rules.v6 netfilter-persistent start && netfilter-persistent save
Conclusion
Nous avons donc assemblé notre propre outil à partir d'une combinaison de divers composants qui, avec un degré de fiabilité assez élevé, sont capables de fournir un anonymat continu de l'utilisateur Linux sur le réseau. En conclusion, il faut dire que tout ce qui est décrit dans l'article est implémenté comme un outil
Toroxy disponible sur GitHub.