Android AES加密解密

AES加密算法模式有四种：ECB、CBC、CFB、OFB

要想AES加密，至少需要一个16位的密钥，如果是非ECB模式的加密，至少还得需要密钥偏移量。

下面是AES在线加密解密链接：

AES在线加密解密链接

如上图所示：“hello everyone!”被加密成了“X/T+Vxr5QZEp/GBr/iul8w==”

好的，那如何用android代码实现这样的加密呢？网上代码不少，但是有的确是很混乱，我现在来整理整理

主要代码如下：

AES.java类：

public class AES {
	private final String KEY_GENERATION_ALG = "PBEWITHSHAANDTWOFISH-CBC";
	// private final String KEY_GENERATION_ALG = "PBKDF2WithHmacSHA1";
	private final int HASH_ITERATIONS = 10000;
	private final int KEY_LENGTH = 128;
	private char[] humanPassphrase = { "P", "e", "r", " ", "v", "a", "l", "l",
			"u", "m", " ", "d", "u", "c", "e", "s", " ", "L", "a", "b", "a",
			"n", "t" };// per vallum duces labant
	private byte[] salt = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xA, 0xB, 0xC, 0xD,
			0xE, 0xF }; // must save this for next time we want the key

	private PBEKeySpec myKeyspec = new PBEKeySpec(humanPassphrase, salt,
			HASH_ITERATIONS, KEY_LENGTH);
	private final String CIPHERMODEPADDING = "AES/CBC/PKCS5Padding";// AES/CBC/PKCS7Padding

	private SecretKeyFactory keyfactory = null;
	private SecretKey sk = null;
	private SecretKeySpec skforAES = null;
	private static String ivParameter = "1234567890123456";// 密钥默认偏移，可更改
	// private byte[] iv = { 0xA, 1, 0xB, 5, 4, 0xF, 7, 9, 0x17, 3, 1, 6, 8,
	// 0xC,
	// 0xD, 91 };
	private byte[] iv = ivParameter.getBytes();
	private IvParameterSpec IV;
	String sKey = "1234567890123456";// key必须为16位，可更改为自己的key

	public AES() {
		try {
			keyfactory = SecretKeyFactory.getInstance(KEY_GENERATION_ALG);
			sk = keyfactory.generateSecret(myKeyspec);
		} catch (NoSuchAlgorithmException nsae) {
			Log.e("AESdemo",
					"no key factory support for PBEWITHSHAANDTWOFISH-CBC");
		} catch (InvalidKeySpecException ikse) {
			Log.e("AESdemo", "invalid key spec for PBEWITHSHAANDTWOFISH-CBC");
		}

		// This is our secret key. We could just save this to a file instead of
		// regenerating it
		// each time it is needed. But that file cannot be on the device (too
		// insecure). It could
		// be secure if we kept it on a server accessible through https.
	
		// byte[] skAsByteArray = sk.getEncoded();
		byte[] skAsByteArray;
		try {
			skAsByteArray = sKey.getBytes("ASCII");
			skforAES = new SecretKeySpec(skAsByteArray, "AES");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		IV = new IvParameterSpec(iv);
	}

	public String encrypt(byte[] plaintext) {
		byte[] ciphertext = encrypt(CIPHERMODEPADDING, skforAES, IV, plaintext);
		String base64_ciphertext = Base64Encoder.encode(ciphertext);
		return base64_ciphertext;
	}

	public String decrypt(String ciphertext_base64) {
		byte[] s = Base64Decoder.decodeToBytes(ciphertext_base64);
		String decrypted = new String(decrypt(CIPHERMODEPADDING, skforAES, IV,
				s));
		return decrypted;
	}

	// Use this method if you want to add the padding manually
	// AES deals with messages in blocks of 16 bytes.
	// This method looks at the length of the message, and adds bytes at the end
	// so that the entire message is a multiple of 16 bytes.
	// the padding is a series of bytes, each set to the total bytes added (a
	// number in range 1..16).
	private byte[] addPadding(byte[] plain) {
		byte plainpad[] = null;
		int shortage = 16 - (plain.length % 16);
		// if already an exact multiple of 16, need to add another block of 16
		// bytes
		if (shortage == 0)
			shortage = 16;
		// reallocate array bigger to be exact multiple, adding shortage bits.
		plainpad = new byte[plain.length + shortage];
		for (int i = 0; i < plain.length; i++) {
			plainpad[i] = plain[i];
		}
		for (int i = plain.length; i < plain.length + shortage; i++) {
			plainpad[i] = (byte) shortage;
		}
		return plainpad;
	}

	// Use this method if you want to remove the padding manually
	// This method removes the padding bytes
	private byte[] dropPadding(byte[] plainpad) {
		byte plain[] = null;
		int drop = plainpad[plainpad.length - 1]; // last byte gives number of
													// bytes to drop

		// reallocate array smaller, dropping the pad bytes.
		plain = new byte[plainpad.length - drop];
		for (int i = 0; i < plain.length; i++) {
			plain[i] = plainpad[i];
			plainpad[i] = 0; // don"t keep a copy of the decrypt
		}
		return plain;
	}

	private byte[] encrypt(String cmp, SecretKey sk, IvParameterSpec IV,
			byte[] msg) {
		try {
			Cipher c = Cipher.getInstance(cmp);
			c.init(Cipher.ENCRYPT_MODE, sk, IV);
			return c.doFinal(msg);
		} catch (NoSuchAlgorithmException nsae) {
			Log.e("AESdemo", "no cipher getinstance support for " + cmp);
		} catch (NoSuchPaddingException nspe) {
			Log.e("AESdemo", "no cipher getinstance support for padding " + cmp);
		} catch (InvalidKeyException e) {
			Log.e("AESdemo", "invalid key exception");
		} catch (InvalidAlgorithmParameterException e) {
			Log.e("AESdemo", "invalid algorithm parameter exception");
		} catch (IllegalBlockSizeException e) {
			Log.e("AESdemo", "illegal block size exception");
		} catch (BadPaddingException e) {
			Log.e("AESdemo", "bad padding exception");
		}
		return null;
	}

	private byte[] decrypt(String cmp, SecretKey sk, IvParameterSpec IV,
			byte[] ciphertext) {
		try {
			Cipher c = Cipher.getInstance(cmp);
			c.init(Cipher.DECRYPT_MODE, sk, IV);
			return c.doFinal(ciphertext);
		} catch (NoSuchAlgorithmException nsae) {
			Log.e("AESdemo", "no cipher getinstance support for " + cmp);
		} catch (NoSuchPaddingException nspe) {
			Log.e("AESdemo", "no cipher getinstance support for padding " + cmp);
		} catch (InvalidKeyException e) {
			Log.e("AESdemo", "invalid key exception");
		} catch (InvalidAlgorithmParameterException e) {
			Log.e("AESdemo", "invalid algorithm parameter exception");
		} catch (IllegalBlockSizeException e) {
			Log.e("AESdemo", "illegal block size exception");
		} catch (BadPaddingException e) {
			Log.e("AESdemo", "bad padding exception");
			e.printStackTrace();
		}
		return null;
	}
}

Base64Decoder.java类：

package com.test.aesforandroid;

import java.io.*;

public class Base64Decoder extends FilterInputStream {

	private static final char[] chars = { "A", "B", "C", "D", "E", "F", "G",
			"H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
			"U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g",
			"h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
			"u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6",
			"7", "8", "9", "+", "/" };

	// A mapping between char values and six-bit integers
	private static final int[] ints = new int[128];
	static {
		for (int i = 0; i < 64; i++) {
			ints[chars[i]] = i;
		}
	}

	private int charCount;
	private int carryOver;

	/***
	 * Constructs a new Base64 decoder that reads input from the given
	 * InputStream.
	 * 
	 * @param in
	 *            the input stream
	 */
	public Base64Decoder(InputStream in) {
		super(in);
	}

	/***
	 * Returns the next decoded character from the stream, or -1 if end of
	 * stream was reached.
	 * 
	 * @return the decoded character, or -1 if the end of the input stream is
	 *         reached
	 * @exception IOException
	 *                if an I/O error occurs
	 */
	public int read() throws IOException {
		// Read the next non-whitespace character
		int x;
		do {
			x = in.read();
			if (x == -1) {
				return -1;
			}
		} while (Character.isWhitespace((char) x));
		charCount++;

		// The "=" sign is just padding
		if (x == "=") {
			return -1; // effective end of stream
		}

		// Convert from raw form to 6-bit form
		x = ints[x];

		// Calculate which character we"re decoding now
		int mode = (charCount - 1) % 4;

		// First char save all six bits, go for another
		if (mode == 0) {
			carryOver = x & 63;
			return read();
		}
		// Second char use previous six bits and first two new bits,
		// save last four bits
		else if (mode == 1) {
			int decoded = ((carryOver << 2) + (x >> 4)) & 255;
			carryOver = x & 15;
			return decoded;
		}
		// Third char use previous four bits and first four new bits,
		// save last two bits
		else if (mode == 2) {
			int decoded = ((carryOver << 4) + (x >> 2)) & 255;
			carryOver = x & 3;
			return decoded;
		}
		// Fourth char use previous two bits and all six new bits
		else if (mode == 3) {
			int decoded = ((carryOver << 6) + x) & 255;
			return decoded;
		}
		return -1; // can"t actually reach this line
	}

	/***
	 * Reads decoded data into an array of bytes and returns the actual number
	 * of bytes read, or -1 if end of stream was reached.
	 * 
	 * @param buf
	 *            the buffer into which the data is read
	 * @param off
	 *            the start offset of the data
	 * @param len
	 *            the maximum number of bytes to read
	 * @return the actual number of bytes read, or -1 if the end of the input
	 *         stream is reached
	 * @exception IOException
	 *                if an I/O error occurs
	 */
	public int read(byte[] buf, int off, int len) throws IOException {
		if (buf.length < (len + off - 1)) {
			throw new IOException("The input buffer is too small: " + len
					+ " bytes requested starting at offset " + off
					+ " while the buffer " + " is only " + buf.length
					+ " bytes long.");
		}

		// This could of course be optimized
		int i;
		for (i = 0; i < len; i++) {
			int x = read();
			if (x == -1 && i == 0) { // an immediate -1 returns -1
				return -1;
			} else if (x == -1) { // a later -1 returns the chars read so far
				break;
			}
			buf[off + i] = (byte) x;
		}
		return i;
	}

	/***
	 * Returns the decoded form of the given encoded string, as a String. Note
	 * that not all binary data can be represented as a String, so this method
	 * should only be used for encoded String data. Use decodeToBytes()
	 * otherwise.
	 * 
	 * @param encoded
	 *            the string to decode
	 * @return the decoded form of the encoded string
	 */
	public static String decode(String encoded) {
		return new String(decodeToBytes(encoded));
	}

	/***
	 * Returns the decoded form of the given encoded string, as bytes.
	 * 
	 * @param encoded
	 *            the string to decode
	 * @return the decoded form of the encoded string
	 */
	public static byte[] decodeToBytes(String encoded) {
		byte[] bytes = null;
		try {
			bytes = encoded.getBytes("UTF-8");
		} catch (UnsupportedEncodingException ignored) {
		}

		Base64Decoder in = new Base64Decoder(new ByteArrayInputStream(bytes));

		ByteArrayOutputStream out = new ByteArrayOutputStream(
				(int) (bytes.length * 0.67));

		try {
			byte[] buf = new byte[4 * 1024]; // 4K buffer
			int bytesRead;
			while ((bytesRead = in.read(buf)) != -1) {
				out.write(buf, 0, bytesRead);
			}
			out.close();

			return out.toByteArray();
		} catch (IOException ignored) {
			return null;
		}
	}

	public static void main(String[] args) throws Exception {
		if (args.length != 1) {
			System.err.println("Usage: java Base64Decoder fileToDecode");
			return;
		}

		Base64Decoder decoder = null;
		try {
			decoder = new Base64Decoder(new BufferedInputStream(
					new FileInputStream(args[0])));
			byte[] buf = new byte[4 * 1024]; // 4K buffer
			int bytesRead;
			while ((bytesRead = decoder.read(buf)) != -1) {
				System.out.write(buf, 0, bytesRead);
			}
		} finally {
			if (decoder != null)
				decoder.close();
		}
	}
}

Base64Encoder.java类：

package com.test.aesforandroid;

import java.io.*;

public class Base64Encoder extends FilterOutputStream {

	private static final char[] chars = { "A", "B", "C", "D", "E", "F", "G",
			"H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
			"U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g",
			"h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
			"u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6",
			"7", "8", "9", "+", "/" };

	private int charCount;
	private int carryOver;

	/***
	 * Constructs a new Base64 encoder that writes output to the given
	 * OutputStream.
	 * 
	 * @param out
	 *            the output stream
	 */
	public Base64Encoder(OutputStream out) {
		super(out);
	}

	/***
	 * Writes the given byte to the output stream in an encoded form.
	 * 
	 * @exception IOException
	 *                if an I/O error occurs
	 */
	public void write(int b) throws IOException {
		// Take 24-bits from three octets, translate into four encoded chars
		// Break lines at 76 chars
		// If necessary, pad with 0 bits on the right at the end
		// Use = signs as padding at the end to ensure encodedLength % 4 == 0

		// Remove the sign bit,
		// thanks to Christian Schweingruber <chrigu@lorraine.ch>
		if (b < 0) {
			b += 256;
		}

		// First byte use first six bits, save last two bits
		if (charCount % 3 == 0) {
			int lookup = b >> 2;
			carryOver = b & 3; // last two bits
			out.write(chars[lookup]);
		}
		// Second byte use previous two bits and first four new bits,
		// save last four bits
		else if (charCount % 3 == 1) {
			int lookup = ((carryOver << 4) + (b >> 4)) & 63;
			carryOver = b & 15; // last four bits
			out.write(chars[lookup]);
		}
		// Third byte use previous four bits and first two new bits,
		// then use last six new bits
		else if (charCount % 3 == 2) {
			int lookup = ((carryOver << 2) + (b >> 6)) & 63;
			out.write(chars[lookup]);
			lookup = b & 63; // last six bits
			out.write(chars[lookup]);
			carryOver = 0;
		}
		charCount++;

		// Add newline every 76 output chars (that"s 57 input chars)
		if (charCount % 57 == 0) {
			out.write("
");
		}
	}

	/***
	 * Writes the given byte array to the output stream in an encoded form.
	 * 
	 * @param buf
	 *            the data to be written
	 * @param off
	 *            the start offset of the data
	 * @param len
	 *            the length of the data
	 * @exception IOException
	 *                if an I/O error occurs
	 */
	public void write(byte[] buf, int off, int len) throws IOException {
		// This could of course be optimized
		for (int i = 0; i < len; i++) {
			write(buf[off + i]);
		}
	}

	/***
	 * Closes the stream, this MUST be called to ensure proper padding is
	 * written to the end of the output stream.
	 * 
	 * @exception IOException
	 *                if an I/O error occurs
	 */
	public void close() throws IOException {
		// Handle leftover bytes
		if (charCount % 3 == 1) { // one leftover
			int lookup = (carryOver << 4) & 63;
			out.write(chars[lookup]);
			out.write("=");
			out.write("=");
		} else if (charCount % 3 == 2) { // two leftovers
			int lookup = (carryOver << 2) & 63;
			out.write(chars[lookup]);
			out.write("=");
		}
		super.close();
	}

	/***
	 * Returns the encoded form of the given unencoded string. The encoder uses
	 * the ISO-8859-1 (Latin-1) encoding to convert the string to bytes. For
	 * greater control over the encoding, encode the string to bytes yourself
	 * and use encode(byte[]).
	 * 
	 * @param unencoded
	 *            the string to encode
	 * @return the encoded form of the unencoded string
	 */
	public static String encode(String unencoded) {
		byte[] bytes = null;
		try {
			bytes = unencoded.getBytes("UTF-8");
		} catch (UnsupportedEncodingException ignored) {
		}
		return encode(bytes);
	}

	/***
	 * Returns the encoded form of the given unencoded string.
	 * 
	 * @param bytes
	 *            the bytes to encode
	 * @return the encoded form of the unencoded string
	 */
	public static String encode(byte[] bytes) {
		ByteArrayOutputStream out = new ByteArrayOutputStream(
				(int) (bytes.length * 1.37));
		Base64Encoder encodedOut = new Base64Encoder(out);

		try {
			encodedOut.write(bytes);
			encodedOut.close();

			return out.toString("UTF-8");
		} catch (IOException ignored) {
			return null;
		}
	}

	public static void main(String[] args) throws Exception {
		if (args.length != 1) {
			System.err
					.println("Usage: java com.oreilly.servlet.Base64Encoder fileToEncode");
			return;
		}

		Base64Encoder encoder = null;
		BufferedInputStream in = null;
		try {
			encoder = new Base64Encoder(System.out);
			in = new BufferedInputStream(new FileInputStream(args[0]));

			byte[] buf = new byte[4 * 1024]; // 4K buffer
			int bytesRead;
			while ((bytesRead = in.read(buf)) != -1) {
				encoder.write(buf, 0, bytesRead);
			}
		} finally {
			if (in != null)
				in.close();
			if (encoder != null)
				encoder.close();
		}
	}
}

Android测试代码如下：

package com.test.aesforandroid;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.widget.TextView;

public class MainActivity extends Activity {

	private TextView textView1, textView2;
	String mString = "hello everyone!";
	byte[] mBytes = null;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		textView1 = (TextView) findViewById(R.id.textView1);
		textView2 = (TextView) findViewById(R.id.textView2);

		AES mAes = new AES();
		try {
			mBytes = mString.getBytes("UTF8");
		} catch (Exception e) {
			Log.i("qing", "MainActivity----catch");
		}
		String enString = mAes.encrypt(mBytes);
		textView1.setText("加密后：" + enString);
		String deString = mAes.decrypt(enString);
		textView2.setText("解密后：" + deString);
	}
}

Run APP，可以发现界面上会出现如下图所示：

与上面在线测试工具的相比对，一模一样，棒棒哒，搞定！

附上我上传到CSDN上的代码：http://download.csdn.net/detail/qq_33237207/9678602

X/T+Vxr5QZEp/GBr/iul8w==