Come crittografare e decodificare String con la mia passphrase in Java (piattaforma PC non mobile)?

Question

Voglio crittografare una stringa e quindi metterla su un file. Voglio anche decifrarlo quando voglio. Non ho bisogno di sicurezza molto forte. Voglio solo rendere più difficile ottenere i miei dati da altri.

Ho provato diversi modi. Ecco questi.

Md5 Encryption:

How to hash a string 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 cifrare una stringa, ma non riesco a decifrare i dati da esso. Quindi non è la soluzione.

DES Encryption:

Encrypt and decrypt a String in java

Qui passphrase viene generato Auto. La frase segreta è sempre la stessa in qualsiasi momento? Allora dov'è la mia sicurezza. Quindi non è la mia soluzione anche.

AES Encryption:

How do I encrypt/decrypt a string with another string as a password?

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

C'è qualche altro modo?

Answer 1

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

Answer 2

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); 
    } 
}

Answer 3

Buona risposta Vignesh, grazie!

Voglio solo aggiungere che, se si desidera memorizzare in qualche modo l'array di byte criptato as String e quindi recuperare e decifrare (spesso per l'offuscamento dei valori del 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(); 
    } 
} 

Answer 4

utilizzare questo questo lavoro per assicurarsi

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); 
    } 

} 

Answer 5

Encrypt:

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; 
} 

Decrypt:

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 How to easily encrypt and decrypt text in Java