Est-il possible de bloquer les utilisateurs de Tor?

le blocage de Tor est erroné car les utilisateurs (ab) et les adresses IP ne sont pas les mêmes. En bloquant Tor, vous bloquerez également les utilisateurs légitimes et les nœuds de sortie de Tor limités et inoffensifs configurés avec des politiques de sortie conservatrices.

par exemple, si vous craignez des attaques sur SSH (port 22), bloquer seulement Tor ne fera pas grand chose pour augmenter la sécurité. Ce dont vous avez vraiment besoin, c'est d'une liste noire synchronisée dynamique comme http://denyhosts.sourceforge.net/ qui traquent les contrevenants sans tenir compte de leur affiliation avec Tor.

Denyhosts bloquera automatiquement les noeuds de sortie Tor qui permettent à Tor d'accéder au port 22 sans interdire inutilement l'accès aux utilisateurs anonymes et aux opérateurs de noeuds de sortie Tor qui ne laissent jamais les contrevenants attaquer vos services SSH.

Le Projet Tor fournit en fait sa propre liste ici:

https://check.torproject.org/exit-addresses

.NET, il est possible et simple. Je l'ai implémenté sur mon site.

disons que votre site a une adresse IP externe de 192.168.0.5 pour l'argument. Adresse IP réelle au moment de l'affichage: 95.215.44.97

Imports System.Net
Imports System.Net.Sockets
Imports System.Web

Private Function IsTorExitNode(sIP As String) As Boolean

    ' Reverse your IP (97.44.215.95) then pass to the string, I have just created it as one for this example
    Try
        Dim strTor As String = "97.44.215.95.80.5.0.168.192.ip-port.exitlist.torproject.org"
        Dim host As IPHostEntry = Dns.GetHostEntry(strTor)

        If host.AddressList.Length = 0 Then
            Return False
        Else
            If host.AddressList(0).ToString() = "127.0.0.2" Then
                Return True
            Else
                Return False
            End If
        End If
    Catch ex As SocketException
        Return False
    End Try
End Function

Ventilation

adresse IP inversée: 97.44.215.95

Port: 80

adresse IP inversée: (votre adresse IP externe)

Si le address est un TorExitNode il retournera 127.0.0.2.

dans votre Global.fichier asax, vous pouvez utiliser L'Application_Start pour vérifier si L'adresse IP retourne true et ensuite les rediriger loin de votre site:

If IsTorExitNode("97.44.215.95") = True Then Response.Redirect("http://www.google.co.uk")

maintenant, dès qu'ils atteignent votre site ils sont redirigés loin de lui.

TOR a une liste de adresses IP, mais évidemment ils changent tout le temps donc utiliser ma fonction serait le meilleur moyen car c'est toujours en temps réel.

c'est un fait, que la meilleure défense d'application est son code et sa sécurité, Pas une liste de blocklist pare-feu. Si c'est un élément essentiel pour vous d'avoir les vrais utilisateurs, vous devez utiliser l'authentification à deux facteurs. Les Blocklists sont totalement inutiles de nos jours.

Ici (voir https://github.com/RD17/DeTor) est une API REST simple pour déterminer si une requête a été faite à partir du réseau TOR ou non.

La demande est: curl -X GET http://detor.ambar.cloud/.

La réponse est: { "sourceIp": "104.200.20.46", "destIp": "89.207.89.82", "destPort": "8080", "found": true }

en bonus, vous pouvez ajouter un badge à votre site pour détecter si un utilisateur vient de TOR ou pas:

<img src="http://detor.ambar.cloud/badge" />

j'ai trouvé une liste de tous les nœuds Tor mis à jour toutes les demi-heures: https://www.dan.me.uk/tornodes

cela devrait inclure la sortie, les entrées et les noeuds de pont utilisés pour se connecter et parcourir le Tor.

Utilisez ce script Perl pour recueillir les adresses IP à partir d'une page Web téléchargée:

perl -lne 'print $& if /(\d+\.){3}\d+/' downloadedwebpage.html > listofips.out

Il vous donnera une liste d'adresses IP , un par ligne. J'ai essayé de trouver quelque chose qui fera cela sans le script Perl, mais après beaucoup des heures de recherche je ne pouvais pas en trouver un.

j'espère que cette aide.

j'ai aussi trouvé quelques bonnes informations ici aussi, sur le même site: https://www.dan.me.uk/dnsbl

la détection du trafic Tor est assez facile. La principale façon de le faire est de surveiller l' sortie Tor de la liste des nœuds et comparez L'IP par rapport à la liste.

j'ai eu le besoin de faire une telle chose récemment et j'ai construit un petit joyau de rubis pour garder la liste des noeuds de sortie à jour et fournir un moyen simple pour détecter les noeuds de sortie. J'ai aussi écrit un petit exécutable que vous pouvez utiliser pour détecter les noeuds de sortie.

Le bijou est open source et peut être trouvé ici: tor-garde

installer la gemme est assez simple:

$ gem install tor-guard

utiliser la bibliothèque dans votre propre Ruby code peut être fait comme suit:

require 'tor-guard'

if TorGuard.exit_node?('108.56.199.13')
    puts "Yep, it's an exit node!"
end

L'exécutable est également facile à utiliser:

$ tg 108.56.199.13 && echo "Yep, it's an exit node"

function isTorExitNode() {
    $serverPort = $_SERVER['SERVER_PORT'];
    $remoteAddr = reverseIp(getClientIp());
    $serverAddr = reverseIp($_SERVER['SERVER_ADDR']);
    $placeholders = '%s.%s.%s.ip-port.exitlist.torproject.org';
    $name = sprintf($placeholders, $remoteAddr, $serverPort, $serverAddr);
    return ( gethostbyname($name) === '127.0.0.2' );
}

function getClientIp() {
    if (isset($_SERVER['HTTP_CF_CONNECTING_IP'])) {
        return $_SERVER['HTTP_CF_CONNECTING_IP'];
    }
    return $_SERVER['REMOTE_ADDR'];
}

function reverseIp($ip) {
    $ipParts = explode('.', $ip);
    return $ipParts[3] . '.' . $ipParts[2] . '.' .
            $ipParts[1] . '.' . $ipParts[0];
}

if(!isTorExitNode()) {
    // Do nothing
} else {
    Die("Sorry, You cannot use TOR network!!!");
}

C'est possible grâce à la publication par le projet tor d'une liste de mandataires de sortie.

la liste des procurations de sortie peut être téléchargée directement à partir du projet à https://check.torproject.org/exit-addresses dans l'espace délimité forme du texte.

j'ai écrit un script python pour ajouter des règles iptables pour tous les noeuds de sortie qui rejettent tous les paquets. Vous pouvez trouver le script sur github ici: https://github.com/vab/torblock

si la Projet Tor décide d'arrêter la publication d'une liste de nœuds de sortie, il sera possible de les bloquer. Le Code devrait simplement être écrit pour se connecter au réseau tor et découvrir les noeuds de sortie.

(ceci a été écrit pour une question spécifique à PHP qui a ensuite été supprimée et liée ici en tant que dupliqué).

Avertissement: tenir compte de l'impact de blocage de tous les utilisateurs de Tor comme on l'a soulevé dans la meilleure réponse ici. Considérez seulement les fonctions de blocage telles que l'enregistrement, le paiement, les commentaires etc et non un bloc général sur tout.

--

voici deux solutions PHP pures. Les premiers téléchargements et caches une liste de noeuds de Tor et compare L'IP visiteur contre liste. La seconde utilise la Tor DNS Exit List projet visant à déterminer si le visiteur utilise le Tor au moyen de recherches DNS.

Méthode n ° 1 (Vérification de la propriété intellectuelle à l'encontre d'un relais Tor liste):

en utilisant l'ensemble suivant de fonctions nous pouvons déterminer si une IP appartient au réseau Tor en la vérifiant par rapport à une dynamique liste qui est téléchargé et mis en cache pendant 10 minutes. N'hésitez pas à utiliser cette liste mais s'il vous plaît cache pendant 10 minutes lorsque possible.

où vous voulez appliquer la vérification de Tor, vous pouvez simplement utiliser:

$isTorUser = isTorUser($_SERVER['REMOTE_ADDR']);

if ($isTorUser) {
    // blocking action
}

voici le code que vous pouvez mettre dans un fichier de fonctions séparé et inclure lorsque vous voulez exécuter la vérification. Notez que vous voudrez peut-être en ajuster une partie pour changer le chemin du fichier cache.

<?php

function isTorUser($ip)
{
    $list = getTorExitList();

    if (arrayBinarySearch($ip, $list) !== false) {
        return true;
    } else {
        return false;
    }
}

function getTorExitList()
{
    $path = __DIR__ . '/tor-list.cache';

    if ( file_exists($path) && time() - filemtime($path) < 600 ) {
        $list = include $path;
        if ($list && is_array($list)) {
            return $list;
        }
    }

    $data = file('https://openinternet.io/tor/tor-node-list.txt');
    if (!$data) {
        return array();
    }

    $list = array();

    foreach($data as $line) {
        $line = trim($line);
        if ($line == '' || $line[0] == '#') continue;

        list($nick, $ip) = explode("\t", $line);
        $list[] = $ip;
    }

    sort($list);

    file_put_contents($path, sprintf("<?php return %s;", var_export($list, true)));

    return $list;
}

/**
 * Perform binary search of a sorted array.
 * Credit: http://php.net/manual/en/function.array-search.php#39115
 *
 * Tested by VigilanTor for accuracy and efficiency
 *
 * @param string $needle String to search for
 * @param array $haystack Array to search within
 * @return boolean|number false if not found, or index if found
 */
function arrayBinarySearch($needle, $haystack)
{
    $high = count($haystack);
    $low = 0;

    while ($high - $low > 1){
        $probe = ($high + $low) / 2;
        if ($haystack[$probe] < $needle){
            $low = $probe;
        } else{
            $high = $probe;
        }
    }

    if ($high == count($haystack) || $haystack[$high] != $needle) {
        return false;
    } else {
        return $high;
    }
}

Méthode n ° 2 (Vérification de la propriété intellectuelle contre la Tor DNS de Liste de Sortie de Projet):

la vérification de sortie DNS est un peu plus robuste en ce qu'elle prend en compte la sortie du relais politique et regarde à quelle IP et port sur votre serveur le client se connecte et si un tel trafic de sortie est autorisé, il retournera une correspondance. La chute potentielle est que si le projet DNS est en panne temporairement, les requêtes DNS peuvent être suspendues avant que le calendrier ne ralentisse les choses.

pour cet exemple, j'utiliserai une classe d'une bibliothèque que j'ai écrite et maintenue appelée TorUtils.

tout d'abord, vous aurez besoin de l'installer avec Composer en utilisant composer require dapphp/torutils et comprennent les standard vendor/autoloader.php code dans votre application.

le code pour Le vérifier: $ isTor = false;

try {
    // check for Tor using the remote (client IP), server IP, and server Port (e.g. 80, 443).
    $isTor = TorDNSEL::IpPort(
        $_SERVER['SERVER_ADDR'],
        $_SERVER['SERVER_PORT'],
        $_SERVER['REMOTE_ADDR']
    );
} catch (\Exception $ex) {
    // This would likely be a timeout, or possibly a malformed DNS response
    //echo $ex->getMessage() . "\n";
}

if ($isTor) {
    // blocking action
}

Autres Considérations

si votre application utilise des sessions PHP, je suggère fortement de mettre en cache la réponse" isTorUser " dans la session (avec L'IP source) et d'exécuter la vérification seulement au départ ou lorsque l'IP change (par exemple $_SERVER['REMOTE_ADDR'] != $_SESSION['last_remote_addr']) comme ne pas effectuer beaucoup de recherches dupliquées. Même s'ils essaient d'être très efficaces, c'est un gaspillage à refaire et au cours de la même adresse IP.