前言
此工具类加解密适用与Android平台
代码
package net.wt.gate.dev.util; import android.annotation.SuppressLint; import android.os.Build; import android.util.Log; import java.nio.charset.StandardCharsets; import java.security.Provider; import java.security.SecureRandom; import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; public class AESUtil { private final static String HEX = "0123456789ABCDEF"; /** * 加密 * * @param key * 密钥 * @param src * 加密文本 * @return * @throws Exception */ public static String encrypt(String key, String src) throws Exception { byte[] rawKey = getRawKey(key.getBytes()); byte[] result = encrypt(rawKey, src.getBytes()); return toHex(result); } /** * 解密 * * @param key * 密钥 * @param encrypted * 待揭秘文本 * @return * @throws Exception */ public static String decrypt(String key, String encrypted) throws Exception { byte[] rawKey = getRawKey(key.getBytes()); byte[] enc = toByte(encrypted); byte[] result = decrypt(rawKey, enc); return new String(result); } /** * 获取256位的加密密钥 * * @param seed * @return * @throws Exception */ @SuppressLint("TrulyRandom") private static byte[] getRawKey(byte[] seed) throws Exception { return deriveKeyInsecurely(seed); /** * 请注意，如果是Android9.0以下的版本可以选择以下的生成加密Key，但是与可能上面的互不兼容， * 所以建议直接使用 InsecureSHA1PRNGKeyDerivator 方式生成加密key，这个类是google提供用于兼容9.0 AES生成加密Key的类 */ // if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.P){ // return deriveKeyInsecurely(seed); // } // KeyGenerator kgen = KeyGenerator.getInstance("AES"); // SecureRandom sr = null; // // 在4.2以上版本中，SecureRandom获取方式发生了改变 // if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) { // sr = SecureRandom.getInstance("SHA1PRNG", new CryptoProvider()); // } else { // sr = SecureRandom.getInstance("SHA1PRNG"); // } // sr.setSeed(seed); // // 256 bits or 128 bits,192bits // kgen.init(128, sr); // SecretKey skey = kgen.generateKey(); // byte[] raw = skey.getEncoded(); // return raw; } /** * 真正的加密过程 * * @param key * @param src * @return * @throws Exception */ private static byte[] encrypt(byte[] key, byte[] src) throws Exception { SecretKeySpec skeySpec = new SecretKeySpec(key, "AES"); Cipher cipher = Cipher.getInstance("AES"); cipher.init(Cipher.ENCRYPT_MODE, skeySpec); byte[] encrypted = cipher.doFinal(src); return encrypted; } /** * 真正的解密过程 * * @param key * @param encrypted * @return * @throws Exception */ private static byte[] decrypt(byte[] key, byte[] encrypted) throws Exception { SecretKeySpec skeySpec = new SecretKeySpec(key, "AES"); Cipher cipher = Cipher.getInstance("AES"); cipher.init(Cipher.DECRYPT_MODE, skeySpec); byte[] decrypted = cipher.doFinal(encrypted); return decrypted; } private static byte[] deriveKeyInsecurely(byte[] key) { // byte[] passwordBytes = key.getBytes(StandardCharsets.US_ASCII); //InsecureSHA1PRNGKeyDerivator return InsecureSHA1PRNGKeyDerivator.deriveInsecureKey(key, 32); // return new SecretKeySpec(InsecureSHA1PRNGKeyDerivator.deriveInsecureKey(key, 32), "AES"); } 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)); } public static class CryptoProvider extends Provider { /** * Creates a Provider and puts parameters */ public CryptoProvider() { super("Crypto", 1.0, "HARMONY (SHA1 digest; SecureRandom; SHA1withDSA signature)"); put("SecureRandom.SHA1PRNG", "org.apache.harmony.security.provider.crypto.SHA1PRNG_SecureRandomImpl"); put("SecureRandom.SHA1PRNG ImplementedIn", "Software"); } } /* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /** * Stripped-down version of the SHA1PRNG provided by the Crypto provider. * * The Crypto provider that offers this functionality was deprecated on Android. * * Use this class only to retrieve encrypted data that couldn't be retrieved otherwise. */ private static class InsecureSHA1PRNGKeyDerivator { /** * Only public method. Derive a key from the given seed. * * Use this method only to retrieve encrypted data that couldn't be retrieved otherwise. * * @param seed seed used for the random generator, usually coming from a password * @param keySizeInBytes length of the array returned */ public static byte[] deriveInsecureKey(byte[] seed, int keySizeInBytes) { InsecureSHA1PRNGKeyDerivator derivator = new InsecureSHA1PRNGKeyDerivator(); derivator.setSeed(seed); byte[] key = new byte[keySizeInBytes]; derivator.nextBytes(key); return key; } // constants to use in expressions operating on bytes in int and long variables: // END_FLAGS - final bytes in words to append to message; // see "ch.5.1 Padding the Message, FIPS 180-2" // RIGHT1 - shifts to right for left half of long // RIGHT2 - shifts to right for right half of long // LEFT - shifts to left for bytes // MASK - mask to select counter's bytes after shift to right private static final int[] END_FLAGS = { 0x80000000, 0x800000, 0x8000, 0x80 }; private static final int[] RIGHT1 = { 0, 40, 48, 56 }; private static final int[] RIGHT2 = { 0, 8, 16, 24 }; private static final int[] LEFT = { 0, 24, 16, 8 }; private static final int[] MASK = { 0xFFFFFFFF, 0x00FFFFFF, 0x0000FFFF, 0x000000FF }; // HASHBYTES_TO_USE defines # of bytes returned by "computeHash(byte[])" // to use to form byte array returning by the "nextBytes(byte[])" method // Note, that this implementation uses more bytes than it is defined // in the above specification. private static final int HASHBYTES_TO_USE = 20; // value of 16 defined in the "SECURE HASH STANDARD", FIPS PUB 180-2 private static final int FRAME_LENGTH = 16; // miscellaneous constants defined in this implementation: // COUNTER_BASE - initial value to set to "counter" before computing "nextBytes(..)"; // note, that the exact value is not defined in STANDARD // HASHCOPY_OFFSET - offset for copy of current hash in "copies" array // EXTRAFRAME_OFFSET - offset for extra frame in "copies" array; // as the extra frame follows the current hash frame, // EXTRAFRAME_OFFSET is equal to length of current hash frame // FRAME_OFFSET - offset for frame in "copies" array // MAX_BYTES - maximum # of seed bytes processing which doesn't require extra frame // see (1) comments on usage of "seed" array below and // (2) comments in "engineNextBytes(byte[])" method // // UNDEFINED - three states of engine; initially its state is "UNDEFINED" // SET_SEED call to "engineSetSeed" sets up "SET_SEED" state, // NEXT_BYTES call to "engineNextByte" sets up "NEXT_BYTES" state private static final int COUNTER_BASE = 0; private static final int HASHCOPY_OFFSET = 0; private static final int EXTRAFRAME_OFFSET = 5; private static final int FRAME_OFFSET = 21; private static final int MAX_BYTES = 48; private static final int UNDEFINED = 0; private static final int SET_SEED = 1; private static final int NEXT_BYTES = 2; // Structure of "seed" array: // - 0-79 - words for computing hash // - 80 - unused // - 81 - # of seed bytes in current seed frame // - 82-86 - 5 words, current seed hash private transient int[] seed; // total length of seed bytes, including all processed private transient long seedLength; // Structure of "copies" array // - 0-4 - 5 words, copy of current seed hash // - 5-20 - extra 16 words frame; // is used if final padding exceeds 512-bit length // - 21-36 - 16 word frame to store a copy of remaining bytes private transient int[] copies; // ready "next" bytes; needed because words are returned private transient byte[] nextBytes; // index of used bytes in "nextBytes" array private transient int nextBIndex; // variable required according to "SECURE HASH STANDARD" private transient long counter; // contains int value corresponding to engine's current state private transient int state; /** * constant defined in "SECURE HASH STANDARD" */ private static final int H0 = 0x67452301; /** * constant defined in "SECURE HASH STANDARD" */ private static final int H1 = 0xEFCDAB89; /** * constant defined in "SECURE HASH STANDARD" */ private static final int H2 = 0x98BADCFE; /** * constant defined in "SECURE HASH STANDARD" */ private static final int H3 = 0x10325476; /** * constant defined in "SECURE HASH STANDARD" */ private static final int H4 = 0xC3D2E1F0; /** * offset in buffer to store number of bytes in 0-15 word frame */ private static final int BYTES_OFFSET = 81; /** * offset in buffer to store current hash value */ private static final int HASH_OFFSET = 82; /** * # of bytes in H0-H4 words; <BR> * in this implementation # is set to 20 (in general # varies from 1 to 20) */ private static final int DIGEST_LENGTH = 20; // The "seed" array is used to compute both "current seed hash" and "next bytes". // // As the "SHA1" algorithm computes a hash of entire seed by splitting it into // a number of the 512-bit length frames (512 bits = 64 bytes = 16 words), // "current seed hash" is a hash (5 words, 20 bytes) for all previous full frames; // remaining bytes are stored in the 0-15 word frame of the "seed" array. // // As for calculating "next bytes", // both remaining bytes and "current seed hash" are used, // to preserve the latter for following "setSeed(..)" commands, // the following technique is used: // - upon getting "nextBytes(byte[])" invoked, single or first in row, // which requires computing new hash, that is, // there is no more bytes remaining from previous "next bytes" computation, // remaining bytes are copied into the 21-36 word frame of the "copies" array; // - upon getting "setSeed(byte[])" invoked, single or first in row, // remaining bytes are copied back. private InsecureSHA1PRNGKeyDerivator() { seed = new int[HASH_OFFSET + EXTRAFRAME_OFFSET]; seed[HASH_OFFSET] = H0; seed[HASH_OFFSET + 1] = H1; seed[HASH_OFFSET + 2] = H2; seed[HASH_OFFSET + 3] = H3; seed[HASH_OFFSET + 4] = H4; seedLength = 0; copies = new int[2 * FRAME_LENGTH + EXTRAFRAME_OFFSET]; nextBytes = new byte[DIGEST_LENGTH]; nextBIndex = HASHBYTES_TO_USE; counter = COUNTER_BASE; state = UNDEFINED; } /* * The method invokes the SHA1Impl's "updateHash(..)" method * to update current seed frame and * to compute new intermediate hash value if the frame is full. * * After that it computes a length of whole seed. */ private void updateSeed(byte[] bytes) { // on call: "seed" contains current bytes and current hash; // on return: "seed" contains new current bytes and possibly new current hash // if after adding, seed bytes overfill its buffer updateHash(seed, bytes, 0, bytes.length - 1); seedLength += bytes.length; } /** * Changes current seed by supplementing a seed argument to the current seed, * if this already set; * the argument is used as first seed otherwise. <BR> * * The method overrides "engineSetSeed(byte[])" in class SecureRandomSpi. * * @param * seed - byte array * @throws * NullPointerException - if null is passed to the "seed" argument */ private void setSeed(byte[] seed) { if (seed == null) { throw new NullPointerException("seed == null"); } if (state == NEXT_BYTES) { // first setSeed after NextBytes; restoring hash System.arraycopy(copies, HASHCOPY_OFFSET, this.seed, HASH_OFFSET, EXTRAFRAME_OFFSET); } state = SET_SEED; if (seed.length != 0) { updateSeed(seed); } } /** * Writes random bytes into an array supplied. * Bits in a byte are from left to right. <BR> * * To generate random bytes, the "expansion of source bits" method is used, * that is, * the current seed with a 64-bit counter appended is used to compute new bits. * The counter is incremented by 1 for each 20-byte output. <BR> * * The method overrides engineNextBytes in class SecureRandomSpi. * * @param * bytes - byte array to be filled in with bytes * @throws * NullPointerException - if null is passed to the "bytes" argument */ protected synchronized void nextBytes(byte[] bytes) { int i, n; long bits; // number of bits required by Secure Hash Standard int nextByteToReturn; // index of ready bytes in "bytes" array int lastWord; // index of last word in frame containing bytes // This is a bug since words are 4 bytes. Android used to keep it this way for backward // compatibility. final int extrabytes = 7;// # of bytes to add in order to computer # of 8 byte words if (bytes == null) { throw new NullPointerException("bytes == null"); } // This is a bug since extraBytes == 7 instead of 3. Android used to keep it this way for // backward compatibility. lastWord = seed[BYTES_OFFSET] == 0 ? 0 : (seed[BYTES_OFFSET] + extrabytes) >> 3 - 1; if (state == UNDEFINED) { throw new IllegalStateException("No seed supplied!"); } else if (state == SET_SEED) { System.arraycopy(seed, HASH_OFFSET, copies, HASHCOPY_OFFSET, EXTRAFRAME_OFFSET); // possible cases for 64-byte frame: // // seed bytes < 48 - remaining bytes are enough for all, 8 counter bytes, // 0x80, and 8 seedLength bytes; no extra frame required // 48 < seed bytes < 56 - remaining 9 bytes are for 0x80 and 8 counter bytes // extra frame contains only seedLength value at the end // seed bytes > 55 - extra frame contains both counter's bytes // at the beginning and seedLength value at the end; // note, that beginning extra bytes are not more than 8, // that is, only 2 extra words may be used // no need to set to "0" 3 words after "lastWord" and // more than two words behind frame for (i = lastWord + 3; i < FRAME_LENGTH + 2; i++) { seed[i] = 0; } bits = (seedLength << 3) + 64; // transforming # of bytes into # of bits // putting # of bits into two last words (14,15) of 16 word frame in // seed or copies array depending on total length after padding if (seed[BYTES_OFFSET] < MAX_BYTES) { seed[14] = (int) (bits >>> 32); seed[15] = (int) (bits & 0xFFFFFFFF); } else { copies[EXTRAFRAME_OFFSET + 14] = (int) (bits >>> 32); copies[EXTRAFRAME_OFFSET + 15] = (int) (bits & 0xFFFFFFFF); } nextBIndex = HASHBYTES_TO_USE; // skipping remaining random bits } state = NEXT_BYTES; if (bytes.length == 0) { return; } nextByteToReturn = 0; // possibly not all of HASHBYTES_TO_USE bytes were used previous time n = (HASHBYTES_TO_USE - nextBIndex) < (bytes.length - nextByteToReturn) ? HASHBYTES_TO_USE - nextBIndex : bytes.length - nextByteToReturn; if (n > 0) { System.arraycopy(nextBytes, nextBIndex, bytes, nextByteToReturn, n); nextBIndex += n; nextByteToReturn += n; } if (nextByteToReturn >= bytes.length) { return; // return because "bytes[]" are filled in } n = seed[BYTES_OFFSET] & 0x03; for (;;) { if (n == 0) { seed[lastWord] = (int) (counter >>> 32); seed[lastWord + 1] = (int) (counter & 0xFFFFFFFF); seed[lastWord + 2] = END_FLAGS[0]; } else { seed[lastWord] |= (int) ((counter >>> RIGHT1[n]) & MASK[n]); seed[lastWord + 1] = (int) ((counter >>> RIGHT2[n]) & 0xFFFFFFFF); seed[lastWord + 2] = (int) ((counter << LEFT[n]) | END_FLAGS[n]); } if (seed[BYTES_OFFSET] > MAX_BYTES) { copies[EXTRAFRAME_OFFSET] = seed[FRAME_LENGTH]; copies[EXTRAFRAME_OFFSET + 1] = seed[FRAME_LENGTH + 1]; } computeHash(seed); if (seed[BYTES_OFFSET] > MAX_BYTES) { System.arraycopy(seed, 0, copies, FRAME_OFFSET, FRAME_LENGTH); System.arraycopy(copies, EXTRAFRAME_OFFSET, seed, 0, FRAME_LENGTH); computeHash(seed); System.arraycopy(copies, FRAME_OFFSET, seed, 0, FRAME_LENGTH); } counter++; int j = 0; for (i = 0; i < EXTRAFRAME_OFFSET; i++) { int k = seed[HASH_OFFSET + i]; nextBytes[j] = (byte) (k >>> 24); // getting first byte from left nextBytes[j + 1] = (byte) (k >>> 16); // getting second byte from left nextBytes[j + 2] = (byte) (k >>> 8); // getting third byte from left nextBytes[j + 3] = (byte) (k); // getting fourth byte from left j += 4; } nextBIndex = 0; j = HASHBYTES_TO_USE < (bytes.length - nextByteToReturn) ? HASHBYTES_TO_USE : bytes.length - nextByteToReturn; if (j > 0) { System.arraycopy(nextBytes, 0, bytes, nextByteToReturn, j); nextByteToReturn += j; nextBIndex += j; } if (nextByteToReturn >= bytes.length) { break; } } } /** * The method generates a 160 bit hash value using * a 512 bit message stored in first 16 words of int[] array argument and * current hash value stored in five words, beginning OFFSET+1, of the array argument. * Computation is done according to SHA-1 algorithm. * * The resulting hash value replaces the previous hash value in the array; * original bits of the message are not preserved. * * No checks on argument supplied, that is, * a calling method is responsible for such checks. * In case of incorrect array passed to the method * either NPE or IndexOutOfBoundException gets thrown by JVM. * * @params * arrW - integer array; arrW.length >= (BYTES_OFFSET+6); <BR> * only first (BYTES_OFFSET+6) words are used */ private static void computeHash(int[] arrW) { int a = arrW[HASH_OFFSET ]; int b = arrW[HASH_OFFSET +1]; int c = arrW[HASH_OFFSET +2]; int d = arrW[HASH_OFFSET +3]; int e = arrW[HASH_OFFSET +4]; int temp; // In this implementation the "d. For t = 0 to 79 do" loop // is split into four loops. The following constants: // K = 5A827999 0 <= t <= 19 // K = 6ED9EBA1 20 <= t <= 39 // K = 8F1BBCDC 40 <= t <= 59 // K = CA62C1D6 60 <= t <= 79 // are hex literals in the loops. for ( int t = 16; t < 80 ; t++ ) { temp = arrW[t-3] ^ arrW[t-8] ^ arrW[t-14] ^ arrW[t-16]; arrW[t] = ( temp<<1 ) | ( temp>>>31 ); } for ( int t = 0 ; t < 20 ; t++ ) { temp = ( ( a<<5 ) | ( a>>>27 ) ) + ( ( b & c) | ((~b) & d) ) + ( e + arrW[t] + 0x5A827999 ) ; e = d; d = c; c = ( b<<30 ) | ( b>>>2 ) ; b = a; a = temp; } for ( int t = 20 ; t < 40 ; t++ ) { temp = ((( a<<5 ) | ( a>>>27 ))) + (b ^ c ^ d) + (e + arrW[t] + 0x6ED9EBA1) ; e = d; d = c; c = ( b<<30 ) | ( b>>>2 ) ; b = a; a = temp; } for ( int t = 40 ; t < 60 ; t++ ) { temp = (( a<<5 ) | ( a>>>27 )) + ((b & c) | (b & d) | (c & d)) + (e + arrW[t] + 0x8F1BBCDC) ; e = d; d = c; c = ( b<<30 ) | ( b>>>2 ) ; b = a; a = temp; } for ( int t = 60 ; t < 80 ; t++ ) { temp = ((( a<<5 ) | ( a>>>27 ))) + (b ^ c ^ d) + (e + arrW[t] + 0xCA62C1D6) ; e = d; d = c; c = ( b<<30 ) | ( b>>>2 ) ; b = a; a = temp; } arrW[HASH_OFFSET ] += a; arrW[HASH_OFFSET +1] += b; arrW[HASH_OFFSET +2] += c; arrW[HASH_OFFSET +3] += d; arrW[HASH_OFFSET +4] += e; } /** * The method appends new bytes to existing ones * within limit of a frame of 64 bytes (16 words). * * Once a length of accumulated bytes reaches the limit * the "computeHash(int[])" method is invoked on the array to compute updated hash, * and the number of bytes in the frame is set to 0. * Thus, after appending all bytes, the array contain only those bytes * that were not used in computing final hash value yet. * * No checks on arguments passed to the method, that is, * a calling method is responsible for such checks. * * @params * intArray - int array containing bytes to which to append; * intArray.length >= (BYTES_OFFSET+6) * @params * byteInput - array of bytes to use for the update * @params * from - the offset to start in the "byteInput" array * @params * to - a number of the last byte in the input array to use, * that is, for first byte "to"==0, for last byte "to"==input.length-1 */ private static void updateHash(int[] intArray, byte[] byteInput, int fromByte, int toByte) { // As intArray contains a packed bytes // the buffer's index is in the intArray[BYTES_OFFSET] element int index = intArray[BYTES_OFFSET]; int i = fromByte; int maxWord; int nBytes; int wordIndex = index >>2; int byteIndex = index & 0x03; intArray[BYTES_OFFSET] = ( index + toByte - fromByte + 1 ) & 077 ; // In general case there are 3 stages : // - appending bytes to non-full word, // - writing 4 bytes into empty words, // - writing less than 4 bytes in last word if ( byteIndex != 0 ) { // appending bytes in non-full word (as if) for ( ; ( i <= toByte ) && ( byteIndex < 4 ) ; i++ ) { intArray[wordIndex] |= ( byteInput[i] & 0xFF ) << ((3 - byteIndex)<<3) ; byteIndex++; } if ( byteIndex == 4 ) { wordIndex++; if ( wordIndex == 16 ) { // intArray is full, computing hash computeHash(intArray); wordIndex = 0; } } if ( i > toByte ) { // all input bytes appended return ; } } // writing full words maxWord = (toByte - i + 1) >> 2; // # of remaining full words, may be "0" for ( int k = 0; k < maxWord ; k++ ) { intArray[wordIndex] = ( ((int) byteInput[i ] & 0xFF) <<24 ) | ( ((int) byteInput[i +1] & 0xFF) <<16 ) | ( ((int) byteInput[i +2] & 0xFF) <<8 ) | ( ((int) byteInput[i +3] & 0xFF) ) ; i += 4; wordIndex++; if ( wordIndex < 16 ) { // buffer is not full yet continue; } computeHash(intArray); // buffer is full, computing hash wordIndex = 0; } // writing last incomplete word // after writing free byte positions are set to "0"s nBytes = toByte - i +1; if ( nBytes != 0 ) { int w = ((int) byteInput[i] & 0xFF) <<24 ; if ( nBytes != 1 ) { w |= ((int) byteInput[i +1] & 0xFF) <<16 ; if ( nBytes != 2) { w |= ((int) byteInput[i +2] & 0xFF) <<8 ; } } intArray[wordIndex] = w; } return ; } } }