Come crittografare e decrittografare Stringa con la mia password in Java (il Pc non è una piattaforma mobile)?

Voglio criptare una stringa e poi metterlo su un file. Anche voler decifrare quando voglio. Non ho bisogno di protezione molto efficace. Voglio solo rendere più difficile per ottenere i miei dati altri.

Ho provato diversi modi. Ecco sono questi.

Crittografia Md5:

Come hash di una stringa in Android?

public static final String md5(final String toEncrypt) {
        try {
            final MessageDigest digest = MessageDigest.getInstance("md5");
            digest.update(toEncrypt.getBytes());
            final byte[] bytes = digest.digest();
            final StringBuilder sb = new StringBuilder();
            for (int i = 0; i < bytes.length; i++) {
                sb.append(String.format("%02X", bytes[i]));
            }
            return sb.toString().toLowerCase();
        } catch (Exception exc) {
            return ""; //Impossibru!
        }
    }

Ho provato questa funzione e in grado di criptare una stringa ma non riesco a decifrare i dati da esso. Quindi non è la soluzione.

Crittografia DES:

Crittografare e decrittografare una Stringa in java

Qui passphrase viene generato automaticamente. È sempre passphrase stesso su tutti i tempi? Quindi dove è la mia sicurezza. Quindi non è la mia soluzione troppo.

Crittografia AES:

Come faccio a codificare/decodificare una stringa in un’altra stringa come una password?

Ho provato anche Aes da questo link. Qui la chiave è anche generata automaticamente?

C’è qualche altro modo?

  • possibile duplicato di Java AES a 256-bit Basata su Password di Crittografia
  • O controllare la mia risposta qui se si desidera memorizzare una chiave nell’applicazione anziché di una password, quella creata da Erickson utilizza PBKDF2, che è utile per convertire le password dei tasti, ma è veramente lento.
InformationsquelleAutor Xplosive | 2014-05-09



6 Replies
  1. 49
    package com.example;
    import java.security.Key;
    import javax.crypto.Cipher;
    import javax.crypto.spec.SecretKeySpec;
    public class StrongAES 
    {
        public void run() 
        {
            try 
            {
                String text = "Hello World";
                String key = "Bar12345Bar12345"; //128 bit key
                //Create key and cipher
                Key aesKey = new SecretKeySpec(key.getBytes(), "AES");
                Cipher cipher = Cipher.getInstance("AES");
                //encrypt the text
                cipher.init(Cipher.ENCRYPT_MODE, aesKey);
                byte[] encrypted = cipher.doFinal(text.getBytes());
                System.err.println(new String(encrypted));
                //decrypt the text
                cipher.init(Cipher.DECRYPT_MODE, aesKey);
                String decrypted = new String(cipher.doFinal(encrypted));
                System.err.println(decrypted);
            }
            catch(Exception e) 
            {
                e.printStackTrace();
            }
        }
        public static void main(String[] args) 
        {
            StrongAES app = new StrongAES();
            app.run();
        }
    }
    • Si prega di motivare la risposta, in modo che il richiedente può capire la soluzione.
    • Si otterrà un carattere speciale nel messaggio cifrato. Utilizzare la codifica per evitare, se necessario.
    • Come passare un vettore di inizializzazione ?
    • Conciso e funziona perfettamente! plusOne!
    • Quando si utilizza stringa di grandi dimensioni la decrittografia restituisce una stringa vuota solo
    • C’è un modo per gestire l’uscita lunghezza del messaggio cifrato?
    • String non è un contenitore di dati binari. Si dovrebbe utilizzare un byte[].

  2. 12
    package com.ezeon.util.gen;
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.security.InvalidAlgorithmParameterException;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.security.spec.AlgorithmParameterSpec;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.KeySpec;
    import javax.crypto.*;
    import javax.crypto.spec.PBEKeySpec;
    import javax.crypto.spec.PBEParameterSpec;
    /*** Encryption and Decryption of String data; PBE(Password Based Encryption and Decryption)
    * @author Vikram
    */
    public class CryptoUtil 
    {
    
        Cipher ecipher;
        Cipher dcipher;
        //8-byte Salt
        byte[] salt = {
            (byte) 0xA9, (byte) 0x9B, (byte) 0xC8, (byte) 0x32,
            (byte) 0x56, (byte) 0x35, (byte) 0xE3, (byte) 0x03
        };
        //Iteration count
        int iterationCount = 19;
    
        public CryptoUtil() {
    
        }
    
        /**
         *
         * @param secretKey Key used to encrypt data
         * @param plainText Text input to be encrypted
         * @return Returns encrypted text
         * @throws java.security.NoSuchAlgorithmException
         * @throws java.security.spec.InvalidKeySpecException
         * @throws javax.crypto.NoSuchPaddingException
         * @throws java.security.InvalidKeyException
         * @throws java.security.InvalidAlgorithmParameterException
         * @throws java.io.UnsupportedEncodingException
         * @throws javax.crypto.IllegalBlockSizeException
         * @throws javax.crypto.BadPaddingException
         *
         */
        public String encrypt(String secretKey, String plainText)
                throws NoSuchAlgorithmException,
                InvalidKeySpecException,
                NoSuchPaddingException,
                InvalidKeyException,
                InvalidAlgorithmParameterException,
                UnsupportedEncodingException,
                IllegalBlockSizeException,
                BadPaddingException {
            //Key generation for enc and desc
            KeySpec keySpec = new PBEKeySpec(secretKey.toCharArray(), salt, iterationCount);
            SecretKey key = SecretKeyFactory.getInstance("PBEWithMD5AndDES").generateSecret(keySpec);
            //Prepare the parameter to the ciphers
            AlgorithmParameterSpec paramSpec = new PBEParameterSpec(salt, iterationCount);
    
            //Enc process
            ecipher = Cipher.getInstance(key.getAlgorithm());
            ecipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);
            String charSet = "UTF-8";
            byte[] in = plainText.getBytes(charSet);
            byte[] out = ecipher.doFinal(in);
            String encStr = new String(Base64.getEncoder().encode(out));
            return encStr;
        }
    
        /**
         * @param secretKey Key used to decrypt data
         * @param encryptedText encrypted text input to decrypt
         * @return Returns plain text after decryption
         * @throws java.security.NoSuchAlgorithmException
         * @throws java.security.spec.InvalidKeySpecException
         * @throws javax.crypto.NoSuchPaddingException
         * @throws java.security.InvalidKeyException
         * @throws java.security.InvalidAlgorithmParameterException
         * @throws java.io.UnsupportedEncodingException
         * @throws javax.crypto.IllegalBlockSizeException
         * @throws javax.crypto.BadPaddingException
         */
        public String decrypt(String secretKey, String encryptedText)
                throws NoSuchAlgorithmException,
                InvalidKeySpecException,
                NoSuchPaddingException,
                InvalidKeyException,
                InvalidAlgorithmParameterException,
                UnsupportedEncodingException,
                IllegalBlockSizeException,
                BadPaddingException,
                IOException {
            //Key generation for enc and desc
            KeySpec keySpec = new PBEKeySpec(secretKey.toCharArray(), salt, iterationCount);
            SecretKey key = SecretKeyFactory.getInstance("PBEWithMD5AndDES").generateSecret(keySpec);
            //Prepare the parameter to the ciphers
            AlgorithmParameterSpec paramSpec = new PBEParameterSpec(salt, iterationCount);
            //Decryption process; same key will be used for decr
            dcipher = Cipher.getInstance(key.getAlgorithm());
            dcipher.init(Cipher.DECRYPT_MODE, key, paramSpec);
            byte[] enc = Base64.getDecoder().decode(encryptedText);
            byte[] utf8 = dcipher.doFinal(enc);
            String charSet = "UTF-8";
            String plainStr = new String(utf8, charSet);
            return plainStr;
        }    
        public static void main(String[] args) throws Exception {
            CryptoUtil cryptoUtil=new CryptoUtil();
            String key="ezeon8547";   
            String plain="This is an important message";
            String enc=cryptoUtil.encrypt(key, plain);
            System.out.println("Original text: "+plain);
            System.out.println("Encrypted text: "+enc);
            String plainAfter=cryptoUtil.decrypt(key, enc);
            System.out.println("Original text after decryption: "+plainAfter);
        }
    }
    • Questo richiede Android API 26+. Potete per favore adattarlo per farlo funzionare su 15+?
    • Forse usando android.util.Base64.decode(str, android.util.Base64.DEFAULT);
    • String non è un contenitore di dati binari. Si dovrebbe utilizzare un byte[].
  3. 7

    Buona risposta Vignesh, grazie!

    Voglio solo aggiungere che se si vuole, in qualche modo, archivio crittografato matrice di byte come Stringa e poi la recupera e la decodifica (spesso per l’offuscamento dei valori di database), è possibile utilizzare questo approccio:

    import java.security.Key;
    import javax.crypto.Cipher;
    import javax.crypto.spec.SecretKeySpec;
    public class StrongAES 
    {
        public void run() 
        {
            try 
            {
                String text = "Hello World";
                String key = "Bar12345Bar12345"; //128 bit key
                //Create key and cipher
                Key aesKey = new SecretKeySpec(key.getBytes(), "AES");
                Cipher cipher = Cipher.getInstance("AES");
                //encrypt the text
                cipher.init(Cipher.ENCRYPT_MODE, aesKey);
                byte[] encrypted = cipher.doFinal(text.getBytes());
    
                StringBuilder sb = new StringBuilder();
                for (byte b: encrypted) {
                    sb.append((char)b);
                }
    
                //the encrypted String
                String enc = sb.toString();
                System.out.println("encrypted:" + enc);
    
                //now convert the string to byte array
                //for decryption
                byte[] bb = new byte[enc.length()];
                for (int i=0; i<enc.length(); i++) {
                    bb[i] = (byte) enc.charAt(i);
                }
    
                //decrypt the text
                cipher.init(Cipher.DECRYPT_MODE, aesKey);
                String decrypted = new String(cipher.doFinal(bb));
                System.err.println("decrypted:" + decrypted);
    
            }
            catch(Exception e) 
            {
                e.printStackTrace();
            }
        }
        public static void main(String[] args) 
        {
            StrongAES app = new StrongAES();
            app.run();
        }
    }
    • Soluzione ideale sarebbe quella di avere passaggio intermedio come seconda stringa codificata in base64 stackoverflow.com/a/5760584/470835
    • String non è un contenitore di dati binari. Si dovrebbe utilizzare un byte[].
  4. 5

    Il codice indicato come soluzione non ha funzionato per me. Questa è stata la mia soluzione.

    /*
     * http://www.java2s.com/Code/Java/Security/EncryptingaStringwithDES.htm
     * https://stackoverflow.com/questions/23561104/how-to-encrypt-and-decrypt-string-with-my-passphrase-in-java-pc-not-mobile-plat
     */
    package encryptiondemo;
    
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    
    
    /**
     *
     * @author zchumager
     */
    public class EncryptionDemo {
    
      Cipher ecipher;
      Cipher dcipher;
    
      EncryptionDemo(SecretKey key) throws Exception {
        ecipher = Cipher.getInstance("AES");
        dcipher = Cipher.getInstance("AES");
        ecipher.init(Cipher.ENCRYPT_MODE, key);
        dcipher.init(Cipher.DECRYPT_MODE, key);
      }
    
      public String encrypt(String str) throws Exception {
        //Encode the string into bytes using utf-8
        byte[] utf8 = str.getBytes("UTF8");
    
        //Encrypt
        byte[] enc = ecipher.doFinal(utf8);
    
        //Encode bytes to base64 to get a string
        return new sun.misc.BASE64Encoder().encode(enc);
      }
    
      public String decrypt(String str) throws Exception {
        //Decode base64 to get bytes
        byte[] dec = new sun.misc.BASE64Decoder().decodeBuffer(str);
    
        byte[] utf8 = dcipher.doFinal(dec);
    
        //Decode using utf-8
        return new String(utf8, "UTF8");
      }
    
    
        public static void main(String args []) throws Exception
        {
    
            String data = "Don't tell anybody!";
            String k = "Bar12345Bar12345";
    
            //SecretKey key = KeyGenerator.getInstance("AES").generateKey();
            SecretKey key = new SecretKeySpec(k.getBytes(), "AES");
            EncryptionDemo encrypter = new EncryptionDemo(key);
    
            System.out.println("Original String: " + data);
    
            String encrypted = encrypter.encrypt(data);
    
            System.out.println("Encrypted String: " + encrypted);
    
            String decrypted = encrypter.decrypt(encrypted);
    
            System.out.println("Decrypted String: " + decrypted);
        }
    }
    • String non è un contenitore di dati binari. Si dovrebbe utilizzare un byte[].
    • Una penso che funziona meglio di altre soluzioni quando si devono trasportare i dati crittografati. Il codice è molto più semplice di troppo. Ho dovuto modificare il sole.misc.BASE64Encoder e sole.misc.BASE64Decoder per il java.util.Base64 classi interne (Java 8).
  5. 2

    Cifrare:

      public static String encrypt(String strClearText,String strKey) throws Exception{
        String strData="";
    
        try {
            SecretKeySpec skeyspec=new SecretKeySpec(strKey.getBytes(),"Blowfish");
            Cipher cipher=Cipher.getInstance("Blowfish");
            cipher.init(Cipher.ENCRYPT_MODE, skeyspec);
            byte[] encrypted=cipher.doFinal(strClearText.getBytes());
            strData=new String(encrypted);
    
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception(e);
        }
        return strData;
    }

    Decifrare:

    public static String decrypt(String strEncrypted,String strKey) throws Exception{
        String strData="";
    
        try {
            SecretKeySpec skeyspec=new SecretKeySpec(strKey.getBytes(),"Blowfish");
            Cipher cipher=Cipher.getInstance("Blowfish");
            cipher.init(Cipher.DECRYPT_MODE, skeyspec);
            byte[] decrypted=cipher.doFinal(strEncrypted.getBytes());
            strData=new String(decrypted);
    
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception(e);
        }
        return strData;
    }

    Fonte Come facilmente crittografare e decrittografare il testo in Java

    • La sua grande hai fornito un link, ma sarebbe utile se ci fossero maggiori informazioni sui pacchetti di importazione, etc.
    • non ha funzionato per voi? Perché a me ha funzionato solo la cifra non la decifrare
    • String non è un contenitore di dati binari. Si dovrebbe utilizzare un byte[].
  6. 1

    Utilizzare Questa funzionerà Di sicuro

    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.security.GeneralSecurityException;
    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.PBEKeySpec;
    import javax.crypto.spec.PBEParameterSpec;
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    
    public class ProtectedConfigFile {
    
        private static final char[] PASSWORD = "enfldsgbnlsngdlksdsgm".toCharArray();
        private static final byte[] SALT = { (byte) 0xde, (byte) 0x33, (byte) 0x10, (byte) 0x12, (byte) 0xde, (byte) 0x33,
                (byte) 0x10, (byte) 0x12, };
    
        public static void main(String[] args) throws Exception {
            String originalPassword = "Aman";
            System.out.println("Original password: " + originalPassword);
            String encryptedPassword = encrypt(originalPassword);
            System.out.println("Encrypted password: " + encryptedPassword);
            String decryptedPassword = decrypt(encryptedPassword);
            System.out.println("Decrypted password: " + decryptedPassword);
        }
    
        private static String encrypt(String property) throws GeneralSecurityException, UnsupportedEncodingException {
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
            SecretKey key = keyFactory.generateSecret(new PBEKeySpec(PASSWORD));
            Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
            pbeCipher.init(Cipher.ENCRYPT_MODE, key, new PBEParameterSpec(SALT, 20));
            return base64Encode(pbeCipher.doFinal(property.getBytes("UTF-8")));
        }
    
        private static String base64Encode(byte[] bytes) {
            //NB: This class is internal, and you probably should use another impl
            return new BASE64Encoder().encode(bytes);
        }
    
        private static String decrypt(String property) throws GeneralSecurityException, IOException {
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithMD5AndDES");
            SecretKey key = keyFactory.generateSecret(new PBEKeySpec(PASSWORD));
            Cipher pbeCipher = Cipher.getInstance("PBEWithMD5AndDES");
            pbeCipher.init(Cipher.DECRYPT_MODE, key, new PBEParameterSpec(SALT, 20));
            return new String(pbeCipher.doFinal(base64Decode(property)), "UTF-8");
        }
    
        private static byte[] base64Decode(String property) throws IOException {
            //NB: This class is internal, and you probably should use another impl
            return new BASE64Decoder().decodeBuffer(property);
        }
    
    }
    • String non è un contenitore di dati binari. Si dovrebbe utilizzare un byte[].

Lascia un commento