[Script] Scan de réseau [Résolu]

[BUENOO]

Bonjour à tous,

Je rencontres un petit soucis dans le cadre d'un script.

Celui ci à pour but de scanner une plage d'adresses IP afin de retourner le nom de domaine correspondant grace à un socket.gethostbyaddr(ip).

J'ai donc une variable de type liste 'list' (list = [192.9.202.1, 192.9.202.2, ...] avec toutes les IP, voici comment je fonctionnes (j'utilise le threading pour que les requêtes soit effectué simultanément) :

Code :

1
2
3
4
5
6
7
8
9
10
11
 
for x in list:
    t=threading.Thread(target=scan, args=(x,))
    t.start
 
def scan(ip):
    try:
        name,alias,addresslist = socket.gethostbyaddr(ip)
        final = final.append(ip + ' <-> ' + name)
    except socket.herror:
        final = final.append(ip + ' <->  Aucune reponse')

Je me retrouves donc avec une liste 'final' contenant les résultats des requêtes. Après sa, je créé un document excel qui liste tout sa ... Mon problème vient ici, car les ip ne sont pas en ordre croissant ...

Comment est il possible d'enregistrer les résultats, tout en liant l'ip + name et de pouvoir réorganiser sa avec les adressis ip par ordre croissant ? Dictionnaire ? Tuple ? N'ayant pas trop utilisé ceux ci je vous avou être en difficulté ...

[tyrtamos]

Bonjour,

Donne un exemple de la liste 'avant', et le résultat que tu souhaites 'après'.

[Sve@r]

Envoyé par BUENOO

Comment est il possible d'enregistrer les résultats, tout en liant l'ip + name et de pouvoir réorganiser sa avec les adressis ip par ordre croissant ? Dictionnaire ? Tuple ? N'ayant pas trop utilisé ceux ci je vous avou être en difficulté ...

Salut
Moi je passerais par un dictionnaire de type "ip" => "name".
Exemple

Code python :

1
2
3
4
5
final={
    "127.0.0.1" : "localhost",
    "158.55.42.123" : "www.truc.com",
    "222.41.77.30" : "www.chose.com",
}

Ensuite, en utilisant sorted(final.keys(), fct) ça te donnerait les IP par ordre croissant (à toi de programmer la fonction "fct" pour que sorted connaisse ta façon de comparer 2 IP) ce qui amènerait automatiquement les noms associés...
Exemple

Code python :

1
2
3
4
5
6
7
8
9
def fct(ip1, ip2):
    if ip1 < ip2: return -1
    if ip1 > ip2: return 1
    return 0
    # Bien entendu à toi d'écrire le vrai code permettant de comparer 2 IP
# fct()
 
for k in sorted(final.keys(), fct):
    print "ip:[%s] => [%s]" % (k, final[k])

[pfeuh]

Salut,

pour trier de l' ip, le plus simple est de s'arranger pour le faire en mode texte, mais en formatant les ips. Par exemple trier '127.0.0.1' et '127.255.0.0' ne donnera pas forcément le même résultat que trier '127000000001' et '127255000000'. En python on a hérité du printf du C, le "f" de printf signifiant format.

Code :

1
2
text = "%03u%03u%03u%03u"%(127, 0, 0, 1)
print text

Il y a également une méthode split qui se révèle très utile:

Code :

1
2
words = '127.0.0.1'.split('.')
print words

Avec ça, tu devrais t'en sortir

A+

Pfeuh

[BUENOO]

Bonjour,

Merci pour vos réponses.

Alors voilà comment ma liste est construite :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#Recuperation des donnees (ip debut et ip fin)
debut = raw_input('Ip du debut de la plage a scanner : \n')
fin = raw_input('Ip de la fin de la plage a scanner : \n')
 
#Separation des ip par les points 192.9.200.1 = '192', '9', '200', '1'
d_split = debut.split('.')
f_split = fin.split('.')
 
#Creation d'une ip de base 192.9.200
base = '.'.join(d_split[0:3])
 
#Creation list vide pour reception des ip a scanner
list = []
i = int(d_split[3])
 
#Listing et ajout des ip a scanner dans list
while i <= int(f_split[3]):
			list.append(str(base) + '.' + str(i))
			i += 1

Sa me donne donc par exemple : list = ['192.9.202.1','192.9.202.2','192.9.202.3','192.9.202.4',.....]

La solution de Svear est ce que je recherches je penses. Le but étant simplement de pouvoir réorganiser les IP une fois qu'un nom lui à été attribué par la requête.
Par exemple pour réorganiser une liste comme celle ci :

Code :

1
2
3
4
5
6
7
 
final= {
    "192.9.202.15" : "Toto.domaine",
    "192.9.202.11" : "Stagiaire.domaine",
    "192.9.202.8" : "Thomas.domaine",
    "192.9.202.5" : "Benjamin.domaine",
}

De sorte que sa donne :

Code :

1
2
3
4
5
6
7
 
final = {
    "192.9.202.5" : "Benjamin.domaine",
    "192.9.202.8" : "Thomas.domaine",
    "192.9.202.11" : "Stagiaire.domaine",
    "192.9.202.15" : "Toto.domaine",
}

Je vais regarder sa cette après midi dès que j'ai le temps et je me retournes vers vous pour vous tenir informer.

Merci bien.

[wiztricks]

Pour info.

Python 3.3 vient avec le module "ipaddress" - ce module doit pouvoir être installé sur des versions antérieures. Il contient des tas de fonctions pour convertir des adresses IPv4 et v6 dans tous les sens.

Si vous voulez convertir des adresses IP en entiers (et les ranger par ordre croissants par exemple) :

Code :

1
2
>>> int(ipaddress.IPv4Address('192.168.1.0'))
3232235776

Réciproquement,

Code :

1
2
>>> ipaddress.IPv4Address(3232235776)
IPv4Address('192.168.1.0')

D'un autre côté, une plage d'adresse IP est généralement associé à un s/réseau "192.168.1.0/24" et les numéros 1.255 sont des numéros de host dans ce s/réseau.
=> ranger par s/réseau puis par numéro de "host" est une autre façon de faire.

- W

[tyrtamos]

Bonjour,

Intéressant, merci wiztricks.

Il s'agit en fait de convertir en décimal un nombre écrit en base 256, et vice versa:

Code :

1
2
3
x1, x2, x3, x4 = 192, 168, 1, 0
print x4 + x3*256 + x2*256**2 + x1*256**3
3232235776

Code :

1
2
3
4
5
6
7
x = 3232235776
x, x4 = divmod(x, 256)
x, x3 = divmod(x, 256)
x, x2 = divmod(x, 256)
x1 = x
print x1, x2, x3, x4
192 168 1 0

[wiztricks]

Salut,

Envoyé par tyrtamos

Il s'agit en fait de convertir en décimal un nombre écrit en base 256, et vice versa:

C'est une représentation commode.
Mais en exprimant les s/réseau, on y perd vite son latin.
En fait, le module inclus la comparaison d'adresses et ces objets sont hashables.

On peut donc écrire:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
>>> net = ipaddress.ip_network('192.168.1.0/29')
>>> for z in net: 
...         print(z)
...
192.168.1.0
192.168.1.1
192.168.1.2
192.168.1.3
192.168.1.4
192.168.1.5
192.168.1.6
192.168.1.7
>>> z1 = net[0]
>>> z2 = net[1]
>>> z1 < z2
True
>>> dd = { z1: None, z2: None }
>>> dd
{IPv4Address('192.168.1.0'): None, IPv4Address('192.168.1.1'): None}

Inutile de convertir l'adresse en entier pour "ranger" tout est dedans.
Vous pouvez bien sur faire votre cuisine à vous.
Il n'est jamais inutile de comprendre comment çà marche.

Mais si ce module a été intégré à la PSL, c'est en général suite à de nombreuses discussions pour valider que l'API répondait à de nombreux cas d'utilisation.
Et çà fait toujours çà de moins à maintenir, documenter, tester,..
- W

[dividee]

Personne ne tique sur la mutation d'une liste sans lock dans les threads ? Il se peut que ça ne pose pas de problème ici, si on se contente de faire un append, mais je ne prendrais pas ça pour acquis...

[wiztricks]

Envoyé par dividee

Personne ne tique sur la mutation d'une liste sans lock dans les threads ? Il se peut que ça ne pose pas de problème ici, si on se contente de faire un append, mais je ne prendrais pas ça pour acquis...

Bonne remarque.
En fait, je ne suis pas sûr que .gethostbyaddr puisse s'exécuter en parallèle.
Ca doit sérialiser sur un verrou de l'OS protégeant ses structures partagées.
- W

[dividee]

Envoyé par wiztricks

En fait, je ne suis pas sûr que .gethostbyaddr puisse s'exécuter en parallèle.

Ca m'étonnerait qu'il ne puisse pas; si c'était la cas, il n'y aurait pas grand intérêt à utiliser des threads, il me semble.

Je me demandais plutôt si le GIL était libéré lors de l'appel à append.

[wiztricks]

Envoyé par dividee

Je me demandais plutôt si le GIL était libéré lors de l'appel à append.

Pour CPython, çà dit:

global interpreter lock

The mechanism used by the CPython interpreter to assure that only one thread executes Python bytecode at a time. This simplifies the CPython implementation by making the object model (including critical built-in types such as dict) implicitly safe against concurrent access. Locking the entire interpreter makes it easier for the interpreter to be multi-threaded, at the expense of much of the parallelism afforded by multi-processor machines.

However, some extension modules, either standard or third-party, are designed so as to release the GIL when doing computationally-intensive tasks such as compression or hashing. Also, the GIL is always released when doing I/O.

Past efforts to create a “free-threaded” interpreter (one which locks shared data at a much finer granularity) have not been successful because performance suffered in the common single-processor case. It is believed that overcoming this performance issue would make the implementation much more complicated and therefore costlier to maintain.

Et le code fait ce que dit la doc donc c'est "thread safe" (dans le cas CPython).
- W

[BUENOO]

Bonjour

Je suis en plein de test de ce que Svear m'avait montré. Concernant ta remarque Wiz, sur le module "ipadress", je n'utilises pas python 3.x car enfaite derrière j'ai besoin de la bibliothèque pour les fichiers excels qui il me semble n'est pas disponible avec python 3.x ...

Par contre là "Personne ne tique sur la mutation d'une liste sans lock dans les threads ?" vous m'avez un peu perdu
Enfête j'ai utilisé les threads, car imaginons que j'avais 50ip à faire, c'était super long, car il attend que le premier gethostbyaddr() se finisse ... alors quand y'a pas de réponse et que du coup il attend ... je vous laisses imaginer

[wiztricks]

Salut,
En fait ce sont de faux problèmes.
Désolé pour avoir semé la confusion dans votre esprit.
- W

[BUENOO]

Bonjour,

Je reviens vers vous car je n'arrives pas à trouver une solution ...

Actuellement j'ai pensé à ceci. J'ai ma list_ip = ['192.9.202.1','192.9.202.2','19.9.202.3','192.9.202.4','192.9.202.5'] qui est dans l'ordre et que j'utilises pour faire les requêtes ET list_dic = {'192.9.202.3' : 'toto', '192.9.202.2' : 'titi', '192.9.202.5' : 'tutu', '192.9.202.4' : 'tata', '192.9.202.1' : 'tyty'}.
Je me suis donc dit qu'en utilisant les deux j'aurais moyen de faire sa :

Code :

1
2
3
4
 
for x,y in list_dic:
    if x == z in list_ip:
        #Ici, j'aurais souhaité ajouter y (la value de mon dictionnaire) lors que les ip concordent, mais est ce possible car je n'y parviens pas ?

Par avance merci pour vos idées à venir.

[wiztricks]

Je ne vois pas trop ce que vous cherchez à faire avec l'instruction
if x == z in list_ip:
"z in list_ip" retourne un boolean alors que x est un "str".

Si votre soucis est de préserver l'ordre, pourquoi ne pas utiliser un OrderedDict?
C'est un dict dans le module collection qui devrait être dispo en 2.7
- W

[wiztricks]

Je ne vois pas trop ce que vous cherchez à faire avec l'instruction
if x == z in list_ip:
"z in list_ip" retourne un boolean alors que x est un "str".

Si votre soucis est de préserver l'ordre, pourquoi ne pas utiliser un OrderedDict?
C'est un dict dans le module collection qui devrait être dispo en 2.7
- W

[BUENOO]

Re,

J'ai donc essayé OrderedDict mais sa ne fonctionne pas pour mon problème ...

Code :

1
2
3
4
5
6
7
 
final= {
    "192.9.202.15" : "Toto.domaine",
    "192.9.202.11" : "Stagiaire.domaine",
    "192.9.202.8" : "Thomas.domaine",
    "192.9.202.5" : "Benjamin.domaine",
}

Mon but est que les ip dans final soit croissante sachant que je ne peux utiliser le module ipadresse car je suis sous python 2.7.

[tyrtamos]

Bonjour,

Voilà une solution avec OrderedDict (Python 2.7):

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
from collections import OrderedDict
 
final= {
    "192.9.202.15" : "Toto.domaine",
    "192.9.202.11" : "Stagiaire.domaine",
    "192.9.202.8" : "Thomas.domaine",
    "192.9.202.5" : "Benjamin.domaine",
}
 
def cle(ip):
    """conversion de l'IP en nombre pour trier les IP"""
    c1, c2, c3, c4 = ip.split('.')
    return int(c4) + int(c3)*256 + int(c2)*256**2 + int(c1)*256**3
 
odict = OrderedDict(sorted(final.items(), key=lambda t: cle(t[0])))
 
print odict
OrderedDict([('192.9.202.5', 'Benjamin.domaine'), ('192.9.202.8', 'Thomas.domaine'), ('192.9.202.11', 'Stagiaire.domaine'), ('192.9.202.15', 'Toto.domaine')])
 
print odict['192.9.202.8']
'Thomas.domaine'
 
for ip in odict:
    print ip, odict[ip]
192.9.202.5 Benjamin.domaine
192.9.202.8 Thomas.domaine
192.9.202.11 Stagiaire.domaine
192.9.202.15 Toto.domaine

[BUENOO]

Merci Tyrtamos ! J'avais pensé à refaire un split des ip comme j'ai fait pour générer la plage d'ip, j'étais entrain d'essayer de faire fonctionner sa. Un grand merci à vous !

Par contre j'aurais une petite question à ce sujet :

Code :

1
2
3
4
5
6
7
8
9
10
 
from collections import OrderedDict
 
final = {'192.9.202.15' : 'tutu', '192.9.202.10' : 'tata', '192.9.202.1' : 'toto', '192.9.202.11' : 'titi'}
 
def cle(ip):
    c1,c2,c3,c4 = ip.split('.')
    return int(c4)
 
final_sorted = OrderedDict(sorted(final.items(), key=lambda t: cle(t[0])))

Sa fonctionne parfaitement, donc pourquoi tu as utilisé les c1, c2 et c3 ET pourquoi les avoir multiplié comme tu l'as fait ?