JAVA对接Jira与加密机的安全实践

1.keyGenerator
public static byte[] generateKey(int keySize) throws Exception {
    KeyGenerator kg = KeyGenerator.getInstance(ALGORIGTHM_NAME, BouncyCastleProvider.PROVIDER_NAME);
    kg.init(keySize, new SecureRandom());
    return kg.generateKey().getEncoded();
}2.KeyFactory
RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));3.KeyPairGenerator
类用于生成公钥和私钥对，基于RSA算法生成对象
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
// 初始化密钥对生成器，密钥大小为96-1024位
keyPairGen.initialize(1024,new SecureRandom());
// 生成一个密钥对，保存在keyPair中
KeyPair keyPair = keyPairGen.generateKeyPair();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();   // 得到私钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  // 得到公钥
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

/**
 *
 * @param strSrc 需要被加密的字符串
 * @param encName 加密方式，有 MD5、SHA-1和SHA-256 这三种加密方式
 * @return 返回加密后的字符串
 */
private static String EncryptStr(String strSrc, String encName) {
    MessageDigest md = null;
    String strDes = null;

    byte[] bt = strSrc.getBytes();
    try {
        if (StringUtils.isBlank(encName)) {
            encName = "MD5";
        }
        md = MessageDigest.getInstance(encName);
        md.update(bt);
        strDes = bytes2Hex(md.digest()); // to HexString
    } catch (NoSuchAlgorithmException e) {
        System.out.println("Invalid algorithm.");
        return null;
    }
    return strDes;
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

/**
 * 加密
 * @param datasource byte[]
 * @param password String
 * @return byte[]
 */
public static  byte[] encrypt(byte[] datasource, String password) {
    try{
        SecureRandom random = new SecureRandom();
        DESKeySpec desKey = new DESKeySpec(password.getBytes());
        //创建一个密匙工厂，然后用它把DESKeySpec转换成密钥
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey securekey = keyFactory.generateSecret(desKey);
        //Cipher对象实际完成加密操作
        Cipher cipher = Cipher.getInstance("DES");
        //用密匙初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
        //现在，获取数据并加密
        //正式执行加密操作
        return cipher.doFinal(datasource);
    }catch(Throwable e){
        e.printStackTrace();
    }
    return null;
}
/**
 * 解密
 * @param src byte[]
 * @param password String
 * @return byte[]
 * @throws Exception
 */
public static byte[] decrypt(byte[] src, String password) throws Exception {
    // DES算法要求有一个可信任的随机数源
    SecureRandom random = new SecureRandom();
    // 创建一个DESKeySpec对象
    DESKeySpec desKey = new DESKeySpec(password.getBytes());
    // 创建一个密匙工厂
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    // 将DESKeySpec对象转换成SecretKey对象
    SecretKey securekey = keyFactory.generateSecret(desKey);
    // Cipher对象实际完成解密操作
    Cipher cipher = Cipher.getInstance("DES");
    // 用密匙初始化Cipher对象
    cipher.init(Cipher.DECRYPT_MODE, securekey, random);
    // 真正开始解密操作
    return cipher.doFinal(src);
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.

/**
 * DESede 加密操作
 *
 * @param content
 *            待加密内容
 * @param key
 *            加密密钥
 * @return 返回Base64转码后的加密数据
 */
public static String encrypt(String content, String key) {
    try {
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM);
        // 创建密码器
        byte[] byteContent = content.getBytes("utf-8");
        cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(key));
        // 初始化为加密模式的密码器
        byte[] result = cipher.doFinal(byteContent);// 加密
        return Base64.encodeBase64String(result);// 通过Base64转码返回
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    return null;
}

/**
 * } } DESede 解密操作
 *
 * @param content
 * @param key
 * @return
 */
public static String decrypt(String content, String key) {
    try {
        // 实例化
        Cipher cipher = Cipher.getInstance(KEY_ALGORITHM); // 使用密钥初始化，设置为解密模式
        cipher.init(Cipher.DECRYPT_MODE, getSecretKey(key)); // 执行操作
        byte[] result = cipher.doFinal(Base64.decodeBase64(content));
        return new String(result, "utf-8");
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    return null;
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.

/**
 * @param content 加密前原内容
 * @param pkey    长度为16个字符,128位
 * @return base64EncodeStr   aes加密完成后内容
 * @throws
 * @Title: aesEncryptStr
 * @Description: aes对称加密
 */
public static String aesEncryptStr(String content, String pkey) throws UnsupportedEncodingException {

    content=Base64.encodeBase64String(content.getBytes("UTF-8"));
    byte[] aesEncrypt = aesEncrypt(content, pkey);
    System.out.println("加密后的byte数组:" + Arrays.toString(aesEncrypt));
    String base64EncodeStr = Base64.encodeBase64String(aesEncrypt);
    System.out.println("加密后 base64EncodeStr:" + base64EncodeStr);
    base64EncodeStr= URLEncoder.encode(base64EncodeStr,"UTF-8");
    return base64EncodeStr;
}

/**
 * @param content base64处理过的字符串
 * @param pkey    密匙
 * @return String    返回类型
 * @throws Exception
 * @throws
 * @Title: aesDecodeStr
 * @Description: 解密 失败将返回NULL
 */
public static String aesDecodeStr(String content, String pkey) throws Exception {
    try {
        content=URLDecoder.decode(content,"UTF-8");
        System.out.println("待解密内容:" + content);
        byte[] base64DecodeStr = Base64.decodeBase64(content);
        System.out.println("base64DecodeStr:" + Arrays.toString(base64DecodeStr));
        byte[] aesDecode = aesDecode(base64DecodeStr, pkey);
        System.out.println("aesDecode:" + Arrays.toString(aesDecode));
        if (aesDecode == null) {
            return null;
        }
        String result;
        result = new String(Base64.decodeBase64(aesDecode), "UTF-8");
        System.out.println("aesDecode result:" + result);
        return result;
    } catch (Exception e) {
        System.out.println("Exception:" + e.getMessage());
        throw new Exception("解密异常");
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.

/**
 * RSA公钥加密
 *
 * @param str
 *            加密字符串
 * @param publicKey
 *            公钥
 * @return 密文
 * @throws Exception
 *             加密过程中的异常信息
 */
public static String encrypt( String str, String publicKey,KeyPair keyPair) throws Exception{
    //base64编码的公钥
    byte[] decoded = Base64.decodeBase64(publicKey);
    //RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(decoded));
    //RSA加密
    Cipher cipher = Cipher.getInstance("RSA");
    cipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());
    String outStr = Base64.encodeBase64String(cipher.doFinal(str.getBytes("UTF-8")));
    return outStr;
}

/**
 * RSA私钥解密
 *
 * @param str
 *            加密字符串
 * @param privateKey
 *            私钥
 * @return 铭文
 * @throws Exception
 *             解密过程中的异常信息
 */
public static String decrypt(String str, String privateKey,KeyPair keyPair) throws Exception{
    //64位解码加密后的字符串
    byte[] inputByte = Base64.decodeBase64(str.getBytes("UTF-8"));
    //base64编码的私钥
    byte[] decoded = Base64.decodeBase64(privateKey);
    RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(decoded));
    //RSA解密
    Cipher cipher = Cipher.getInstance("RSA");
    cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
    String outStr = new String(cipher.doFinal(inputByte));
    return outStr;
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.