Comment crypter une chaîne en Java



Answers

Ceci est la première page qui s'affiche via Google et les failles de sécurité dans toutes les implémentations me font grincer des dents, donc je publie ceci pour ajouter des informations concernant le cryptage pour les autres comme il a été 7 Ans de la publication originale. Je suis titulaire d'une maîtrise en génie informatique et j'ai passé beaucoup de temps à étudier et à apprendre la cryptographie. Je lance donc mes deux cents pour rendre Internet plus sûr.

En outre, notez que beaucoup de mise en œuvre peut être sécurisée pour une situation donnée, mais pourquoi les utiliser et potentiellement faire une erreur accidentellement? Utilisez les outils les plus puissants dont vous disposez, sauf si vous avez une raison spécifique de ne pas le faire. Dans l'ensemble, je conseille fortement d'utiliser une bibliothèque et rester à l'écart des détails Nitty Gritty si vous le pouvez.

UPDATE 4/5/18: J'ai réécrit certaines parties pour les rendre plus simples à comprendre et changé la bibliothèque recommandée de Jasypt à la nouvelle bibliothèque Tink de Google , je recommanderais de supprimer complètement Jasypt d'une configuration existante.

Avant-propos

Je vais décrire les bases de la cryptographie symétrique sécurisée ci-dessous et souligner les erreurs courantes que je vois en ligne lorsque les gens implémentent eux-mêmes la cryptographie avec la bibliothèque Java standard. Si vous voulez simplement passer tous les détails dans la nouvelle bibliothèque de Google, Tink l' importera dans votre projet et utilisera le mode AES-GCM pour tous vos cryptages et vous serez sûr.

Maintenant, si vous voulez apprendre les détails Nitty Gritty sur la façon de crypter dans Java lire :)

Blocs chiffrés

La première chose que vous devez d'abord choisir une clé de chiffrement de clé symétrique. Un bloc de chiffrement est une fonction / programme informatique utilisé pour créer un pseudo-aléatoire. Pseudo-Randomness est faux aléatoire qu'aucun ordinateur autre qu'un ordinateur quantique ne serait capable de faire la différence entre elle et l'aléatoire réel. Le bloc de chiffrement est comme le bloc de construction de la cryptographie, et lorsqu'il est utilisé avec différents modes ou schémas, nous pouvons créer des chiffrements.

Maintenant, en ce qui concerne les algorithmes de chiffrement de bloc disponibles aujourd'hui, assurez-vous de ne JAMAIS , je répète ne jamais utiliser DES , je dirais même jamais utiliser 3DES . Le seul code de bloc que même la version NSA de Snowden a pu vérifier est vraiment aussi proche de Pseudo-Random que possible est AES . Il existe également AES 128, la différence est AES 256 fonctionne dans les blocs de 256 bits, tandis que AES 128 fonctionne dans 128 blocs. Dans l'ensemble, l'AES 128 est considéré comme sécurisé bien que certaines faiblesses aient été découvertes, mais 256 est aussi solide que possible.

Fait amusant Le DES été brisé par la NSA quand il a été fondé et a gardé un secret pendant quelques années et bien que certaines personnes prétendent encore que 3DES est sécurisé, il y a quelques recherches qui ont trouvé et analysé les faiblesses de 3DES .

Modes de chiffrement

Le cryptage est créé lorsque vous prenez un code de bloc et que vous utilisez un schéma spécifique de sorte que le caractère aléatoire est combiné avec une clé pour créer quelque chose de réversible tant que vous connaissez la clé. Ceci est appelé un mode de cryptage.

Voici un exemple de mode de cryptage et le mode le plus simple connu sous le nom ECB juste pour que vous puissiez comprendre visuellement ce qui se passe:

Les modes de cryptage que vous verrez le plus souvent en ligne sont les suivants:

BCE CTR, CBC, GCM

Il existe d'autres modes en dehors de ceux énumérés et les chercheurs travaillent toujours vers de nouveaux modes pour améliorer les problèmes existants.

Passons maintenant aux implémentations et à ce qui est sécurisé. N'utilisez JAMAIS ECB c'est mauvais pour cacher des données répétitives comme indiqué par le fameux pingouin de Linux .

Lors de l'implémentation en Java, notez que si vous utilisez le code suivant, le mode ECB est défini par défaut:

Cipher cipher = Cipher.getInstance("AES");

... DANGER C'EST UNE VULNÉRABILITÉ! et malheureusement, cela est vu partout dans StackOverflow et en ligne dans des tutoriels et des exemples.

Nonces et IVs

En réponse au problème rencontré avec le mode ECB, des noms également connus sous le nom d'IV ont été créés. L'idée est que nous générons une nouvelle variable aléatoire et l'attachons à chaque chiffrement de sorte que lorsque vous cryptez deux messages qui sont les mêmes, ils sortent différents. La beauté derrière cela est qu'un IV ou un nonce est de notoriété publique. Cela signifie qu'un attaquant peut avoir accès à cela, mais tant qu'ils n'ont pas votre clé, ils ne peuvent rien faire avec cette connaissance.

Les problèmes courants que je verrai est que les gens vont définir le IV comme une valeur statique dans la même valeur fixe dans leur code. et voici le piège à IVs le moment où vous répétez celui que vous compromettez réellement la sécurité entière de votre cryptage.

Générer un IV aléatoire

SecureRandom randomSecureRandom = SecureRandom.getInstance("SHA1PRNG");
byte[] iv = new byte[cipher.getBlockSize()];
randomSecureRandom.nextBytes(iv);
IvParameterSpec ivParams = new IvParameterSpec(iv);

Note: SHA1 est cassé mais je n'ai pas trouvé comment implémenter SHA256 dans ce cas d'utilisation correctement, donc si quelqu'un veut faire un crack et mettre à jour ce serait génial! De plus, les attaques SHA1 ne sont toujours pas conventionnelles car cela peut prendre quelques années sur un énorme cluster à craquer. Découvrez les détails ici.

Mise en œuvre du CTR

Aucun remplissage n'est requis pour le mode CTR.

 Cipher cipher = Cipher.getInstance("AES/NoPadding");

Mise en œuvre CBC

Si vous choisissez d'implémenter le mode CBC, faites-le avec PKCS7Padding comme suit:

 Cipher cipher = Cipher.getInstance("AES/CBC/PKCS7Padding");

Vulnérabilité CBC et CTR et pourquoi utiliser GCM

Bien que d'autres modes tels que CBC et CTR soient sécurisés, ils se heurtent au problème où un attaquant peut retourner les données cryptées, en changeant sa valeur lorsqu'il est déchiffré. Alors disons que vous cryptez un message bancaire imaginaire "Vendre 100", votre message crypté ressemble à ceci "eu23ng" l'attaquant change un bit pour "eu53ng" et tout à coup quand déchiffré votre message, il se lit comme "Vendre 900".

Pour éviter cela, la majorité d'Internet utilise GCM, et chaque fois que vous voyez HTTPS, ils utilisent probablement GCM. GCM signe le message crypté avec un hachage et vérifie que le message n'a pas été modifié à l'aide de cette signature.

J'éviterais de mettre en œuvre le GCM en raison de sa complexité. Vous feriez mieux d'utiliser la nouvelle bibliothèque Tink de Googles parce que là encore, si vous répétez accidentellement un IV, vous compromettez la clé dans le cas de GCM, ce qui est le défaut de sécurité ultime. De nouveaux chercheurs travaillent sur des modes de cryptage résistant à la répétition IV où même si vous répétez l'IV, la clé n'est pas en danger, mais cela n'a pas encore été le cas.

Maintenant, si vous voulez implémenter GCM, voici un lien vers une bonne implémentation de GCM . Cependant, je ne peux pas assurer la sécurité ou si elle est correctement mise en œuvre, mais il obtient la base vers le bas. Notez également avec GCM il n'y a pas de remplissage.

Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");

Clés vs mots de passe

Une autre remarque très importante est que lorsqu'il s'agit de la cryptographie, une clé et un mot de passe ne sont pas la même chose. Une clé dans la cryptographie doit avoir une certaine quantité d'entropie et de caractère aléatoire pour être considérée comme sûre. C'est pourquoi vous devez vous assurer d'utiliser les bibliothèques cryptographiques appropriées pour générer la clé pour vous.

Donc, vous avez vraiment deux implémentations que vous pouvez faire ici, la première est d'utiliser le code trouvé sur ce thread StackOverflow pour la génération de clé aléatoire . Cette solution utilise un générateur de nombres aléatoires sécurisé pour créer une clé à partir de zéro que vous pouvez utiliser.

L'autre option moins sûre est d'utiliser, l'entrée de l'utilisateur comme un mot de passe. Le problème que nous avons discuté est que le mot de passe n'a pas assez d'entropie, donc nous devrions utiliser PBKDF2 , un algorithme qui prend le mot de passe et le renforce. Voici une implémentation de StackOverflow que j'ai aimé . Cependant, la bibliothèque Google Tink a tout cela intégré et vous devriez en profiter.

Développeurs Android

Un point important à souligner ici est de savoir que votre code android est reverse engineeringable et la plupart des cas le plus de code java est aussi. Cela signifie que si vous stockez le mot de passe en texte brut dans votre code. Un hacker peut facilement le récupérer. Habituellement, pour ce type de cryptage, vous voulez utiliser la cryptographie asymétrique et ainsi de suite. Ceci est en dehors de la portée de ce poste, donc je vais éviter de plonger dedans.

Une lecture intéressante de 2013 : souligne que 88% des implémentations de Crypto dans Android ont été mal faites.

Dernières pensées

Encore une fois, je suggère d'éviter d'implémenter directement la librairie Java pour crypto et d'utiliser Google Tink , cela vous évitera le mal de tête car ils ont vraiment fait un bon travail d'implémentation de tous les algorithmes correctement. Et même alors, assurez-vous de vérifier les problèmes soulevés sur le github Tink, vulnérabilités popup ici et là.

Si vous avez des questions ou des commentaires n'hésitez pas à commenter! La sécurité est en constante évolution et vous devez faire de votre mieux pour suivre le rythme :)

Question

Ce dont j'ai besoin, c'est de crypter la chaîne qui apparaîtra dans le code à barres 2D (PDF-417), donc quand quelqu'un aura une idée à scanner, il n'aura rien de lisible.

Autres exigences:

  • ne devrait pas être compliqué
  • il ne doit pas être composé d'une RSA, d'une infrastructure PKI, de paires de clés, etc.

Il doit être assez simple pour se débarrasser des gens qui fouinent autour, et facile à déchiffrer pour les autres entreprises intéressées à obtenir ces données. Ils nous appellent, nous leur disons la norme ou leur donnons une clé simple qui peut ensuite être utilisée pour le décryptage.

Probablement que ces entreprises pourraient utiliser différentes technologies, il serait donc bon de s'en tenir à une norme qui n'est pas liée à une plate-forme ou à une technologie particulière.

Que suggérez-vous? Y at-il une classe Java faisant encrypt () decrypt () sans trop de complication pour atteindre des standards de sécurité élevés?




merci ive fait cette classe en utilisant votre code peut-être quelqu'un le trouve userfull

crypter d'objet

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.ShortBufferException;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;


public class ObjectCrypter {

private Cipher deCipher;
private Cipher enCipher;
private SecretKeySpec key;
private IvParameterSpec ivSpec;


public ObjectCrypter(byte[] keyBytes,   byte[] ivBytes) {
    // wrap key data in Key/IV specs to pass to cipher


     ivSpec = new IvParameterSpec(ivBytes);
    // create the cipher with the algorithm you choose
    // see javadoc for Cipher class for more info, e.g.
    try {
         DESKeySpec dkey = new  DESKeySpec(keyBytes);
          key = new SecretKeySpec(dkey.getKey(), "DES");
         deCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
         enCipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
    } catch (NoSuchAlgorithmException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (NoSuchPaddingException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (InvalidKeyException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}
public byte[] encrypt(Object obj) throws InvalidKeyException, InvalidAlgorithmParameterException, IOException, IllegalBlockSizeException, ShortBufferException, BadPaddingException {
    byte[] input = convertToByteArray(obj);
    enCipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);

    return enCipher.doFinal(input);




//  cipher.init(Cipher.ENCRYPT_MODE, key, ivSpec);
//  byte[] encypted = new byte[cipher.getOutputSize(input.length)];
//  int enc_len = cipher.update(input, 0, input.length, encypted, 0);
//  enc_len += cipher.doFinal(encypted, enc_len);
//  return encypted;


}
public Object decrypt( byte[]  encrypted) throws InvalidKeyException, InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException, IOException, ClassNotFoundException {
    deCipher.init(Cipher.DECRYPT_MODE, key, ivSpec);

    return convertFromByteArray(deCipher.doFinal(encrypted));

}



private Object convertFromByteArray(byte[] byteObject) throws IOException,
        ClassNotFoundException {
    ByteArrayInputStream bais;

    ObjectInputStream in;
    bais = new ByteArrayInputStream(byteObject);
    in = new ObjectInputStream(bais);
    Object o = in.readObject();
    in.close();
    return o;

}



private byte[] convertToByteArray(Object complexObject) throws IOException {
    ByteArrayOutputStream baos;

    ObjectOutputStream out;

    baos = new ByteArrayOutputStream();

    out = new ObjectOutputStream(baos);

    out.writeObject(complexObject);

    out.close();

    return baos.toByteArray();

}


}



String s1="arshad"; 
char[] s2=s1.toCharArray(); 
int s3= s2.length; 

  System.out.println(s3);
 int i=0; 

// for(int j=0;j<s3;j++) 
// System.out.println(s2[j]); 

for(i=0;i<((s3)/2);i++) { 

char z,f=10; 
z=(char) (s2[i] * f); 
s2[i]=s2[(s3-1)-i]; 
s2[(s3-1)-i]=z; 

String b=new String(s2);

 print(b);  }



Voici une solution simple avec seulement les dépendances java.* Et javax.crypto.* Pour le cryptage des octets assurant la confidentialité et l' intégrité . Il doit être indiscernable sous une attaque en texte clair choisie .

Il utilise AES en mode GCM sans rembourrage, une clé 128 bits est dérivée par PBKDF2 avec beaucoup d'itérations et un sel statique du mot de passe fourni. Cela garantit que les mots de passe de forçage brut sont durs et distribue l'entropie sur l'ensemble de la clé.

Un vecteur d'initialisation aléatoire (IV) est généré et sera ajouté au texte chiffré. En outre, l'octet statique 0x01 est ajouté en tant que premier octet en tant que «version».

Le message entier va dans le code d'authentification de message (MAC) généré par AES/GCM .

Ici, ça va, zéro classe de chiffrement des dépendances externes assurant la confidentialité et l' intégrité :

package cryptor;

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.KeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * This class implements AES-GCM symmetric key encryption with a PBKDF2 derived password.
 * It provides confidentiality and integrity of the plaintext.
 *
 * @created 2018-02-25
 */
public class AesGcmCryptor {

    // https://crypto.stackexchange.com/questions/26783/ciphertext-and-tag-size-and-iv-transmission-with-aes-in-gcm-mode
    private static final byte VERSION_BYTE = 0x01;
    private static final int VERSION_BYTE_LENGTH = 1;
    private static final int AES_KEY_BITS_LENGTH = 128;
    private static final int GCM_IV_BYTES_LENGTH = 12;
    private static final int GCM_TAG_BYTES_LENGTH = 16;

    private static final int PBKDF2_ITERATIONS = 16384;

    private static final byte[] PBKDF2_SALT = hexStringToByteArray("4d3fe0d71d2abd2828e7a3196ea450d4");

    /**
     * Decrypts an AES-GCM encrypted ciphertext and is
     * the reverse operation of {@link AesGcmCryptor#encrypt(char[], byte[])}
     *
     * @param password   passphrase for decryption
     * @param ciphertext encrypted bytes
     *
     * @return plaintext bytes
     *
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws NoSuchProviderException
     * @throws InvalidKeySpecException
     * @throws InvalidAlgorithmParameterException
     * @throws InvalidKeyException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws IllegalArgumentException           if the length or format of the ciphertext is bad
     */
    public byte[] decrypt(char[] password, byte[] ciphertext)
            throws NoSuchPaddingException, NoSuchAlgorithmException, NoSuchProviderException, InvalidKeySpecException,
            InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException,
            BadVersionException {

        // input validation
        if (ciphertext == null) {
            throw new IllegalArgumentException("Ciphertext cannot be null.");
        }

        if (ciphertext.length <= VERSION_BYTE_LENGTH + GCM_IV_BYTES_LENGTH + GCM_TAG_BYTES_LENGTH) {
            throw new IllegalArgumentException("Ciphertext too short.");
        }

        // the version must match, we don't decrypt other versions
        if (ciphertext[0] != VERSION_BYTE) {
            throw new BadVersionException();
        }

        // input seems legit, lets decrypt and check integrity

        // derive key from password
        SecretKey key = deriveAesKey(password, PBKDF2_SALT, AES_KEY_BITS_LENGTH);

        // init cipher
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "SunJCE");
        GCMParameterSpec params = new GCMParameterSpec(GCM_TAG_BYTES_LENGTH * 8,
                ciphertext,
                VERSION_BYTE_LENGTH,
                GCM_IV_BYTES_LENGTH
        );
        cipher.init(Cipher.DECRYPT_MODE, key, params);

        final int ciphertextOffset = VERSION_BYTE_LENGTH + GCM_IV_BYTES_LENGTH;

        // add version and IV to MAC
        cipher.updateAAD(ciphertext, 0, ciphertextOffset);

        // decipher and check MAC
        return cipher.doFinal(ciphertext, ciphertextOffset, ciphertext.length - ciphertextOffset);
    }

    /**
     * Encrypts a plaintext with a password.
     *
     * The encryption provides the following security properties:
     * Confidentiality + Integrity
     *
     * This is achieved my using the AES-GCM AEAD blockmode with a randomized IV.
     *
     * The tag is calculated over the version byte, the IV as well as the ciphertext.
     *
     * Finally the encrypted bytes have the following structure:
     * <pre>
     *          +-------------------------------------------------------------------+
     *          |         |               |                             |           |
     *          | version | IV bytes      | ciphertext bytes            |    tag    |
     *          |         |               |                             |           |
     *          +-------------------------------------------------------------------+
     * Length:     1B        12B            len(plaintext) bytes            16B
     * </pre>
     * Note: There is no padding required for AES-GCM, but this also implies that
     * the exact plaintext length is revealed.
     *
     * @param password  password to use for encryption
     * @param plaintext plaintext to encrypt
     *
     * @throws NoSuchAlgorithmException
     * @throws NoSuchProviderException
     * @throws NoSuchPaddingException
     * @throws InvalidAlgorithmParameterException
     * @throws InvalidKeyException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws InvalidKeySpecException
     */
    public byte[] encrypt(char[] password, byte[] plaintext)
            throws NoSuchAlgorithmException, NoSuchProviderException, NoSuchPaddingException,
            InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException,
            InvalidKeySpecException {

        // initialise random and generate IV (initialisation vector)
        SecretKey key = deriveAesKey(password, PBKDF2_SALT, AES_KEY_BITS_LENGTH);
        final byte[] iv = new byte[GCM_IV_BYTES_LENGTH];
        SecureRandom random = SecureRandom.getInstanceStrong();
        random.nextBytes(iv);

        // encrypt
        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding", "SunJCE");
        GCMParameterSpec spec = new GCMParameterSpec(GCM_TAG_BYTES_LENGTH * 8, iv);
        cipher.init(Cipher.ENCRYPT_MODE, key, spec);

        // add IV to MAC
        final byte[] versionBytes = new byte[] { VERSION_BYTE };
        cipher.updateAAD(versionBytes);
        cipher.updateAAD(iv);

        // encrypt and MAC plaintext
        byte[] ciphertext = cipher.doFinal(plaintext);

        // prepend VERSION and IV to ciphertext
        byte[] encrypted = new byte[1 + GCM_IV_BYTES_LENGTH + ciphertext.length];
        int pos = 0;
        System.arraycopy(versionBytes, 0, encrypted, 0, VERSION_BYTE_LENGTH);
        pos += VERSION_BYTE_LENGTH;
        System.arraycopy(iv, 0, encrypted, pos, iv.length);
        pos += iv.length;
        System.arraycopy(ciphertext, 0, encrypted, pos, ciphertext.length);

        return encrypted;
    }

    /**
     * We derive a fixed length AES key with uniform entropy from a provided
     * passphrase. This is done with PBKDF2/HMAC256 with a fixed count
     * of iterations and a provided salt.
     *
     * @param password passphrase to derive key from
     * @param salt     salt for PBKDF2 if possible use a per-key salt, alternatively
     *                 a random constant salt is better than no salt.
     * @param keyLen   number of key bits to output
     *
     * @return a SecretKey for AES derived from a passphrase
     *
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     */
    private SecretKey deriveAesKey(char[] password, byte[] salt, int keyLen)
            throws NoSuchAlgorithmException, InvalidKeySpecException {

        if (password == null || salt == null || keyLen <= 0) {
            throw new IllegalArgumentException();
        }
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        KeySpec spec = new PBEKeySpec(password, salt, PBKDF2_ITERATIONS, keyLen);
        SecretKey pbeKey = factory.generateSecret(spec);

        return new SecretKeySpec(pbeKey.getEncoded(), "AES");
    }

    /**
     * Helper to convert hex strings to bytes.
     *
     * May be used to read bytes from constants.
     */
    private static byte[] hexStringToByteArray(String s) {

        if (s == null) {
            throw new IllegalArgumentException("Provided `null` string.");
        }

        int len = s.length();
        if (len % 2 != 0) {
            throw new IllegalArgumentException("Invalid length: " + len);
        }

        byte[] data = new byte[len / 2];
        for (int i = 0; i < len - 1; i += 2) {
            byte b = (byte) toHexDigit(s, i);
            b <<= 4;
            b |= toHexDigit(s, i + 1);
            data[i / 2] = b;
        }
        return data;
    }

    private static int toHexDigit(String s, int pos) {
        int d = Character.digit(s.charAt(pos), 16);
        if (d < 0) {
            throw new IllegalArgumentException("Cannot parse hex digit: " + s + " at " + pos);
        }
        return d;
    }
}

Here the entire project with a nice CLI: https://github.com/trichner/tcrypt




public static String encryptParams(String myTextInput) {

        String myKey = "40674244454045cb9a70040a30e1c007";
        String myVector = "@1B2c3D4e5F6g7H8";

        String encData = "";

        try{
            JavaEncryprtionUtil encUtil = new JavaEncryprtionUtil();
            encData = Base64.encodeToString(encUtil.encrypt(myTextInput.getBytes("UTF-8"), myKey.getBytes("UTF-8"), myVector.getBytes("UTF-8")),Base64.DEFAULT);
            System.out.println(encData);
        }catch(NoSuchAlgorithmException ex){
            ex.printStackTrace();
        }catch(NoSuchPaddingException ex){
            ex.printStackTrace();
        }catch(InvalidKeyException ex){
            ex.printStackTrace();
        }catch(InvalidAlgorithmParameterException ex){
            ex.printStackTrace();
        }catch(IllegalBlockSizeException ex){
            ex.printStackTrace();
        }catch(BadPaddingException ex){
            ex.printStackTrace();
        }catch(UnsupportedEncodingException ex){
            ex.printStackTrace();
        }

        return encData;
    }



Voici ma mise en œuvre de meta64.com en tant que Spring Singleton. Si vous voulez créer une instance de ciper pour chaque appel qui fonctionne également, vous pouvez supprimer les appels "synchronisés", mais attention, "cipher" n'est pas compatible avec les threads.

import java.security.Key;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import javax.xml.bind.DatatypeConverter;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("singleton")
public class Encryptor {

    @Value("${aeskey}")
    private String keyStr;

    private Key aesKey = null;
    private Cipher cipher = null;

    synchronized private void init() throws Exception {
        if (keyStr == null || keyStr.length() != 16) {
            throw new Exception("bad aes key configured");
        }
        if (aesKey == null) {
            aesKey = new SecretKeySpec(keyStr.getBytes(), "AES");
            cipher = Cipher.getInstance("AES");
        }
    }

    synchronized public String encrypt(String text) throws Exception {
        init();
        cipher.init(Cipher.ENCRYPT_MODE, aesKey);
        return toHexString(cipher.doFinal(text.getBytes()));
    }

    synchronized public String decrypt(String text) throws Exception {
        init();
        cipher.init(Cipher.DECRYPT_MODE, aesKey);
        return new String(cipher.doFinal(toByteArray(text)));
    }

    public static String toHexString(byte[] array) {
        return DatatypeConverter.printHexBinary(array);
    }

    public static byte[] toByteArray(String s) {
        return DatatypeConverter.parseHexBinary(s);
    }

    /*
     * DO NOT DELETE
     * 
     * Use this commented code if you don't like using DatatypeConverter dependency
     */
    // public static String toHexStringOld(byte[] bytes) {
    // StringBuilder sb = new StringBuilder();
    // for (byte b : bytes) {
    // sb.append(String.format("%02X", b));
    // }
    // return sb.toString();
    // }
    //
    // public static byte[] toByteArrayOld(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;
    // }
}



Voici quelques liens que vous pouvez lire ce que Java supporte

Cryptage / décryptage d'un flux de données.

Cet exemple montre comment crypter (en utilisant un algorithme de cryptage symétrique tel que AES, Blowfish, RC2, 3DES, etc.) une grande quantité de données. Les données sont transmises par morceaux à l'une des méthodes chiffrées: EncryptBytes, EncryptString, EncryptBytesENC ou EncryptStringENC. (Le nom de la méthode indique le type d'entrée (chaîne ou tableau d'octets) et le type de retour (chaîne codée ou tableau d'octets) .Les propriétés FirstChunk et LastChunk sont utilisées pour indiquer si un segment est premier, milieu ou dernier dans un flux être crypté Par défaut, FirstChunk et LastChunk sont tous deux égaux à true, ce qui signifie que les données transmises représentent le montant total.

JCERefGuide

Exemples de chiffrement Java




Links