Cryptage de fichier par la méthode rsa (avec de petits nombres)

Soyez le premier à donner votre avis sur cette source.

Snippet vu 5 865 fois - Téléchargée 26 fois

Contenu du snippet

C'est un code permettant de crypter n'importe quel fichier avec la méthode RSA, mais avec des petites clés et le fichier obtenu et trois fois plus grand que celui à crypter.

Source / Exemple :


'Pour crypter
    Dim Bit As Byte, Bit2 As Byte, m(2), N1 As Long, Mt As Long
    Adn=Adresse du fichier à encrypter
    Adc=Adresse du fichier encrypté
    N = 33
    e = 3
    c = 1
    Open Adn For Binary As #1
        Open Adc For Binary As #2
            Do While Not EOF(1)
                DoEvents
                Cp = Cp + 1
                Get #1, Cp, Bit
                For v = 0 To Len("" & Bit) - 1
                    N1 = Mid("" & Bit, v + 1, 1)
                    m(v) = N1
                    m(v) = m(v) ^ d
                    m(v) = Round(((m(v) / N) - Int(m(v) / N)) * N, 0)
                    Bit2 = m(v)
                    Select Case Len("" & Bit)
                        Case 1
                            Put #2, c, 0
                            Put #2, c + 1, 0
                            Put #2, c + 2, Bit2
                        Case 2
                            If Two = False Then Put #2, c, 0
                            Put #2, c + a + 1, Bit2
                            Two = True
                        Case 3
                            Put #2, c + a, Bit2
                    End Select
                    a = a + 1
                Next v
                a = 0
                c = c + 3
                Two = False
            Loop
        Close #2
    Close #1
'''''''''''''''''''''''
'Pour décrypter
    Dim Bit As Byte, Bit2 As Byte, m(2), N1 As Long, Mt As Long
    Adn=Adresse du fichier à encrypter
    Adc=Adresse du fichier encrypté
    N = 33
    d = 7
    Open Adc For Binary As #1
        Open Adn For Binary As #2
            Do While Not EOF(1)
                Do While v <> 3
                    DoEvents
                    Cp = Cp + 1
                    Get #1, Cp, Bit
                    N1 = Bit
                    If N1 = 0 Then GoTo F
                    m(v) = N1
                    m(v) = m(v) ^ e
                    m(v) = Round(((m(v) / N) - Int(m(v) / N)) * N, 0)
                    Mt = Mt + m(v) * 10 ^ (2 - v)
F:
                    v = v + 1
                Loop
                Cp2 = Cp2 + 1
                Bit2 = Mt
                Put #2, Cp2, Bit2
                Mt = 0
                v = 0
            Loop
        Close #2
    Close #1
''''''''''''''''''''''''''''

Conclusion :


Désolé, mais je ne donnerai pas l'algorithme extremement difficile du cryptage RSA avec de grands nombres.

A voir également

Ajouter un commentaire

Commentaires

gandalfkhorne
Messages postés
70
Date d'inscription
dimanche 11 janvier 2004
Statut
Membre
Dernière intervention
1 octobre 2004
-
Exact mais j'ai du arriver à cette conclusion moi-même j'ai du chercher un bon moment j'aurais préféré avoir vu ton msg plus tot, mais pour le cryptage RSA je le laisse de coté pour l'instant, thx qd meme

++
cs_Warny
Messages postés
478
Date d'inscription
mercredi 7 août 2002
Statut
Membre
Dernière intervention
10 juin 2015
-
Je ne vois pas de fonction modulo dans ton programme !!!
Sinon, pour augmenter la taille de tes clefs il faut utiliser le théorême suivant :

m^x [c]= m*m*m*...*m [c]
= (...((m*m [c])*m [c])..*m[c])

ce qui se traduit par
temp=1
m= unnombre
MaxX = unexposant
C = unmodulo
for x=0 to MaxX
temp = m*temp mod c
next x

et qui permet d'utiliser des clef sur 32 bit avec vb et 64 bits avec .NET
pour aller plus loin, il faut reprogrammer un système de calcul à soi.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.