[UNDEFINED] Chiffrement RSA plus Key ?

[InstinctHack]

Bonjour à tous! Comme je l'ai dit dans un autre topic, je m'intéresse actuellement à la sécurisation des data (chiffrement/stégano) mais cela de façon totalement privé.
définition de privé : aucun lien avec une librairies, je veux un code fait par moi, pour que je puisse le comprendre et le modifier.

J'ai trouvé ce code sur le sdz
http://www.siteduzero.com/tutoriel-3-230...ptage.html

Mais le truc c'est que les clé sont des nombres (premiers) et que je voudrais que ça soit une passphrase à la truecrypt, mais j'ignore comment m'y prendre, et comme je suis débutant en chiffrement :/
Avez-vous une idée ?

Code :

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# L'utilisateur entre p
p = input('Entrez un grand nombre premier p : ')

# L'utilisateur entre q
q = input('Entrez un grand nombre premier q : ')

# On calcule n
n = p*q

print "\nn = ",n,

# On calcul phi(n)
phiden = (p-1)*(q-1)

print "\nphi de n = ",phiden
#raw_input('\n\nFin\n\n')


# Variables de la boucle
compteur = 0
PGCD1 = 0

# Notre e qui s'incrementera
e = 0

# La fonction PGCD avec ses 2 arguments a et b
def pgcd(a,b):
    # L'algo PGCD
    while a != b:
        if a > b:
            a = a - b
        else:
            b = b - a
    return a;



# Tant que PGCD de e et phi(n) differents de 1
while PGCD1 != 1 :
    # Tant que compteur=0
    while compteur == 0 :
        # Si p inferieur à e et si q inferieur à e et si e inferieur à n
        if((p < e)and(q < e)and(e < phiden)) :
            # La boucle se coupe (on peut aussi mettre le mot-clé : break
            compteur = 1
        # Tant que rien n'est trouve, e s'incremente
        e = e + 1
    # On recupere le résultat du pgcd
    PGCD1 = pgcd(e,phiden)


# On affiche notre clé publique
print "\nCle publique (",e,",",n,")"

# On demande d'entrer le texte à crypter
mot = raw_input('\nEntrez le mot ou la phrase à crypter : ')


# On récupère le nombre de caractères du texte.
taille_du_mot = len(mot)
i = 0

# Tant que i inférieur au nombre de caractères
while i < taille_du_mot :
    # Comme i s'incrémente jusqu'à égalité avec la taille du mot,
    #à chaque passage dans la fonction chaque lettre sera convertie.
    ascii = ord(mot[i])
    # On crypte la lettre ou plutôt son code ASCII
    lettre_crypt = pow(ascii,e)%n
    # Si le code ASCII est supérieur à n
    if ascii > n :
        print "Les nombres p et q sont trop petits veuillez recommencer."
    # Si le bloc crypté est supérieur à phi(n)
    if lettre_crypt > phiden :
        print "Erreur de calcul"
    # On affiche chaque bloc crypté
    print "\n Block : ",lettre_crypt,
    # On incrémente i
    i = i + 1

# On bloque le programme avant la fermeture
raw_input('\n\nFin\n\n')

[Horgh]

Mais le truc c'est que les clé sont des nombres (premiers) et que je voudrais que ça soit une passphrase à la truecrypt, mais j'ignore comment m'y prendre, et comme je suis débutant en chiffrement :/

Tu es obligé d'utiliser des nombres premiers pour RSA, une grande partie de l'algorithme repose là-dessus.

[b0fh]

Hello,

Quel tuto absolument horrible (sur sdz). Il est évident que l'auteur n'a rien compris.

Il chiffre le message lettre par lettre, dans ces conditions il est trivial de casser le chiffrement, il suffit de construire une table de substitution pour chaque byte possible en le chiffrant avec la clef publique.

Son choix de e est sous-optimal, si le message chiffré est suffisamment large une petite valeur de e convient très bien et accélère immensément le chiffrement (65537 est un bon choix, d'abord parce que l'élévation à la puissance ne demande que 16 multiplications, et ensuite parce qu'il est premier donc pas besoin de tester sa co-primalité avec phi(n)). L'algorithme utilisé pour le générer est débile pour de nombreuses raisons (par exemple parce que si p ou q sont premiers, phi(n) est toujours pair, donc e ne peut pas l'être).

Son calcul de d est totalement idiot aussi, la manière correcte est d'utiliser l'algorithme d'Euclide étendu, que je vais te laisser googler et redemander si tu ne comprends pas bien.

En fait, RSA peut fonctionner même si p et q ne sont pas premiers. Les conditions pour que ça fonctionne sont que:

- e soit co-premier à phi(n) (le calcul de phi(n) change par contre si p et q ne sont pas premiers, je te laisse googler la Fonction Totiente d'Euler)
- le message m soit toujours co-premier à n (la probabilité que ça arrive est quasi nulle avec p et q grands premiers, mais diminue dangereusement si tu choisis p et q au hasard)

Mais de manière générale, pour une taille de clef équivalente tu auras une sécurité plus faible, ce n'est donc pas recommandé.

Transformer une passphrase en nombres premiers pour RSA n'est pas forcément une bonne idée, mais tu peux quand même le faire, si tu utilises la passphrase comme seed pour un générateur de nombres aléatoires qui sera utilisé pour générer tes nombres premiers, par exemple avec la méthode de Rabin-Miller.

Il est très important de générer les deux nombres d'un coup, et de ne pas reset le générateur aléatoire entre les deux ou d'utiliser deux seeds de sources différentes pour les deux nombres, sinon le risque est plus élevé d'avoir une collision partielle qui rend deux clefs publiques mutuellements cassables.

[CyberSee]

Quoi dire de plus si non félicitation b0fh pour un message bien composer. Je suis toute a fait d'accord avec ce que tu dit. REP+2 On a pas de tuto sur les RSA encore ... va falloir pallier a ça.

[InstinctHack]

Et bien merci beaucoup pour ce commentaire très instructif (je me disais que c'était trop simple)

Je vais donc me renseigner sur le chiffrement AES et son fonctionnement interne et tenter de le recoder