Umgewandelt geheimen Schlüssels in bytes, wie es zu konvertieren zurück zu secrect key?

Ich umwandeln der secretkey in bytes mit folgenden code

SecretKey key = KeyGenerator.getInstance("DES").generateKey();
byte[] bkey=key.getEncoded();

Wie bekomme ich nun den Schlüssel aus bkey? Ich habe versucht:

SecretKeySpec secretkey = new SecretKeySpec(bkey,"DES");   
SecretKeyFactory sfkey = SecretKeyFactory.getInstance("DES");
SecretKey skey = sfkey.generateSecret(secretkey);

Bekomme ich die folgende Fehlermeldung:

Error during Exception java.security.spec.InvalidKeySpecException: Inappropriate key specification
Warum brauchen Sie, um dies zu tun? Geben Sie einfach key zu Ihrer Chiffre.
warum wurde dieser nach unten gestimmt? scheint wie eine vernünftige Frage an mich.
Ich benutze eigentlich das Byte-format, um es zu speichern in Datenbank, und verwenden Sie es wieder zu entschlüsseln
Manche Leute wollen einfach nur Ihre Fragen beantwortet, ohne eine herablassende, elitäre Antwort. Kommentare wie diese machen unerfahrene Nutzer Angst um Ihre Fragen; ich würde es wissen, denn ich war (und immer noch irgendwie bin) in so einer situation mich...
Es war nicht eine Antwort sondern ein Kommentar, und einige Leute tatsächlich tun, zu schätzen, zu früh angehalten, wenn Ihre Wanderschaft führt Sie direkt auf den Abgrund zu. Beispiel gibt es zuhauf auf dieser Seite von Menschen, die mit grob unsichere Krypto, weil niemand sagte Ihnen, früh genug.

InformationsquelleAutor Princeyesuraj | 2011-03-19

  1. 30

    Sollte diese Arbeit

        SecretKey key = KeyGenerator.getInstance("DES").generateKey();
    byte[] data = key.getEncoded();
    SecretKey key2 = new SecretKeySpec(data, 0, data.length, "DES");

    InformationsquelleAutor MeBigFatGuy

  2. 3

    Versuchen einige der in diesem code...

    import javax.crypto.Cipher;
import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.InvalidKeyException;

public class DESede {
    private static String algorithm = "DESede";
    private static Key key = null;
    private static SecretKey secretKey = null;
    private static Cipher cipher = null;
    private static DESede obj = new DESede();

    private DESede() {
        try {
            key = KeyGenerator.getInstance(algorithm).generateKey();
            KeyGenerator.getInstance(algorithm).getProvider();
            byte[] keyBytes = key.getEncoded();
            String keyFormat = key.getFormat();
            String keyAlgorithm = key.getAlgorithm();
            String keyString = new String(keyBytes);
            System.out.println("Key Format::" + keyFormat);
            System.out.println("Key Algorithm::" + keyAlgorithm);
            System.out.println("Key String::" + keyString);
            keyString.getBytes();
            secretKey = new SecretKeySpec(keyBytes, 0, keyBytes.length, "DESede");
            byte[] secretKeyBytes = key.getEncoded();
            String secretKeyFormat = key.getFormat();
            String secretKeyAlgorithm = key.getAlgorithm();
            String secretKeyString = new String(secretKeyBytes);
            System.out.println("Secret Key Format::" + secretKeyFormat);
            System.out.println("Secret Key Algorithm::" + secretKeyAlgorithm);
            System.out.println("Secret Key String::" + secretKeyString);
            String keyNewString = "bXŒ*êÂÕê›æOÄ’Îý‘ãô|8¶Ë1­";
            byte[] keyNewBytes = keyString.getBytes();
            secretKey = new SecretKeySpec(keyBytes, 0, keyBytes.length, "DESede");
            cipher = Cipher.getInstance(algorithm);
        } catch (Exception e) {
        }
    }

    public static DESede getInstance() {
        return obj;
    }

    public static byte[] encrypt(String input) throws InvalidKeyException,
            BadPaddingException, IllegalBlockSizeException {
        System.out.println("Inside encrypt()");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] inputBytes = input.getBytes();
        System.out.println("Exit encrypt()");
        return cipher.doFinal(inputBytes);
    }

    public static String decrypt(byte[] encryptionBytes)
            throws InvalidKeyException, BadPaddingException,
            IllegalBlockSizeException {
        System.out.println("Inside decrypt()");
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] recoveredBytes = cipher.doFinal(encryptionBytes);
        String recovered = new String(recoveredBytes);
        System.out.println("Exiting decrypt()");
        return recovered;
    }

    public static void main(String args[]) throws InvalidKeyException,
            BadPaddingException, IllegalBlockSizeException {
        byte[] encryptedValue = DESede.encrypt("plz try encrypt and decrypt me");
        System.out.println("encryptedValue::" + encryptedValue);
        String decryptedValue = DESede.decrypt(encryptedValue);
        System.out.println("decryptedValue::" + decryptedValue);
    }
}

    InformationsquelleAutor Manoj

Schreibe einen Kommentar