常用的加密方式

常用的加密方式

BASE64

      按照RFC2045的定义，Base64被定义为：Base64内容传送编码被设计用来把任意序列的8位字节描述为一种不易被人直接识别的形式。常见于邮件、http加密，截取http信息，你就会发现登录操作的用户名、密码字段通过BASE64加密的。

• 加密

  public static String encryptBASE64(byte[] key) throws Exception {
    return (new BASE64Encoder()).encodeBuffer(key);
  }

• 解密

  public static byte[] decryptBASE64(String key) throws Exception {
    return (new BASE64Decoder()).decodeBuffer(key);
  }

单向加密

      MD5较SHA的安全性较低，但速度上有一定优势，即MD5加密1一个序列需4秒，SHA需要5秒。

• MD5

  public final static String encryptByMD5(String s) {
    try {
      byte[] btInput = s.getBytes();
      MessageDigest mdInst = MessageDigest.getInstance("MD5");
      mdInst.update(btInput);
      byte[] md = mdInst.digest();
      StringBuffer sb = new StringBuffer();
      for (int i = 0; i < md.length; i++) {
        int val = (md[i]) & 0xff;
        if (val < 16)
          sb.append("0");
        sb.append(Integer.toHexString(val));
      }
      return sb.toString();
    } catch (Exception e) {
      return null;
    }
  }

• RSA

  public final static String encryptBySHA(String s) {
    try {
      byte[] btInput = s.getBytes();
      MessageDigest mdInst = MessageDigest.getInstance("SHA");
      mdInst.update(btInput);
      byte[] md = mdInst.digest();
      StringBuffer sb = new StringBuffer();
      for (int i = 0; i < md.length; i++) {
        int val = (md[i]) & 0xff;
        if (val < 16)
          sb.append("0");
        sb.append(Integer.toHexString(val));
      }
      return sb.toString();
    } catch (Exception e) {
      return null;
    }
  }

双向加密

      与单向加密相对的，双向加密是通过一组双方已同步的密钥进行加密的一种手段，AES较DES的安全性更高，速度更快

  /**-----------------------------------------encrypt&decrypt--------------------------------------------
   * ALGORITHM 算法 <br>
   * 可替换为以下任意一种算法，同时key值的size相应改变。
   * 
   * DES                  key size must be equal to 56
   * DESede(TripleDES)    key size must be equal to 112 or 168
   * AES                  key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
   * Blowfish             key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
   * RC2                  key size must be between 40 and 1024 bits
   * RC4(ARCFOUR)         key size must be between 40 and 1024 
   */
  public static final String ALGORITHM = "DES";
  /**
   * 转换密钥<br>
   */
  private static Key toKey(byte[] key) throws Exception {
      DESKeySpec dks = new DESKeySpec(key);
      SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
      SecretKey secretKey = keyFactory.generateSecret(dks);

      // 当使用其他对称加密算法时，如AES、Blowfish等算法时，用下述代码替换上述三行代码
      // SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);

      return secretKey;
  }

  /**
   * 解密
   */
  public static byte[] decrypt(byte[] data, String key) throws Exception {
      Key k = toKey(decryptBASE64(key));

      Cipher cipher = Cipher.getInstance(ALGORITHM);
      cipher.init(Cipher.DECRYPT_MODE, k);
      return cipher.doFinal(data);
  }

  /**
   * 加密
   */
  public static byte[] encrypt(byte[] data, String key) throws Exception {
      Key k = toKey(decryptBASE64(key));
      Cipher cipher = Cipher.getInstance(ALGORITHM);
      cipher.init(Cipher.ENCRYPT_MODE, k);
      return cipher.doFinal(data);
  }

  /**
   * 生成密钥
   */
  public static String initKey() throws Exception {
      return initKey(null);
  }

  /**
   * 生成密钥
   */
  public static String initKey(String seed) throws Exception {
      SecureRandom secureRandom = null;
      if (seed != null) {
          secureRandom = new SecureRandom(decryptBASE64(seed));
      } else {
          secureRandom = new SecureRandom();
      }
      KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);
      kg.init(secureRandom);
      SecretKey secretKey = kg.generateKey();
      return encryptBASE64(secretKey.getEncoded());
  }

RSA

      RSA是非对称加密，通过公钥和私钥进行加密，比如个大系统中常见的SSH使用的就是这种原理

  /**-------------------------------------RSA----encrypt&decrypt-----------------------------------------
   * 用私钥对信息生成数字签名
   */
  public static final String KEY_ALGORITHM = "RSA";
  public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

  private static final String PUBLIC_KEY = "RSAPublicKey";
  private static final String PRIVATE_KEY = "RSAPrivateKey";

  public static String sign(byte[] data, String privateKey) throws Exception {
      byte[] keyBytes = decryptBASE64(privateKey);
      PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
      KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
      PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
      Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
      signature.initSign(priKey);
      signature.update(data);
      return encryptBASE64(signature.sign());
  }

  /**
   * 校验数字签名
   */
  public static boolean verify(byte[] data, String publicKey, String sign)
          throws Exception {
      byte[] keyBytes = decryptBASE64(publicKey);
      X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
      KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
      PublicKey pubKey = keyFactory.generatePublic(keySpec);
      Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
      signature.initVerify(pubKey);
      signature.update(data);
      return signature.verify(decryptBASE64(sign));
  }

  /**
   * 用私钥解密
   */
  public static byte[] decryptByPrivateKey(byte[] data, String key)
          throws Exception {
      byte[] keyBytes = decryptBASE64(key);
      PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
      KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
      Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
      Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
      cipher.init(Cipher.DECRYPT_MODE, privateKey);
      return cipher.doFinal(data);
  }

  /**
   * 用公钥解密
   */
  public static byte[] decryptByPublicKey(byte[] data, String key)
          throws Exception {
      byte[] keyBytes = decryptBASE64(key);
      X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
      KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
      Key publicKey = keyFactory.generatePublic(x509KeySpec);
      Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
      cipher.init(Cipher.DECRYPT_MODE, publicKey);
      return cipher.doFinal(data);
  }

  /**
   * 用公钥加密
   */
  public static byte[] encryptByPublicKey(byte[] data, String key)
          throws Exception {
      byte[] keyBytes = decryptBASE64(key);
      X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
      KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
      Key publicKey = keyFactory.generatePublic(x509KeySpec);
      Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
      cipher.init(Cipher.ENCRYPT_MODE, publicKey);
      return cipher.doFinal(data);
  }

  /**
   * 用私钥加密
   */
  public static byte[] encryptByPrivateKey(byte[] data, String key)
          throws Exception {
      byte[] keyBytes = decryptBASE64(key);
      PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
      KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
      Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
      Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
      cipher.init(Cipher.ENCRYPT_MODE, privateKey);
      return cipher.doFinal(data);
  }

  /**
   * 取得私钥
   */
  public static String getPrivateKey(Map<String, Object> keyMap)
          throws Exception {
      Key key = (Key) keyMap.get(PRIVATE_KEY);
      return encryptBASE64(key.getEncoded());
  }

  /**
   * 取得公钥
   */
  public static String getPublicKey(Map<String, Object> keyMap)
          throws Exception {
      Key key = (Key) keyMap.get(PUBLIC_KEY);
      return encryptBASE64(key.getEncoded());
  }

  /**
   * 初始化密钥
   */
  public static Map<String, Object> initRsaKey() throws Exception {
      KeyPairGenerator keyPairGen = KeyPairGenerator
              .getInstance(KEY_ALGORITHM);
      keyPairGen.initialize(1024);
      KeyPair keyPair = keyPairGen.generateKeyPair();
      RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
      RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
      Map<String, Object> keyMap = new HashMap<String, Object>(2);
      keyMap.put(PUBLIC_KEY, publicKey);
      keyMap.put(PRIVATE_KEY, privateKey);
      return keyMap;
  }
  
  
  public static void main(String[] args) {
    String data = "1111111111111111111111111111111111111111111111111111111111111111111111111111111";
    try {
      Map<String,Object> m = initRsaKey();
      String privateKey = getPrivateKey(m);
      byte[] dataBeEncrypt = encryptByPrivateKey(data.getBytes(), privateKey);
      String sign = sign(dataBeEncrypt, privateKey);
      
      String publicKey = getPublicKey(m);
      if (verify(dataBeEncrypt, publicKey, sign)) {
        byte[] dataBeDecrypt = decryptByPublicKey(dataBeEncrypt, publicKey);
        System.out.println(new String(dataBeDecrypt));
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }