Scripts Réalisés

De Justine's wiki
Aller à la navigation Aller à la recherche

Script de découpage de réseaux en VLSM (Python)

###Ce programme sert à découper un réseau IP selon la méthode du VLSM.
###This script's purpose is to subnet using the VLSM method.
###Justine Pelletreau 2018 - innertech.ovh


# -*-coding:Latin-1 -*


###Classes

class IP:
    """Classe servant à stocker une adresse IPv4"""

    def __init__(self, octet1, octet2, octet3, octet4, masque):
        self.type = "AdresseIPv4"
        self.octet1 = octet1
        self.octet2 = octet2
        self.octet3 = octet3
        self.octet4 = octet4
        self.masque = masque

    def __str__(self):
        return "{}.{}.{}.{}/{}".format(self.octet1, self.octet2, self.octet3, self.octet4, self.masque)


class Sousreseau(IP):
    """Fonction servant à stocker un sous-réseau et le nombre d'hôtes qu'il peut contenir"""

    def __init__(self, octet1, octet2, octet3, octet4, masque, nombre_hotes, nom):
        IP.__init__(self, octet1, octet2, octet3, octet4, masque)
        self.nom = nom
        self.nombre_hotes = nombre_hotes

    def __str__(self):
        return "Reseau {}: {}.{}.{}.{}/{} : {} adresses".format(self.nom, self.octet1, self.octet2, self.octet3, self.octet4, self.masque, self.nombre_hotes)


###Fonctions


def strversIP(IPStr):
    """Fonction traduisant un string contenant une IP en objet de la classe IP"""
    o1, o2, o3, o4, msk = str = "", "", "", "", ""
    separateurs = []
    i = 0
    octetencours = 1

    while i < IPStr.__len__():
        if IPStr[i] != '.' and IPStr[i] != '/':
            if octetencours == 1:
                o1 = o1 + IPStr[i]
            elif octetencours == 2:
                o2 = o2 + IPStr[i]
            elif octetencours == 3:
                o3 = o3 + IPStr[i]
            elif octetencours == 4:
                o4 = o4 + IPStr[i]
            elif octetencours == 5:
                msk = msk + IPStr[i]

        else:
            octetencours += 1

        i += 1

    try:
        o1 = int(o1)
        o2 = int(o2)
        o3 = int(o3)
        o4 = int(o4)
        msk = int(msk)

    except ValueError:
        print("Veuillez recommencer et rentrer une adresse IPv4 et son masque, par exemple : 10.0.0.0/8")
        input()
        exit()

    adresseip = IP(o1, o2, o3, o4, msk)

    return adresseip


def SRpuiss2(ListeSR: dict):
    """Cette fonction arrondit le nombre d'hôtes par sous-réseau en puissances de 2, et laisse la place pour les adresses de broadcast et de reseau"""
    Puiss2 = [4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648]
    i = 1

    while i <= len(ListeSR):
        for ii in Puiss2:
            if ListeSR[i] + 2 <= ii:
                ListeSR[i] = ii
                break
        i += 1

    return ListeSR


def ControlePossible(masque, ListeSR):
    """Fonction qui sert à vérifier que mon découpage est possible"""
    Puiss2 = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648]
    oh = 32 - masque  # Bits d'hote dispos
    totalitehotes = 0
    bitssr = 0  # Bits pour les sous-reseaux
    nsr = 0  # Nombre de sous-reseaux

    for i in ListeSR:
        nsr += 1
        totalitehotes = totalitehotes + ListeSR[i]

    for i in range(0, 32):
        if 2 ** i >= nsr:
            bitssr = i
            break

    oh = oh - bitssr

    if totalitehotes > 2 ** oh:
        return False
    else:
        return True


def SsReseaux(ListeSR, NomsSR):
    """Crée la liste des sous-reseaux en tant qu'objets et les trier du plus au moins peuple"""
    ListeObjetsSR = []
    NBits = 0

    for i in ListeSR:
        for ii in range(0, 32):
            if 2 ** ii == ListeSR[i]:
                NBits = ii
        reseau = Sousreseau(0, 0, 0, 0, (32 - NBits), ListeSR[i], NomsSR[i])
        ListeObjetsSR.append(reseau)

        ListeObjetsSR.sort(key=lambda x: x.nombre_hotes, reverse=True)

    return ListeObjetsSR


def GenTableau(ListeSR):
    """Crée un tableau ajoutant première et dernère adresse utilisable"""

    ListeBuffer = ListeSR


    Tableau = []
    NbHotes = 0

    for i in ListeBuffer:
        NbHotes = i.nombre_hotes
        NbHotes = NbHotes - 2
        Tableau.append(i.__str__() + "|")

        ## Première adresse d'hote

        i.octet4 += 1

        oct1 = i.octet1
        octs1 = '{}'.format(oct1)
        oct2 = i.octet2
        octs2 = '{}'.format(oct2)
        oct3 = i.octet3
        octs3 = '{}'.format(oct3)
        oct4 = i.octet4
        octs4 = '{}'.format(oct4)
        FirstAdd = "Première Adresse Attribuable :" + octs1 + "." + octs2 + "." + octs3 + "." + octs4 + "|"
        Tableau.append(FirstAdd)
        i.octet4 -= 1

        ##Dernière Adresse d'hôte

        while NbHotes > 0:
            while i.octet4 < 255 and NbHotes > 0:
                i.octet4 += 1
                NbHotes -= 1
            if i.octet4 >= 255 and i.octet3 < 255:
                i.octet3 += 1
                NbHotes -= 1
                i.octet4 = 0
            elif i.octet3 >= 255 and i.octet2 < 255:
                i.octet2 += 1
                i.octet3 = 0
                i.octet4 = 0
                NbHotes -= 1
            elif i.octet2 >= 255 and i.octet1 < 255:
                i.octet1 += 1
                i.octet2 = 0
                i.octet3 = 0
                i.octet4 = 0
                NbHotes -= 1

        oct1 = i.octet1
        octs1 = '{}'.format(oct1)
        oct2 = i.octet2
        octs2 = '{}'.format(oct2)
        oct3 = i.octet3
        octs3 = '{}'.format(oct3)
        oct4 = i.octet4
        octs4 = '{}'.format(oct4)

        LastAdd = "Dernière Adresse Attribuable : " + octs1 + "." + octs2 + "." + octs3 + "." + octs4 + "\n"
        Tableau.append(LastAdd)

    return Tableau


###Main

###Récupération d'informations : Adresse IP, Nombre d'hôtes, Nombres de sous-réseaux
print("Programme de segmentation VLSM")
ipstr = str = input("Veuillez rentrer l'adresse réseau IPv4 à diviser en sous-reseaux, au format CIDR:")

ipRzo = strversIP(ipstr)

del ipstr

print("Adresse réseau enregistree :", ipRzo)

# Informations sur les sous-reseaux

NbreSSRzo = int(input("Combien de sous reseaux desirez-vous?"))

i = 1
ListeSR = {}
NomsSR = {}

while i <= NbreSSRzo:
    print("Combien d'hotes (adresses d'interfaces uniquement !) voulez-vous dans le sous-reseau numero ", i, "?")
    ListeSR[i] = int(input())

    print("Quel est le nom de ce sous-reseau?")
    NomsSR[i] = input()
    i += 1

###Algorithme en lui-meme

ListeSR = SRpuiss2(ListeSR)
print(ListeSR)

# Verification et résumé des sous-reseaux

if ControlePossible(ipRzo.masque, ListeSR):
    print("Ce découpage est possible")
else:
    print("Ce découpage est impossible ! Veuillez recommencer")
    input()
    exit()

# Creation des sous-reseaux en tant qu'objets, ils sont dans une liste qui est triée

ListeSR = SsReseaux(ListeSR, NomsSR)

# Tous les sousreseaux deviennt comme l'adresse reseau
ii = 0
for i in ListeSR:
    ListeSR[ii].octet1 = ipRzo.octet1
    ListeSR[ii].octet2 = ipRzo.octet2
    ListeSR[ii].octet3 = ipRzo.octet3
    ListeSR[ii].octet4 = ipRzo.octet4
    ii += 1

# C'est parti, itérations


NbHotes = 0
i = 1

while i <= len(ListeSR) - 1:
    NbHotes = ListeSR[i - 1].nombre_hotes
    ListeSR[i].octet1 = ListeSR[i - 1].octet1
    ListeSR[i].octet2 = ListeSR[i - 1].octet2
    ListeSR[i].octet3 = ListeSR[i - 1].octet3
    ListeSR[i].octet4 = ListeSR[i - 1].octet4

    while NbHotes > 0:
        if ListeSR[i].octet4 < 255:
            while ListeSR[i].octet4 < 255 and NbHotes > 0:
                NbHotes -= 1
                ListeSR[i].octet4 += 1
        elif ListeSR[i].octet3 < 255:
            ListeSR[i].octet3 += 1
            NbHotes -= 1
            ListeSR[i].octet4 = 0
        elif ListeSR[i].octet2 < 255:
            ListeSR[i].octet2 += 1
            NbHotes -= 1
            ListeSR[i].octet4 = 0
            ListeSR[i].octet3 = 0
        elif ListeSR[i].octet1 < 255:
            ListeSR[i].octet1 += 1
            NbHotes -= 1
            ListeSR[i].octet4 = 0
            ListeSR[i].octet3 = 0
            ListeSR[i].octet2 = 0

    i += 1

Tableau = GenTableau(ListeSR)
TableauChaine = .join(Tableau)

print(TableauChaine)

###Création d'un fichier de sauvegarde

entree = ""

while entree != "o" and entree != "O" and entree != "n" and entree != "N":
    entree = input("Voulez-vous imprimer ces résultats dans un fichier? o / n :")

if entree == "o" or entree == "O":
    nom = input("Le fichier sera au format.txt \nQuel nom voulez-vous donner au fichier? \n(Ne pas mettre l'extension de fichier):")
    nom = nom + ".txt"
    text_file = open(nom, "w")
    text_file.write(TableauChaine)
    text_file.close()
    print("Fichier sauvegardé sous le nom", nom, "\n")

input("Appuyez sur Entrée pour quitter")

 

Récupérée de « https://wiki.squi.fr/index.php?title=Scripts_Réalisés&oldid=211 »