在网上查了很多的rsa试过好多种方法，加密和解密多少都有点瑕疵
下面总结下 直接使用copy大法
干货
首先copy这5个类
1.Base64
public class Base64 { /** * Chunk size per RFC 2045 section 6.8. * * <p>The {@value} character limit does not count the trailing CRLF, but counts * all other characters, including any equal signs.</p> * * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 6.8</a> */ static final int CHUNK_SIZE = 76; /** * Chunk separator per RFC 2045 section 2.1. * * @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section 2.1</a> */ static final byte[] CHUNK_SEPARATOR = " ".getBytes(); /** * The base length. */ static final int BASELENGTH = 255; /** * Lookup length. */ static final int LOOKUPLENGTH = 64; /** * Used to calculate the number of bits in a byte. */ static final int EIGHTBIT = 8; /** * Used when encoding something which has fewer than 24 bits. */ static final int SIXTEENBIT = 16; /** * Used to determine how many bits data contains. */ static final int TWENTYFOURBITGROUP = 24; /** * Used to get the number of Quadruples. */ static final int FOURBYTE = 4; /** * Used to test the sign of a byte. */ static final int SIGN = -128; /** * Byte used to pad output. */ static final byte PAD = (byte) '='; // Create arrays to hold the base64 characters and a // lookup for base64 chars private static byte[] base64Alphabet = new byte[BASELENGTH]; private static byte[] lookUpBase64Alphabet = new byte[LOOKUPLENGTH]; // Populating the lookup and character arrays static { for (int i = 0; i < BASELENGTH; i++) { base64Alphabet[i] = (byte) -1; } for (int i = 'Z'; i >= 'A'; i--) { base64Alphabet[i] = (byte) (i - 'A'); } for (int i = 'z'; i >= 'a'; i--) { base64Alphabet[i] = (byte) (i - 'a' + 26); } for (int i = '9'; i >= '0'; i--) { base64Alphabet[i] = (byte) (i - '0' + 52); } base64Alphabet['+'] = 62; base64Alphabet['/'] = 63; for (int i = 0; i <= 25; i++) { lookUpBase64Alphabet[i] = (byte) ('A' + i); } for (int i = 26, j = 0; i <= 51; i++, j++) { lookUpBase64Alphabet[i] = (byte) ('a' + j); } for (int i = 52, j = 0; i <= 61; i++, j++) { lookUpBase64Alphabet[i] = (byte) ('0' + j); } lookUpBase64Alphabet[62] = (byte) '+'; lookUpBase64Alphabet[63] = (byte) '/'; } private static boolean isBase64(byte octect) { if (octect == PAD) { return true; } else if (base64Alphabet[octect] == -1) { return false; } else { return true; } } /** * Tests a given byte array to see if it contains * only valid characters within the Base64 alphabet. * * @param arrayOctect byte array to test * @return true if all bytes are valid characters in the Base64 * alphabet or if the byte array is empty; false, otherwise */ public static boolean isArrayByteBase64(byte[] arrayOctect) { arrayOctect = discardWhitespace(arrayOctect); int length = arrayOctect.length; if (length == 0) { // shouldn't a 0 length array be valid base64 data? // return false; return true; } for (int i = 0; i < length; i++) { if (!isBase64(arrayOctect[i])) { return false; } } return true; } /** * Encodes binary data using the base64 algorithm but * does not chunk the output. * * @param binaryData binary data to encode * @return Base64 characters */ public static byte[] encodeBase64(byte[] binaryData) { return encodeBase64(binaryData, false); } /** * Encodes binary data using the base64 algorithm and chunks * the encoded output into 76 character blocks * * @param binaryData binary data to encode * @return Base64 characters chunked in 76 character blocks */ public static byte[] encodeBase64Chunked(byte[] binaryData) { return encodeBase64(binaryData, true); } /** * Decodes a byte[] containing containing * characters in the Base64 alphabet. * * @param pArray A byte array containing Base64 character data * @return a byte array containing binary data */ public static byte[] decode(byte[] pArray) { return decodeBase64(pArray); } /** * Encodes binary data using the base64 algorithm, optionally * chunking the output into 76 character blocks. * * @param binaryData Array containing binary data to encode. * @param isChunked if isChunked is true this encoder will chunk * the base64 output into 76 character blocks * @return Base64-encoded data. */ public static byte[] encodeBase64(byte[] binaryData, boolean isChunked) { int lengthDataBits = binaryData.length * EIGHTBIT; int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP; int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP; byte encodedData[] = null; int encodedDataLength = 0; int nbrChunks = 0; if (fewerThan24bits != 0) { //data not divisible by 24 bit encodedDataLength = (numberTriplets + 1) * 4; } else { // 16 or 8 bit encodedDataLength = numberTriplets * 4; } // If the output is to be "chunked" into 76 character sections, // for compliance with RFC 2045 MIME, then it is important to // allow for extra length to account for the separator(s) if (isChunked) { nbrChunks = (CHUNK_SEPARATOR.length == 0 ? 0 : (int) Math.ceil((float) encodedDataLength / CHUNK_SIZE)); encodedDataLength += nbrChunks * CHUNK_SEPARATOR.length; } encodedData = new byte[encodedDataLength]; byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0; int encodedIndex = 0; int dataIndex = 0; int i = 0; int nextSeparatorIndex = CHUNK_SIZE; int chunksSoFar = 0; //log.debug("number of triplets = " + numberTriplets); for (i = 0; i < numberTriplets; i++) { dataIndex = i * 3; b1 = binaryData[dataIndex]; b2 = binaryData[dataIndex + 1]; b3 = binaryData[dataIndex + 2]; //log.debug("b1= " + b1 +", b2= " + b2 + ", b3= " + b3); l = (byte) (b2 & 0x0f); k = (byte) (b1 & 0x03); byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0); byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc); encodedData[encodedIndex] = lookUpBase64Alphabet[val1]; //log.debug( "val2 = " + val2 ); //log.debug( "k4 = " + (k<<4) ); //log.debug( "vak = " + (val2 | (k<<4)) ); encodedData[encodedIndex + 1] = lookUpBase64Alphabet[val2 | (k << 4)]; encodedData[encodedIndex + 2] = lookUpBase64Alphabet[(l << 2) | val3]; encodedData[encodedIndex + 3] = lookUpBase64Alphabet[b3 & 0x3f]; encodedIndex += 4; // If we are chunking, let's put a chunk separator down. if (isChunked) { // this assumes that CHUNK_SIZE % 4 == 0 if (encodedIndex == nextSeparatorIndex) { System.arraycopy( CHUNK_SEPARATOR, 0, encodedData, encodedIndex, CHUNK_SEPARATOR.length); chunksSoFar++; nextSeparatorIndex = (CHUNK_SIZE * (chunksSoFar + 1)) + (chunksSoFar * CHUNK_SEPARATOR.length); encodedIndex += CHUNK_SEPARATOR.length; } } } // form integral number of 6-bit groups dataIndex = i * 3; if (fewerThan24bits == EIGHTBIT) { b1 = binaryData[dataIndex]; k = (byte) (b1 & 0x03); //log.debug("b1=" + b1); //log.debug("b1<<2 = " + (b1>>2) ); byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); encodedData[encodedIndex] = lookUpBase64Alphabet[val1]; encodedData[encodedIndex + 1] = lookUpBase64Alphabet[k << 4]; encodedData[encodedIndex + 2] = PAD; encodedData[encodedIndex + 3] = PAD; } else if (fewerThan24bits == SIXTEENBIT) { b1 = binaryData[dataIndex]; b2 = binaryData[dataIndex + 1]; l = (byte) (b2 & 0x0f); k = (byte) (b1 & 0x03); byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0); encodedData[encodedIndex] = lookUpBase64Alphabet[val1]; encodedData[encodedIndex + 1] = lookUpBase64Alphabet[val2 | (k << 4)]; encodedData[encodedIndex + 2] = lookUpBase64Alphabet[l << 2]; encodedData[encodedIndex + 3] = PAD; } if (isChunked) { // we also add a separator to the end of the final chunk. if (chunksSoFar < nbrChunks) { System.arraycopy( CHUNK_SEPARATOR, 0, encodedData, encodedDataLength - CHUNK_SEPARATOR.length, CHUNK_SEPARATOR.length); } } return encodedData; } /** * Decodes Base64 data into octects * * @param base64Data Byte array containing Base64 data * @return Array containing decoded data. */ public static byte[] decodeBase64(byte[] base64Data) { // RFC 2045 requires that we discard ALL non-Base64 characters base64Data = discardNonBase64(base64Data); // handle the edge case, so we don't have to worry about it later if (base64Data.length == 0) { return new byte[0]; } int numberQuadruple = base64Data.length / FOURBYTE; byte decodedData[] = null; byte b1 = 0, b2 = 0, b3 = 0, b4 = 0, marker0 = 0, marker1 = 0; // Throw away anything not in base64Data int encodedIndex = 0; int dataIndex = 0; { // this sizes the output array properly - rlw int lastData = base64Data.length; // ignore the '=' padding while (base64Data[lastData - 1] == PAD) { if (--lastData == 0) { return new byte[0]; } } decodedData = new byte[lastData - numberQuadruple]; } for (int i = 0; i < numberQuadruple; i++) { dataIndex = i * 4; marker0 = base64Data[dataIndex + 2]; marker1 = base64Data[dataIndex + 3]; b1 = base64Alphabet[base64Data[dataIndex]]; b2 = base64Alphabet[base64Data[dataIndex + 1]]; if (marker0 != PAD && marker1 != PAD) { //No PAD e.g 3cQl b3 = base64Alphabet[marker0]; b4 = base64Alphabet[marker1]; decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4); decodedData[encodedIndex + 1] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); decodedData[encodedIndex + 2] = (byte) (b3 << 6 | b4); } else if (marker0 == PAD) { //Two PAD e.g. 3c[Pad][Pad] decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4); } else if (marker1 == PAD) { //One PAD e.g. 3cQ[Pad] b3 = base64Alphabet[marker0]; decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4); decodedData[encodedIndex + 1] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); } encodedIndex += 3; } return decodedData; } /** * Discards any whitespace from a base-64 encoded block. * * @param data The base-64 encoded data to discard the whitespace * from. * @return The data, less whitespace (see RFC 2045). */ static byte[] discardWhitespace(byte[] data) { byte groomedData[] = new byte[data.length]; int bytesCopied = 0; for (int i = 0; i < data.length; i++) { switch (data[i]) { case (byte) ' ' : case (byte) ' ' : case (byte) ' ' : case (byte) ' ' : break; default: groomedData[bytesCopied++] = data[i]; } } byte packedData[] = new byte[bytesCopied]; System.arraycopy(groomedData, 0, packedData, 0, bytesCopied); return packedData; } /** * Discards any characters outside of the base64 alphabet, per * the requirements on page 25 of RFC 2045 - "Any characters * outside of the base64 alphabet are to be ignored in base64 * encoded data." * * @param data The base-64 encoded data to groom * @return The data, less non-base64 characters (see RFC 2045). */ static byte[] discardNonBase64(byte[] data) { byte groomedData[] = new byte[data.length]; int bytesCopied = 0; for (int i = 0; i < data.length; i++) { if (isBase64(data[i])) { groomedData[bytesCopied++] = data[i]; } } byte packedData[] = new byte[bytesCopied]; System.arraycopy(groomedData, 0, packedData, 0, bytesCopied); return packedData; } /** * Encodes a byte[] containing binary data, into a byte[] containing * characters in the Base64 alphabet. * * @param pArray a byte array containing binary data * @return A byte array containing only Base64 character data */ public static byte[] encode(byte[] pArray) { return encodeBase64(pArray, false); } public static String encode(String str) throws UnsupportedEncodingException { String baseStr = new String(encode(str.getBytes("UTF-8"))); String tempStr = Digest.digest(str).toUpperCase(); String result = tempStr+baseStr; return new String(encode(result.getBytes("UTF-8"))); } public static String decode(String cryptoStr) throws UnsupportedEncodingException { if(cryptoStr.length()<40) return ""; try { String tempStr = new String(decode(cryptoStr.getBytes("UTF-8"))); String result = tempStr.substring(40, tempStr.length()); return new String(decode(result.getBytes("UTF-8"))); } catch(ArrayIndexOutOfBoundsException ex) { return ""; } } /** * Decodes Base64 data into octects * * @param encoded string containing Base64 data * @return Array containind decoded data. */ public static byte[] decode2(String encoded) { if (encoded == null) { return null; } char[] base64Data = encoded.toCharArray(); // remove white spaces int len = removeWhiteSpace(base64Data); if (len % FOURBYTE != 0) { return null;//should be divisible by four } int numberQuadruple = (len / FOURBYTE); if (numberQuadruple == 0) { return new byte[0]; } byte decodedData[] = null; byte b1 = 0, b2 = 0, b3 = 0, b4 = 0; char d1 = 0, d2 = 0, d3 = 0, d4 = 0; int i = 0; int encodedIndex = 0; int dataIndex = 0; decodedData = new byte[(numberQuadruple) * 3]; for (; i < numberQuadruple - 1; i++) { if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++])) || !isData((d3 = base64Data[dataIndex++])) || !isData((d4 = base64Data[dataIndex++]))) { return null; }//if found "no data" just return null b1 = base64Alphabet[d1]; b2 = base64Alphabet[d2]; b3 = base64Alphabet[d3]; b4 = base64Alphabet[d4]; decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); decodedData[encodedIndex++] = (byte) (b3 << 6 | b4); } if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) { return null;//if found "no data" just return null } b1 = base64Alphabet[d1]; b2 = base64Alphabet[d2]; d3 = base64Data[dataIndex++]; d4 = base64Data[dataIndex++]; if (!isData((d3)) || !isData((d4))) {//Check if they are PAD characters if (isPad(d3) && isPad(d4)) { if ((b2 & 0xf) != 0)//last 4 bits should be zero { return null; } byte[] tmp = new byte[i * 3 + 1]; System.arraycopy(decodedData, 0, tmp, 0, i * 3); tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4); return tmp; } else if (!isPad(d3) && isPad(d4)) { b3 = base64Alphabet[d3]; if ((b3 & 0x3) != 0)//last 2 bits should be zero { return null; } byte[] tmp = new byte[i * 3 + 2]; System.arraycopy(decodedData, 0, tmp, 0, i * 3); tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); return tmp; } else { return null; } } else { //No PAD e.g 3cQl b3 = base64Alphabet[d3]; b4 = base64Alphabet[d4]; decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); decodedData[encodedIndex++] = (byte) (b3 << 6 | b4); } return decodedData; } private static boolean isWhiteSpace(char octect) { return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9); } private static boolean isData(char octect) { return (octect < BASELENGTH && base64Alphabet[octect] != -1); } private static boolean isPad(char octect) { return (octect == PAD); } /** * remove WhiteSpace from MIME containing encoded Base64 data. * * @param data the byte array of base64 data (with WS) * @return the new length */ private static int removeWhiteSpace(char[] data) { if (data == null) { return 0; } // count characters that's not whitespace int newSize = 0; int len = data.length; for (int i = 0; i < len; i++) { if (!isWhiteSpace(data[i])) { data[newSize++] = data[i]; } } return newSize; } }
2.ConfigureEncryptAndDecrypt
public class ConfigureEncryptAndDecrypt { public static final String CHAR_ENCODING = "UTF-8"; public static final String AES_ALGORITHM = "AES/CBC/PKCS5Padding"; public static final String RSA_ALGORITHM = "RSA/ECB/PKCS1Padding"; }
3.ConvertUtils
public class ConvertUtils { private static final DecimalFormat simpleFormat = new DecimalFormat("####"); public static final boolean objectToBoolean(Object o){ return o != null ? Boolean.valueOf(o.toString()).booleanValue() : false; } public static final int objectToInt(Object o){ if(o instanceof Number) return ((Number)o).intValue(); try{ if(o == null) return -1; else return Integer.parseInt(o.toString()); }catch(NumberFormatException e){ return -1; } } public static final short objectToShort(Object o){ if(o instanceof Number) return ((Number)o).shortValue(); try{ if(o == null) return -1; else return Short.parseShort(o.toString()); }catch(NumberFormatException e){ return -1; } } public static final double objectToDouble(Object o){ if(o instanceof Number) return ((Number)o).doubleValue(); try{ if(o == null) return -1D; else return Double.parseDouble(o.toString()); }catch(NumberFormatException e){ return -1D; } } public static final long objectToLong(Object o) { if(o instanceof Number) return ((Number)o).longValue(); try{ if(o == null) return -1L; else return Long.parseLong(o.toString()); }catch(NumberFormatException e){ return -1L; } } public static final String objectToString(Object obj, DecimalFormat fmt) { fmt.setDecimalSeparatorAlwaysShown(false); if(obj instanceof Double) return fmt.format(((Double)obj).doubleValue()); if(obj instanceof Long) return fmt.format(((Long)obj).longValue()); else return obj.toString(); } public static final Object getObjectValue(String value) { try{ return Long.valueOf(value); }catch(NumberFormatException e) {} try{ return Double.valueOf(value); }catch(NumberFormatException e){ return value; } } public static String longToSimpleString(long value){ return simpleFormat.format(value); } public static String asHex(byte hash[]){ return toHex(hash); } public static String toHex(byte input[]){ if(input == null) return null; StringBuffer output = new StringBuffer(input.length * 2); for(int i = 0; i < input.length; i++){ int current = input[i] & 0xff; if(current < 16) output.append("0"); output.append(Integer.toString(current, 16)); } return output.toString(); } public static byte[] fromHex(String input){ if(input == null) return null; byte output[] = new byte[input.length() / 2]; for(int i = 0; i < output.length; i++) output[i] = (byte)Integer.parseInt(input.substring(i * 2, (i + 1) * 2), 16); return output; } public static String stringToHexString(String input, String encoding) throws UnsupportedEncodingException { return input != null ? toHex(input.getBytes(encoding)) : null; } public static String stringToHexString(String input){ try{ return stringToHexString(input, "UTF-8"); }catch(UnsupportedEncodingException e){ throw new IllegalStateException("UTF-8 encoding is not supported by JVM"); } } public static String hexStringToString(String input, String encoding) throws UnsupportedEncodingException{ return input != null ? new String(fromHex(input), encoding) : null; } public static String hexStringToString(String input){ try{ return hexStringToString(input, "UTF-8"); }catch(UnsupportedEncodingException e){ throw new IllegalStateException("UTF-8 encoding is not supported by JVM"); } } public static String timeZoneToCode(TimeZone tz){ return timeZoneToString(tz); } public static TimeZone codeToTimeZone(String tzString){ return stringToTimeZone(tzString); } public static String timeZoneToString(TimeZone tz){ return tz != null ? tz.getID() : ""; } public static TimeZone stringToTimeZone(String tzString){ return TimeZone.getTimeZone(tzString != null ? tzString : ""); } public static String localeToCode(Locale aLocale){ return localeToString(aLocale); } public static Locale codeToLocale(String locString){ return stringToLocale(locString); } public static String localeToString(Locale loc){ return loc != null ? loc.toString() : ""; } public static Locale stringToLocale(String locString){ locString = locString != null ? locString.trim() : ""; if(locString.equals("")) return new Locale("", "", ""); int pos = locString.indexOf(95); if(pos == -1) return new Locale(locString, "", ""); String language = locString.substring(0, pos); locString = locString.substring(pos + 1); pos = locString.indexOf(95); if(pos == -1){ return new Locale(language, locString, ""); }else{ String country = locString.substring(0, pos); locString = locString.substring(pos + 1); return new Locale(language, country, locString); } } public static Date dateToSQLDate(java.util.Date d){ return d != null ? new Date(d.getTime()) : null; } public static Time dateToSQLTime(java.util.Date d){ return d != null ? new Time(d.getTime()) : null; } public static Timestamp dateToSQLTimestamp(java.util.Date d){ return d != null ? new Timestamp(d.getTime()) : null; } public static java.util.Date sqlTimestampToDate(Timestamp t){ return t != null ? new java.util.Date(Math.round((double)t.getTime() + (double)t.getNanos() / 1000000D)) : null; } public static Timestamp getCurrentDate(){ Calendar c = Calendar.getInstance(); c.set(c.get(1), c.get(2), c.get(5), 0, 0, 0); Timestamp t = new Timestamp(c.getTime().getTime()); t.setNanos(0); return t; } public static java.util.Date getDate(int y, int m, int d, boolean inclusive) { java.util.Date dt = null; Calendar c = Calendar.getInstance(); c.clear(); if(c.getActualMinimum(1) <= y && y <= c.getActualMaximum(1)) { c.set(1, y); if(c.getActualMinimum(2) <= m && m <= c.getActualMaximum(2)) { c.set(2, m); if(c.getActualMinimum(5) <= d && d <= c.getActualMaximum(5)) c.set(5, d); } if(inclusive) { c.add(5, 1); c.add(14, -1); } dt = c.getTime(); } return dt; } public static java.util.Date getDateStart(java.util.Date d) { Calendar c = new GregorianCalendar(); c.clear(); Calendar co = new GregorianCalendar(); co.setTime(d); c.set(Calendar.DAY_OF_MONTH,co.get(Calendar.DAY_OF_MONTH)); c.set(Calendar.MONTH,co.get(Calendar.MONTH)); c.set(Calendar.YEAR,co.get(Calendar.YEAR)); //c.add(Calendar.DAY_OF_MONTH,1); //c.add(Calendar.MILLISECOND,-1); return c.getTime(); } public static java.util.Date getDateEnd(java.util.Date d) { Calendar c = Calendar.getInstance(); c.clear(); Calendar co = Calendar.getInstance(); co.setTime(d); c.set(Calendar.DAY_OF_MONTH,co.get(Calendar.DAY_OF_MONTH)); c.set(Calendar.MONTH,co.get(Calendar.MONTH)); c.set(Calendar.YEAR,co.get(Calendar.YEAR)); c.add(Calendar.DAY_OF_MONTH,1); c.add(Calendar.MILLISECOND,-1); return c.getTime(); } public static double roundNumber(double rowNumber, int roundingPoint) { double base = Math.pow(10D, roundingPoint); return (double)Math.round(rowNumber * base) / base; } public static Object getObject(String type,String value) throws Exception{ type=type.toLowerCase(); if("boolean".equals(type)) return Boolean.valueOf(value); if("byte".equals(type)) return Byte.valueOf(value); if("short".equals(type)) return Short.valueOf(value); if("char".equals(type)) if(value.length() != 1) throw new NumberFormatException("Argument is not a character!"); else return Character.valueOf(value.toCharArray()[0]); if("int".equals(type)) return Integer.valueOf(value); if("long".equals(type)) return Long.valueOf(value); if("float".equals(type)) return Float.valueOf(value); if("double".equals(type)) return Double.valueOf(value); if("string".equals(type)) return value; else{ Object objs[]=new String[]{value}; return Class.forName(type).getConstructor(new Class[] { String.class }).newInstance(objs); } } private ConvertUtils(){} // public static void main(String[] args) // { // System.out.println(getDateStart(new java.util.Date())); // } }
4.Digest
public class Digest { public static final String ENCODE = "UTF-8"; public static String signMD5(String aValue, String encoding) { try { byte[] input = aValue.getBytes(encoding); MessageDigest md = MessageDigest.getInstance("MD5"); return ConvertUtils.toHex(md.digest(input)); } catch (NoSuchAlgorithmException e) { LogUtil.print(e); return null; } catch (UnsupportedEncodingException e) { LogUtil.print(e); return null; } } public static String hmacSign(String aValue) { try { byte[] input = aValue.getBytes(); MessageDigest md = MessageDigest.getInstance("MD5"); return ConvertUtils.toHex(md.digest(input)); } catch (NoSuchAlgorithmException e) { LogUtil.print(e); return null; } } public static String hmacSign(String aValue, String aKey) { return hmacSign(aValue, aKey, ENCODE); } public static String hmacSign(String aValue, String aKey, String encoding) { byte k_ipad[] = new byte[64]; byte k_opad[] = new byte[64]; byte keyb[]; byte value[]; try { keyb = aKey.getBytes(encoding); value = aValue.getBytes(encoding); } catch (UnsupportedEncodingException e) { keyb = aKey.getBytes(); value = aValue.getBytes(); } Arrays.fill(k_ipad, keyb.length, 64, (byte) 54); Arrays.fill(k_opad, keyb.length, 64, (byte) 92); for (int i = 0; i < keyb.length; i++) { k_ipad[i] = (byte) (keyb[i] ^ 0x36); k_opad[i] = (byte) (keyb[i] ^ 0x5c); } MessageDigest md = null; try { md = MessageDigest.getInstance("MD5"); } catch (NoSuchAlgorithmException e) { LogUtil.print(e); return null; } md.update(k_ipad); md.update(value); byte dg[] = md.digest(); md.reset(); md.update(k_opad); md.update(dg, 0, 16); dg = md.digest(); return ConvertUtils.toHex(dg); } public static String hmacSHASign(String aValue, String aKey, String encoding) { byte k_ipad[] = new byte[64]; byte k_opad[] = new byte[64]; byte keyb[]; byte value[]; try { keyb = aKey.getBytes(encoding); value = aValue.getBytes(encoding); } catch (UnsupportedEncodingException e) { keyb = aKey.getBytes(); value = aValue.getBytes(); } Arrays.fill(k_ipad, keyb.length, 64, (byte) 54); Arrays.fill(k_opad, keyb.length, 64, (byte) 92); for (int i = 0; i < keyb.length; i++) { k_ipad[i] = (byte) (keyb[i] ^ 0x36); k_opad[i] = (byte) (keyb[i] ^ 0x5c); } MessageDigest md = null; try { md = MessageDigest.getInstance("SHA"); } catch (NoSuchAlgorithmException e) { LogUtil.print(e); return null; } md.update(k_ipad); md.update(value); byte dg[] = md.digest(); md.reset(); md.update(k_opad); md.update(dg, 0, 20); dg = md.digest(); return ConvertUtils.toHex(dg); } public static String digest(String aValue) { return digest(aValue, ENCODE); } public static String digest(String aValue, String encoding) { aValue = aValue.trim(); byte value[]; try { value = aValue.getBytes(encoding); } catch (UnsupportedEncodingException e) { value = aValue.getBytes(); } MessageDigest md = null; try { md = MessageDigest.getInstance("SHA"); } catch (NoSuchAlgorithmException e) { return null; } return ConvertUtils.toHex(md.digest(value)); } public static String digest(String aValue, String alg, String encoding) { aValue = aValue.trim(); byte value[]; try { value = aValue.getBytes(encoding); } catch (UnsupportedEncodingException e) { value = aValue.getBytes(); } MessageDigest md = null; try { md = MessageDigest.getInstance(alg); } catch (NoSuchAlgorithmException e) { return null; } return ConvertUtils.toHex(md.digest(value)); } public static String udpSign(String aValue) { try { byte[] input = aValue.getBytes("UTF-8"); MessageDigest md = MessageDigest.getInstance("SHA1"); return new String(Base64.encode(md.digest(input)), ENCODE); } catch (Exception e) { return null; } } }
5.RSA
public class RSA { public static String PUBLICKEY = "";//你的publicbey public static String PRIVATEKEY = "";//你的privatekey /** * 指定key的大小 */ private static int KEYSIZE = 2048; /** * 生成密钥对 */ public static Map<String, String> generateKeyPair() throws Exception { /** RSA算法要求有一个可信任的随机数源 */ SecureRandom sr = new SecureRandom(); /** 为RSA算法创建一个KeyPairGenerator对象 */ KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA"); /** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */ kpg.initialize(KEYSIZE, sr); /** 生成密匙对 */ KeyPair kp = kpg.generateKeyPair(); /** 得到公钥 */ Key publicKey = kp.getPublic(); byte[] publicKeyBytes = publicKey.getEncoded(); String pub = new String(Base64.encodeBase64(publicKeyBytes), ConfigureEncryptAndDecrypt.CHAR_ENCODING); /** 得到私钥 */ Key privateKey = kp.getPrivate(); byte[] privateKeyBytes = privateKey.getEncoded(); String pri = new String(Base64.encodeBase64(privateKeyBytes), ConfigureEncryptAndDecrypt.CHAR_ENCODING); Map<String, String> map = new HashMap<String, String>(); map.put("publicKey", pub); map.put("privateKey", pri); RSAPublicKey rsp = (RSAPublicKey) kp.getPublic(); BigInteger bint = rsp.getModulus(); byte[] b = bint.toByteArray(); byte[] deBase64Value = Base64.encodeBase64(b); String retValue = new String(deBase64Value); map.put("modulus", retValue); return map; } /** * 加密方法 source： 源数据 */ public static String encrypt(String source, String publicKey) throws Exception { Key key = getPublicKey(publicKey); /** 得到Cipher对象来实现对源数据的RSA加密 */ Cipher cipher = Cipher.getInstance(ConfigureEncryptAndDecrypt.RSA_ALGORITHM); cipher.init(Cipher.ENCRYPT_MODE, key); byte[] b = source.getBytes(); /** 执行加密操作 */ byte[] b1 = cipher.doFinal(b); return new String(Base64.encodeBase64(b1), ConfigureEncryptAndDecrypt.CHAR_ENCODING); } /** * 解密算法 cryptograph:密文 */ public static String decrypt(String cryptograph, String privateKey) throws Exception { Key key = getPrivateKey(privateKey); /** 得到Cipher对象对已用公钥加密的数据进行RSA解密 */ Cipher cipher = Cipher.getInstance(ConfigureEncryptAndDecrypt.RSA_ALGORITHM); cipher.init(Cipher.DECRYPT_MODE, key); byte[] b1 = Base64.decodeBase64(cryptograph.getBytes()); /** 执行解密操作 */ byte[] b = cipher.doFinal(b1); return new String(b); } /** * 得到公钥 * * @param key 密钥字符串（经过base64编码） * @throws Exception */ public static PublicKey getPublicKey(String key) throws Exception { X509EncodedKeySpec keySpec = new X509EncodedKeySpec( Base64.decodeBase64(key.getBytes())); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); PublicKey publicKey = keyFactory.generatePublic(keySpec); return publicKey; } /** * 得到私钥 * * @param key 密钥字符串（经过base64编码） * @throws Exception */ public static PrivateKey getPrivateKey(String key) throws Exception { PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec( Base64.decodeBase64(key.getBytes())); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); PrivateKey privateKey = keyFactory.generatePrivate(keySpec); return privateKey; } public static String sign(String content, String privateKey) { String charset = ConfigureEncryptAndDecrypt.CHAR_ENCODING; try { PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec( Base64.decodeBase64(privateKey.getBytes())); KeyFactory keyf = KeyFactory.getInstance("RSA"); PrivateKey priKey = keyf.generatePrivate(priPKCS8); Signature signature = Signature.getInstance("SHA256WithRSA"); signature.initSign(priKey); signature.update(content.getBytes(charset)); byte[] signed = signature.sign(); return new String(Base64.encodeBase64(signed)); } catch (Exception e) { } return null; } public static boolean checkSign(String content, String sign, String publicKey) { try { KeyFactory keyFactory = KeyFactory.getInstance("RSA"); byte[] encodedKey = Base64.decode2(publicKey); PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey)); Signature signature = Signature .getInstance("SHA256WithRSA"); signature.initVerify(pubKey); signature.update(content.getBytes("utf-8")); boolean bverify = signature.verify(Base64.decode2(sign)); return bverify; } catch (Exception e) { LogUtil.print(e); } return false; } }
用法：
//加密
String aesStr = tv_8.getText().toString();
aesStr = RSA.encrypt(aesStr.substring(11, aesStr.length()), RSA.PUBLICKEY); //解密 String jieMiStr = RSA.decrypt(aesStr, RSA.PRIVATEKEY);
具体怎么解决的就不用管了直接用就好了，爆赞
by： leileitua