1、Base64工具类（可逆）：

  1. import java.util.HashMap;
  2. import java.util.Map;
  3.  
  4. /**
  5.  * Base64加解密算法
  6.  * </p>
  7.  * Base64加密算法：<br/>
  8.  * 1、获取字符串中每个字符的ASCII码；<br/>
  9.  * 2、按照每3个8bit的字符为一组来分组，即每组24bit；<br/>
  10.  * 3、将这24bit划分成4个6bit的4个单位，每个单位前面添加2个0，得到4个8bit的单位；<br/>
  11.  * 4、将每个8bit的单位转换成十进制数字，对照Base64编码表找到对应的字符进行拼接，得到最终的加密后的字符串。<br/>
  12.  * </p>
  13.  * Base64解密算法：<br/>
  14.  * 1、读入4个字符，对照Base64编码表找到字符对应的索引，生成4个6为的值；<br/>
  15.  * 2、将这4个6为的值拼接起来，形成一个24为的值；<br/>
  16.  * 3、将这个24位的值按照8位一组截断成3个8位的值；<br/>
  17.  * 4、对照ASCII表找到这三个8位的值对应的字符，即解码后的字符。<br/>
  18.  * </p>
  19.  * 注意事项：<br/>
  20.  * 1、被编码的字符必须是8bit的，即必须在ASCII码范围内，中文不行；<br/>
  21.  * 2、如果被编码的字符长度不是3的倍数，则在最后添加1或2个0，对应的输出字符为“=”；
  22.  * 3、给定一个字符串，用Base64方法对其进行加密后解密，得到的结果就不是开始时候的字符串了。<br/>
  23.  */
  24. public class BASE64Util {
  25.     private static final Map<Integer, Character> base64CharMap = new HashMap<>();
  26.     private static final String base64CharString = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  27.  
  28.     private static BASE64Util instance;
  29.  
  30.     private BASE64Util() {
  31.         for (int i = 0; i < base64CharString.length(); i++) {
  32.             char c = base64CharString.charAt(i);
  33.             base64CharMap.put(new Integer(i), new Character(c));
  34.         }
  35.     }
  36.  
  37.     public static BASE64Util getInstance() {
  38.         if (instance == null) {
  39.             synchronized (BASE64Util.class) {
  40.                 if (instance == null) {
  41.                     instance = new BASE64Util();
  42.                 }
  43.             }
  44.         }
  45.         return instance;
  46.     }
  47.  
  48.     /**
  49.      * This method is used to encode a normal string to base64 string @param
  50.      * origin The String to be encoded @return The String after encoded.
  51.      */
  52.     public String encode(String origin) {
  53.         if (origin == null) {
  54.             return null;
  55.         }
  56.         if (origin.length() == 0) {
  57.             return "";
  58.         }
  59.         int length = origin.length();
  60.         String binaryString = "";
  61.         // to binary String
  62.         for (int i = 0; i < length; i++) {
  63.             int ascii = origin.charAt(i);
  64.             String binaryCharString = Integer.toBinaryString(ascii);
  65.             while (binaryCharString.length() < 8) {
  66.                 binaryCharString = "0" + binaryCharString;
  67.             }
  68.             binaryString += binaryCharString;
  69.         }
  70.  
  71.         // to base64 index
  72.         int beginIndex = 0;
  73.         int endIndex = beginIndex + 6;
  74.         String base64BinaryString = "";
  75.         String charString = "";
  76.         while ((base64BinaryString = binaryString.substring(beginIndex, endIndex)).length() > 0) {
  77.             // if length is less than 6, add "0".
  78.             while (base64BinaryString.length() < 6) {
  79.                 base64BinaryString += "0";
  80.             }
  81.             int index = Integer.parseInt(base64BinaryString, 2);
  82.             char base64Char = base64CharMap.get(index);
  83.             charString = charString + base64Char;
  84.             beginIndex += 6;
  85.             endIndex += 6;
  86.             if (endIndex >= binaryString.length()) {
  87.                 endIndex = binaryString.length();
  88.             }
  89.             if (endIndex < beginIndex) {
  90.                 break;
  91.             }
  92.         }
  93.         if (length % 3 == 2) {
  94.             charString += "=";
  95.         }
  96.         if (length % 3 == 1) {
  97.             charString += "==";
  98.         }
  99.         return charString;
  100.     }
  101.  
  102.     public String decode(String encodedString) {
  103.         if (encodedString == null) {
  104.             return null;
  105.         }
  106.         if (encodedString.length() == 0) {
  107.             return "";
  108.         }
  109.         // get origin base64 String
  110.         String origin = encodedString.substring(0, encodedString.indexOf("="));
  111.         String equals = encodedString.substring(encodedString.indexOf("="));
  112.  
  113.         String binaryString = "";
  114.         // convert base64 string to binary string
  115.         for (int i = 0; i < origin.length(); i++) {
  116.             char c = origin.charAt(i);
  117.             int ascii = base64CharString.indexOf(c);
  118.             String binaryCharString = Integer.toBinaryString(ascii);
  119.             while (binaryCharString.length() < 6) {
  120.                 binaryCharString = "0" + binaryCharString;
  121.             }
  122.             binaryString += binaryCharString;
  123.         }
  124.         // the encoded string has 1 "=", means that the binary string has append
  125.         // 2 "0"
  126.         if (equals.length() == 1) {
  127.             binaryString = binaryString.substring(0, binaryString.length() - 2);
  128.         }
  129.         // the encoded string has 2 "=", means that the binary string has append
  130.         // 4 "0"
  131.         if (equals.length() == 2) {
  132.             binaryString = binaryString.substring(0, binaryString.length() - 4);
  133.         }
  134.  
  135.         // convert to String
  136.         String charString = "";
  137.         String resultString = "";
  138.         int beginIndex = 0;
  139.         int endIndex = beginIndex + 8;
  140.         while ((charString = binaryString.substring(beginIndex, endIndex)).length() == 8) {
  141.             int ascii = Integer.parseInt(charString, 2);
  142.             resultString += (char) ascii;
  143.             beginIndex += 8;
  144.             endIndex += 8;
  145.             if (endIndex > binaryString.length()) {
  146.                 break;
  147.             }
  148.         }
  149.         return resultString;
  150.     }
  151. }

2、MD5工具类（不可逆）：

  1. import java.security.MessageDigest;
  2.  
  3. import javax.crypto.KeyGenerator;
  4. import javax.crypto.Mac;
  5. import javax.crypto.SecretKey;
  6. import javax.crypto.spec.SecretKeySpec;
  7.  
  8. public class MD5Util {
  9.     public static final String MD5 = "MD5";
  10.     public static final String HmacMD5 = "HmacMD5";
  11.     public static final String charset = null; // 编码格式；默认null为GBK
  12.  
  13.     private static MD5Util instance;
  14.  
  15.     private MD5Util() {
  16.     }
  17.  
  18.     // 单例
  19.     public static MD5Util getInstance() {
  20.         if (instance == null) {
  21.             synchronized (MD5Util.class) {
  22.                 if (instance == null) {
  23.                     instance = new MD5Util();
  24.                 }
  25.             }
  26.         }
  27.         return instance;
  28.     }
  29.  
  30.     /**
  31.      * 使用 MD5 方法加密（无密码）
  32.      */
  33.     public String encode(String res) {
  34.         try {
  35.             MessageDigest md = MessageDigest.getInstance(MD5);
  36.             byte[] resBytes = charset == null ? res.getBytes() : res.getBytes(charset);
  37.             return BASE64Util.getInstance().encode(md.digest(resBytes).toString());
  38.         } catch (Exception e) {
  39.             e.printStackTrace();
  40.         }
  41.         return null;
  42.     }
  43.  
  44.     /**
  45.      * 使用 MD5 方法加密（可以设密码）
  46.      */
  47.     public String encode(String res, String key) {
  48.         try {
  49.             SecretKey sk = null;
  50.             if (key == null) {
  51.                 KeyGenerator kg = KeyGenerator.getInstance(HmacMD5);
  52.                 sk = kg.generateKey();
  53.             } else {
  54.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
  55.                 sk = new SecretKeySpec(keyBytes, HmacMD5);
  56.             }
  57.             Mac mac = Mac.getInstance(HmacMD5);
  58.             mac.init(sk);
  59.             byte[] result = mac.doFinal(res.getBytes());
  60.             return BASE64Util.getInstance().encode(result.toString());
  61.         } catch (Exception e) {
  62.             e.printStackTrace();
  63.         }
  64.         return null;
  65.     }
  66. }

3、SHA1工具类（不可逆）：

  1. import java.security.MessageDigest;
  2.  
  3. import javax.crypto.KeyGenerator;
  4. import javax.crypto.Mac;
  5. import javax.crypto.SecretKey;
  6. import javax.crypto.spec.SecretKeySpec;
  7.  
  8. /**
  9.  * 使用 SHA1 方法进行加密<br/>
  10.  * SHA1方法加密是不可逆的，不能解密，要想解密就必须使用暴力解密<br/>
  11.  * <p/>
  12.  * 方法中的 res 参数：原始的数据<br/>
  13.  * 方法中的 key 参数：密钥，可以随便写<br/>
  14.  */
  15. public class SHA1Util {
  16.     public static final String SHA1 = "SHA1";
  17.     public static final String HmacSHA1 = "HmacSHA1";
  18.     public static final String charset = null; // 编码格式；默认null为GBK
  19.  
  20.     private static SHA1Util instance;
  21.  
  22.     private SHA1Util() {
  23.     }
  24.  
  25.     // 单例
  26.     public static SHA1Util getInstance() {
  27.         if (instance == null) {
  28.             synchronized (SHA1Util.class) {
  29.                 if (instance == null) {
  30.                     instance = new SHA1Util();
  31.                 }
  32.             }
  33.         }
  34.         return instance;
  35.     }
  36.  
  37.     /**
  38.      * 使用 SHA1 方法加密（无密码）
  39.      */
  40.     public String encode(String res) {
  41.         try {
  42.             MessageDigest md = MessageDigest.getInstance(SHA1);
  43.             byte[] resBytes = charset == null ? res.getBytes() : res.getBytes(charset);
  44.             return BASE64Util.getInstance().encode(md.digest(resBytes).toString());
  45.         } catch (Exception e) {
  46.             e.printStackTrace();
  47.         }
  48.         return null;
  49.     }
  50.  
  51.     /**
  52.      * 使用 SHA1 方法加密（可以设密码）
  53.      */
  54.     public String encode(String res, String key) {
  55.         try {
  56.             SecretKey sk = null;
  57.             if (key == null) {
  58.                 KeyGenerator kg = KeyGenerator.getInstance(HmacSHA1);
  59.                 sk = kg.generateKey();
  60.             } else {
  61.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
  62.                 sk = new SecretKeySpec(keyBytes, HmacSHA1);
  63.             }
  64.             Mac mac = Mac.getInstance(HmacSHA1);
  65.             mac.init(sk);
  66.             byte[] result = mac.doFinal(res.getBytes());
  67.             return BASE64Util.getInstance().encode(result.toString());
  68.         } catch (Exception e) {
  69.             e.printStackTrace();
  70.         }
  71.         return null;
  72.     }
  73. }

4、AES工具类（可逆）：

  1. import java.security.SecureRandom;
  2.  
  3. import javax.crypto.Cipher;
  4. import javax.crypto.KeyGenerator;
  5. import javax.crypto.SecretKey;
  6. import javax.crypto.spec.SecretKeySpec;
  7.  
  8. public class AESUtil {
  9.     public static final String AES = "AES";
  10.     public static final String charset = null; // 编码格式；默认null为GBK
  11.     public static final int keysizeAES = 128;
  12.  
  13.     private static AESUtil instance;
  14.  
  15.     private AESUtil() {
  16.     }
  17.  
  18.     // 单例
  19.     public static AESUtil getInstance() {
  20.         if (instance == null) {
  21.             synchronized (MD5Util.class) {
  22.                 if (instance == null) {
  23.                     instance = new AESUtil();
  24.                 }
  25.             }
  26.         }
  27.         return instance;
  28.     }
  29.  
  30.     /**
  31.      * 使用 AES 进行加密
  32.      */
  33.     public String encode(String res, String key) {
  34.         return keyGeneratorES(res, AES, key, keysizeAES, true);
  35.     }
  36.  
  37.     /**
  38.      * 使用 AES 进行解密
  39.      */
  40.     public String decode(String res, String key) {
  41.         return keyGeneratorES(res, AES, key, keysizeAES, false);
  42.     }
  43.  
  44.     // 使用KeyGenerator双向加密，DES/AES，注意这里转化为字符串的时候是将2进制转为16进制格式的字符串，不是直接转，因为会出错
  45.     private String keyGeneratorES(String res, String algorithm, String key, int keysize, boolean isEncode) {
  46.         try {
  47.             KeyGenerator kg = KeyGenerator.getInstance(algorithm);
  48.             if (keysize == 0) {
  49.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
  50.                 kg.init(new SecureRandom(keyBytes));
  51.             } else if (key == null) {
  52.                 kg.init(keysize);
  53.             } else {
  54.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
  55.                 kg.init(keysize, new SecureRandom(keyBytes));
  56.             }
  57.             SecretKey sk = kg.generateKey();
  58.             SecretKeySpec sks = new SecretKeySpec(sk.getEncoded(), algorithm);
  59.             Cipher cipher = Cipher.getInstance(algorithm);
  60.             if (isEncode) {
  61.                 cipher.init(Cipher.ENCRYPT_MODE, sks);
  62.                 byte[] resBytes = charset == null ? res.getBytes() : res.getBytes(charset);
  63.                 return parseByte2HexStr(cipher.doFinal(resBytes));
  64.             } else {
  65.                 cipher.init(Cipher.DECRYPT_MODE, sks);
  66.                 return new String(cipher.doFinal(parseHexStr2Byte(res)));
  67.             }
  68.         } catch (Exception e) {
  69.             e.printStackTrace();
  70.         }
  71.         return null;
  72.     }
  73.  
  74.     // 将二进制转换成16进制
  75.     private String parseByte2HexStr(byte buf[]) {
  76.         StringBuffer sb = new StringBuffer();
  77.         for (int i = 0; i < buf.length; i++) {
  78.             String hex = Integer.toHexString(buf[i] & 0xFF);
  79.             if (hex.length() == 1) {
  80.                 hex = '0' + hex;
  81.             }
  82.             sb.append(hex.toUpperCase());
  83.         }
  84.         return sb.toString();
  85.     }
  86.  
  87.     // 将16进制转换为二进制
  88.     private byte[] parseHexStr2Byte(String hexStr) {
  89.         if (hexStr.length() < 1)
  90.             return null;
  91.         byte[] result = new byte[hexStr.length() / 2];
  92.         for (int i = 0; i < hexStr.length() / 2; i++) {
  93.             int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
  94.             int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
  95.             result[i] = (byte) (high * 16 + low);
  96.         }
  97.         return result;
  98.     }
  99. }

5、DES工具类（可逆）：

  1. import java.security.SecureRandom;
  2.  
  3. import javax.crypto.Cipher;
  4. import javax.crypto.KeyGenerator;
  5. import javax.crypto.SecretKey;
  6. import javax.crypto.spec.SecretKeySpec;
  7.  
  8. public class DESUtil {
  9.     public static final String DES = "DES";
  10.     public static final String charset = null; // 编码格式；默认null为GBK
  11.     public static final int keysizeDES = 0;
  12.  
  13.     private static DESUtil instance;
  14.  
  15.     private DESUtil() {
  16.     }
  17.  
  18.     // 单例
  19.     public static DESUtil getInstance() {
  20.         if (instance == null) {
  21.             synchronized (MD5Util.class) {
  22.                 if (instance == null) {
  23.                     instance = new DESUtil();
  24.                 }
  25.             }
  26.         }
  27.         return instance;
  28.     }
  29.  
  30.     /**
  31.      * 使用 DES 进行加密
  32.      */
  33.     public String encode(String res, String key) {
  34.         return keyGeneratorES(res, DES, key, keysizeDES, true);
  35.     }
  36.  
  37.     /**
  38.      * 使用 DES 进行解密
  39.      */
  40.     public String decode(String res, String key) {
  41.         return keyGeneratorES(res, DES, key, keysizeDES, false);
  42.     }
  43.  
  44.     // 使用KeyGenerator双向加密，DES/AES，注意这里转化为字符串的时候是将2进制转为16进制格式的字符串，不是直接转，因为会出错
  45.     private String keyGeneratorES(String res, String algorithm, String key, int keysize, boolean isEncode) {
  46.         try {
  47.             KeyGenerator kg = KeyGenerator.getInstance(algorithm);
  48.             if (keysize == 0) {
  49.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
  50.                 kg.init(new SecureRandom(keyBytes));
  51.             } else if (key == null) {
  52.                 kg.init(keysize);
  53.             } else {
  54.                 byte[] keyBytes = charset == null ? key.getBytes() : key.getBytes(charset);
  55.                 kg.init(keysize, new SecureRandom(keyBytes));
  56.             }
  57.             SecretKey sk = kg.generateKey();
  58.             SecretKeySpec sks = new SecretKeySpec(sk.getEncoded(), algorithm);
  59.             Cipher cipher = Cipher.getInstance(algorithm);
  60.             if (isEncode) {
  61.                 cipher.init(Cipher.ENCRYPT_MODE, sks);
  62.                 byte[] resBytes = charset == null ? res.getBytes() : res.getBytes(charset);
  63.                 return parseByte2HexStr(cipher.doFinal(resBytes));
  64.             } else {
  65.                 cipher.init(Cipher.DECRYPT_MODE, sks);
  66.                 return new String(cipher.doFinal(parseHexStr2Byte(res)));
  67.             }
  68.         } catch (Exception e) {
  69.             e.printStackTrace();
  70.         }
  71.         return null;
  72.     }
  73.  
  74.     // 将二进制转换成16进制
  75.     private String parseByte2HexStr(byte buf[]) {
  76.         StringBuffer sb = new StringBuffer();
  77.         for (int i = 0; i < buf.length; i++) {
  78.             String hex = Integer.toHexString(buf[i] & 0xFF);
  79.             if (hex.length() == 1) {
  80.                 hex = '0' + hex;
  81.             }
  82.             sb.append(hex.toUpperCase());
  83.         }
  84.         return sb.toString();
  85.     }
  86.  
  87.     // 将16进制转换为二进制
  88.     private byte[] parseHexStr2Byte(String hexStr) {
  89.         if (hexStr.length() < 1)
  90.             return null;
  91.         byte[] result = new byte[hexStr.length() / 2];
  92.         for (int i = 0; i < hexStr.length() / 2; i++) {
  93.             int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
  94.             int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
  95.             result[i] = (byte) (high * 16 + low);
  96.         }
  97.         return result;
  98.     }
  99. }

6、XOR（异或加密）工具类（可逆）：

  1. public class XORUtil {
  2.     private static XORUtil instance;
  3.  
  4.     private XORUtil() {
  5.     }
  6.  
  7.     // 单例
  8.     public static XORUtil getInstance() {
  9.         if (instance == null) {
  10.             synchronized (XORUtil.class) {
  11.                 if (instance == null) {
  12.                     instance = new XORUtil();
  13.                 }
  14.             }
  15.         }
  16.         return instance;
  17.     }
  18.  
  19.     /**
  20.      * 对一个数字进行异或加解密
  21.      */
  22.     public int code(int res, String key) {
  23.         return res ^ key.hashCode();
  24.     }
  25.  
  26.     /**
  27.      * 异或加密
  28.      */
  29.     public String encode(String res, String key) {
  30.         byte[] bs = res.getBytes();
  31.         for (int i = 0; i < bs.length; i++) {
  32.             bs[i] = (byte) ((bs[i]) ^ key.hashCode());
  33.         }
  34.         return parseByte2HexStr(bs);
  35.     }
  36.  
  37.     /**
  38.      * 异或解密
  39.      */
  40.     public String decode(String res, String key) {
  41.         byte[] bs = parseHexStr2Byte(res);
  42.         for (int i = 0; i < bs.length; i++) {
  43.             bs[i] = (byte) ((bs[i]) ^ key.hashCode());
  44.         }
  45.         return new String(bs);
  46.     }
  47.  
  48.     // 将二进制转换成16进制
  49.     private String parseByte2HexStr(byte buf[]) {
  50.         StringBuffer sb = new StringBuffer();
  51.         for (int i = 0; i < buf.length; i++) {
  52.             String hex = Integer.toHexString(buf[i] & 0xFF);
  53.             if (hex.length() == 1) {
  54.                 hex = '0' + hex;
  55.             }
  56.             sb.append(hex.toUpperCase());
  57.         }
  58.         return sb.toString();
  59.     }
  60.  
  61.     // 将16进制转换为二进制
  62.     private byte[] parseHexStr2Byte(String hexStr) {
  63.         if (hexStr.length() < 1)
  64.             return null;
  65.         byte[] result = new byte[hexStr.length() / 2];
  66.         for (int i = 0; i < hexStr.length() / 2; i++) {
  67.             int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
  68.             int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
  69.             result[i] = (byte) (high * 16 + low);
  70.         }
  71.         return result;
  72.     }
  73. }

7、测试：

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         int xorNum = 12345;
  4.         String res = "I am the text to be encoded and decoded.";
  5.         String key = "我是密钥key";
  6.         System.out.println("-------------------------BASE64--------------------------");
  7.         String base64_encodedStr = BASE64Util.getInstance().encode(res);
  8.         System.out.println("加密：" + base64_encodedStr);
  9.         System.out.println("解密：" + BASE64Util.getInstance().decode(base64_encodedStr));
  10.         System.out.println("-------------------------MD5--------------------------");
  11.         String md5_encodedStr = MD5Util.getInstance().encode(res);
  12.         System.out.println("无密码加密：" + md5_encodedStr);
  13.         System.out.println("有密码加密：" + MD5Util.getInstance().encode(md5_encodedStr, key));
  14.         System.out.println("-------------------------SHA1--------------------------");
  15.         String sha1_encodedStr = SHA1Util.getInstance().encode(res);
  16.         System.out.println("无密码加密：" + sha1_encodedStr);
  17.         System.out.println("有密码加密：" + SHA1Util.getInstance().encode(sha1_encodedStr, key));
  18.         System.out.println("-------------------------AES--------------------------");
  19.         String aes_encodedStr = AESUtil.getInstance().encode(res, key);
  20.         System.out.println("加密：" + aes_encodedStr);
  21.         System.out.println("解密：" + AESUtil.getInstance().decode(aes_encodedStr, key));
  22.         System.out.println("-------------------------DES--------------------------");
  23.         String des_encodedStr = DESUtil.getInstance().encode(res, key);
  24.         System.out.println("加密：" + des_encodedStr);
  25.         System.out.println("解密：" + DESUtil.getInstance().decode(des_encodedStr, key));
  26.         System.out.println("-------------------------XOR--------------------------");
  27.         String xor_encodedStr = XORUtil.getInstance().encode(res, key);
  28.         System.out.println("文本加密：" + xor_encodedStr);
  29.         System.out.println("文本解密：" + XORUtil.getInstance().decode(xor_encodedStr, key));
  30.         int xor_encodedNum = XORUtil.getInstance().code(xorNum, key);
  31.         System.out.println("数字加密：" + xor_encodedNum);
  32.         System.out.println("数字解密：" + XORUtil.getInstance().code(xor_encodedNum, key));
  33.     }
  34. }

测试结果：

【JAVA - 基础】之数据加密和解密的更多相关文章

  1. 【推荐】JAVA基础◆浅谈3DES加密解密

    国内私募机构九鼎控股打造APP,来就送 20元现金领取地址:http://jdb.jiudingcapital.com/phone.html内部邀请码:C8E245J (不写邀请码,没有现金送)国内私 ...

  2. Java基础知识【上】(转载)

    http://blog.csdn.net/silentbalanceyh/article/details/4608272 (最终还是决定重新写一份Java基础相关的内容,原来因为在写这一个章节的时候没 ...

  3. java中的数据加密

    记录 一.java中的数据加密 Java提供的安全模型和API 加密基础知识 使用JAVA实现加密 二.Java提供的安全模型和API 2.1.Java语言本身的安全性 自动内存管理:对于生成的对象在 ...

  4. C# Java间进行RSA加密解密交互

    原文:C# Java间进行RSA加密解密交互 这里,讲一下RSA算法加解密在C#和Java之间交互的问题,这两天纠结了很久,也看了很多其他人写的文章,颇受裨益,但没能解决我的实际问题,终于,还是被我捣 ...

  5. Python之数据加密与解密及相关操作（hashlib模块、hmac模块、random模块、base64模块、pycrypto模块）

    本文内容 数据加密概述 Python中实现数据加密的模块简介 hashlib与hmac模块介绍 random与secrets模块介绍 base64模块介绍 pycrypto模块介绍 总结 参考文档 提 ...

  6. C# RSA加解密与验签，AES加解密，以及与JAVA平台的密文加解密

    前言: RSA算法是利用公钥与密钥对数据进行加密验证的一种算法.一般是拿私钥对数据进行签名,公钥发给友商,将数据及签名一同发给友商,友商利用公钥对签名进行验证.也可以使用公钥对数据加密,然后用私钥对数 ...

  7. Java采用RSA加密及解密技术的有关Maven项目的配置流程:

    第一步: 获得RSA公钥私钥(秘钥格式:PKCS#8 ,测试使用的是无私钥密码的) 公钥: -----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4G ...

  8. Python之数据加密与解密及相关操作（hashlib、hmac、random、base64、pycrypto）

    本文内容 数据加密概述 Python中实现数据加密的模块简介 hashlib与hmac模块介绍 random与secrets模块介绍 base64模块介绍 pycrypto模块介绍 总结 参考文档 提 ...

  9. java基础-day6

    第06天 java基础语法 今日内容介绍 u Eclipse断点调试 u 基础语法的练习 第1章   Eclipse断点调试 1.1      Eclipse断点调试概述 Eclipse的断点调试可以 ...

随机推荐

  1. mysql修改字符集 转载

    查看编码:    show variables like 'collation_%';    show variables like 'character_set_%';    修改:    MySQ ...

  2. mysql建表出现Timestamp错误

    mysql建表时如果有两个或以上的字段为Timestamp,那么可能会出现如下错误: Incorrect table definition; there can be only one TIMESTA ...

  3. Savelog项目总结回忆

    Savelog项目的细节已经不太记得,感觉有些遥远,需要翻回旧的笔记本电脑或者是旧的笔记本. 概述: 本项目采用的Linux C,监听一个或多个特殊的端口,当其中一个端口有发起连接时就产生一个新的线程 ...

  4. lamp环境中的/到底是指的网站根目录还是linux的根

    在lamp中经常会用到 require,require_once等包含文件的语句. 如果你使用相对路径没有问题. 但是如果你使用了这样的语句就要小心了. 对于如图网站目录 require_once ' ...

  5. Linux下glui 的安装,以及错误解决

    下载源文件: http://sourceforge.net/projects/glui/ 2. 解压源文件 3. 用terminal进入glui-2.36/src文件 4. make 5. make之 ...

  6. 百度富文本编辑器ueditor使用总结

    最近做的项目用到了ueditor这个东东,但是他的一些配置文档对初次使用者来说很难以理解,故作此总结 相关详细操作链接地址: http://blog.csdn.net/wusuopubupt/arti ...

  7. bzoj 2594: [Wc2006]水管局长数据加强版 动态树

    2594: [Wc2006]水管局长数据加强版 Time Limit: 25 Sec  Memory Limit: 128 MBSubmit: 934  Solved: 291[Submit][Sta ...

  8. MATLAB中的结构数组

    MATLAB中的结构数组 结构数组: 结构是包含一组记录的数据类型,而记录则是存储在相应的字段中.结构的字段可以是任意一种MATLAB数据类型的变量或者对象.结构类型的变量也可以是一维的.二维的或多维 ...

  9. [topcoder]UnsealTheSafe

    http://community.topcoder.com/stat?c=problem_statement&pm=4471&rd=10711 这题果然是道简单题,图+DP.拿道题便觉 ...

  10. hibernate api

    http://docs.jboss.org/hibernate/orm/4.3/manual/en-US/html/