1. #1
    Membre habitué
    Inscrit en
    août 2005
    Messages
    92
    Détails du profil
    Informations forums :
    Inscription : août 2005
    Messages : 92
    Points : 180
    Points
    180

    Par défaut Windev : Chiffrement RSA et chiffrement hybride RSA + AES

    Bonjour,

    Voici une procédure permettant d'effectuer un chiffrement / déchiffrement RSA avec Windev.

    J'utilise une dll RSA.dll (à télécharger ici : RSA.7z) que j'ai programmée en c# et dont voici le code :

    Code c# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
     
    namespace RSA
    {
        using System;
        using System.Security.Cryptography;
        using System.Text;
     
        public class RSATool
        {
     
            static public void GenerateKeys(ref string __publicPrivateKeyXML, ref string __publicOnlyKeyXML, ref string __sMessErr, int _ikeySize=1024)
            {
                try
                {
                    RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(_ikeySize);
                    //Pair of public and private key as XML string. Do not share this to other party
                    __publicPrivateKeyXML = RSA.ToXmlString(true);
                    //Private key in xml file, this string should be share to other parties
                    __publicOnlyKeyXML = RSA.ToXmlString(false);
                }
                catch (CryptographicException e)
                {
                    __sMessErr = e.ToString();
                }
            }
     
            static public string RSAEncrypt(string _sDataToEncrypt, string _sPublicKeyXML, ref string __sMessErr, int _ikeySize=1024, bool DoOAEPPadding=true)
            {
                try
                {
                    byte[] dataToEncrypt = Encoding.UTF8.GetBytes(_sDataToEncrypt);
                    byte[] encryptedData;
     
                    //Create a new instance of RSACryptoServiceProvider.
                    using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(_ikeySize))
                    {
                        RSA.FromXmlString(_sPublicKeyXML);
     
                        //Encrypt the passed byte array and specify OAEP padding. OAEP padding is only available on Microsoft Windows XP or later.  
                        encryptedData = RSA.Encrypt(dataToEncrypt, DoOAEPPadding);
                    }
                    return Convert.ToBase64String(encryptedData);
                }
                catch (CryptographicException e)
                {
                    __sMessErr = e.ToString();
                    return null;
                }
     
            }
     
            static public string RSADecrypt(string _sDataToDecryptBase64,string _sPrivateKeyXML, ref string __sMessErr, int _ikeySize=1024, bool DoOAEPPadding=true)
            {
                try
                {
                    byte[] dataToDecrypt = Convert.FromBase64String(_sDataToDecryptBase64);
                    byte[] decryptedBytes;
                    string decryptedData;
     
                    //Create a new instance of RSACryptoServiceProvider.
                    using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(_ikeySize))
                    {
                        RSA.FromXmlString(_sPrivateKeyXML);
     
                        //Decrypt the passed byte array and specify OAEP padding. OAEP padding is only available on Microsoft Windows XP or later.  
                        decryptedBytes = RSA.Decrypt(dataToDecrypt, DoOAEPPadding);
                        decryptedData = Encoding.UTF8.GetString(decryptedBytes);  
                    }
                    return decryptedData;
                }
                catch (CryptographicException e)
                {
                    __sMessErr = e.ToString();
                    return null;
                }
     
            }
        }
    }

    Pour utiliser la dll RSA.dll dans Windev, il faut tout d'abord l'extraire du répertoire compressé RSA.7z (avec l'utilitaire 7-Zip http://www.7-zip.org/ par exemple) et la copier dans le répertoire "exe" de votre projet.
    Ensuite, cliquez sur le menu "Atelier/.NET/Utiliser un assemblage .NET dans votre projet".
    Dans la fenêtre listant les assemblages disponibles, cliquez sur le bouton "Parcourir" et sélectionnez la dll RSA.dll que vous venez de copier.
    Cliquez sur le bouton de validation pour l'importer dans votre projet.

    Le code Windev est le suivant :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
     
    LOCAL
    	sClePrivee est une chaîne
    	sClePublique est une chaîne
    	sMessErr est une chaîne
    	iKeySize est un entier
    	bOAEPPadding est un booléen
     
    iKeySize = 2048
    bOAEPPadding = Vrai
     
    //Générer les clés privée et publique
    RSATool.GenerateKeys(sClePrivee,sClePublique,sMessErr,iKeySize)
    SI sMessErr <> "" ALORS
    	Erreur(sMessErr)
    	RENVOYER Faux
    FIN
     
    LOCAL
    	sChaineAChiffrer est une chaîne
    	sChaineChiffree est une chaîne
    	sChaineDeChiffree est une chaîne
     
    sChaineAChiffrer = "Message à chiffrer"
     
    //Chiffrer le message (Attention, avec une clé de 2048 bits, la taille de la chaine à chiffrer ne peut pas excéder 214 caractères (octets pour être précis)
    //et 86 caractères avec une clé de 1024 bits, en utilisant l'OAEP (Optimal Asymmetric Encryption Padding))
    sChaineChiffree = RSATool.RSAEncrypt(sChaineAChiffrer,sClePublique,sMessErr,iKeySize,bOAEPPadding)
    SI sMessErr <> "" ALORS
    	Erreur(sMessErr)
    	RENVOYER Faux
    FIN
     
    //Déchiffrer le message
    sChaineDeChiffree = RSATool.RSADecrypt(sChaineChiffree,sClePrivee,sMessErr,iKeySize,bOAEPPadding)
    SI sMessErr <> "" ALORS
    	Erreur(sMessErr)
    	RENVOYER Faux
    FIN
     
    Info(sChaineDeChiffree)
    Plus d'infos et d'exemples ici :

    https://fr.wikipedia.org/wiki/Chiffrement_RSA
    https://gist.github.com/zachbonham/3...-crypto-cs-L50
    http://www.csharpdeveloping.net/Snip..._algorithm_rsa

    Concernant la taille maximale des données à chiffrer selon la taille de la clé de chiffrement :
    http://info.townsendsecurity.com/bid...-with-rsa-keys

    Bonne prog

  2. #2
    Membre habitué
    Inscrit en
    août 2005
    Messages
    92
    Détails du profil
    Informations forums :
    Inscription : août 2005
    Messages : 92
    Points : 180
    Points
    180

    Par défaut Windev : Chiffrement hybride RSA + AES

    Bonjour,

    Afin de chiffrer des messages de taille plus importante que ce que permet RSA (en une seule passe), il est possible de combiner chiffrement RSA (asymétrique) + chiffrement AES (symétrique).

    Cela permet de mettre en place un système d'échange de messages entièrement sécurisé.

    Le RSA servira à chiffrer la clé AES, elle même utilisée pour chiffrer le message en AES.

    Exemple :

    Bob et Alice souhaitent s'envoyer des messages de manière sécurisée.

    - Chacun de leur côté, il génèrent un couple clé privée / clé publique avec RSA.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    LOCAL
    	sClePrivee est une chaine
    	sClePublique est une chaine
     
    RSATool.GenerateKeys(sClePrivee,sClePublique,sMessErr,2048)
    - Bob envoie par mail sa clé publique à Alice et Alice envoie par mail sa clé publique à Bob.
    En possession de la clé publique d'Alice, Bob peut lui envoyer des messages qu'elle seule pourra déchiffrer, et inversement,
    en possession de la clé publique de Bob, Alice peut lui envoyer des messages que lui seul pourra déchiffrer.

    - Bob souhaite envoyer un message à Alice.

    - Il commence par générer une clé AES de manière aléatoire.
    Cette clé AES est symétrique, c'est à dire qu'elle sert aussi bien à chiffrer un message qu'à le déchiffrer.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
     
    LOCAL
    	sKeyAES est une chaîne
    	bufKeyAES est un Buffer
     
    //On détermine une clé AES aléatoire
    sKeyAES = GénèreMotDePasse(128)
    bufKeyAES = HashChaîne(HA_MD5_128,sKeyAES)
    - Il chiffre son message en AES, à l'aide de cette clé.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
     
    LOCAL
    	sMessageChiffre est une chaîne
     
    //On chiffre le message en AES avec la clé AES
    sMessageChiffre = CrypteStandard(bufMessage,bufKeyAES,crypteAES128)
    - Pour déchiffrer le message de Bob, Alice aura donc besoin de cette clé AES.
    Cependant, comment la lui transférer sans risquer qu'elle soit interceptée par un tiers ?
    C'est là qu'intervient RSA.

    - Bob chiffre la clé AES en RSA avec la clé publique d'Alice et l'adjoint à son message (chiffré en AES).

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    LOCAL
    	sKeyAESChiffree est une chaîne
    	sMessageFinal est une chaine
     
    //On chiffre la clé AES avec RSA et on ajoute la clé chiffrée au message final
    //On a au final <Clé AES chiffrée en RSA>+<Message chiffré en AES>
    sKeyAES = bufKeyAES
    sKeyAESChiffree = RSATool.RSAEncrypt(sKeyAES,sClePubliqueAlice,sMessErr,2048,Vrai)
     
    //On ajoute la clé AES chiffrée en RSA au message
    sMessageFinal = Complète(""+Taille(sKeyAESChiffree),5,"X")+sKeyAESChiffree+sMessageChiffre
    - Bob envoie le message final à Alice par mail

    - De son côté, lorsque Alice réceptionne le message, elle en extrait la clé AES et la déchiffre avec sa clé privée.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    LOCAL
    	iTailleKey est un entier
    	sKeyAESChiffree est une chaîne
     
    //On extrait la clé AES chiffrée en RSA du message
    iTailleKey = Val(Gauche(sMessageFinal,5))
    sKeyAESChiffree = Milieu(sMessageFinal,6,iTailleKey)
     
    //On déchiffre la clé AES
    bufKeyAES = RSATool.RSADecrypt(sKeyAESChiffree,sClePriveeAlice,sMessErr,2048,Vrai)
    - Une fois la clé AES déchiffrée, elle peut simplement déchiffrer le reste du message.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     
    LOCAL
    	buffMessageChiffre est un Buffer
    	sMessageDechiffre est une chaîne
     
    //On extrait le message chiffré en AES
    buffMessageChiffre = Droite(sMessageFinal,Taille(sMessageFinal)-(6+iTailleKey-1))
     
    //On déchiffre le message chiffré en AES
    sMessageDechiffre = DécrypteStandard(buffMessageChiffre,bufKeyAES,crypteAES128)
    Et voilà !

    Au final on peut faire :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
     
    //Générer les clés privée et publique
    LOCAL
    	sClePrivee est une chaîne
    	sClePublique est une chaîne
    	iKeySize est un entier
    	sMessErr est une chaîne
     
    iKeySize = 2048
     
    RSATool.GenerateKeys(sClePrivee,sClePublique,sMessErr,iKeySize)
    SI sMessErr <> "" ALORS
    	ExceptionDéclenche(1,sMessErr)
    FIN
     
    sChaineChiffree est une chaîne = Chiffrer("Un message pour Alice",sClePublique,iKeySize)
    Info(Dechiffrer(sChaineChiffree,sClePrivee))
    Méthode Chiffrer :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
     
    PROCEDURE GLOBALE Chiffrer(LOCAL _bufChaineAChiffrer est un Buffer,LOCAL _sClePublique est une chaîne,LOCAL _iKeySize est un entier=2048,LOCAL _bOAEPPadding est un booléen=Vrai)
    //Chiffrer une chaîne de caractères en utilisant l'algorithme RSA + AES
    LOCAL
    	sKeyAES est une chaîne
    	bufKeyAES est un Buffer
    	sKeyAESChiffree est une chaîne
    	sChaineChiffree est une chaîne
    	sMessErr est une chaîne
     
    //On détermine une clé AES aléatoire
    sKeyAES = GénèreMotDePasse(128)
    bufKeyAES = HashChaîne(HA_MD5_128,sKeyAES)
     
    //On chiffre le message en AES avec la clé AES
    sChaineChiffree = CrypteStandard(_bufChaineAChiffrer,bufKeyAES,crypteAES128)	
     
    //On chiffre la clé AES avec RSA et on ajoute la clé chiffrée au message final
    //On a au final <Clé AES chiffrée en RSA>+<Message chiffré en AES>
    sKeyAES = bufKeyAES
    sKeyAESChiffree = RSATool.RSAEncrypt(sKeyAES,_sClePublique,sMessErr,_iKeySize,_bOAEPPadding)
    SI sMessErr <> "" ALORS
    	ExceptionDéclenche(1,sMessErr)
    FIN
     
    //On ajoute la clé AES chiffrée en RSA au message
    RENVOYER Complète(""+Taille(sKeyAESChiffree),5,"X")+sKeyAESChiffree+sChaineChiffree
    Méthode Dechiffrer :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
     
    PROCEDURE GLOBALE Dechiffrer(_sChaineChiffree est une chaîne,_sClePrivee est une chaîne,LOCAL _iKeySize est un entier=2048,LOCAL _bOAEPPadding est un booléen=Vrai)
    //Déchiffrer une chaîne de caractères en utilisant l'algorithme RSA + AES
    LOCAL
    	iTailleKey est un entier
    	sKeyAESChiffree est une chaîne
    	bufKeyAES est un Buffer
    	buffMessageChiffre est un Buffer
    	sChaineDeChiffree est une chaîne
    	sMessErr est une chaîne
     
    //On extrait la clé AES chiffrée en RSA du message
    iTailleKey = Val(Gauche(_sChaineChiffree,5))
    sKeyAESChiffree = Milieu(_sChaineChiffree,6,iTailleKey)
     
    //On déchiffre la clé AES
    bufKeyAES = RSATool.RSADecrypt(sKeyAESChiffree,_sClePrivee,sMessErr,_iKeySize,_bOAEPPadding)
    SI sMessErr <> "" ALORS
    	ExceptionDéclenche(1,sMessErr)
    FIN
     
    //On extrait le message chiffré en AES
    buffMessageChiffre = Droite(_sChaineChiffree,Taille(_sChaineChiffree)-(6+iTailleKey-1))
     
    //On déchiffre le message chiffré en AES
    sChaineDeChiffree = DécrypteStandard(buffMessageChiffre,bufKeyAES,crypteAES128)
     
    RENVOYER sChaineDeChiffree
    Bonne prog

  3. #3
    Membre habitué
    Inscrit en
    août 2005
    Messages
    92
    Détails du profil
    Informations forums :
    Inscription : août 2005
    Messages : 92
    Points : 180
    Points
    180

    Par défaut Windev : Hachage avec SHA-1, SHA-256, SHA-384, SHA-512 ou MD5

    Pour aller un peu plus loin, voici une dll Crypto.dll (Fichier compressé ici : Crypto.7z) permettant de faire du hachage de chaines avec SHA-1, SHA-256, SHA-384, SHA-512 ou MD5 : https://fr.wikipedia.org/wiki/SHA-1, en plus du chiffrement RSA.
    L'idée est de permettre la réalisation d'une signature numérique garantissant l'intégrité d'un document électronique, comme expliqué ici : https://fr.wikipedia.org/wiki/Signature_num%C3%A9rique

    Un petit exemple Windev ici :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
     
    LOCAL
    	sClePrivee est une chaîne
    	sClePublique est une chaîne
    	sMessErr est une chaîne
    	iKeySize est un entier
    	bOAEPPadding est un booléen
     
    iKeySize = 2048
    bOAEPPadding = Vrai
     
    //Générer les clés privée et publique
    Crypto.GenerateKeys(sClePrivee,sClePublique,sMessErr,iKeySize)
    SI sMessErr <> "" ALORS
    	Erreur(sMessErr)
    	RENVOYER Faux
    FIN
     
    LOCAL
    	sMessAChiffrer est une chaîne
    	sMessUTF8 est une chaîne
    	sMessChiffre est une chaîne
    	sMessDechiffre est une chaîne
    	iCodePage est un entier
    	sHash est une chaîne
     
    sMessAChiffrer = "Message à chiffrer"
     
    //Il faut préciser l'encodage d'origine du message
    //Codes page du message en paramètres correspondant à l'encodage utilisé : https://msdn.microsoft.com/en-us/library/system.text.encoding.getencodings(v=vs.110).aspx
    iCodePage = 1252 //Pour windows-1252
    sMessUTF8 = Crypto.UTF8Encode(sMessAChiffrer,Crypto.GetEncoding(iCodePage))
     
    //Hashage du message (pour vérifier la conformité du résultat : http://www.sha1-online.com/)
    sHash = Crypto.GetSHA1(sMessUTF8,Crypto.GetEncoding(iCodePage))
     
    //Chiffrage du hash en RSA
    sMessChiffre = Crypto.RSAEncrypt(sHash,sClePublique,sMessErr,iKeySize,bOAEPPadding)
    SI sMessErr <> "" ALORS
    	Erreur(sMessErr)
    	RENVOYER Faux
    FIN
     
    //Déchiffrer le hash
    sMessDechiffre = Crypto.RSADecrypt(sMessChiffre,sClePrivee,sMessErr,iKeySize,bOAEPPadding)
    SI sMessErr <> "" ALORS
    	Erreur(sMessErr)
    	RENVOYER Faux
    FIN
     
    //Vérifier la signature
    sHash = Crypto.GetSHA1(sMessUTF8,Crypto.GetEncoding(iCodePage))
    SI sMessDechiffre = sHash ALORS
    	Info("Signature valide")
    SINON
    	Info("Signature invalide")
    FIN
    Et le code C# de la dll :

    Code c# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
     
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
     
    namespace Crypto
    {
        using System;
        using System.Diagnostics;
        using System.Security.Cryptography;
        using System.Text;
     
        public class Crypto
        {
     
            //---------------------------------------
            //RSA
     
            static public void GenerateKeys(ref string __publicPrivateKeyXML, ref string __publicOnlyKeyXML, ref string __sMessErr, int _ikeySize=1024)
            {
                try
                {
                    RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(_ikeySize);
                    //Pair of public and private key as XML string. Do not share this to other party
                    __publicPrivateKeyXML = RSA.ToXmlString(true);
                    //Private key in xml file, this string should be share to other parties
                    __publicOnlyKeyXML = RSA.ToXmlString(false);
                }
                catch (CryptographicException e)
                {
                    __sMessErr = e.ToString();
                }
            }
     
            static public string RSAEncrypt(string _sDataToEncrypt, string _sPublicKeyXML, ref string __sMessErr, int _ikeySize=1024, bool DoOAEPPadding=true)
            {
                try
                {
                    byte[] dataToEncrypt = Encoding.UTF8.GetBytes(_sDataToEncrypt);
                    byte[] encryptedData;
     
                    //Create a new instance of RSACryptoServiceProvider.
                    using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(_ikeySize))
                    {
                        RSA.FromXmlString(_sPublicKeyXML);
     
                        //Encrypt the passed byte array and specify OAEP padding. OAEP padding is only available on Microsoft Windows XP or later.  
                        encryptedData = RSA.Encrypt(dataToEncrypt, DoOAEPPadding);
                    }
                    return Convert.ToBase64String(encryptedData);
                }
                catch (CryptographicException e)
                {
                    __sMessErr = e.ToString();
                    return null;
                }
     
            }
     
            static public string RSADecrypt(string _sDataToDecryptBase64,string _sPrivateKeyXML, ref string __sMessErr, int _ikeySize=1024, bool DoOAEPPadding=true)
            {
                try
                {
                    byte[] dataToDecrypt = Convert.FromBase64String(_sDataToDecryptBase64);
                    byte[] decryptedBytes;
                    string decryptedData;
     
                    //Create a new instance of RSACryptoServiceProvider.
                    using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(_ikeySize))
                    {
                        RSA.FromXmlString(_sPrivateKeyXML);
     
                        //Decrypt the passed byte array and specify OAEP padding. OAEP padding is only available on Microsoft Windows XP or later.  
                        decryptedBytes = RSA.Decrypt(dataToDecrypt, DoOAEPPadding);
                        decryptedData = Encoding.UTF8.GetString(decryptedBytes);  
                    }
                    return decryptedData;
                }
                catch (CryptographicException e)
                {
                    __sMessErr = e.ToString();
                    return null;
                }
     
            }
     
            //---------------------------------------
            //Haschage
     
            public static string GetMD5(string text)
            {
                return GetMD5(text, Encoding.Default);
            }
            public static string GetMD5(string text, Encoding enc)
            {
                return GetHash<MD5CryptoServiceProvider>(text, enc);
            }
            public static string GetSHA1(string text)
            {
                return GetSHA1(text, Encoding.Default);
            }
            public static string GetSHA1(string text, Encoding enc)
            {
                return GetHash<SHA1CryptoServiceProvider>(text, enc);
            }
     
            public static string GetSHA384(string text)
            {
                return GetSHA384(text, Encoding.Default);
            }
            public static string GetSHA384(string text, Encoding enc)
            {
                return GetHash<SHA384CryptoServiceProvider>(text, enc);
            }
     
            public static string GetSHA512(string text)
            {
                return GetSHA512(text, Encoding.Default);
            }
            public static string GetSHA512(string text, Encoding enc)
            {
                return GetHash<SHA512CryptoServiceProvider>(text, enc);
            }
     
            public static string GetSHA256(string text)
            {
                return GetSHA256(text, Encoding.Default);
            }
            public static string GetSHA256(string text, Encoding enc)
            {
                return GetHash<SHA256CryptoServiceProvider>(text, enc);
            }
     
            public static string GetHash<TP>(string text, Encoding enc)
                where TP : HashAlgorithm, new()
            {
                var buffer = enc.GetBytes(text);
                var provider = new TP();
                return BitConverter.ToString(provider.ComputeHash(buffer)).Replace("-", "");
            }
     
            //---------------------------------------
            //Encodage
     
            public static Encoding GetEncoding(int codePage)
            {
                return Encoding.GetEncoding(codePage);
            }
     
            public static string UTF8Encode(string text)
            {
                return UTF8Encode(text,Encoding.Default);
            }
            public static string UTF8Encode(string text, Encoding enc)
            {
                byte[] textUTF8 = Encoding.Convert(enc,Encoding.UTF8,enc.GetBytes(text));
                return enc.GetString(textUTF8);
            }
     
            public static string UnicodeEncode(string text)
            {
                return UnicodeEncode(text, Encoding.Default);
            }
            public static string UnicodeEncode(string text, Encoding enc)
            {
                byte[] textUnicode = Encoding.Convert(enc, Encoding.Unicode, enc.GetBytes(text));
                return enc.GetString(textUnicode);
            }
     
        }
    }

    Bonne prog

  4. #4
    Nouveau Candidat au Club
    Homme Profil pro
    Consultant en sécurité
    Inscrit en
    septembre 2016
    Messages
    1
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vienne (Poitou Charente)

    Informations professionnelles :
    Activité : Consultant en sécurité

    Informations forums :
    Inscription : septembre 2016
    Messages : 1
    Points : 1
    Points
    1

    Par défaut Chiffrement RSA en WinDev : Blocage à l'ouverture de l'assemblage .Net

    Bonjour Bastien,

    Bravo pour cette initiative ! C'est une bonne idée de pouvoir utiliser une librairie RSA dans WinDev.

    Aucun problème pour :
    - télécharger et décompresser les dll Crypto et RSA
    - ajouter les dll comme assemblage .Net dans WinDev (version 19)

    Mais je rencontre un problème lors de l'exécution du code sous WinDev :
    L'assemblage <C:\Mes Projets\XXXX\Exe\RSA.dll> n'a pas pu être ouvert
    Le framework .NET a renvoyé l'erreur suivante :
    Impossible de charger le fichier ou l'assembly 'file:///C:\Mes Projets\XXXX\Exe\RSA.dll' ou une de ses dépendances. Tentative de chargement d’un programme de format incorrect.
    L'assemblage <RSA> n'a pas pu être ouvert

    En consultant les forums, j'ai vu une solution (en cas de téléchargement des fichiers .dll) qui consiste à cliquer droit sur le fichier RSA.dll dans l'Explorateur de fichiers Windows puis dans l'onglet Général à cliquer sur un bouton [Débloquer]. Dans mon cas, aucun bouton [Débloquer] n'apparait dans mon Explorateur (Windows 7 et 10).

    As-tu une idée pour que je puisse utiliser ta dll ?

    Petite remarque sur Crypto.dll : Pour signer, il faut chiffrer l'empreinte avec la clé privée. Pour vérifier la signature, il faut déchiffrer l'empreinte chiffrée avec la clé publique. Ainsi, une seule personne peut signer (avec sa clé privée) et tout le monde peut vérifier cette signature avec la clé publique du signataire

    Pascal

  5. #5
    Membre habitué
    Inscrit en
    août 2005
    Messages
    92
    Détails du profil
    Informations forums :
    Inscription : août 2005
    Messages : 92
    Points : 180
    Points
    180

    Par défaut

    Bonjour Pascal,

    Concernant les DLLs :

    La dll Crypto.dll reprend les fonctionnalités de la dll RSA.dll, donc tu n'as pas besoin d'utiliser les deux.

    Concernant ton crash, tu peux essayer les pistes suivantes :

    1/Fermer ton projet Windev. Vider son répertoire de compilation "<NomProjet>.cpl". Rouvrir ton projet et le recompiler.

    2/Installer les packages redistribuables Visual C++ pour Visual Studio 2013 sur les postes devant exécuter ton application : https://www.microsoft.com/fr-fr/down....aspx?id=40784.

    3/Tu as peut être un répertoire .NET dans ton projet.
    - Dans ce cas, il faut aller dans le répertoire <RépertoireDeTonProjet>\.NET.
    - Cliquer droit sur le répertoire <RépertoireDeTonProjet>\.NET\Compile avec la touche Maj gauche enfoncée et cliquer sur "Ouvrir une fenêtre de commande ici"
    - Dans l'invite de commande, copier le contenu complet du fichier <RepDeTonProjet>\.NET\Compile\Compile.bat, puis valider avec Entrée.
    - Un fichier <NomDeTonProjet>.dll va se créer. Il faut le copier dans le répertoire "Exe" de ton projet.

    4/Relancer les étapes précédentes si nécessaire.

  6. #6
    Futur Membre du Club
    Homme Profil pro
    Développeur informatique
    Inscrit en
    juin 2016
    Messages
    4
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juin 2016
    Messages : 4
    Points : 5
    Points
    5

    Par défaut Souci sur RSA.dll

    Bonjour BastienCB,

    Je suis développeur en Windev sous Windev21 et je suis heureux de trouver votre votre solution RSA.dll.
    Sur vos directives, j'ai installé :
    - Visual C++ pour visual Studion 2013
    - Atelier/.NET.. OK
    - Utiliser RSA.dll OK

    Cela n'a pas fonctionné sous débogueur avec message suivant :
    ----- Informations techniques -----

    Projet : ProCashNF525

    Appel WL :
    Traitement de 'Procédure globale pSignerRSA' (ProcéduresGlobales.pSignerRSA), ligne 30, thread 0

    Que s'est-il passé ?
    L'objet <RSATool> est inconnu dans l'assemblage <C:\Mes Projets NF525\ProCashNF525\Exe\RSA.dll>.
    Vérifier que la version de l'assemblage <C:\Mes Projets NF525\ProCashNF525\Exe\RSA.dll> utilisée en exécution est la même que la version utilisée pour la compilation du projet.
    L'objet de type <RSA.RSATool> (assemblage <C:\Mes Projets NF525\ProCashNF525\Exe\RSA.dll>) n'a pas pu être créé
    L'assemblage <c:\ProCashNF525\RSA.dll> n'a pas pu être ouvert
    Le framework .NET a renvoyé l'erreur suivante :
    Impossible de charger le fichier ou l'assembly 'file:///c:\ProCashNF525\RSA.dll' ou une de ses dépendances. Tentative de chargement d’un programme de format incorrect.
    L'assemblage <RSA> n'a pas pu être ouvert
    Par hasard, sous atelier\.NET, générer une dll, assemblage .NEt qui m'a généré <MonProjet>.dll et la configuration passe en mode Assemblage .NET
    - Sous débogueur, Toutes les fonctions RSA fonctionnent correctement. C'est formidable !

    Mais avec la configuration .NET, je ne peux pas créer un exe.
    JE remets en configuration Exe initiale, et j'ai le même problème

    J'ai utiliser les procédures que vous avez préconiser à Pascal mais rien ne change.

    Merci de m'éclairer STP

    Vincent

  7. #7
    Membre habitué
    Inscrit en
    août 2005
    Messages
    92
    Détails du profil
    Informations forums :
    Inscription : août 2005
    Messages : 92
    Points : 180
    Points
    180

    Par défaut

    Bonjour,

    Avez vous essayé de créer un nouveau projet pour tester la DLL ?

    Pour solutionner votre problème, j'essayerai cela :

    - Dans Windev, se mettre dans une configuration permettant de générer un exécutable Windows.
    - Dans l'explorateur de projet / Assemblages .NET, enlever l'assemblage RSA
    - Ensuite, cliquer sur le menu "Atelier/.NET/Utiliser un assemblage .NET dans votre projet".
    - Dans la fenêtre listant les assemblages disponibles, cliquer sur le bouton "Parcourir" et sélectionner la dll RSA.dll que vous venez de copier.
    - Cliquer sur le bouton de validation pour l'importer dans votre projet.

    - Relancer votre projet....

    Vous pouvez aussi essayer d'utiliser la DLL Crypto.dll qui reprend les fonctionnalités de la dll RSA.dll.

  8. #8
    Futur Membre du Club
    Homme Profil pro
    Développeur informatique
    Inscrit en
    juin 2016
    Messages
    4
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juin 2016
    Messages : 4
    Points : 5
    Points
    5

    Par défaut Problème semble résolu en 32 bits

    Bonjour Mr BastienCB,
    Excuses moi de vous dire tardivement, car j'étais sur autre projet.
    En recompilant exe en 32 bits, tout semble entrer ordre
    Pouvez vous que c'est cela la cause ? (non compatible 64 bits)

    Un grand merci
    Vincent

  9. #9
    Futur Membre du Club
    Homme Profil pro
    Développeur informatique
    Inscrit en
    juin 2016
    Messages
    4
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juin 2016
    Messages : 4
    Points : 5
    Points
    5

    Par défaut Merci

    rebonjour Mr BastienCb,
    Merci pour votre réponse rapide, toute fois elle ne correspond pas à ma question.
    Peut-être j'ai mal formulé ma question, qui concerne l'utilisation des clés
    Veuillez relire mon dernier message ci-dessous SVP

    Merci d'avance
    Vincent

    Bonjour Mr BastienCB,
    Votre solution RSA fonctionne très bien.
    Toute fois, j'ai une petite question :
    - Avec votre solution, on signe avec la clé publique, et on déchiffre avec la clé privée.
    - Dans le cadre de mon projet, c'est l'inverse qui est exigé.
    - J'ai donc inversé les appellations, en nommant la clé publique en clé secrète et la clé privée devient clé publique.
    - L'inconvénient de cette clé publique (ancienne clé privée) que je donne au public, contient l'ancienne clé publique, avec lequel je signe.
    - Ce n'est donc pas convenable pour le secret.
    - Avez vous une solution

    Merci par avance
    Vincent

    Citation Envoyé par bastiencb Voir le message
    Bonjour,

    Avez vous essayé de créer un nouveau projet pour tester la DLL ?

    Pour solutionner votre problème, j'essayerai cela :

    - Dans Windev, se mettre dans une configuration permettant de générer un exécutable Windows.
    - Dans l'explorateur de projet / Assemblages .NET, enlever l'assemblage RSA
    - Ensuite, cliquer sur le menu "Atelier/.NET/Utiliser un assemblage .NET dans votre projet".
    - Dans la fenêtre listant les assemblages disponibles, cliquer sur le bouton "Parcourir" et sélectionner la dll RSA.dll que vous venez de copier.
    - Cliquer sur le bouton de validation pour l'importer dans votre projet.

    - Relancer votre projet....

    Vous pouvez aussi essayer d'utiliser la DLL Crypto.dll qui reprend les fonctionnalités de la dll RSA.dll.

  10. #10
    Futur Membre du Club
    Homme Profil pro
    Développeur informatique
    Inscrit en
    août 2014
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vendée (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : août 2014
    Messages : 5
    Points : 7
    Points
    7

    Par défaut Merci :)

    Bonjour, je tenais à vous remercié bastiencb.

    Ma petite entreprise passait l'audit de la norme NF525 quand je me suis rendu compte que mon cryptage (WD 21) n'était pas valide.

    J'ai parcouru désespérément le web en urgence pour trouver une solution et suis tombé sur votre topic.
    Votre .dll Crypto à parfaitement fonctionnée et nous à littéralement sauvé la vie.
    Nous avons décroché la norme et mon entreprise peut encore exister grâce à vous.

    Au nom de mes collègues et de moi-même, un grand merci !

  11. #11
    Candidat au Club
    Profil pro
    Inscrit en
    mars 2008
    Messages
    3
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : mars 2008
    Messages : 3
    Points : 4
    Points
    4

    Par défaut crypyo.dll et certificat elliptic curve

    Bonjour
    Est-ce que cette crypto.dll supporte le certificat Elliptic Curve ?
    merci de votre réponse
    Yves67

  12. #12
    Nouveau Candidat au Club
    Homme Profil pro
    Chef de projet en SSII
    Inscrit en
    décembre 2016
    Messages
    1
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hautes Pyrénées (Midi Pyrénées)

    Informations professionnelles :
    Activité : Chef de projet en SSII
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : décembre 2016
    Messages : 1
    Points : 1
    Points
    1

    Par défaut Contact avec Bastiencb

    Bonjour bastiencb

    je dois réaliser une fonction de génération de clé public et clé privée et un CSR à partir d'une chaîne de caractère et le renvoyé dans un programme tiers.

    au vue de votre développement RSA.DLL j'aimerais rentrée en contact avec vous.

    Vous pouvez me joindre à l'adresse email contact@icdnousty.fr


    Merci

    Et a bientôt j'espère.

    Cordialement

  13. #13
    Futur Membre du Club
    Homme Profil pro
    Développeur informatique
    Inscrit en
    juin 2016
    Messages
    4
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Val de Marne (Île de France)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juin 2016
    Messages : 4
    Points : 5
    Points
    5

    Par défaut Existe-il un RSA.dll 64bits et comment le récupérer ?

    [QUOTE=VINCENT1504;8851295]rebonjour Mr BastienCb,

    Tout d'abord, merci pour m'avoir donné la solution RSA.
    RSA fonctionne très bien avec une application 32bits réalisée avec Windev.

    J'ai juste un problème. Dans cette même application de 32bits, je dois utiliser un autre composant de 64bits non modifiable, qui lui ne marche pas dans une appli 32 bits.

    Question : Existe-il un RSA.dll 64bits ? si oui, comment le récupérer ?

    Merci d'avance
    Vincent

  14. #14
    Nouveau Candidat au Club
    Homme Profil pro
    Chargé d'affaire
    Inscrit en
    septembre 2017
    Messages
    1
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Hautes Alpes (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Chargé d'affaire
    Secteur : Boutique - Magasin

    Informations forums :
    Inscription : septembre 2017
    Messages : 1
    Points : 1
    Points
    1

    Par défaut Signature avec clef privée

    Bonjour à tous, bonjour Vincent,

    Déjà un grand merci à chacun et tout particulièrement merci Bastien pour avoir partagé ton développement (Crypto.7z).
    Je travaille aussi sous windev, sur un logiciel de caisse. Comme beaucoup d'entre vous je dois donc me mettre en conformité avec la NF525 et (comme beaucoup d'entre vous surement aussi) les fonctions Windev ne m'apportent pas totale satisfaction.

    J'ai donc intégré cet assemblable et il s'avère très performant (merci encore !).
    Cependant (je rebondis sur le message de Vincent), nous créons une signature en utilisant une clef publique et décryptons avec la clef privé. Or de ce que j'ai pu lire ici et ailleurs (ici : https://fr.wikipedia.org/wiki/Signature_num%C3%A9rique), c'est à priori l'inverse qu'il faut faire.

    J'ai donc naturellement tenté d'encrypter avec la clef privé et décrypter avec la clé publique et ... ça ne passe pas (ce qui n'est pas vraiment surprenant).
    A ce stade, j'ai trouvé un moyen "détourné" et peut-être "acceptable" :
    - J'utilise donc la clé publique pour créer ma signature (tel quelle)
    - J'utilise la clé privée préalablement "retravaillée" pour décrypter.
    - Retravaillée : J'ai ôté la clef publique (qui s'y trouvée aussi) entre les balises : <Modulus>###</Modulus>

    Ainsi, mon fichier retravaillé (pseudo clé privé) peut être partagée sans risque, car elle ne permet plus de signer.

    Bref, c'est le moyen que j'ai trouvé pour me conformer "dans une certaine mesure" à la NF525... Tout en ayant conscience que j'utilise une clef publique et non privé pour signer.

    Jarkartha pourrait peut-être nous éclairer sur les options retenues. Merci d'avance pour votre aide (et mes félicitations pour la certif .

    Cordialement

    PS : En coup de vent, avons nous la possibilité d'extraire nos clef/publique (une fois générées) dans un format +/- standard afin de les réutiliser depuis un logiciel tiers (OPENSSL pour ne pas le citer) ?



    Bonjour Mr BastienCB,
    Votre solution RSA fonctionne très bien.
    Toute fois, j'ai une petite question :
    - Avec votre solution, on signe avec la clé publique, et on déchiffre avec la clé privée.
    - Dans le cadre de mon projet, c'est l'inverse qui est exigé.
    - J'ai donc inversé les appellations, en nommant la clé publique en clé secrète et la clé privée devient clé publique.
    - L'inconvénient de cette clé publique (ancienne clé privée) que je donne au public, contient l'ancienne clé publique, avec lequel je signe.
    - Ce n'est donc pas convenable pour le secret.
    - Avez vous une solution

    Merci par avance
    Vincent[/QUOTE]

  15. #15
    Futur Membre du Club
    Homme Profil pro
    Développeur informatique
    Inscrit en
    août 2014
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vendée (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : août 2014
    Messages : 5
    Points : 7
    Points
    7

    Par défaut Moindre mal

    Bonsoir

    Merci pour votre retour. J'avoue que je n'y ai pas touché depuis le passage de notre certification ^^ (D'autre projet en cour ....)

    Dans l'urgence du moment j'avais bien remarqué ce problème d'inversion des clés, mais le temps m'étant compté j'avais décidé d'en faire abstraction.
    Je pense qu'a court terme je vais employer votre technique Orbitbaz (merci) comme solution temporaire, ça n'est pas très propre mais si ça fait le job ça me va ^^
    Nous avons pris la décisions de refondre entièrement notre logiciel en java, une fois fini le problème ne ce posera plus.

    En tout cas bonne chance à tout les camarades codeur qui font face au NF525 !

    Cordialement.

  16. #16
    Membre habitué
    Inscrit en
    août 2005
    Messages
    92
    Détails du profil
    Informations forums :
    Inscription : août 2005
    Messages : 92
    Points : 180
    Points
    180

    Par défaut RSA : Signer et vérifier la signature

    Bonjour,

    Suite à vos observations , j'ai modifié quelque peu la dll Crypto.dll, pour ajouter deux méthodes pour signer et vérifier la signature.

    Vous pouvez la télécharger ici :
    -En version 32 bits : Crypto32.7z
    -En version 64 bits (non testé) : Crypto64.7z

    Le principe est donc de signer avec la CLÉ PRIVÉE, et de vérifier la signature avec la CLÉ PUBLIQUE.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
     
    LOCAL
    	sClePrivee est une chaîne
    	sClePublique est une chaîne
    	sMessErr est une chaîne
    	iKeySize est un entier
    	bOAEPPadding est un booléen
     
    iKeySize = 2048
    bOAEPPadding = Vrai
     
    //Générer les clés privée et publique
    Crypto.GenerateKeys(sClePrivee,sClePublique,sMessErr,iKeySize)
    SI sMessErr <> "" ALORS
    	Erreur(sMessErr)
    	RENVOYER Faux
    FIN
     
    LOCAL
    	sMessage est une chaîne
    	sMessUTF8 est une chaîne
    	sSignature est une chaîne
    	iCodePage est un entier
    	sHashType est une chaîne
     
    sMessage = "Message à signer"
     
    sHashType = "SHA1" //Les valeurs possibles pour le type d'algorithme de Hash sont "MD5", "SHA1", "SHA256", "SHA384" ou "SHA512"
    //Cf https://msdn.microsoft.com/en-us/library/system.security.cryptography.hashalgorithmname(v=vs.110).aspx
     
    //Il faut préciser l'encodage d'origine du message
    //Codes page du message en paramètres correspondant à l'encodage utilisé : https://msdn.microsoft.com/en-us/library/system.text.encoding.getencodings(v=vs.110).aspx
    iCodePage = 1252 //Pour windows-1252
    sMessUTF8 = Crypto.UTF8Encode(sMessage,Crypto.GetEncoding(iCodePage))
     
    //Signer le hash
    sSignature = Crypto.SignData(sMessUTF8,sClePrivee,sMessErr,iKeySize,sHashType)
    SI sMessErr <> "" ALORS
    	Erreur(sMessErr)
    	RENVOYER Faux
    FIN
     
    //vérifier la signature
    bOK est un booléen
     
    bOK = Crypto.VerifyData(sMessUTF8,sSignature,sClePublique,sMessErr,iKeySize,sHashType)
    SI bOK ALORS
    	Info("Signature valide")
    SINON
    	Info("Signature invalide")
    FIN
     
    sMessage = "Message modifié"
    sMessUTF8 = Crypto.UTF8Encode(sMessage,Crypto.GetEncoding(iCodePage))
     
    bOK = Crypto.VerifyData(sMessUTF8,sSignature,sClePublique,sMessErr,iKeySize,sHashType)
    SI bOK ALORS
    	Info("Signature valide")
    SINON
    	Info("Signature invalide")
    FIN
    Et voici le code .NET :

    Code c# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
     
    static public string SignData(string _sDataToSign, string __spublicPrivateKeyXML, ref string __sMessErr,int _ikeySize = 1024, string _sHashType = "SHA1")
    {
    	try
    	{
    		byte[] dataToSign = Encoding.UTF8.GetBytes(_sDataToSign);
    		byte[] signedData;
     
    		//Create a new instance of RSACryptoServiceProvider.
    		using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(_ikeySize))
    		{
    			RSA.FromXmlString(__spublicPrivateKeyXML);
     
    			//Sign with private key
    			signedData = RSA.SignData(dataToSign, CryptoConfig.MapNameToOID(_sHashType));
    		}
     
    		return Convert.ToBase64String(signedData);
    	}
    	catch (CryptographicException e)
    	{
    	   __sMessErr = e.ToString();
    	   return null;
    	}
    }
     
    static public bool VerifyData(string _sDataToVerify, string _sSignature, string __sPublicKeyXML, ref string __sMessErr, int _ikeySize = 1024, string _sHashType = "SHA1")
    {
    	bool bSuccess = false;
     
    	try
    	{
    		byte[] dataToVerify = Encoding.UTF8.GetBytes(_sDataToVerify);
    		byte[] signedData = Convert.FromBase64String(_sSignature);
     
    		//Create a new instance of RSACryptoServiceProvider.
    		using (RSACryptoServiceProvider RSA = new RSACryptoServiceProvider(_ikeySize))
    		{
    			RSA.FromXmlString(__sPublicKeyXML);
     
    			//Vérify with public key
    			bSuccess = RSA.VerifyData(dataToVerify, CryptoConfig.MapNameToOID(_sHashType), signedData);
    		}
     
    		return bSuccess;
    	}
    	catch (CryptographicException e)
    	{
    		__sMessErr = e.ToString();
    		return bSuccess;
    	}
    }

    Bonne prog

  17. #17
    Futur Membre du Club
    Homme Profil pro
    Développeur informatique
    Inscrit en
    août 2014
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vendée (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : août 2014
    Messages : 5
    Points : 7
    Points
    7

    Par défaut kanpai !

    Génial !! Merci Bastiencb !!!!
    (Tu n'imagine pas le nombre de gens que tu sauve ^^)

  18. #18
    Futur Membre du Club
    Homme Profil pro
    Développeur informatique
    Inscrit en
    août 2014
    Messages
    5
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Vendée (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Multimédia et Internet

    Informations forums :
    Inscription : août 2014
    Messages : 5
    Points : 7
    Points
    7

    Par défaut Précision

    Je viens de relire le document de norme nf525. Il est bien indiqué de signer avec la clé privée :

    Extrait : "La clé privée permettant de créer les signatures doit être strictement confidentielle."

    C'est certes une utilisation inversé du RSA (signé avec la public , décrypté avec la privée) mais c'est ce qu'ils demandent

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Chiffrement RSA - stockage des clés
    Par oieretxe dans le forum Android
    Réponses: 9
    Dernier message: 07/04/2015, 23h59
  2. Chiffrement RSA - Problème avec des caractères accentués
    Par HommeDeJava dans le forum Sécurité
    Réponses: 10
    Dernier message: 01/02/2012, 18h14
  3. chiffrement RSA en java
    Par LadyN dans le forum Sécurité
    Réponses: 3
    Dernier message: 26/03/2010, 11h09
  4. Chiffrement RSA : PHP et Java
    Par tagadapouetfr dans le forum Débuter
    Réponses: 6
    Dernier message: 17/07/2009, 10h49
  5. Faire du chiffrement RSA avec SATSA
    Par skip78 dans le forum Java ME
    Réponses: 3
    Dernier message: 01/06/2009, 17h58

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo