Android AES Encrypt encrypt(byte[] raw, byte[] clear)

Description

Actual encrypt data function.

License

Open Source License

Parameter

Parameter	Description
raw	the Raw byte data,
clear	the Original text byte data.

Return

return the encrypted data's byte data.

Declaration

private static byte[] encrypt(byte[] raw, byte[] clear)
        throws Exception 

Method Source Code

//package com.java2s;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class Main {
    /**//from  ww w  .  j  a v a2  s. c  o  m
     * Padding HEX string.
     */
    public static final String HEX = "0123456789ABCDEF";

    /**
     * To encrypt a string.
     * @param seed the Key used to encrypt the data.
     * @param clearText the Original text to be encrypted.
     * @return the encrypted content as a string.
     */
    public static String encrypt(String seed, String clearText) {
        byte[] result = null;
        try {
            byte[] rawkey = getRawKey(seed.getBytes());
            result = encrypt(rawkey, clearText.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        if (result == null) {
            return null;
        }

        String content = toHex(result);
        return content;
    }

    /**
     * Actual encrypt data function.
     * @param raw the Raw byte data,
     * @param clear the Original text byte data.
     * @return return the encrypted data's byte data.
     */
    private static byte[] encrypt(byte[] raw, byte[] clear)
            throws Exception {
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec, new IvParameterSpec(
                new byte[cipher.getBlockSize()]));
        byte[] encrypted = cipher.doFinal(clear);
        return encrypted;
    }

    /**
     * To get a raw key.
     * @param seed the byte data of a seed.
     * @return return the seed's byte data.
     */
    private static byte[] getRawKey(byte[] seed) throws Exception {
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        //SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
        SecureRandom sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");
        sr.setSeed(seed);
        kgen.init(128, sr);
        SecretKey sKey = kgen.generateKey();
        byte[] raw = sKey.getEncoded();
        return raw;
    }

    /**
     * Retrieve a string's hex format
     * @param txt the Original text,
     * @return the hex format string
     */
    public static String toHex(String txt) {
        return toHex(txt.getBytes());
    }

    /**
     * Retrieve the string format of a byte data.
     * @param buf the byte source.
     * @return the string format.
     */
    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();
    }

    /**
     * utility function to transfer the byte data.
     * @param sb the string to be appended new character.
     * @param b the byte data
     */
    private static void appendHex(StringBuffer sb, byte b) {
        sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
    }
}

Related

1. encrypt(byte[] key, byte[] src)
2. encrypt(byte[] key, byte[] src)
3. encrypt(byte[] raw, byte[] clear)
4. encrypt(byte[] raw, byte[] clear)
5. encrypt(byte[] raw, byte[] clear)
6. encrypt(byte[] source)
7. encryptBase64(String content, String key)
8. encryptBase64(byte[] source)
9. encryptBytes(String seed, byte[] cleartext)