Ich generiere einen Schlüssel und muss ihn in der Datenbank speichern, also konvertiere ich ihn in einen String, aber um den Schlüssel aus dem String zurückzubekommen. Was sind die möglichen Wege, um dies zu erreichen?

Mein Code ist,

SecretKey key = KeyGenerator.getInstance("AES").generateKey();
String stringKey=key.toString();
System.out.println(stringKey);

Wie kann ich den Schlüssel vom String zurückbekommen?

Sie können das SecretKeyin ein Byte-Array ( byte[]) konvertieren und Base64 das dann in ein codieren String. Um wieder in a zu konvertieren SecretKey, dekodiert Base64 den String und verwendet ihn in a SecretKeySpec, um Ihr Original neu zu erstellen SecretKey.

Für Java 8

SecretKey to String:

// create new key
SecretKey secretKey = KeyGenerator.getInstance("AES").generateKey();
// get base64 encoded version of the key
String encodedKey = Base64.getEncoder().encodeToString(secretKey.getEncoded());

String zu SecretKey:

// decode the base64 encoded string
byte[] decodedKey = Base64.getDecoder().decode(encodedKey);
// rebuild key using SecretKeySpec
SecretKey originalKey = new SecretKeySpec(decodedKey, 0, decodedKey.length, "AES"); 

Für Java 7 und früher (einschließlich Android):

HINWEIS I: Sie können den Base64-Codierungs- / Decodierungsteil überspringen und den byte[]in SQLite speichern . Das Durchführen der Base64-Codierung / -Decodierung ist jedoch kein teurer Vorgang, und Sie können Zeichenfolgen problemlos in nahezu jeder Datenbank speichern.

HINWEIS II: Frühere Java-Versionen enthalten kein Base64 in einem der Pakete java.langoder java.util. Es ist jedoch möglich, Codecs aus Apache Commons Codec , Bouncy Castle oder Guava zu verwenden .

SecretKey to String:

// CREATE NEW KEY
// GET ENCODED VERSION OF KEY (THIS CAN BE STORED IN A DB)

    SecretKey secretKey;
    String stringKey;

    try {secretKey = KeyGenerator.getInstance("AES").generateKey();}
    catch (NoSuchAlgorithmException e) {/* LOG YOUR EXCEPTION */}

    if (secretKey != null) {stringKey = Base64.encodeToString(secretKey.getEncoded(), Base64.DEFAULT)}

String zu SecretKey:

// DECODE YOUR BASE64 STRING
// REBUILD KEY USING SecretKeySpec

    byte[] encodedKey     = Base64.decode(stringKey, Base64.DEFAULT);
    SecretKey originalKey = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");

Um zu zeigen, wie viel Spaß es macht, einige Funktionen zu erstellen, die schnell ausfallen, habe ich die folgenden 3 Funktionen geschrieben.

Man erstellt einen AES-Schlüssel, man codiert ihn und man decodiert ihn zurück. Diese drei Methoden können mit Java 8 verwendet werden (ohne Abhängigkeit von internen Klassen oder externen Abhängigkeiten):

public static SecretKey generateAESKey(int keysize)
        throws InvalidParameterException {
    try {
        if (Cipher.getMaxAllowedKeyLength("AES") < keysize) {
            // this may be an issue if unlimited crypto is not installed
            throw new InvalidParameterException("Key size of " + keysize
                    + " not supported in this runtime");
        }

        final KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(keysize);
        return keyGen.generateKey();
    } catch (final NoSuchAlgorithmException e) {
        // AES functionality is a requirement for any Java SE runtime
        throw new IllegalStateException(
                "AES should always be present in a Java SE runtime", e);
    }
}

public static SecretKey decodeBase64ToAESKey(final String encodedKey)
        throws IllegalArgumentException {
    try {
        // throws IllegalArgumentException - if src is not in valid Base64
        // scheme
        final byte[] keyData = Base64.getDecoder().decode(encodedKey);
        final int keysize = keyData.length * Byte.SIZE;

        // this should be checked by a SecretKeyFactory, but that doesn't exist for AES
        switch (keysize) {
        case 128:
        case 192:
        case 256:
            break;
        default:
            throw new IllegalArgumentException("Invalid key size for AES: " + keysize);
        }

        if (Cipher.getMaxAllowedKeyLength("AES") < keysize) {
            // this may be an issue if unlimited crypto is not installed
            throw new IllegalArgumentException("Key size of " + keysize
                    + " not supported in this runtime");
        }

        // throws IllegalArgumentException - if key is empty
        final SecretKeySpec aesKey = new SecretKeySpec(keyData, "AES");
        return aesKey;
    } catch (final NoSuchAlgorithmException e) {
        // AES functionality is a requirement for any Java SE runtime
        throw new IllegalStateException(
                "AES should always be present in a Java SE runtime", e);
    }
}

public static String encodeAESKeyToBase64(final SecretKey aesKey)
        throws IllegalArgumentException {
    if (!aesKey.getAlgorithm().equalsIgnoreCase("AES")) {
        throw new IllegalArgumentException("Not an AES key");
    }

    final byte[] keyData = aesKey.getEncoded();
    final String encodedKey = Base64.getEncoder().encodeToString(keyData);
    return encodedKey;
}

Eigentlich hat das, was Luis vorgeschlagen hat, bei mir nicht funktioniert. Ich musste einen anderen Weg finden. Das hat mir geholfen. Könnte dir auch helfen. Links:

1. * .getEncoded (): https://docs.oracle.com/javase/7/docs/api/java/security/Key.html

2. Encoder-Informationen: https://docs.oracle.com/javase/8/docs/api/java/util/Base64.Encoder.html

3. Decoder-Informationen: https://docs.oracle.com/javase/8/docs/api/java/util/Base64.Decoder.html

Codefragmente: Zum Codieren:

String temp = new String(Base64.getEncoder().encode(key.getEncoded()));

Zum Entschlüsseln:

byte[] encodedKey = Base64.getDecoder().decode(temp);
SecretKey originalKey = new SecretKeySpec(encodedKey, 0, encodedKey.length, "DES");

Du willst nicht benutzen .toString().

Beachten Sie, dass SecretKey von java.security.Key erbt, das selbst von Serializable erbt. Der Schlüssel hier (kein Wortspiel beabsichtigt) besteht darin, den Schlüssel in einen ByteArrayOutputStream zu serialisieren, das Array byte [] abzurufen und in der Datenbank zu speichern. Der umgekehrte Prozess wäre, das Byte [] -Array aus der Datenbank zu entfernen, einen ByteArrayInputStream aus dem Byte [] -Array zu erstellen und den SecretKey daraus zu deserialisieren ...

... oder noch einfacher, verwenden Sie einfach die .getEncoded()von java.security.Key (einer übergeordneten Schnittstelle von SecretKey) geerbte Methode. Diese Methode gibt das codierte Byte [] -Array von Key / SecretKey zurück, das Sie speichern oder aus der Datenbank abrufen können.

Dies alles setzt voraus, dass Ihre SecretKey-Implementierung die Codierung unterstützt. Andernfalls getEncoded()wird null zurückgegeben.

bearbeiten:

Sie sollten sich die Key / SecretKey-Javadocs ansehen (verfügbar direkt am Anfang einer Google-Seite):

http://download.oracle.com/javase/6/docs/api/java/security/Key.html

Oder dies von CodeRanch (auch mit der gleichen Google-Suche gefunden):

http://www.coderanch.com/t/429127/java/java/Convertion-between-SecretKey-String-or

Konvertieren von SecretKeySpec in String und umgekehrt: Sie können eine getEncoded()Methode verwenden, mit SecretKeySpecder angegeben wird byteArray, aus der Sie encodeToString()den stringWert von SecretKeySpecin Base64object abrufen können .

Während der Konvertierung SecretKeySpecnach String: use decode()in Base64wird geben byteArray, daraus können Sie eine Instanz SecretKeySpecmit den Parametern erstellen byteArray, um Ihre zu reproduzieren SecretKeySpec.

String mAesKey_string;
SecretKeySpec mAesKey= new SecretKeySpec(secretKey.getEncoded(), "AES");

//SecretKeySpec to String 
    byte[] byteaes=mAesKey.getEncoded();
    mAesKey_string=Base64.encodeToString(byteaes,Base64.NO_WRAP);

//String to SecretKeySpec
    byte[] aesByte = Base64.decode(mAesKey_string, Base64.NO_WRAP);
    mAesKey= new SecretKeySpec(aesByte, "AES");

Versuchen Sie dies, es funktioniert ohne Base64 (das nur in JDK 1.8 enthalten ist), dieser Code wird auch in der vorherigen Java-Version ausgeführt :)

private static String SK = "Secret Key in HEX";


//  To Encrupt

public static String encrypt( String Message ) throws Exception{

    byte[] KeyByte = hexStringToByteArray( SK);
    SecretKey k = new SecretKeySpec(KeyByte, 0, KeyByte.length, "DES");

    Cipher c = Cipher.getInstance("DES","SunJCE");
    c.init(1, k);
    byte mes_encrypted[] = cipher.doFinal(Message.getBytes());

    String MessageEncrypted = byteArrayToHexString(mes_encrypted);
    return MessageEncrypted;
}

//  To Decrypt

public static String decrypt( String MessageEncrypted )throws Exception{

    byte[] KeyByte = hexStringToByteArray( SK );
    SecretKey k = new SecretKeySpec(KeyByte, 0, KeyByte.length, "DES");

    Cipher dcr =  Cipher.getInstance("DES","SunJCE");
    dc.init(Cipher.DECRYPT_MODE, k);
    byte[] MesByte  = hexStringToByteArray( MessageEncrypted );
    byte mes_decrypted[] = dcipher.doFinal( MesByte );
    String MessageDecrypeted = new String(mes_decrypted);

    return MessageDecrypeted;
}

public static String byteArrayToHexString(byte bytes[]){

    StringBuffer hexDump = new StringBuffer();
    for(int i = 0; i < bytes.length; i++){
    if(bytes[i] < 0)
    {   
        hexDump.append(getDoubleHexValue(Integer.toHexString(256 - Math.abs(bytes[i]))).toUpperCase());
    }else
    {
        hexDump.append(getDoubleHexValue(Integer.toHexString(bytes[i])).toUpperCase());
    }
    return hexDump.toString();

}



public static byte[] hexStringToByteArray(String s) {

    int len = s.length();
    byte[] data = new byte[len / 2];
    for (int i = 0; i < len; i += 2)
    {   
        data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i+1), 16));
    }
    return data;

}