Java utilisant le chiffrement à clé symétrique AES 256 et 128

Je suis nouveau dans le chiffrement de la technologie. J'ai trouvé ce code pour faire du Chiffrement Symétrique.

byte[] key = //... secret sequence of bytes
byte[] dataToSend = ...
Cipher c = Cipher.getInstance("AES");
SecretKeySpec k = new SecretKeySpec(key, "AES");
c.init(Cipher.ENCRYPT_MODE, k);
byte[] encryptedData = c.doFinal(dataToSend);

Son travail. Ici, je peux utiliser mon propre mot de passe. Et c'est exactement ce dont j'avais besoin. Mais je ne sais pas comment faire, 128 ou 256 Symétrique Enctryption.
Comment puis-je utiliser 128 et 256 clé dans mon code ?

source d'informationauteur Bhuban

  1. 14

    Si AES utilise 128 ou 256 bits en mode dépend de la taille de votre clé, qui doit être de 128 ou 256 bits. En général, vous n'utilisez pas votre mot de passe comme clé, car les mots de passe ont rarement la longueur exacte que vous en avez besoin. Au lieu de cela, vous obtenez de clé de chiffrement de votre mot de passe en utilisant une fonction de dérivation de clé.

    exemple Très simple: prendre le MD5 de votre mot de passe pour obtenir une clé de 128 bits. Si vous voulez la clé de 256 bits, vous pouvez utiliser SHA-256 pour obtenir 256 bits hash de votre mot de passe. -Clé de la dérivation des fonctions généralement exécuter ce hachage plusieurs centaines de fois et utiliser plus de sel. Découvrez http://en.wikipedia.org/wiki/Key_derivation_function pour plus de détails.

    Également note: pour exécuter de chiffrement supérieur à 128 bits, vous devrez télécharger et installer "Java Cryptography Extension (JCE) Force Illimitée de la Compétence de la Politique de Fichiers de 6" de http://www.oracle.com/technetwork/java/javase/downloads/index.html.

  2. 6

    La Réponse de 128 bits

    La méthode suivante consiste à chiffrer une chaîne de caractères (valueEnc) avec le cryptage AES:

    private static final String ALGORITHM = "AES"; 

public String encrypt(final String valueEnc, final String secKey) { 

    String encryptedVal = null;

    try {
        final Key key = generateKeyFromString(secKey);
        final Cipher c = Cipher.getInstance(ALGORITHM);
        c.init(Cipher.ENCRYPT_MODE, key);
        final byte[] encValue = c.doFinal(valueEnc.getBytes());
        encryptedVal = new BASE64Encoder().encode(encValue);
    } catch(Exception ex) {
        System.out.println("The Exception is=" + ex);
    }

    return encryptedVal;
}

    La méthode suivante va décrypter la chaîne cryptée AES (encryptedVal):

        public String decrypt(final String encryptedValue, final String secretKey) {

    String decryptedValue = null;

    try {

        final Key key = generateKeyFromString(secretKey);
        final Cipher c = Cipher.getInstance(ALGORITHM);
        c.init(Cipher.DECRYPT_MODE, key);
        final byte[] decorVal = new BASE64Decoder().decodeBuffer(encryptedValue);
        final byte[] decValue = c.doFinal(decorVal);
        decryptedValue = new String(decValue);
    } catch(Exception ex) {
        System.out.println("The Exception is=" + ex);
    }

    return decryptedValue;
}

    La secKey est une clé de 128 bits, ce qui est codé dans le BASE64Encoder. Le BASE64Decoder la méthode suivante génère une clé de 128 bits

    private Key generateKeyFromString(final String secKey) throws Exception {
    final byte[] keyVal = new BASE64Decoder().decodeBuffer(secKey);
    final Key key = new SecretKeySpec(keyVal, ALGORITHM);
    return key;
}
  3. 2

    Vous pouvez utiliser un simple KeyGenerator objet comme ceci:

    KeyGenerator generator = KeyGenerator.getInstance("AES/CTR/PKCS5PADDING");
generator.init(128);
SecretKey key = generator.generateKey();
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, key);
...
  4. 1

    De Java docs pour Chiffrement.init(...):

    public final void init(int opmode,
    Key)

    Lance:
    InvalidKeyException - si la clé donnée est inapproprié pour l'initialisation de
    ce chiffrement, ou si ce niveau de chiffrement est
    en cours d'initialisation pour le décryptage et
    nécessite des paramètres de l'algorithme qui
    ne peut pas être déterminé à partir de la donnée
    la clé, ou si la clé donnée a un keysize
    qui dépasse le maximum autorisé
    keysize (tel que déterminé à partir de la
    configuré de la compétence de la politique de fichiers).

    Pour moi, cela signifie que, en tant que Martijn Courteaux dit dans son commentaire, vous devez utiliser une clé de 256 bits (c'est à dire initialiser le SecretKeySpec avec un tableau d'octets contenant 32 octets), et le chiffre qui va l'accepter et l'utiliser, ou de le rejeter et de lever une exception si sa taille n'est pas acceptable.

    Si vous obtenez une exception, c'est probablement parce que vous n'avez pas installé la force illimitée de chiffrement des fichiers, (le JDK par défaut permet d'installer les clés 128 bits comme indiqué dans ce crypto spec document). Téléchargement illimité de la force de la cryptographie paquet ici.

  5. 0
    public class CipherUtils
{
    private static byte[] key = {
            0x74, 0x68, 0x69, 0x73, 0x49, 0x73, 0x41, 0x53, 0x65, 0x63, 0x72, 0x65, 0x74, 0x4b, 0x65, 0x79
    };//"thisIsASecretKey";

    public static String encrypt(String strToEncrypt)
    {
        try
        {
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            final SecretKeySpec secretKey = new SecretKeySpec(key, "AES");
            cipher.init(Cipher.ENCRYPT_MODE, secretKey);
            final String encryptedString = Base64.encodeBase64String(cipher.doFinal(strToEncrypt.getBytes()));
            return encryptedString;
        }
        catch (Exception e)
        {
           e.printStackTrace();
        }
        return null;
    }
}