AES 256 位 加密

public class AES256Utils {    public AES256Utils() throws Exception {    }    // 加密    public static String Encrypt(String sSrc, String sKey) throws Exception {        if (sKey == null) {            System.out.print("Key为空null");            return null;        }        // 判断Key是否为16位        if (sKey.length() != 16) {            System.out.print("Key长度不是16位");            return null;        }        byte[] raw = sKey.getBytes();        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");// "算法/模式/补码方式"        IvParameterSpec iv = new IvParameterSpec("0102030405060708".getBytes());// 使用CBC模式，需要一个向量iv，可增加加密算法的强度        cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);        byte[] encrypted = cipher.doFinal(sSrc.getBytes());        return Base64Encoder.encode(encrypted);// 此处使用BASE64做转码功能，同时能起到2次加密的作用。    }    // 解密    public static String Decrypt(String sSrc, String sKey) throws Exception {        try {            // 判断Key是否正确            if (sKey == null) {                System.out.print("Key为空null");                return null;            }            // 判断Key是否为16位            if (sKey.length() != 16) {                System.out.print("Key长度不是16位");                return null;            }            byte[] raw = sKey.getBytes("UTF-8");            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");            IvParameterSpec iv = new IvParameterSpec(                    "0102030405060708".getBytes());            cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);            byte[] encrypted1 = Base64Decoder.decodeToBytes(sSrc);// Base64Decoder.decode(sSrc);//先用base64解密            try {                byte[] original = cipher.doFinal(encrypted1);                String originalString = new String(original);                return originalString;            } catch (Exception e) {                System.out.println(e.toString());                return null;            }        } catch (Exception ex) {            System.out.println(ex.toString());            return null;        }    }    public static void main(String[] args) throws Exception {        /* * 加密用的Key 可以用26个字母和数字组成，最好不要用保留字符，虽然不会错，至于怎么裁决，个人看情况而定 * 此处使用AES-128-CBC加密模式，key需要为16位。 */        String cKey = "world12312312312";        // 需要加密的字串        String cSrc = "{'amt':'" + "0.01" + "'},{'traceNo':'" + "000415" + "'}";        System.out.println(cSrc); // 加密        String enString = Encrypt(cSrc, cKey);        System.out.println("加密" + enString);        String DeString = Decrypt(enString, cKey);        System.out.println("解密" + DeString);/*String cKey = "world12312312312";String cSrc = "18511829819";String enString = AES256Utils.Encrypt(cSrc, cKey);System.out.println("加密后：" + enString);String cnString = AES256Utils.Decrypt(enString, cKey);System.out.println("解密后：" + cnString);*/    }}

这里还缺少两个Base64解密和加密的类

/**  * tang *Base64转码的工具类处理----解码 */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();    }  }}

  

 /** *Base64转码的工具类处理----转码 */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 {       if (b < 0) {      b += 256;    }       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('\n');    }  }  /***   * 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();    }  }}