moyen facile de stocker/restaurer la clé de chiffrement pour chaîne en java

Question

décryptage

Pour le cryptage J'utilise quelque chose comme ceci:

SecretKey aesKey = KeyGenerator.getInstance("AES").generateKey(); 
StringEncrypter aesEncrypt = new StringEncrypter(aesKey, aesKey.getAlgorithm()); 
String aesEncrypted= aesEncrypt.encrypt(StringContent); 

Si j'imprimer aesKey je reçois: « javax.crypto.spec.SecretKeySpec@1708d » .

Donc, pour le cryptage, je voudrais demander à l'utilisateur pour la clé, mais ne sais pas comment et quel format devrait-il être. Mon plan était quelque chose comme ceci:

SecretKey aesKey = javax.crypto.spec.SecretKeySpec@1708d; 
StringEncrypter aesEncrypt = new StringEncrypter(aesKey, aesKey.getAlgorithm()); 
String aesDecrypt = aesEncrypt.decrypt(aesEncrypted); 

Mais semble son ne fonctionne pas. Existe-t-il un moyen facile d'imprimer la clé après le cryptage sur la console afin que l'utilisateur puisse l'enregistrer (ou s'en souvenir), puis utiliser pour le déchiffrement?

Tout le code est ici: Cannot decrypt cyphertext from text file, symmetric key implement. in java Donc je suis désolé de poster à nouveau mais je ne suis pas sûr Si le code est encore lisible (je suis novice).

Answer 1

J'ai stocké des clés dans des fichiers keystore java. Voici un article qui peut vous aider

http://www.informit.com/articles/article.aspx?p=170967&seqNum=3

Answer 2

Juste pour référence, la sortie que vous voyez est le résultat de la méthode par défaut toString et le nombre drôle sur la fin est un code de hachage. Voir here. Les codes de hachage ne sont pas forcément réversibles et toString n'est pas forcément garanti pour vous donner assez d'informations pour reconstruire l'objet original (bien que ce soit le cas pour certaines classes).

Answer 3

La plupart des instances Java Key sont représentées par une chaîne d'octets résultant de leur méthode getEncoded(). C'est ce qui doit être stocké afin de reconstruire la clé plus tard. Toutefois, pour stocker une clé en toute sécurité sous forme électronique, elle doit être cryptée. Bien sûr, le cryptage de la clé nécessiterait une autre clé (ou mot de passe) & hellip; et ainsi vous avez une régression infinie. Un Java KeyStore peut être utilisé pour stocker des objets SecretKey de cette manière, ce qui est utile lorsque vous avez de nombreuses clés secrètes qui sont toutes protégées par un seul mot de passe «maître». Mais pour protéger une seule clé, cela n'a pas beaucoup de sens. Une alternative consiste à présenter la clé à l'utilisateur sous une forme qui peut être stockée de manière sûre (dans de nombreuses applications, qui peuvent être sur une feuille de papier dans leur portefeuille). Cela peut être aussi simple que d'afficher les octets de la clé codée en hexadécimal, Base-64, ou tout autre encodage de texte, et demander à l'utilisateur de l'écrire.

Une autre approche consiste à permettre à l'utilisateur de choisir un mot de passe mémorable, et de générer une clé avec cela, en utilisant un algorithme comme PBKDF2. Le sel (et peut-être le nombre d'itérations) utilisé pour la dérivation de clé devrait être enregistré quelque part cependant. Un autre inconvénient est que les gens ont tendance à choisir parmi un nombre relativement limité de mots de passe sur le total disponible. Les clés dérivées des mots de passe peuvent donc être plus faciles à deviner que ne le suggère la taille de la clé. Voici une illustration de la technique de base pour persister et reconstituer une clé secrète.

byte[] encoded = aesKey.getEncoded(); 
/* Now store "encoded" somewhere. For example, display the key and 
    ask the user to write it down. */ 
String output = Base64.getEncoder().withoutPadding().encodeToString(encoded); 
System.out.println("Keep it secret, keep it safe! " + output); 

... 

/* At some point, you need to reconstitute the key. Let's say the user 
    enters it as a base-64 number that you convert to bytes. */ 
String input = ... ; 
byte[] encoded = Base64.getDecoder().decode(input); 
SecretKey aesKey = new SecretKeySpec(encoded, "AES"); 

Answer 4

J'ai dû le faire moi-même récemment. Et tandis que les réponses d'autres m'ont amené dans la bonne direction, cela aurait pu être plus facile. Donc, voici ma "part" pour la journée, un couple de méthodes d'aide pour la manipulation de clé simple AES.(Notez la dépendance et Apache Commons Codec.)

C'est dans un moment git: github.com/stuinzuri/SimpleJavaKeyStore

import static org.apache.commons.codec.binary.Hex.*; 
import static org.apache.commons.io.FileUtils.*; 
import java.io.*; 
import java.security.NoSuchAlgorithmException; 
import javax.crypto.*; 
import org.apache.commons.codec.DecoderException; 

public static SecretKey generateKey() throws NoSuchAlgorithmException 
{ 
    KeyGenerator keyGenerator = KeyGenerator.getInstance("AES"); 
    keyGenerator.init(256); // 128 default; 192 and 256 also possible 
    return keyGenerator.generateKey(); 
} 

public static void saveKey(SecretKey key, File file) throws IOException 
{ 
    char[] hex = encodeHex(key.getEncoded()); 
    writeStringToFile(file, String.valueOf(hex)); 
} 

public static SecretKey loadKey(File file) throws IOException 
{ 
    String data = new String(readFileToByteArray(file)); 
    byte[] encoded; 
    try { 
     encoded = decodeHex(data.toCharArray()); 
    } catch (DecoderException e) { 
     e.printStackTrace(); 
     return null; 
    } 
    return new SecretKeySpec(encoded, "AES"); 
}