Attaque d'accès utilisateur

Explication.md

Ici nous avons 5 parties :

• Le gestionaire de base de donnée qui restera le même
• Des fonctions définies par un développeur qui évolueront en fonction des évolutions logicielles
• L'insertion des données qui resteront les même au fur et à mesure
• Test de connexion classique
• Test d'attaque en connaissance du code

A ce stade du developement, le programmeur a mis en place un algorithme avec un clef de hashage 24 bit en faisant un hash combiné du nom du site, de son hash, du nom de l'utilisateur, de son hash, du mot de passe et de son hash.

Le hackeur à besoin de générer des clefs au hazard afin de trouver un couple de mot de passe avec la clef de hashage correspondant au site et à l'utilisateur, ce qui fait qu'il ne peut utiliser une rainbow table et est donc obligé de générer à la volée pour chaque utilisateur, si l'attaque cible un seul utilisateur, dans ce cas le hackeur gagne le temps de la génération de la rainbow table, toutefois s'il cherche à attaquer des utilisateurs en masse, il perd du temps de recherche pour chaque utilisateur, pour chaque site et si l'utilisateur change de mot de passe, il est obligé de relancer la recherche.

Comparé à la précédente attaque, un clef 24 bit est plus forte qu'une clef 16 bit et rend l'attaque beaucoup plus ineficace du à un tmps de calcul plus long à effectuer.

script.py

#!/usr/bin/python
# encoding: utf-8
import uuid, timeit

def showtime(t):
  return "%dj %dh %dm %ds %dns" % (t/86400%1,t/3600%24,t/60%60,t%60,t*1e9%1e9)

### base de données propriétaire
class Bdd:
  def __init__(self, bdd={}):
    self.bdd = bdd
  def enregistre(self, site, utilisateur, motdepasse):
    if site not in self.bdd:
      self.bdd[site] = {}
    self.bdd[site][utilisateur]=motdepasse
  def obtient(self, site, utilisateur):
    if site not in self.bdd and utilisateur not in self.bdd[site]:
      return False
    return self.bdd[site][utilisateur]

#### fonctions du panneau utilisateur sur le site
import codecs

bdd = Bdd()

def custom_hash(site,utilisateur,motdepasse):
  return hash("%s %s %s %s %s %s" % (site, hash(str(site)), utilisateur, hash(str(utilisateur)), motdepasse, hash(str(motdepasse))))%pow(2,24)

def enregistre(site, utilisateur, motdepasse):
  bdd.enregistre(site, utilisateur, custom_hash(site, utilisateur, motdepasse))

def conexion(site, utilisateur, motdepasse):
  if bdd.obtient(site, utilisateur) == False:
    return False
  return bdd.obtient(site, utilisateur) == custom_hash(site, utilisateur, motdepasse)

#### insertion des données
def gen():
  mdp1 = uuid.uuid4().get_hex().upper()[:6]
  mdp2 = uuid.uuid4().get_hex().upper()[:6]
  
  enregistre("SuperSite.com", "Alice", mdp1)
  enregistre("SuperSite.com", "Bob",   mdp1)
  enregistre("MegaDaube.com", "Alice", mdp1)
  enregistre("MegaDaube.com", "Bob",   mdp2)
  print(bdd.bdd)
  print([conexion("SuperSite.com", "Alice", mdp1), # True
         conexion("SuperSite.com", "Bob",   mdp1), # True
         conexion("MegaDaube.com", "Alice", mdp1), # True
         conexion("MegaDaube.com", "Bob",   mdp2)]) # True

#### nétoyage des variables
mdp1 = None
mdp2 = None

#### test d'attaque
def attack():
  attacks=[]
  password=0
  for site in ["SuperSite.com", "MegaDaube.com"]:
    for utilisateur in ["Alice", "Bob"]:
      hash_bdd = bdd.bdd[site][utilisateur]
      while True:
        hash_test = custom_hash(site, utilisateur, password)
        if hash_bdd == hash_test:
          print(password, hash_test, hash_bdd)
          attacks.append(conexion(site, utilisateur, password))
          break
        password +=1
  print(attacks)

#### display result
result=timeit.repeat("attack()", setup="from __main__ import attack,gen;gen()", repeat=10,number=1)
print(" min: %s\nmean: %s\n max: %s" % (showtime(min(result)), showtime(sum(result)/10) , showtime(max(result))))