ooniprobe - En ligne dans le Cloud

PROGRAMME:

Nom

ooniprobe - un outil de mesure de la censure du réseau.

SYNOPSIS

sonde [-hnsp] [--version] [--vomir] [-o fichier de rapport] [-i plate-forme d'essai] [-c collectionneur] [-b
videur] [-l fichier journal] [-O fichier pcap] [-f fichier de configuration] [-d répertoire de données] nom du test

DESCRIPTION

ooniprobe est un outil pour effectuer des mesures de censure sur Internet. Notre objectif est d'atteindre
un format de données commun et un ensemble de méthodologies pour mener des recherches liées à la censure.

OPTIONS

-h or --Aidez-moi
Affichez cette aide et quittez.

-n or --pas de collecteur
Désactivez la communication des résultats du test net à un collecteur d'oonib.

-s or --liste
Répertoriez tous les tests nets disponibles.

-p or --deck d'impression
Imprimer sur la sortie standard les options de ligne de commande spécifiées en tant que test de sonde unique
le pont.

-o or --fichier de rapport
Spécifiez le chemin d'accès au fichier de rapport à écrire.

-i or --testdeck
Spécifiez en entrée un test deck : un fichier yaml contenant les tests à exécuter et leurs
arguments.

-c or --collectionneur
Spécifiez l'adresse du collecteur des résultats des tests nets. Il est conseillé de toujours
spécifiez et videur et laissez-le retourner un collecteur pour le test ou le pont de test que vous êtes
exécution.

-b or --videur
Adresse du videur qui indiquera à la sonde quel collecteur utiliser et le
adresses des assistants de test. par défaut : httpo://nkvphnp3p6agi5qq.onion

-l or --fichier journal
Chemin d'accès au fichier journal à écrire

-O or --pcapfile
Préfixe du nom du fichier pcap.

-f or --fichier de configuration
Spécifiez un chemin d'accès au fichier de configuration ooniprobe.

-d or --répertoire de données
Spécifiez un chemin vers le répertoire de données ooniprobe

--vomir Imprimez un journal incroyablement détaillé de tout ce qui se passe. Utile lors du débogage
se bloque ou se verrouille dans un code complexe.

--version
Affichez la version de la sonde et quittez.

OONISONDE

Est l'outil que les volontaires et les chercheurs souhaitent fournir des données au projet
devrait être en cours d'exécution.

ooniprobe permet à l'utilisateur de sélectionner quel test doit être exécuté et quel backend doit être
utilisé pour stocker le rapport de test et/ou les assister dans le déroulement du test.

Les tests à sonde unique sont divisés en deux catégories : Traffic Manipulation et Contenu
Blocage.

Traffic Manipulation les tests visent à détecter la présence d'une sorte de falsification du
trafic Internet entre la sonde et un backend d'assistance de test à distance. En tant que tels, ils ont généralement
nécessitent la sélection d'un composant backend oonib pour exécuter le test.

Contenu Blocage visent à énumérer le type de contenu qui est bloqué de la
sonde le point de vue du réseau. En tant que tels, ils nécessitent généralement d'avoir spécifié une liste d'entrée
pour exécuter le test.

Menace Modèle
Notre adversaire est capable d'effectuer une surveillance de réseau à l'échelle du pays et de manipuler des
trafic réseau.

Les objectifs de notre adversaire sont :

· Restreindre l'accès à certains contenus, sans dégrader la qualité globale du
réseau

· Surveiller le réseau de manière à ce qu'ils soient en mesure d'identifier les abus en temps réel

Plus spécifique au déroulement des tests de détection de filtrage réseau :

1. Détecter les acteurs effectuant des tests de détection de censure

2. Tromper les personnes exécutant de tels tests en leur faisant croire que le réseau est illimité

Notez que tandis que 2) => 1) il n'est pas vrai que 1) => 2) comme l'identification de tels acteurs
ne doit pas nécessairement se produire en temps réel. Bien que notre intention soit de minimiser les
risque que les utilisateurs exécutant la sonde OONI soient identifiés, cela entraîne un compromis en termes de précision.
Il est donc nécessaire dans certains tests de troquer l'empreinte digitale en faveur de
teste la précision.

C'est pourquoi nous divisons les tests en fonction du risque auquel l'utilisateur qui l'exécute peut être confronté, ce qui permet au
l'utilisateur de choisir librement le modèle de menace auquel il souhaite adhérer.

Installation
Lire ceci. avant Running sondeur !

L'exécution d'une sonde est une activité potentiellement risquée. Cela dépend grandement de la
juridiction dans laquelle vous vous trouvez et quel test vous passez. c'est techniquement
possible pour une personne observant votre connexion Internet d'être consciente du fait que vous
exécutent ooniprobe. Cela signifie que si exécuter des tests de mesure de réseau est quelque chose
considéré comme illégal dans votre pays, vous pourriez être repéré.

De plus, ooniprobe ne prend aucune précaution pour protéger la machine cible de l'installation des
analyse médico-légale. Si le fait que vous ayez installé ou utilisé la sonde ooni est une responsabilité
pour vous, veuillez être conscient de ce risque.

Debian basé les systèmes
sudo sh -c 'écho "deb http://deb.ooni.nu/ooni sifflement principale" >> /etc/apt/sources.list'

gpg --serveur de clés pgp.mit.edu --recv-clé 0x49B8CDF4

gpg --exportation 89AB86D4788F3785FE9EDA31F9E2D9B049B8CDF4 | sudo clé apt ajouter -

sudo apt-get Mise à jour && sudo apt-get installer sonde

Linux
Nous pensons qu'ooniprobe fonctionne raisonnablement bien sur Debian GNU/Linux wheezy ainsi que
versions d'Ubuntu telles que natty et les versions ultérieures. Exécuter ooniprobe sans installer
il est pris en charge avec les commandes suivantes :

jet cloner https://git.torproject.org/ooni-probe.git

cd ooni-sonde

./setup-dependencies.sh

python configuration.py installer

Paramètres up développant sûr, heureux et sain
Sur les systèmes basés sur Debian, cela peut être fait avec :

Vsudo apt-get installer libgeoip-dev python-virtualenv enveloppe virtuelle

mkvirtualenv sonde

python configuration.py installer

pépin installer -r exigences-dev.txt

Autres plates-formes (avec Vagabond)
Installer Vagabond et Installer Virtualbox

On OS X :

Si vous ne l'avez pas installé homebrew

brasser installer jet

On debian/ubuntu :

sudo apt-get installer jet

1. Ouvrez un terminal et exécutez :

jet cloner https://git.torproject.org/ooni-probe.git

cd ooni-sonde/

vagabond up

2. Connectez-vous à la box avec :

vagabond ssh

ooniprobe sera installé dans /ooni.

3. Vous pouvez exécuter des tests avec :

sonde blocage/demandes_http -f /ooni/inputs/input-pack/alexa-top-1k.txt

En utilisant sonde
Net tester est un ensemble de mesures permettant d'évaluer le type de censure sur Internet.

Planches sont des collections de réseaux à sonde unique avec quelques entrées associées.

Collector est un service utilisé pour rapporter les résultats des mesures.

Le test assistant est un service utilisé par une sonde pour effectuer avec succès ses mesures.

Videur est un service utilisé pour découvrir les adresses des assistants de test et des collectionneurs.

Configuration sonde
Vous pouvez éditer la configuration pour ooniprobe en éditant le fichier de configuration trouvé
l'intérieur de ~/.ooni/ooniprobe.conf.

Par défaut, ooniprobe n'inclura pas d'informations d'identification personnelle dans le résultat du test,
ni créer un fichier pcap. Ce comportement peut être personnalisé.

Fonctionnement ponts
Vous trouverez tous les decks installés à l'intérieur de /usr/share/ooni/decks.

Vous pouvez ensuite exécuter un deck en utilisant l'option de ligne de commande -i:

En tant que root:

sonde -i /usr/share/ooni/decks/mlab.deck

Ou en tant qu'utilisateur :

sonde -i /usr/share/ooni/decks/mlab_no_root.deck

Ou:

En tant que root:

sonde -i /usr/share/ooni/decks/complete.deck

Ou en tant qu'utilisateur :

sonde -i /usr/share/ooni/decks/complete_no_root.deck

Les tests ci-dessus nécessiteront environ 20 à 30 minutes selon votre réseau
la vitesse.

Si vous préférez exécuter des tests plus rapides, vous devez exécuter : En tant que root :

sonde -i /usr/share/ooni/decks/fast.deck

Ou en tant qu'utilisateur :

sonde -i /usr/share/ooni/decks/fast_no_root.deck

Fonctionnement net tests
Vous pouvez lister tous les tests nets stables installés avec :

sonde -s

Vous pouvez alors lancer un netst en spécifiant son nom par exemple :

sonde manipulation/http_header_field_manipulation

Il est également possible de spécifier les entrées des tests sous forme d'URL :

sonde blocage/demandes_http -f http://ihiderha53f36lsd.onion/input/
37e60e13536f6afe47a830bfb6b371b5cf65da66d7ad65137344679b24fdccd1

Vous pouvez trouver le résultat du test dans votre répertoire de travail actuel.

Par défaut, le résultat du rapport sera collecté par le collecteur ooni par défaut et le
les adresses des assistants de test seront obtenues à partir du videur par défaut.

Vous pouvez également spécifier votre propre collecteur ou videur avec les options -c et -b.

(Facultatif) Installer obfsproxy
Installez la dernière version d'obfsproxy pour votre plate-forme.

Télécharger Obfsproxy

Ponts et obfsproxy ponts
ooniprobe soumet des rapports aux collecteurs de rapports oonib via Tor à un service caché
point final. Par défaut, ooniprobe utilise le système installé Tor, mais peut également être configuré
pour lancer Tor (voir l'option advanced.start_tor dans ooniprobe.conf), et ooniprobe
prend en charge les ponts (et les ponts obfsproxy, si obfsproxy est installé). Les ponts.tor.
L'option dans ooniprobe.conf définit le chemin d'accès à un fichier qui doit contenir un ensemble de "bridge"
lignes (du même format que celui utilisé dans torrc, et tel que renvoyé par
https://bridges.torproject.org). Si des ponts obfsproxy doivent être utilisés, le chemin d'accès au
Le binaire obfsproxy doit être configuré. Voir l'option advanced.obfsproxy_binary, dans
ooniprobe.conf.

Paramètres capacités on votre virtualenv python binaire
Si votre distribution prend en charge les fonctionnalités, vous pouvez éviter d'avoir à exécuter OONI en tant que root :

setcap cap_net_admin, cap_net_raw+eip /chemin/vers/votre/python/de/virtualenv

Core sonde Tests
La source pour Contenu blocage tests et Traffic Manipulation tests peut être trouvée dans le
répertoires netsts/blocking et netsts/manipulation respectivement.

Contenu Blocage Tests
· Cohérence DNS

· HTTP Demandes

· TCP Connectez

Traffic Manipulation Tests
· HTTP Invalide Demande Ligne:

· DNS Parodie

· HTTP En-tête Champ Manipulation

· Traceroute

· HTTP Hôte

Autres tests
Nous avons également d'autres tests qui ne sont actuellement pas entièrement pris en charge ou qui sont toujours en cours
expérimenté.

Vous pouvez les trouver dans :

· ooni/nettes/expérimental

Les tests qui ne font pas de mesure mais sont utiles pour la numérisation peuvent être trouvés dans :

· ooni/nettes/scanner

Les tests qui impliquent l'exécution d'outils tiers peuvent être trouvés dans :

· ooni/nettes/tiers_partie

Rapports
Les rapports collectés par ooniprobe sont stockés sur https://ooni.torproject.org/reports/0.1/
CC /

Où CC est le code de pays à deux lettres tel que spécifié par ISO 31666-2.

Par exemple les rapports pour l'Italie (CC is it) du peut être trouvé dans:

https://ooni.torproject.org/reports/0.1/IT/

Ce répertoire doit contenir les différents rapports d'essai utilisant les
convention:

nom du test - dateDansISO8601Format - sondeASNumber .yamloo

La date est exprimée en utilisant ISO 8601 secondes incluses et sans : délimiter les heures,
minutes, jours.

Ainsi:

ANNÉE - MOIS - JOURNÉE T HEURES MINUTES SECONDS Z

Style ici pour le up à données liste of ISO 8601 Pays codes

Le temps est toujours exprimé en UTC.

Si une collision est détectée, un int (commençant par 1) sera ajouté au test.

Par exemple, si deux rapports sont créés le premier janvier 2012 à midi (heure UTC)
sharp du MIT (AS3) sera stocké ici :

https://ooni.torproject.org/reports/0.1/US/2012-01-01T120000Z_AS3.yamloo
https://ooni.torproject.org/reports/0.1/US/2012-01-01T120000Z_AS3.1.yamloo

Remarque : il est très peu probable que des rapports soient créés avec le même horodatage exact à partir de
exactement la même ASN. Si cela se produit, cela pourrait être l'index d'un rapport malveillant
attaque d'empoisonnement en cours.

Signaler le format version changelog
Vous trouverez ici des détails sur les principaux changements apportés au format de rapport.

version 0.1
Version format initial.

Écriture OONI tests
L'API de test OONI est fortement influencée et partiellement basée sur le python Test de l'unité
module et procès.tordu.

Le test Exemples of témoignage
L'atome du test OONI est appelé un cas de test. Une classe de cas de test peut contenir plusieurs
Méthodes d'essai.

classe ooni.nettest.NetTestCase
C'est la base de l'univers netst OONI. Lorsque vous écrivez un netst, vous
sous-classe cet objet.

· entrées : peut être réglé sur un ensemble statique d'entrées. Tous les tests (les méthodes commençant
avec le préfixe "test") sera exécuté une fois par entrée. A chaque exécution le _input_
l'attribut de l'instance TestCase sera défini sur la valeur de l'actuel
itération sur les entrées. Tout objet python itérable peut être défini sur des entrées.

· inputFile : l'attribut doit être défini sur un tableau contenant la ligne de commande
argument qui doit être utilisé comme fichier d'entrée. Un tel tableau ressemble à ceci :
["ligne de commande", "c", "défaut valeur" "La la description"]

La deuxième valeur de ce tableau est le raccourci de la ligne de commande arg. Les
l'utilisateur pourra alors spécifier les entrées du test via :
sonde montest.py --ligne de commande chemin/vers/fichier.txt

or
sonde montest.py -c chemin/vers/fichier.txt

· inputProcessor : doit être défini sur une fonction qui prend comme argument un nom de fichier et
il renverra l'entrée à transmettre à l'instance de test.

· name : doit être défini sur le nom du test.

· auteur : doit contenir le nom et les coordonnées de l'auteur du test. Les
le format d'une telle chaîne est le suivant :
Le Nom <email@example.com>

· version : est la chaîne de version du test.

· requireRoot : défini sur True si le test doit être exécuté en tant que root.

· usageOptions : une sous-classe de twisted.python.usage.Options pour le traitement de
arguments de ligne de commande

· localOptions : contient les arguments de ligne de commande analysés.

Bizarreries : chaque classe préfixée par test doit retourner un
twisted.internet.defer.Defer.

Si le test que vous prévoyez d'écrire n'est pas répertorié sur le Tor OONI trac page, tu devrais l'ajouter
à la liste, puis ajoutez une description à ce sujet en suivant les Le test Modèle

Les tests sont pilotés par les entrées. Pour chaque entrée, une nouvelle instance de test est créée, en interne le
La méthode _setUp est appelée qui est définie à l'intérieur des modèles de test, puis la méthode setUp
qui est réinscriptible par les utilisateurs.

Les pièges : jamais appelez réacteur.début de réacteur.arrêt à l'intérieur de votre méthode de test et tout
sois sage.

Contributions
Les entrées sont ce qui est donné comme entrée à chaque itération du scénario de test. Si vous avez 100
entrées, alors chaque cas de test sera exécuté 100 fois.

Pour configurer un ensemble statique d'entrées, vous devez définir le ooni.nettest.NetTestCase
attribuer entrées. Le test sera exécuté len(entrées) fois. Tout objet itérable est un objet valide
entrées attribuer.

Si vous souhaitez que les entrées soient déterminées à partir d'un fichier d'entrée spécifié par l'utilisateur, vous
doit définir le fichier d'entrée attribut. Ceci est un tableau qui spécifie quelle option de ligne de commande
peut être utilisé pour contrôler cette valeur.

Par défaut, le Processeur d'entrée est configuré pour lire le fichier ligne par ligne et supprimer les retours à la ligne
personnages. Pour modifier ce comportement, vous devez définir le Processeur d'entrée attribuer à un
fonction qui prend en argument un descripteur de fichier et renvoie l'élément suivant. Le défaut
Processeur d'entrée ressemble à ça:

def lineByLine(nom de fichier):
fp = ouvrir (nom de fichier)
pour x dans fp.xreadlines() :
rendement x.strip()
fp.close()

installation et commander en ligne en passant
Les tests peuvent définir le installer méthode qui sera appelée à chaque fois que l'objet Test Case est
instancié, ici vous pouvez placer une logique commune à toutes vos méthodes de test qui devraient
être exécuté avant tout test.

Les arguments de la ligne de commande peuvent être analysés grâce au twisted
twisted.python.usage.UsageOptions classe.

Vous devrez le sous-classer et définir l'attribut NetTestCase usageOptions pour pointer
à une sous-classe de celui-ci.

classe UsageOptions(usage.Options) :
optParameters = [['backend', 'b', 'http://127.0.0.1:57001',
'URL du backend de test à utiliser']
]

classe MyTestCase(nettest.NetTestCase):
utilisationOptions = UtilisationOptions

inputFile = ['fichier', 'f', Aucun, "Un fichier foo"]
optionsrequises = ['backend']

def test_my_test(soi) :
self.localOptions['backend']

Vous pourrez alors accéder aux arguments de ligne de commande analysés via l'attribut class
options locales.

Le optionsrequises attributs spécifie un tableau de paramètres requis pour le
test pour fonctionner correctement.

fichier d'entrée est un attribut de classe spécial qui sera utilisé pour le traitement du fichier inputFile.
Le nom de fichier lu ici sera attribué au
ooni.nettest.NetTestCase.inputProcessor méthode qui donnera, par défaut, une ligne de
le fichier à la fois.

Le test Méthodologie
Ceux-ci doivent être définis à l'intérieur de votre ooni.nettest.NetTestCase sous-classe. Ceux-ci seront
méthodes de classe.

Toutes les méthodes de classe préfixées par test_ doivent être exécutées. Des fonctions pertinentes
à votre test doit être tout en minuscules séparés par un trait de soulignement.

Pour ajouter des données au rapport de test, vous pouvez écrire directement dans l'objet de rapport comme suit :

def test_my_function() :
résultat = faire_quelquechose()
self.report['quelque chose'] = résultat

OONI s'occupera ensuite de l'écriture des données dans le rapport de test final.

Pour accéder à l'entrée actuelle, vous pouvez utiliser le contribution attribut, par exemple :

def test_with_input() :
faire_quelque chose_with_input(self.input)

Cela fera à chaque itération sur la liste des entrées quelque chose avec l'entrée.

Le test Gabarits
Les modèles de test vous aident à rédiger des tests. Ils contiennent déjà tous les
fonctionnalité utile pour exécuter un test de ce type. Ils s'occupent également de
écrire les données qu'ils collectent et qui sont pertinentes pour l'exécution du test dans le fichier de rapport.

Les modèles de test actuellement implémentés sont ooni.templates.scapyt pour les tests basés sur Scapy,
ooni.templates.tcpt pour les tests basés sur TCP, ooni.templates.httpt pour les tests basés sur HTTP,
et ooni.templates.dnst pour les tests basés sur DNS.

scapey basé tests
Les tests basés sur Scapy seront une sous-classe de ooni.templates.scapyt.BaseScapyTest.

Il fournit un wrapper autour de la fonction d'envoi et de réception scapy qui écrira le message envoyé
et les paquets reçus au rapport avec la désinfection du src et de l'IP de destination
Adresses.

Elle a la même syntaxe que la fonction Scapy sr, sauf qu'elle renverra un différé.

Pour implémenter un simple ping ICMP basé sur cette fonction, vous pouvez faire comme ceci (Tiré de
netst.examples.example_scapyt.ExampleICMPPingScapy)

à partir de l'utilisation de l'importation twisted.python

de scapy.all importer IP, ICMP

de ooni.templates importer scapyt

classe UsageOptions(usage.Options) :
optParameters = [['target', 't', '127.0.0.1', "Specify the target to ping"]]

classe ExempleICMPPingScapy(scapyt.BaseScapyTest):
name = "Exemple de test de ping ICMP"

utilisationOptions = UtilisationOptions

def test_icmp_ping(self):
def fini (paquets):
imprimer des paquets
répondu, sans réponse = paquets
pour snd, rcv dans répondu :
rcv.show()

paquets = IP(dst=self.localOptions['target'])/ICMP()
d = self.sr(paquets)
d.addCallback (terminé)
retour d

Les arguments pris par self.sr() sont exactement les mêmes que les scapy send et receive
fonction, la seule différence est qu'au lieu d'utiliser le super socket scapy ordinaire, il
utilise notre emballage entraîné torsadé autour d'elle.

Alternativement, ce test peut également être écrit en utilisant le twisted.defer.inlineCallbacks()
décorateur, cela le fait ressembler davantage au code séquentiel régulier.

à partir de l'utilisation de l'importation twisted.python
de twisted.internet import différer

de scapy.all importer IP, ICMP

de ooni.templates importer scapyt

classe UsageOptions(usage.Options) :
optParameters = [['target', 't', '127.0.0.1', "Specify the target to ping"]]

classe ExempleICMPPingScapyYield(scapyt.BaseScapyTest):
name = "Exemple de test de ping ICMP"

utilisationOptions = UtilisationOptions

@defer.inlineCallbacks
def test_icmp_ping(self):
paquets = IP(dst=self.localOptions['target'])/ICMP()
répondu, sans réponse = rendement self.sr (paquets)
pour snd, rcv dans répondu :
rcv.show()

Signaler Format
########################################
# Rapport de sonde OONI pour un exemple de test ICMP Ping Test
# jeu. 22 novembre 18:20:43 2012
########################################
---
{probe_asn : null, probe_cc : null, probe_ip : 127.0.0.1, software_name : ooniprobe, software_version : 0.0.7.1-alpha,
start_time : 1353601243.0, test_name : exemple de test ICMP Ping, test_version : 0.1}

---
entrée: null
rapport:
answer_flags : [ipsrc]
paquets_répondus :
- - raw_packet : !!binaire |
RQAAHAEdAAAuAbjKCAgICH8AAAEAAAAAAAAAAA==
résumé : IP / ICMP 8.8.8.8 > 127.0.0.1 écho-réponse 0
envoyés_paquets :
- - raw_packet : !!binaire |
RQAAHAABAABAAevPfwAAAQgICAgIAPf/AAAAAA==
résumé : IP / ICMP 127.0.0.1 > 8.8.8.8 écho-requête 0
nom_test : test_icmp_ping
test_started : 1353604843.553605


TCP basé tests
Les tests basés sur TCP sous-classeront ooni.templates.tcpt.TCPTest.

Ce modèle de test facilite l'envoi de charges utiles TCP au fil et l'enregistrement des
réponse.

de twisted.internet.error importer ConnectionRefusedError
à partir du journal d'importation ooni.utils
de ooni.templates importer tcpt

classe ExempleTCPT(tcpt.TCPTest):
def test_hello_world(self):
def got_response (réponse):
print « J'ai ces données %s » % réponse

def connection_failed (échec):
fail.trap (ConnectionRefusedError)
imprimer "Connexion refusée"

self.address = "127.0.0.1"
auto.port = 57002
payload = "Bonjour tout le monde !\n\r"
d = self.sendPayload(charge utile)
d.addErrback(connexion_failed)
d.addCallback(got_response)
retour d

Les échecs possibles pour une connexion TCP sont :

twisted.internet.error.NoRouteError qui correspond à errno.ENETUNREACH

twisted.internet.error.ConnectionRefusedError qui correspond à errno.ECONNREFUSED

twisted.internet.error.TCPTimedOutError qui correspond à errno.ETIMEDOUT

Signaler le format
Le rapport de base d'un test TCP ressemble à ce qui suit (il s'agit d'un rapport généré par
l'exécution de l'exemple ci-dessus sur un serveur d'écho TCP).

########################################
# Rapport de sonde OONI pour le test de test TCP de base
# jeu. 22 novembre 18:18:28 2012
########################################
---
{probe_asn : null, probe_cc : null, probe_ip : 127.0.0.1, software_name : ooniprobe, software_version : 0.0.7.1-alpha,
start_time : 1353601108.0, test_name : test TCP de base, test_version : '0.1'}

---
entrée: null
rapport:
les erreurs: []
reçu : ["Bonjour tout le monde !\n\r"]
envoyé : ["Bonjour tout le monde !\n\r"]
test_name : test_hello_world
test_started : 1353604708.705081


TODO terminer ceci avec plus de détails

HTTP basé tests
Les tests basés sur HTTP seront une sous-classe de ooni.templates.httpt.HTTPTest.

Il propose des méthodes ooni.templates.httpt.HTTPTest.processResponseBody() et
ooni.templates.httpt.HTTPTest.processResponseHeaders() pour interagir avec la réponse
corps et en-têtes respectivement.

Par exemple, pour implémenter un test HTTP qui renvoie le hachage sha256 du corps de la réponse
(basé sur netsts.examples.example_httpt):

à partir du journal d'importation ooni.utils
depuis ooni.templates importer httpt
de hashlib importer sha256

classe SHA256HTTPBodyTest(httpt.HTTPTest) :
name = "ChecksumHTTPBodyTest"
auteur = "Aaron Gibson"
version = 0.1

inputFile = ['fichier URL', 'f', Aucun,
'Liste des URL vers lesquelles effectuer les requêtes GET']
requiredOptions = ['fichier URL']

def test_http(soi) :
si self.input :
url = self.input
retourner self.doRequest(url)
autre:
raise Exception("Aucune entrée spécifiée")

def processResponseBody (soi, corps) :
body_sha256sum = sha256(corps).hexdigest()
self.report['checksum'] = body_sha256sum

Signaler le format
########################################
# Rapport de sonde OONI pour le test ChecksumHTTPBodyTest
# jeu. 6 déc. 17:31:57 2012
########################################
---
options:
collecteur : nul
aide : 0
fichier journal : null
pcapfile : null
fichier de rapport : null
reprendre : 0
sous-arguments : [-f, hôtes]
test : netsts/examples/example_http_checksum.py
probe_asn : null
probe_cc : null
ip_sonde : 127.0.0.1
nom_logiciel : ooniprobe
version_du_logiciel : 0.0.7.1-alpha
heure_départ : 1354786317.0
test_name : Somme de contrôleHTTPBodyTest
version_test : 0.1

---
contribution: http://www.google.com
rapport:
mandataire : mandataire
checksum: d630fa2efd547d3656e349e96ff7af5496889dad959e8e29212af1ff843e7aa1
demandes :
- demander:
corps : nul
en-têtes:
- - Agent utilisateur
- - [Opera/9.00 (Windows NT 5.1; U; en), 'Opera 9.0, Windows XP']
méthode : GET
url: http://www.google.com
réponse:
corps: ' '
code: 200
en-têtes:
- - Protection X-XSS
- [1; mode=bloc]
- - Set-Cookie
- ['PREF=ID=fada4216eb3684f9:FF=0:TM=1354800717:LM=1354800717:S=IT-2GCkNAocyXlVa;
expires=Sat, 06-Dec-2014 13:31:57 GMT; path=/; domain=.google.com', 'NID=66=KWaLbNQumuGuYf0HrWlGm54u9l-DKJwhFCMQXfhQPZM-qniRhmF6QRGXUKXb_8CIUuCOHnyoC5oAX5jWNrsfk-LLJLW530UiMp6hemTtDMh_e6GSiEB4GR3yOP_E0TCN;
expire=Ven, 07-Juin-2013 13:31:57 GMT ; chemin=/; domaine=.google.com ; HttpOnly']
- - Expire
- ['-1']
- - Serveur
- [gw]
- - Lien
- [proche]
- - Cache-Contrôle
- ['privé, âge-max=0']
- - Date
- ['Jeu, 06 Déc 2012 13:31:57 GMT']
- -P3P
- ['CP="Ce n'est pas une politique P3P ! Voir http://www.google.com/support/accounts/bin/answer.py?hl=fr&answer=151657
pour plus d'informations."']
- - Type de contenu
- [texte/html ; jeu de caractères=UTF-8]
- - Options X-Frame
- [MÊME ORIGINE]
chaussettes proxy : null
test_name : test_http
test_runtime : 0.08298492431640625
test_started : 1354800717.478403


DNS basé tests
Les tests basés sur DNS seront une sous-classe de ooni.templates.dnst.DNSTest.

Il propose des méthodes ooni.templates.dnst.DNSTest.performPTRLookup() et
ooni.templates.dnst.DNSTest.performALookup()

Par exemple (tiré de netsts.examples.example_dnst):

depuis ooni.templates.dnst importer DNSTest

classe ExempleDNSTest(DNSTest):
def test_a_lookup(soi) :
def gotResult(résultat) :
# Le résultat est un tableau contenant tous les résultats de recherche d'enregistrement A
résultat d'impression

d = self.performALookup('torproject.org', ('8.8.8.8', 53))
d.addCallback(gotResult)
retour d

Signaler le format
########################################
# Rapport de sonde OONI pour le test de test DNS de base
# jeu. 6 déc. 17:42:51 2012
########################################
---
options:
collecteur : nul
aide : 0
fichier journal : null
pcapfile : null
fichier de rapport : null
reprendre : 0
sous-arguments : []
test : netsts/examples/example_dnst.py
probe_asn : null
probe_cc : null
ip_sonde : 127.0.0.1
nom_logiciel : ooniprobe
version_du_logiciel : 0.0.7.1-alpha
heure_départ : 1354786971.0
test_name : test DNS de base
version_test : 0.1

---
entrée: null
rapport:
requêtes :
- adresses : [82.195.75.101, 86.59.30.40, 38.229.72.14, 38.229.72.16]
réponses:
- [ ,
ttl=782>]
- [ ,
ttl=782>]
- [ ,
ttl=782>]
- [ ,
ttl=782>]
requête : '[Requête(''torproject.org'', 1, 1)]'
type_requête : A
résolveur : [8.8.8.8, 53]
test_name : test_a_lookup
test_runtime : 0.028924942016601562
test_started : 1354801371.980114


Pour un exemple plus complexe, voir : netsts.blocking.dnsconsistency

GLOSSAIRE

Ici, nous allons résumer une partie du jargon qui est unique à OONI.

Le test Témoignage client: un ensemble de mesures effectuées sur un réseau à tester qui sont logiquement
mis ensemble

Signaler: est la sortie d'un test contenant toutes les informations nécessaires à un
chercheur pour évaluer le résultat d'un test.

Yamlooni: Le format que nous utilisons pour les rapports, qui est basé sur YAML.

Entrée: Ce qui est donné en entrée à un TestCase pour effectuer une mesure.

Utilisez ooniprobe en ligne en utilisant les services onworks.net