为Android应用程序客户端加密和解密数据

用这个 我将图像转换为字符串。

---

现在我想在将数据发送到服务器之前加密这个字符串。有没有一种简单的方法来加密和解密字符串？

javax.crypto

该包为实现加密、解密或密钥协商算法的加密应用程序提供类和接口

支持流密码以及非对称、对称和分组密码。可以使用SPI（服务提供者接口）抽象类集成来自不同提供者的密码实现。使用类SealedObject，程序员可以通过使用密码对对象进行加密来保护对象

认证可以基于MAC（消息认证码），例如HMAC（散列MAC，即具有SHA-1散列函数）

示例：

使用AES128对字符串进行加密和解密的简单帮助器类。结果是Ascii编码的（实际上是十六进制，没有base64），因此不必存储字节[]。种子值用作共享密钥（“主密码”）。只有使用相同的种子才能解密存储的值

package com.xxx;

import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

/**
 * Usage:
 * <pre>
 * String crypto = SimpleCrypto.encrypt(masterpassword, cleartext)
 * ...
 * String cleartext = SimpleCrypto.decrypt(masterpassword, crypto)
 * </pre>
 * @author ferenc.hechler
 */
public class SimpleCrypto {

    public static String encrypt(String seed, String cleartext) throws Exception {
        byte[] rawKey = getRawKey(seed.getBytes());
        byte[] result = encrypt(rawKey, cleartext.getBytes());
        return toHex(result);
    }

    public static String decrypt(String seed, String encrypted) throws Exception {
        byte[] rawKey = getRawKey(seed.getBytes());
        byte[] enc = toByte(encrypted);
        byte[] result = decrypt(rawKey, enc);
        return new String(result);
    }

    private static byte[] getRawKey(byte[] seed) throws Exception {
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");
        sr.setSeed(seed);
        kgen.init(128, sr); // 192 and 256 bits may not be available
        SecretKey skey = kgen.generateKey();
        byte[] raw = skey.getEncoded();
        return raw;
    }


    private static byte[] encrypt(byte[] raw, byte[] clear) throws Exception {
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
        byte[] encrypted = cipher.doFinal(clear);
        return encrypted;
    }

    private static byte[] decrypt(byte[] raw, byte[] encrypted) throws Exception {
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, skeySpec);
        byte[] decrypted = cipher.doFinal(encrypted);
        return decrypted;
    }

    public static String toHex(String txt) {
        return toHex(txt.getBytes());
    }
    public static String fromHex(String hex) {
        return new String(toByte(hex));
    }

    public static byte[] toByte(String hexString) {
        int len = hexString.length()/2;
        byte[] result = new byte[len];
        for (int i = 0; i < len; i++)
            result[i] = Integer.valueOf(hexString.substring(2*i, 2*i+2), 16).byteValue();
        return result;
    }

    public static String toHex(byte[] buf) {
        if (buf == null)
            return "";
        StringBuffer result = new StringBuffer(2*buf.length);
        for (int i = 0; i < buf.length; i++) {
            appendHex(result, buf[i]);
        }
        return result.toString();
    }
    private final static String HEX = "0123456789ABCDEF";
    private static void appendHex(StringBuffer sb, byte b) {
        sb.append(HEX.charAt((b>>4)&0x0f)).append(HEX.charAt(b&0x0f));
    }

}

package com.xxx；
导入java.security.SecureRandom；
导入javax.crypto.Cipher；
导入javax.crypto.KeyGenerator；
导入javax.crypto.SecretKey；
导入javax.crypto.spec.SecretKeySpec；
/**
*用法：
* 
*String crypto=SimpleCrypto.encrypt（主密码，明文）
* ...
*String cleartext=SimpleCrypto.decrypt（主密码，加密）
* 
*@author ference.hechler
*/
公共类SimpleCrypto{
公共静态字符串加密（字符串种子、字符串明文）引发异常{
byte[]rawKey=getRawKey（seed.getBytes（））；
byte[]result=encrypt（rawKey，cleartext.getBytes（））；
返回到hex（结果）；
}
公共静态字符串解密（字符串种子、字符串加密）引发异常{
byte[]rawKey=getRawKey（seed.getBytes（））；
字节[]enc=toByte（加密）；
字节[]结果=解密（rawKey，enc）；
返回新字符串（结果）；
}
私有静态字节[]getRawKey（字节[]种子）引发异常{
KeyGenerator kgen=KeyGenerator.getInstance（“AES”）；
SecureRandom sr=SecureRandom.getInstance（“SHA1PRNG”、“Crypto”）；
高级种子（种子）；
kgen.init（128，sr）；//192和256位可能不可用
SecretKey skey=kgen.generateKey（）；
字节[]原始=skey.getEncoded（）；
返回原材料；
}
私有静态字节[]加密（字节[]原始，字节[]清除）引发异常{
SecretKeySpec skeySpec=新SecretKeySpec（原始，“AES”）；
Cipher Cipher=Cipher.getInstance（“AES”）；
cipher.init（cipher.ENCRYPT_模式，skeySpec）；
字节[]加密=cipher.doFinal（清除）；
返回加密；
}
私有静态字节[]解密（字节[]原始，字节[]加密）引发异常{
SecretKeySpec skeySpec=新SecretKeySpec（原始，“AES”）；
Cipher Cipher=Cipher.getInstance（“AES”）；
cipher.init（cipher.DECRYPT_模式，skeySpec）；
字节[]解密=cipher.doFinal（加密）；
返回解密；
}
公共静态字符串toHex（字符串txt）{
返回到hex（txt.getBytes（））；
}
公共静态字符串fromHex（字符串十六进制）{
返回新字符串（toByte（hex））；
}
公共静态字节[]toByte（字符串hexString）{
int len=hexString.length（）/2；
字节[]结果=新字节[len]；
对于（int i=0；i>4）和0x0f））.append（十六进制字符（b和0x0f））；
}
}

有关更多信息，请查看和

公共类SecureCresidentialCrypto{
公共静态字符串加密（字符串种子、字符串明文）引发异常{
byte[]rawKey=getRawKey（seed.getBytes（））；
byte[]result=encrypt（rawKey，cleartext.getBytes（））；
返回到hex（结果）；
}
公共静态字符串解密（字符串种子、字符串加密）引发异常{
byte[]rawKey=getRawKey（seed.getBytes（））；
字节[]enc=toByte（加密）；
字节[]结果=解密（rawKey，enc）；
返回新字符串（结果）；
}
私有静态字节[]getRawKey（字节[]种子）引发异常{
KeyGenerator kgen=KeyGenerator.getInstance（“AES”）；
SecureRandom sr=SecureRandom.getInstance（“SHA1PRNG”）；
高级种子（种子）；
kgen.init（128，sr）；//192和256位可能不可用
SecretKey skey=kgen.generateKey（）；
字节[]原始=skey.getEncoded（）；
返回原材料；
}
私有静态字节[]加密（字节[]原始，字节[]清除）引发异常{
SecretKeySpec skeySpec=新SecretKeySpec（原始，“AES”）；
Cipher Cipher=Cipher.getInstance（“AES”）；
cipher.init（cipher.ENCRYPT_模式，skeySpec）；
字节[]加密=cipher.doFinal（清除）；
返回加密；
}
私有静态字节[]解密（字节[]原始，字节[]加密）引发异常{
SecretKeySpec skeySpec=新SecretKeySpec（原始，“AES”）；
Cipher Cipher=Cipher.getInstance（“AES”）；
cipher.init（cipher.DECRYPT_模式，skeySpec）；
字节[]已解密=ci
public class SecureCredentialsCrypto {

            public static String encrypt(String seed, String cleartext) throws Exception {
                    byte[] rawKey = getRawKey(seed.getBytes());
                    byte[] result = encrypt(rawKey, cleartext.getBytes());
                    return toHex(result);
            }

            public static String decrypt(String seed, String encrypted) throws Exception {
                    byte[] rawKey = getRawKey(seed.getBytes());
                    byte[] enc = toByte(encrypted);
                    byte[] result = decrypt(rawKey, enc);
                    return new String(result);
            }

            private static byte[] getRawKey(byte[] seed) throws Exception {
                    KeyGenerator kgen = KeyGenerator.getInstance("AES");
                    SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
                    sr.setSeed(seed);
                kgen.init(128, sr); // 192 and 256 bits may not be available
                SecretKey skey = kgen.generateKey();
                byte[] raw = skey.getEncoded();
                return raw;
            }


            private static byte[] encrypt(byte[] raw, byte[] clear) throws Exception {
                SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
                    Cipher cipher = Cipher.getInstance("AES");
                cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
                byte[] encrypted = cipher.doFinal(clear);
                    return encrypted;
            }

            private static byte[] decrypt(byte[] raw, byte[] encrypted) throws Exception {
                SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
                    Cipher cipher = Cipher.getInstance("AES");
                cipher.init(Cipher.DECRYPT_MODE, skeySpec);
                byte[] decrypted = cipher.doFinal(encrypted);
                    return decrypted;
            }

            public static String toHex(String txt) {
                    return toHex(txt.getBytes());
            }
            public static String fromHex(String hex) {
                    return new String(toByte(hex));
            }

            public static byte[] toByte(String hexString) {
                    int len = hexString.length()/2;
                    byte[] result = new byte[len];
                    for (int i = 0; i < len; i++)
                            result[i] = Integer.valueOf(hexString.substring(2*i, 2*i+2), 16).byteValue();
                    return result;
            }

            public static String toHex(byte[] buf) {
                    if (buf == null)
                            return "";
                    StringBuffer result = new StringBuffer(2*buf.length);
                    for (int i = 0; i < buf.length; i++) {
                            appendHex(result, buf[i]);
                    }
                    return result.toString();
            }
            private final static String HEX = "0123456789ABCDEF";
            private static void appendHex(StringBuffer sb, byte b) {
                    sb.append(HEX.charAt((b>>4)&0x0f)).append(HEX.charAt(b&0x0f));
            }

    }

//for storing encrypt it
String crypto_email = SecureCredentialsCrypto.encrypt("secure", email.toString().trim());

//for reading  decrypt it
//crypto is object name to read 


String correctEmail=SecureCredentialsCrypto.decrypt("secure", crypto);

package com.duplicate;



   public class RSAEncryptionDescription {


 private static final String PUBLIC_KEY_FILE = "Public.key";  
 private static final String PRIVATE_KEY_FILE = "Private.key";  

 public static void main(String[] args) throws IOException {  

  try {  
   System.out.println("-------GENRATE PUBLIC and PRIVATE KEY-------------");  
   KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");  
   keyPairGenerator.initialize(2048); //1024 used for normal securities  
   KeyPair keyPair = keyPairGenerator.generateKeyPair();  
   PublicKey publicKey = keyPair.getPublic();  
   PrivateKey privateKey = keyPair.getPrivate();  
   System.out.println("Public Key - " + publicKey);  
   System.out.println("Private Key - " + privateKey);

   //Pullingout parameters which makes up Key  
   System.out.println("\n------- PULLING OUT PARAMETERS WHICH MAKES KEYPAIR----------\n");  
   KeyFactory keyFactory = KeyFactory.getInstance("RSA");  
   RSAPublicKeySpec rsaPubKeySpec = keyFactory.getKeySpec(publicKey, RSAPublicKeySpec.class);  
   RSAPrivateKeySpec rsaPrivKeySpec = keyFactory.getKeySpec(privateKey, RSAPrivateKeySpec.class);  
   System.out.println("PubKey Modulus : " + rsaPubKeySpec.getModulus());  
   System.out.println("PubKey Exponent : " + rsaPubKeySpec.getPublicExponent());  
   System.out.println("PrivKey Modulus : " + rsaPrivKeySpec.getModulus());  
   System.out.println("PrivKey Exponent : " + rsaPrivKeySpec.getPrivateExponent());  

   //Share public key with other so they can encrypt data and decrypt thoses using private key(Don't share with Other)  
   System.out.println("\n--------SAVING PUBLIC KEY AND PRIVATE KEY TO FILES-------\n");  
   RSAEncryptionDescription rsaObj = new RSAEncryptionDescription();  
   rsaObj.saveKeys(PUBLIC_KEY_FILE, rsaPubKeySpec.getModulus(), rsaPubKeySpec.getPublicExponent());  
   rsaObj.saveKeys(PRIVATE_KEY_FILE, rsaPrivKeySpec.getModulus(), rsaPrivKeySpec.getPrivateExponent());  

   //Encrypt Data using Public Key  
   byte[] encryptedData = rsaObj.encryptData("Anuj Patel - Classified Information !");  

   //Descypt Data using Private Key  
   rsaObj.decryptData(encryptedData);  

  } catch (NoSuchAlgorithmException e) {  
   e.printStackTrace();  
  }catch (InvalidKeySpecException e) {  
   e.printStackTrace();  
  }  

 }  

 /** 
  * Save Files 
  * @param fileName 
  * @param mod 
  * @param exp 
  * @throws IOException 
  */  
 private void saveKeys(String fileName,BigInteger mod,BigInteger exp) throws IOException{  
  FileOutputStream fos = null;  
  ObjectOutputStream oos = null;  

  try {  
   System.out.println("Generating "+fileName + "...");  
   fos = new FileOutputStream(fileName);  
   oos = new ObjectOutputStream(new BufferedOutputStream(fos));  

   oos.writeObject(mod);  
   oos.writeObject(exp);     

   System.out.println(fileName + " generated successfully");  
  } catch (Exception e) {  
   e.printStackTrace();  
  }  
  finally{  
   if(oos != null){  
    oos.close();  

    if(fos != null){  
     fos.close();  
    }  
   }  
  }    
 }  

 /** 
  * Encrypt Data 
  * @param data 
  * @throws IOException 
  */  
 private byte[] encryptData(String data) throws IOException {  
  System.out.println("\n----------------ENCRYPTION STARTED------------");  

  System.out.println("Data Before Encryption :" + data);  
  byte[] dataToEncrypt = data.getBytes();  
  byte[] encryptedData = null;  
  try {  
   PublicKey pubKey = readPublicKeyFromFile(PUBLIC_KEY_FILE);  
   Cipher cipher = Cipher.getInstance("RSA");  
   cipher.init(Cipher.ENCRYPT_MODE, pubKey);  
   encryptedData = cipher.doFinal(dataToEncrypt);  
   System.out.println("Encryted Data: " + encryptedData);  

  } catch (Exception e) {  
   e.printStackTrace();  
  }   

  System.out.println("----------------ENCRYPTION COMPLETED------------");    
  return encryptedData;  
 }  

 /** 
  * Encrypt Data 
  * @param data 
  * @throws IOException 
  */  
 private void decryptData(byte[] data) throws IOException {  
  System.out.println("\n----------------DECRYPTION STARTED------------");  
  byte[] descryptedData = null;  

  try {  
   PrivateKey privateKey = readPrivateKeyFromFile(PRIVATE_KEY_FILE);  
   Cipher cipher = Cipher.getInstance("RSA");  
   cipher.init(Cipher.DECRYPT_MODE, privateKey);  
   descryptedData = cipher.doFinal(data);  
   System.out.println("Decrypted Data: " + new String(descryptedData));  

  } catch (Exception e) {  
   e.printStackTrace();  
  }   

  System.out.println("----------------DECRYPTION COMPLETED------------");    
 }  

 /** 
  * read Public Key From File 
  * @param fileName 
  * @return PublicKey 
  * @throws IOException 
  */  
 public PublicKey readPublicKeyFromFile(String fileName) throws IOException{  
  FileInputStream fis = null;  
  ObjectInputStream ois = null;  
  try {  
   fis = new FileInputStream(new File(fileName));  
   ois = new ObjectInputStream(fis);  

   BigInteger modulus = (BigInteger) ois.readObject();  
      BigInteger exponent = (BigInteger) ois.readObject();  

      //Get Public Key  
      RSAPublicKeySpec rsaPublicKeySpec = new RSAPublicKeySpec(modulus, exponent);  
      KeyFactory fact = KeyFactory.getInstance("RSA");  
      PublicKey publicKey = fact.generatePublic(rsaPublicKeySpec);  

      return publicKey;  

  } catch (Exception e) {  
   e.printStackTrace();  
  }  
  finally{  
   if(ois != null){
    ois.close();  
    if(fis != null){
     fis.close();
    }
   }  
  }  
  return null;  
 }  

 /** 
  * read Public Key From File 
  * @param fileName 
  * @return 
  * @throws IOException 
  */  
 public PrivateKey readPrivateKeyFromFile(String fileName) throws IOException{  
  FileInputStream fis = null;  
  ObjectInputStream ois = null;  
  try {  
   fis = new FileInputStream(new File(fileName));  
   ois = new ObjectInputStream(fis);  

   BigInteger modulus = (BigInteger) ois.readObject();  
      BigInteger exponent = (BigInteger) ois.readObject();  

      //Get Private Key  
      RSAPrivateKeySpec rsaPrivateKeySpec = new RSAPrivateKeySpec(modulus, exponent);  
      KeyFactory fact = KeyFactory.getInstance("RSA");  
      PrivateKey privateKey = fact.generatePrivate(rsaPrivateKeySpec);  

      return privateKey;  

  } catch (Exception e) {  
   e.printStackTrace();  
  }  
  finally{  
   if(ois != null){  
    ois.close();  
    if(fis != null){  
     fis.close();  
    }  
   }  
  }  
  return null;  
 }  
}