以纯文本格式在Android中进行加密/解密

Question

i want to pass some value in productid and give a encrypted String After dat dat encrypted value to set on textfield...i am using dis code but get dvalue of encrpted is in array format how to get dat encrypted dat value in string format and after dat i want to dat encrypted code to convert in original means decrypt ...plz help me

    final EditText productid = (EditText) findViewById(R.id.editText1);
    Button encryptButton = (Button) findViewById(R.id.encrypt);
    final TextView value = (TextView) findViewById(R.id.value);
    encryptButton.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View v) {

            String valid_productid = productid.getText().toString();
            ivspec = new IvParameterSpec(iv.getBytes());

            keyspec = new SecretKeySpec(SecretKey.getBytes(), "AES");

            try {
                    cipher = Cipher.getInstance("AES/CBC/NoPadding");
                    //encrypt(valid_productid);

                    byte[] cipher = encrypt(valid_productid);

                    System.out.print("cipher:  ");
                    for (int i=0; i<cipher.length; i++)
                      System.out.print(new Integer(cipher[i])+" ");
                      System.out.println("");
                      System.out.println(cipher);

                      /*String decrypted = decrypt(cipher);
                      System.out.println("decrypt: " + decrypted);
                          value.setText(cipher);*/

            } catch (NoSuchAlgorithmException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    });  
public byte[] encrypt(String text) throws Exception
{
        if(text == null || text.length() == 0)
                throw new Exception("Empty string");

        byte[] encrypted = null;

        try {
                cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);

                encrypted = cipher.doFinal(padString(text).getBytes());
        } catch (Exception e)
        {                       
                throw new Exception("[encrypt] " + e.getMessage());
        }

        return encrypted;
}

public byte[] decrypt(String code) throws Exception
{
        if(code == null || code.length() == 0)
                throw new Exception("Empty string");

        byte[] decrypted = null;

        try {
                cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);

                decrypted = cipher.doFinal(hexToBytes(code));
        } catch (Exception e)
        {
                throw new Exception("[decrypt] " + e.getMessage());
        }
        return decrypted;
}



public static String bytesToHex(byte[] data)
{
        if (data==null)
        {
                return null;
        }

        int len = data.length;
        String str = "";
        for (int i=0; i<len; i++) {
                if ((data[i]&0xFF)<16)
                        str = str + "0" + java.lang.Integer.toHexString(data[i]&0xFF);
                else
                        str = str + java.lang.Integer.toHexString(data[i]&0xFF);
        }
        return str;
}


public static byte[] hexToBytes(String str) {
        if (str==null) {
                return null;
        } else if (str.length() < 2) {
                return null;
        } else {
                int len = str.length() / 2;
                byte[] buffer = new byte[len];
                for (int i=0; i<len; i++) {
                        buffer[i] = (byte) Integer.parseInt(str.substring(i*2,i*2+2),16);
                }
                return buffer;
        }
}



private static String padString(String source)
{
  char paddingChar = ' ';
  int size = 16;
  int x = source.length() % size;
  int padLength = size - x;

  for (int i = 0; i < padLength; i++)
  {
          source += paddingChar;
  }

  return source;
}

Answer 1

Here i added the sample code for you. Please try and let me know.

import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import android.util.Base64;

public class EncodeDecodeAES {

    private final static String HEX = "0123456789ABCDEF";
    private final static String key = "encryptionKey"
    private final static int JELLY_BEAN_4_2 = 17;

    private final static byte[] key = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

    public static String encrypt(String cleartext) throws Exception {
        return encrypt(key,cleartext);
    }

    public static String decrypt(String cleartext) throws Exception {
        return decrypt(key,cleartext);
    }

    public static String encrypt(String seed, String cleartext) throws Exception {

        byte[] rawKey = getRawKey(seed.getBytes());
        byte[] result = encrypt(rawKey, cleartext.getBytes());
        String fromHex = toHex(result);
        String base64 = new String(Base64.encodeToString(fromHex.getBytes(), 0));
        return base64;
    }     

    public static String decrypt(String seed, String encrypted) throws Exception {

        byte[] seedByte = seed.getBytes();
        System.arraycopy(seedByte, 0, key, 0, ((seedByte.length < 16) ? seedByte.length : 16));
        String base64 = new String(Base64.decode(encrypted, 0));
        byte[] rawKey = getRawKey(seedByte);
        byte[] enc = toByte(base64);
        byte[] result = decrypt(rawKey, enc);
        return new String(result);
    }

    public static byte[] encryptBytes(String seed, byte[] cleartext) throws Exception {

        byte[] rawKey = getRawKey(seed.getBytes());
        byte[] result = encrypt(rawKey, cleartext);
        return result;
    }


    public static byte[] decryptBytes(String seed, byte[] encrypted) throws Exception {

        byte[] rawKey = getRawKey(seed.getBytes());
        byte[] result = decrypt(rawKey, encrypted);
        return result;

    }

    private static byte[] getRawKey(byte[] seed) throws Exception {

        KeyGenerator kgen = KeyGenerator.getInstance("AES"); // , "SC");
        SecureRandom sr = null;
        if (android.os.Build.VERSION.SDK_INT >= JELLY_BEAN_4_2) {
         sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");
        } else {
         sr = SecureRandom.getInstance("SHA1PRNG");
        }
        sr.setSeed(seed);
        try {
         kgen.init(256, sr);
         // kgen.init(128, sr);
        } catch (Exception e) {
         // Log.w(LOG, "This device doesn't suppor 256bits, trying 192bits.");
         try {
          kgen.init(192, sr);
         } catch (Exception e1) {
          // Log.w(LOG, "This device doesn't suppor 192bits, trying 128bits.");
          kgen.init(128, sr);
         }
       }
        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"); // /ECB/PKCS7Padding", "SC");
        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"); // /ECB/PKCS7Padding", "SC");
        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 static void appendHex(StringBuffer sb, byte b) {
        sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
    }

}

How to call in your activity :

Encryption:

 String Name = EncodeDecodeAES.encrypt("John Smith");
Log.d("Encrypted value",Name);

Decryption:

String Name = EncodeDecodeAES.decrypt("NzhEMTlBMUExRTU5OEVDMDBEMDI5NkVDMTlBQzZGNkI=");
Log.d("Decrypted value",Name);

Hope it should helpful for you.