Comment chiffrer une chaîne en Java

Ce dont j’ai besoin, c’est de crypter des chaînes de caractères qui apparaîtront dans les codes à barres 2D (PDF-417).

Autres exigences:

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

Il doit être assez simple pour se débarrasser des personnes qui fouillent, et facile à décrypter pour les autres sociétés 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.

Ces entresockets pourraient probablement utiliser des technologies différentes, il serait donc judicieux de respecter certaines normes qui ne sont pas liées à une plate-forme ou à une technologie particulière.

Que suggérez-vous? Existe-t-il une classe Java faisant encrypt () decrypt () sans trop compliquer la réalisation de normes de sécurité élevées?

Je recommande d’utiliser un chiffreur symésortingque standard largement disponible comme DES , 3DES ou AES . Bien que ce ne soit pas l’algorithme le plus sécurisé, il existe de nombreuses implémentations et il vous suffit de donner la clé à toute personne censée décrypter les informations contenues dans le code à barres. javax.crypto.Cipher est ce que vous voulez travailler avec ici.

Supposons que les octets à chiffrer se trouvent dans

byte[] input; 

Ensuite, vous aurez besoin des octets de la clé et du vecteur d’initialisation

 byte[] keyBytes; byte[] ivBytes; 

Vous pouvez maintenant initialiser le Cipher pour l’algorithme que vous sélectionnez:

 // wrap key data in Key/IV specs to pass to cipher SecretKeySpec key = new SecretKeySpec(keyBytes, "DES"); IvParameterSpec ivSpec = new IvParameterSpec(ivBytes); // create the cipher with the algorithm you choose // see javadoc for Cipher class for more info, eg Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding"); 

Le cryptage irait comme ceci:

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

Et décryptage comme ceci:

 cipher.init(Cipher.DECRYPT_MODE, key, ivSpec); byte[] decrypted = new byte[cipher.getOutputSize(enc_len)]; int dec_len = cipher.update(encrypted, 0, enc_len, decrypted, 0); dec_len += cipher.doFinal(decrypted, dec_len); 

Ceci est la première page qui apparaît via Google et les vulnérabilités de sécurité dans toutes les implémentations me font peur alors je poste ceci pour append des informations concernant le cryptage pour les autres depuis 7 ans à partir du message original. Je suis titulaire d’une maîsortingse 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.

De plus, notez que beaucoup d’implémentations peuvent être sécurisées pour une situation donnée, mais pourquoi les utiliser et potentiellement faire une erreur accidentelle? Utilisez les outils les plus puissants dont vous disposez à moins que vous n’ayez une raison spécifique de ne pas le faire. Dans l’ensemble, je vous conseille vivement d’utiliser une bibliothèque et d’éviter les détails si vous le pouvez.

MISE À JOUR 5/5/18: J’ai réécrit certaines parties pour les rendre plus simples à comprendre et pour changer la bibliothèque recommandée de Jasypt à la nouvelle bibliothèque de Google Tink , je vous recommande de supprimer complètement Jasypt d’une installation existante.

Avant-propos

Je vais décrire les bases de la cryptographie symésortingque sécurisée ci-dessous et signaler les erreurs courantes que je vois en ligne lorsque des personnes implémentent elles-mêmes le chiffrement avec la bibliothèque Java standard. Si vous voulez simplement ignorer tous les détails sur la nouvelle bibliothèque de Google, importez-la dans votre projet et utilisez le mode AES-GCM pour tous vos chiffrements et vous serez en sécurité.

Maintenant, si vous voulez apprendre les détails nitty gritty sur la façon de crypter en java lisez la suite 🙂

Bloquer les chiffres

Tout d’abord, vous devez choisir une clé de bloc symésortingque. Un chiffrement par bloc est une fonction ou un programme informatique utilisé pour créer une pseudo-aléatoire. Le pseudo-aléatoire est un faux hasard qu’aucun ordinateur autre qu’un ordinateur quantique ne serait capable de faire la différence entre lui et le vrai hasard. Le chiffrement par bloc 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 utiliser DES , je dirais même NE JAMAIS utiliser 3DES . Le seul chiffrement de bloc que même la version NSA de Snowden a pu vérifier comme étant aussi proche de Pseudo-Random que possible est AES 256 . Il existe également AES 128, la différence est AES 256 fonctionne dans des blocs de 256 bits, tandis que AES 128 fonctionne dans 128 blocs. Dans l’ensemble, AES 128 est considéré comme sécurisé, bien que certaines faiblesses aient été découvertes, mais que 256 soit aussi solide que possible.

Fait amusant Le DES a été brisé par la NSA lors de sa création initiale et a gardé le secret pendant quelques années. Bien que certains prétendent que 3DES est sécurisé, il existe plusieurs études qui ont trouvé et analysé les faiblesses de 3DES .

Modes de cryptage

Le chiffrement est créé lorsque vous prenez un chiffrement par bloc et que vous utilisez un schéma spécifique pour que le caractère aléatoire soit associé à une clé pour créer quelque chose de réversible, à condition de connaître la clé. Ceci est appelé un mode de cryptage.

Voici un exemple de mode de chiffrement et le mode le plus simple connu sous le nom d’ECB, pour que vous puissiez comprendre ce qui se passe:

Mode ECB

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 listé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 mal de cacher des données répétitives comme le montre le fameux pingouin Linux . Exemple de pingouin 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 CECI EST UNE VULNÉRABILITÉ! et malheureusement, cela se voit partout dans StackOverflow et en ligne dans des tutoriels et des exemples.

Nonces et IVs

En réponse à la question trouvée avec le mode ECB, des noms ont également été créés. L’idée est que nous générons une nouvelle variable aléatoire et que nous l’associons à chaque chiffrement pour que, lorsque vous chiffrez deux messages identiques, ils sortent différents. La beauté derrière cela est que l’IV ou le nonce est une connaissance publique. Cela signifie qu’un attaquant peut y accéder, mais tant qu’il n’a pas votre clé, il ne peut rien faire avec cette connaissance.

Les problèmes communs que je vais voir sont que les utilisateurs définiront la valeur IV comme une valeur statique, comme dans la même valeur fixe de leur code. Et voici le piège des IVs dès que vous en répétez une, vous compromettez réellement la sécurité totale de votre cryptage.

Générer un aléatoire IV

 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 ne pouvais pas trouver comment implémenter SHA256 dans ce cas d’utilisation correctement, donc si quelqu’un veut le faire et le mettre à jour, ce serait génial! De plus, les attaques SHA1 ne sont toujours pas conventionnelles car elles peuvent prendre quelques années sur un énorme cluster. Découvrez les détails ici.

Mise en œuvre du CTR

Aucun remplissage n’est requirejs pour le mode CTR.

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

Mise en œuvre de la 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 certains autres modes, tels que CBC et CTR, soient sécurisés, ils se heurtent au problème dans lequel un attaquant peut retourner les données chiffrées, en modifiant leur valeur lors du déchiffrement. Alors disons que vous cryptez un message bancaire imaginaire “Sell 100”, votre message crypté ressemble à ceci “eu23ng”, l’attaquant change de bit en “eu53ng” et soudainement, lorsqu’il décrypte votre message, il se lit comme “Sell 900”.

Pour éviter cela, la majorité des internautes utilisent 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 GCM en raison de sa complexité. Vous feriez mieux d’utiliser la nouvelle bibliothèque Googles Tink, car là encore, si vous répétez accidentellement une IV, vous compromettez la clé du problème avec GCM, qui est la faille de sécurité ultime. Les nouveaux chercheurs travaillent sur des modes de cryptage résistants à la répétition IV où, même si vous répétez le test IV, la clé n’est pas en danger mais cela n’a pas encore été fait.

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

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

Clés vs mots de passe

Une autre note très importante est qu’en matière de cryptographie, une clé et un mot de passe ne sont pas les mêmes. Une clé dans la cryptographie doit avoir une certaine quantité d’entropie et d’aléatoire pour être considérée comme sécurisée. 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 pouvez vraiment faire deux implémentations ici, la première consiste à utiliser le code trouvé sur ce thread StackOverflow pour la génération de clés aléatoires . Cette solution utilise un générateur de nombres aléatoires sécurisé pour créer une clé à partir de laquelle vous pouvez l’utiliser.

L’autre option moins sécurisée consiste à utiliser une entrée utilisateur telle qu’un mot de passe. Le problème, comme nous en avons discuté, est que le mot de passe n’a pas assez d’entropie, nous devrions donc utiliser PBKDF2 , un algorithme qui prend le mot de passe et le renforce. Voici une implémentation de StackOverflow qui m’a plu . Cependant, la bibliothèque Google Tink a tout cela intégré et vous devriez en tirer parti.

Développeurs Android

Un point important à souligner ici est de savoir que votre code Android est ingénierie inverse et que la plupart des codes Java le sont aussi. Cela signifie que si vous stockez le mot de passe en texte brut dans votre code. Un pirate peut facilement le récupérer. Généralement, pour ce type de cryptage, vous souhaitez utiliser la cryptographie asymésortingque, etc. Ceci est hors de la scope de cet article, donc je vais éviter d’y plonger.

Une lecture intéressante de 2013 : Souligne que 88% des implémentations Crypto dans Android ont été effectuées de manière incorrecte.

Dernières pensées

Encore une fois, je suggère d’éviter d’implémenter directement la bibliothèque java pour crypto et d’utiliser Google Tink , cela vous évitera des problèmes car ils ont vraiment bien implémenté tous les algorithmes. Et même alors, assurez-vous de vérifier les problèmes soulevés dans le github Tink, les vulnérabilités ici et là.

Si vous avez des questions ou des commentaires, n’hésitez pas à commenter! La sécurité change constamment et vous devez faire de votre mieux pour suivre le rythme 🙂

Attention

Ne l’utilisez pas comme mesure de sécurité.

Le mécanisme de chiffrement dans cet article est un pavé unique, ce qui signifie que la clé secrète peut être facilement récupérée par un attaquant en utilisant 2 messages chiffrés. XOR 2 messages cryptés et vous obtenez la clé. C’est simple!

Souligné par Moussa


J’utilise le Base64Encoder / Decoder de Sun, qui se trouve dans le JRE de Sun, pour éviter un autre JAR dans lib. C’est dangereux d’utiliser OpenJDK ou un autre JRE. En outre, y a-t-il une autre raison pour laquelle je devrais envisager d’utiliser Apache commons lib avec Encoder / Decoder?

 public class EncryptUtils { public static final Ssortingng DEFAULT_ENCODING = "UTF-8"; static BASE64Encoder enc = new BASE64Encoder(); static BASE64Decoder dec = new BASE64Decoder(); public static Ssortingng base64encode(Ssortingng text) { try { return enc.encode(text.getBytes(DEFAULT_ENCODING)); } catch (UnsupportedEncodingException e) { return null; } }//base64encode public static Ssortingng base64decode(Ssortingng text) { try { return new Ssortingng(dec.decodeBuffer(text), DEFAULT_ENCODING); } catch (IOException e) { return null; } }//base64decode public static void main(Ssortingng[] args) { Ssortingng txt = "some text to be encrypted"; Ssortingng key = "key phrase used for XOR-ing"; System.out.println(txt + " XOR-ed to: " + (txt = xorMessage(txt, key))); Ssortingng encoded = base64encode(txt); System.out.println(" is encoded to: " + encoded + " and that is decoding to: " + (txt = base64decode(encoded))); System.out.print("XOR-ing back to original: " + xorMessage(txt, key)); } public static Ssortingng xorMessage(Ssortingng message, Ssortingng key) { try { if (message == null || key == null) return null; char[] keys = key.toCharArray(); char[] mesg = message.toCharArray(); int ml = mesg.length; int kl = keys.length; char[] newmsg = new char[ml]; for (int i = 0; i < ml; i++) { newmsg[i] = (char)(mesg[i] ^ keys[i % kl]); }//for i return new String(newmsg); } catch (Exception e) { return null; } }//xorMessage }//class 

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

object crypteur

 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, eg 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(); } } 

Que dis-tu de ça:

 private static byte[] xor(final byte[] input, final byte[] secret) { final byte[] output = new byte[input.length]; if (secret.length == 0) { throw new IllegalArgumentException("empty security key"); } int spos = 0; for (int pos = 0; pos < input.length; ++pos) { output[pos] = (byte) (input[pos] ^ secret[spos]); ++spos; if (spos >= secret.length) { spos = 0; } } return output; } 

Fonctionne bien pour moi et est plutôt compact.

Voici mon implémentation de meta64.com en tant que singleton de spring. Si vous souhaitez créer une instance Ciper pour chaque appel qui fonctionnerait également, vous pourrez alors 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 Ssortingng 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 Ssortingng encrypt(Ssortingng text) throws Exception { init(); cipher.init(Cipher.ENCRYPT_MODE, aesKey); return toHexSsortingng(cipher.doFinal(text.getBytes())); } synchronized public Ssortingng decrypt(Ssortingng text) throws Exception { init(); cipher.init(Cipher.DECRYPT_MODE, aesKey); return new Ssortingng(cipher.doFinal(toByteArray(text))); } public static Ssortingng toHexSsortingng(byte[] array) { return DatatypeConverter.printHexBinary(array); } public static byte[] toByteArray(Ssortingng s) { return DatatypeConverter.parseHexBinary(s); } /* * DO NOT DELETE * * Use this commented code if you don't like using DatatypeConverter dependency */ // public static Ssortingng toHexSsortingngOld(byte[] bytes) { // SsortingngBuilder sb = new SsortingngBuilder(); // for (byte b : bytes) { // sb.append(Ssortingng.format("%02X", b)); // } // return sb.toSsortingng(); // } // // public static byte[] toByteArrayOld(Ssortingng 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; // } } 

J’envisagerais d’utiliser quelque chose comme https://www.bouncycastle.org/ C’est une bibliothèque prédéfinie qui vous permet de chiffrer ce que vous voulez avec un certain nombre de Ciphers différents. Je comprends que vous voulez seulement protéger de l’espionnage, mais si vous vouloir protéger les informations, l’utilisation de Base64 ne vous protégera pas réellement.

Voici quelques liens que vous pouvez lire sur ce que Java supporte

Cryptage / décryptage d’un stream de données.

Cet exemple montre comment chiffrer (à l’aide d’un algorithme de chiffrement symésortingque tel que AES, Blowfish, RC2, 3DES, etc.) une grande quantité de données. Les données sont transmises en morceaux à l’une des méthodes de chiffrement suivantes: EncryptBytes, EncryptSsortingng, EncryptBytesENC ou EncryptSsortingngENC. (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 permettent d’indiquer si un bloc est le premier, le milieu ou le dernier d’un stream. pour être chiffré Par défaut, FirstChunk et LastChunk sont tous deux vrais, ce qui signifie que les données transmises correspondent au montant total.

JCERefGuide

Exemples de cryptage Java

Vous pouvez utiliser Jasypt

Avec Jasypt, le cryptage et la vérification d’un mot de passe peuvent être aussi simples que …

 StrongTextEncryptor textEncryptor = new StrongTextEncryptor(); textEncryptor.setPassword(myEncryptionPassword); 

Cryptage:

 Ssortingng myEncryptedText = textEncryptor.encrypt(myText); 

Décryptage:

 Ssortingng plainText = textEncryptor.decrypt(myEncryptedText); 

Gradle:

 comstack group: 'org.jasypt', name: 'jasypt', version: '1.9.2' 

Caractéristiques:

Jasypt met à votre disposition des techniques de cryptage unidirectionnelles (digest) et bidirectionnelles simples.

API ouverte à utiliser avec n’importe quel fournisseur JCE, et pas seulement celle de Java VM par défaut. Jasypt peut être facilement utilisé avec des fournisseurs renommés comme Bouncy Castle. Apprendre encore plus.

Sécurité accrue pour les mots de passe de vos utilisateurs. Apprendre encore plus.

Prise en charge du chiffrement binary. Jasypt permet de digérer et de chiffrer les binarys (tableaux d’octets). Cryptez vos objects ou fichiers en cas de besoin (pour être envoyé sur le net, par exemple).

Prise en charge du chiffrement des numéros. Outre les textes et les binarys, il permet de digérer et de chiffrer les valeurs numériques (BigInteger et BigDecimal, d’autres types numériques sont pris en charge lors du chiffrement pour la persistance Hibernate). Apprendre encore plus.

Complètement sans fil.

Prise en charge du pool de cryptage / digesteur, afin d’obtenir de hautes performances dans les systèmes multi-processeurs / multi-core.

Inclut une version allégée (“lite”) de la bibliothèque pour une meilleure gestion dans les environnements de taille restreinte tels que les plates-formes mobiles.

Fournit à la fois des outils de chiffrement simples sans configuration pour les utilisateurs novices en matière de chiffrement et des outils de chiffrement standard hautement configurables, pour les utilisateurs avertis.

Intégration optionnelle Hibernate 3 et 4 pour les champs persistants de vos entités mappées de manière chiffrée. Le chiffrement des champs est défini dans les fichiers de mappage d’Hibernate et rest transparent pour le rest de l’application (utile pour les données personnelles sensibles, les bases de données avec de nombreux utilisateurs en lecture …). Crypter des textes, des binarys, des nombres, des booléens, des dates … En savoir plus.

Intégrable en toute transparence dans une application Spring, avec des fonctionnalités d’intégration spécifiques pour Spring 2, Spring 3.0 et Spring 3.1. Tous les digesteurs et chiffreurs de jasypt sont conçus pour être facilement utilisés (instanciés, injectés par des dépendances …) depuis le spring. Et, en raison de leur sécurité vis-à-vis des threads, ils peuvent être utilisés sans soucis de synchronisation dans un environnement singleton tel que Spring. En savoir plus: Spring 2, Spring 3.0, Spring 3.1.

Intégration facultative de Spring Security (anciennement Acegi Security) pour effectuer des tâches de chiffrement de mot de passe et de correspondance pour la structure de sécurité, en améliorant la sécurité des mots de passe de vos utilisateurs grâce à des mécanismes de chiffrement plus sûr Apprendre encore plus.

Fournit des fonctionnalités avancées pour chiffrer tout ou partie des fichiers de configuration d’une application, y compris des informations sensibles telles que les mots de passe de firebase database. Intégrez de manière transparente la configuration cryptée dans des applications simples, basées sur Spring et / ou Hibernate. Apprendre encore plus.

Facilite l’utilisation des outils CLI (interface de ligne de commande) pour permettre aux développeurs d’initialiser leurs données chiffrées et d’inclure des opérations de chiffrement / déchiffrement / résumé dans les tâches de maintenance ou les scripts. Apprendre encore plus.

S’intègre à Apache Wicket, pour un cryptage plus robuste des URL dans vos applications sécurisées.

Guides complets et documentation javadoc, pour permettre aux développeurs de mieux comprendre ce qu’ils font réellement à leurs données.

Prise en charge robuste des jeux de caractères, conçue pour chiffrer et digérer de manière adéquate les textes, quel que soit le charset d’origine. Prise en charge complète de langages tels que le japonais, le coréen, l’arabe … sans problèmes d’encodage ou de plate-forme.

Très haut niveau de capacités de configuration: le développeur peut implémenter des astuces comme demander à un “crypteur” de demander, par exemple, un serveur HTTPS distant pour que le mot de passe soit utilisé pour le cryptage. Il vous permet de répondre à vos besoins de sécurité.

Voici une solution simple avec uniquement des dépendances java.* Et javax.crypto.* Pour le cryptage des octets assurant la confidentialité et l’ intégrité . Il ne peut être distingué par une attaque de texte en clair choisie .

Il utilise AES en mode GCM sans remplissage, 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 brutal sont difficiles et dissortingbue l’entropie sur la clé entière.

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».

L’ensemble du message passe dans le code d’authentification de message (MAC) généré par AES/GCM .

La voici, 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 symmesortingc 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 = hexSsortingngToByteArray("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: * 
 * +-------------------------------------------------------------------+ * | | | | | * | version | IV bytes | ciphertext bytes | tag | * | | | | | * +-------------------------------------------------------------------+ * Length: 1B 12B len(plaintext) bytes 16B * 

* 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/sortingchner/tcrypt

This is method i used.this is simple but it has better protection. https://github.com/chamikaras/simpleEncryptor

Read readme on this project.This is simple to used.

 public SimpleEncryptor(int MaximumLength) { //initialize encryption Key pattern variable pattern = new Integer[MaximumLength]; //Generate pattern pattern =GenarateEncryptionPattern(MaximumLength); } private Integer[] GenarateEncryptionPattern(int Length) { Integer[] randomPattern = new Integer[Length]; //generate encryption pattern for (int i = 0; i < Length; i++) { //make random encrypt key Random random = new Random(); randomPattern[i] = random.nextInt(9); } return randomPattern; } public void simpleEncryptData(String data) { for (int i=0; i 

}

I Have made this Simple Solution for You.

Main Point is Encrypt Ssortingng by shifting ASCII Value of the Integer by the secret key you Provide.

Here is the Solution:

 public Ssortingng encryptText(Ssortingng toEncrypt) { Ssortingng tempEn = toEncrypt + ""; Ssortingng encryptText =""; for(int i=0;i 

Steps to Encode:

  1. Scan each character of Ssortingng, Read ASCII of that character and add it with secret key as 148113 in this case.
  2. Convert shifted Integer into Character and concatenate to the Ssortingng encryptText and finally return it.

Steps to Decode:

  1. Scan each character of Ssortingng, Read ASCII of that character and subtract it with secret key as previous.
  2. Convert that value to character and concatenate with decodeText .

As previous encode output is always Ssortingng '???' and vary according to number of character of input Ssortingng .

 Ssortingng s1="arshad"; char[] s2=s1.toCharArray(); int s3= s2.length; System.out.println(s3); int i=0; // for(int j=0;j 
 public static Ssortingng encryptParams(Ssortingng myTextInput) { Ssortingng myKey = "40674244454045cb9a70040a30e1c007"; Ssortingng myVector = "@1B2c3D4e5F6g7H8"; Ssortingng encData = ""; try{ JavaEncryprtionUtil encUtil = new JavaEncryprtionUtil(); encData = Base64.encodeToSsortingng(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; } 

You might want to consider some automated tool to do the encryption / decryption code generation eg. https://www.ssortingngencrypt.com/java-encryption/

It can generate different encryption and decryption code each time for the ssortingng or file encryption.

It’s pretty handy when it comes to fast ssortingng encryption without using RSA, AES etc.

Sample results:

 // encrypted with https://www.ssortingngencrypt.com (v1.1.0) [Java] // szTest = "Encryption in Java!" Ssortingng szTest = "\u9E3F\uA60F\uAE07\uB61B\uBE1F\uC62B\uCE2D\uD611" + "\uDE03\uE5FF\uEEED\uF699\uFE3D\u071C\u0ED2\u1692" + "\u1E06\u26AE\u2EDC"; for (int iatwS = 0, qUJQG = 0; iatwS < 19; iatwS++) { qUJQG = szTest.charAt(iatwS); qUJQG ++; qUJQG = ((qUJQG << 5) | ( (qUJQG & 0xFFFF) >> 11)) & 0xFFFF; qUJQG -= iatwS; qUJQG = (((qUJQG & 0xFFFF) >> 6) | (qUJQG << 10)) & 0xFFFF; qUJQG ^= iatwS; qUJQG -= iatwS; qUJQG = (((qUJQG & 0xFFFF) >> 3) | (qUJQG << 13)) & 0xFFFF; qUJQG ^= 0xFFFF; qUJQG ^= 0xB6EC; qUJQG = ((qUJQG << 8) | ( (qUJQG & 0xFFFF) >> 8)) & 0xFFFF; qUJQG --; qUJQG = (((qUJQG & 0xFFFF) >> 5) | (qUJQG << 11)) & 0xFFFF; qUJQG ++; qUJQG ^= 0xFFFF; qUJQG += iatwS; szTest = szTest.substring(0, iatwS) + (char)(qUJQG & 0xFFFF) + szTest.substring(iatwS + 1); } System.out.println(szTest); 

We use it all the time in our company.