Forum de mathématiques - Bibm@th.net

bdecoder

Membre

Inscription : 11-09-2024

Messages : 2

besoin de retours sur un algo

Bonjour, voici mon premier post.
J'ai récemment codé un algorithme en Python qui permet de générer une clef complexe à partir de deux clefs simples. Le but sera de réutiliser cette clef par la suite pour créer un algorithme de chiffrement symétrique par bloc dans le style de AES. Voici le code, comment puis-je l'améliorer (ce code n'est qu'une base).

import math
import hashlib

def letter_to_number(letter):
    temp_list = []
    letter = list(str(letter))
    for i in letter:
        temp_list.append(str(ord(i)))
    temp_list = ''.join(temp_list)
    temp_list = int(temp_list)
    return temp_list

def create_key_1(precedent_key, key):
    key1 = pow(key+precedent_key, 10**1000, 10 ** 20 + 97506748931476587196)
    return key1

def create_key_2(precedent_key, key):
    key2 = precedent_key * int(math.sqrt(key))
    return key2

def create_key_3(precedent_key):
    byte_key_3 = precedent_key.to_bytes((precedent_key.bit_length() + 7) // 8, byteorder='big')
    sha_key_3 = hashlib.sha512()
    sha_key_3.update(byte_key_3)
    key3 = letter_to_number(sha_key_3)
    return key3

def key_obfuscation(key, base_key):
    key = letter_to_number(key)
    base_key = letter_to_number(base_key)
    key_number_1 = create_key_1(base_key, key)
    key_number_2 = create_key_2(key_number_1, key)
    key_number_3 = create_key_3(key_number_2)
    final_key = pow(pow(key_number_1 * key_number_2, 100**10000, 10**600)-key_number_3, 100**10000, 10**400+196)
    return final_key

key_input = input('enter the key: ')
key_base = 1938214987
print(key_obfuscation(key_input, key_base))

Captain'Flam

Membre

Inscription : 11-09-2024

Messages : 1

Re : besoin de retours sur un algo

Bonjour,
avant toute remarque concernant des algos de crypto/sécurité, votre code comporte un bug :

dans la fonction create_key_3, vous calculez  key3 = letter_to_number(sha_key_3)
et letter_to_number convertit son argument en string avec letter = list(str(letter))

Or la fonction str appliquée au résultat d'un hash renvoie un identifiant python qui ressemble à :
<sha512 _hashlib.HASH object @ 0x000001485D694B90>
C'est à dire que :
1 - il n'a rien à voir avec le résultat du hachage
2 - il change à chaque execution puisqu'il contient une adresse mémoire qui dépend de l'execution en cours
Je suis d'ailleurs surpris que vous n'ayez pas remarque que le résultat change d'une execution à l'autre..

Pour corriger ce problème, il faut modifier l'avant dernière ligne de create_key_3 comme suit :
return letter_to_number( sha_key_3.digest() )

Concernant la sécurité, c'est souvent une mauvaise idée d'essayer d'inventer ses propres algorithmes.
Je le sais d'experience : chacun de mes algos "géniaux" ont été cassés par mes collègues assez rapidement.
La sagesse est de se reporter à la littérature.
Pour votre cas, je vous suggère de vous intéresser aux fonction PRF qui permettent de générer une séquence pseudo aléatoire à partir d'éléments constant (typiquement vos 2 clefs).
voici un lien vers la RFC 3830 qui décrit une fonction PRF idéale pour votre besoin.
Si j'ai le temps je tâcherais d'ajouter une implémentation python sur cette discussion.

Bonne journée

bdecoder

Membre

Inscription : 11-09-2024

Messages : 2

Re : besoin de retours sur un algo

dans la fonction create_key_3, vous calculez  key3 = letter_to_number(sha_key_3)
et letter_to_number convertit son argument en string avec letter = list(str(letter))

Or la fonction str appliquée au résultat d'un hash renvoie un identifiant python qui ressemble à :
<sha512 _hashlib.HASH object @ 0x000001485D694B90>
C'est à dire que :
1 - il n'a rien à voir avec le résultat du hachage
2 - il change à chaque execution puisqu'il contient une adresse mémoire qui dépend de l'execution en cours
Je suis d'ailleurs surpris que vous n'ayez pas remarque que le résultat change d'une execution à l'autre..

Pour corriger ce problème, il faut modifier l'avant dernière ligne de create_key_3 comme suit :
return letter_to_number( sha_key_3.digest() )

Merci de cette remarque constructive. Lors des nombreux test que j'ai fait, je n'ai jamais remarqué ce changement dans le clef finale. Merci donc de me l'avoir notifié.

Concernant la sécurité, c'est souvent une mauvaise idée d'essayer d'inventer ses propres algorithmes.
Je le sais d'experience : chacun de mes algos "géniaux" ont été cassés par mes collègues assez rapidement.

Cepandant, mon but n'est pas de créer un algo très sécurisé. Aucune données sensibles le transiterons jamais via cet algo. Le but ici est de créer un algo "nouveau" et de le sécuriser. Personellement, j'utiliserai forcément un RSA ou un AES plutôt qu'un olgo perso pour chiffrer mes données sensibles.

Voici donc le code corrigé:
import math
import hashlib

def letter_to_number(letter):
    temp_list = []
    letter = list(str(letter))
    for i in letter:
        temp_list.append(str(ord(i)))
    temp_list = ''.join(temp_list)
    temp_list = int(temp_list)
    return temp_list

def create_key_1(precedent_key, key):
    key1 = pow(key+precedent_key, 10**1000, 10 ** 20 + 97506748931476587196)
    return key1

def create_key_2(precedent_key, key):
    key2 = precedent_key * int(math.sqrt(key))
    return key2

def create_key_3(precedent_key):
    byte_key_3 = precedent_key.to_bytes((precedent_key.bit_length() + 7) // 8, byteorder='big')
    sha_key_3 = hashlib.sha512()
    sha_key_3.update(byte_key_3)
    key3 = letter_to_number(sha_key_3.digest())
    return key3

def key_obfuscation(key, base_key):
    key = letter_to_number(key)
    base_key = letter_to_number(base_key)
    key_number_1 = create_key_1(base_key, key)
    key_number_2 = create_key_2(key_number_1, key)
    key_number_3 = create_key_3(key_number_2)
    final_key = pow(pow(key_number_1 * key_number_2, 100**10000, 10**600)-key_number_3, 100**10000, 10**400+196)
    return final_key

key_input = input('enter the key: ')
key_base = 1938214987
print(key_obfuscation(key_input, key_base))