Question sur le chiffrement/dechiffrement
Bonjour à tous
je souhaite envoyez un mot de passe d'une application cliente jusqu'à mon serveur
pour sécuriser le tout,j'envoie les donnée par SSL,
première question, si je récupère un password sous forme de String, est ce que le fait de transférer ce password du post client au serveur est suffisant niveau sécurité en utilisant SSL ? c'est à dire, est ce que quelqu'un pourrai entre le client et le serveur récupérer ce mot de passe ?
sinon une autre solution, ou pourquoi pas combiner les deux, serait de passer par un couple clé privée/clé publique
mon application cliente chiffre avec la clé publique et mon serveur déchiffre avec sa clé privé.
donc les autres question sont :
1) est ce que l'une ou l'autre solution se suffisent à elle même pour transporter les donnée de manière sécurisé ?
2) la quelle des deux solution est la meilleurs ?
3) vaut-il mieux combiner les deux solution pour un maximum de sécurité ou est-ce inutile ?
------------
dans le même sujet, pour chiffrer/déchiffrer j'ai trouvé ce bout de code
Code:
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
|
/* -------------------------------------Cryptage-------------------------------------------------*/
public MessageCrypteImpl crypterMessage(MessageImpl message) {
/* transformation de la chaine en tableau d'Octets */
byte[] msgEnOctets = message.getContenu().getBytes();
/* ajoute un octet codant le "1" au début du tableau passé en parametres */
byte[] resultat = new byte[msgEnOctets.length+1];
resultat[0] = 1;
for (int i = 0; i < msgEnOctets.length; i++) {
resultat[i+1] = msgEnOctets[i];
}
/* transforme le résultat en BigInteger */
BigInteger msgEnBigInteger = new BigInteger(resultat);
/* crypte le message par la méthode RSA grace a la clef publique (cela renvoi un BigInteger) */
BigInteger msgCrypte = msgEnBigInteger.modPow(clefPublique.getPublicExponent(), clefPublique.getModulus());
/* on retourne le message crypté sous la forme d'un tableau d'octets */
return new MessageCrypteImpl(msgCrypte.toByteArray(), null);
}
/* -------------------------------------Décryptage-------------------------------------------------*/
public MessageImpl decrypterMessage(MessageCrypteImpl messageCrypte) {
/* On repasse le tableau d'octets en BigInteger pour pouvoir le décrypter */
BigInteger msgADecrypteEnBigInt = new BigInteger(messageCrypte.getContenuCrypte());
/* on décrypte le message grace au RSA et a la clef privée */
BigInteger msgDecrypteEnBigInt = msgADecrypteEnBigInt.modPow(clefPrivee.getPrivateExponent(), clefPrivee.getModulus());
/* on repasse le message en octets pour pouvoir retirer l'octet qu'on lui avait ajouté */
byte[] msgDecrypteEnOctets = msgDecrypteEnBigInt.toByteArray();
/* on lui retire son octet en plus */
byte[] resultat = new byte[msgDecrypteEnOctets.length-1];
for (int i = 0; i < resultat.length; i++) {
resultat[i] = msgDecrypteEnOctets[i+1];
}
/* on retourne une chaine de charactères qui provient du tableau d'octets transformé */
return new MessageImpl (new String (resultat),null);
} |
en le remaniant à ma sauce, il fonctionne très bien.
par contre je me demandais à quoi servait le bout de code qui rajoute un octet dans le tableau, est ce vraiment necessaire ?
Code:
1
2
3
4
5
6
7
|
/* ajoute un octet codant le "1" au début du tableau passé en parametres */
# byte[] resultat = new byte[msgEnOctets.length+1];
# resultat[0] = 1;
# for (int i = 0; i < msgEnOctets.length; i++) {
# resultat[i+1] = msgEnOctets[i];
# } |
merci d'avance pour vos réponses.
