Java常用的安全算法

安全算法主要包括摘要算法、对称加密算法、非对称加密算法、信息编码以及数字签名、数字证书。

1.数字摘要

数字摘要也称为消息摘要，它是一个唯一对应一个消息或文本的固定长度的值，由一个单向Hash函数对消息进行计算而产生的。其生产过程如下图所示：

有如下特点：

（1）无论输入的消息有多长，计算出来的消息摘要的长度是固定的。应用MD5，计算出长度是128个比特位，使用SHA-1算法计算出来是160个比特位；

（2）只能进行正向的信息摘要，而无法从摘要中恢复出原来的消息。

常用的算法：

MD5及SHA算法。

java例子：

public class DigestTest {
    public static byte[] testMD5(String content) throws Exception {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] bytes = md.digest(content.getBytes("UTF-8"));
        return bytes;
    }

    public static byte[] testSHA1(String content) throws Exception {
        MessageDigest md = MessageDigest.getInstance("SHA1");
        byte[] bytes = md.digest(content.getBytes("UTF-8"));
        return bytes;
    }

    public static void main(String args[]) throws Exception {
        String content = "123";
        byte[] bytes =  testMD5(content);
        String digest = DatatypeConverter.printHexBinary(bytes);
        System.out.println(digest);

        bytes =  testSHA1(content);
        digest = DatatypeConverter.printHexBinary(bytes);
        System.out.println(digest);
    }

}

2.对称加密算法

在对称加密算法中，数据发送方将明文和加密密钥经过特殊加密算法处理后，生成复杂的加密密文进行发送，数据接收方收到密文后，必须用相同的算法及密钥时行解密。其过程如下：

特点是算法公开、计算量小、加密速度快，加密效率高。

常用的加密算法包括:DES算法、3DES算法、AES算法。

Java例子：

AES对称算法加密：（用DES算法，只需要把AES改成DES即可）

public class AESTest {
    public static String genKeyAES() throws Exception {
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
        keyGenerator.init(128);
        SecretKey key = keyGenerator.generateKey();
        String base64Key =  DatatypeConverter.printBase64Binary(key.getEncoded());
        return base64Key;
    }
    public static SecretKey loadKeyAES(String base64Key){
        byte[] bytes = DatatypeConverter.parseBase64Binary(base64Key);
        SecretKey key = new SecretKeySpec(bytes, "AES");
        return key;
    }

    public static byte[] encryptDES(byte[] source, SecretKey key) throws Exception {
        Cipher ciper = Cipher.getInstance("AES");
        ciper.init(Cipher.ENCRYPT_MODE, key);
        byte[] bytes = ciper.doFinal(source);
        return bytes;
    }

    public static byte[] decrytDES(byte[] source, SecretKey key) throws Exception{
        Cipher ciper = Cipher.getInstance("AES");
        ciper.init(Cipher.DECRYPT_MODE, key);
        byte[] bytes = ciper.doFinal(source);
        return bytes;
    }

    public static void main(String args[]) throws Exception {
        String test = "1234";
        String content = genKeyAES();//"12345678901234567890123456789012";
        System.out.println(content);

        SecretKey secretKey = loadKeyAES(content);

        byte bytes[] =  encryptDES(test.getBytes(), secretKey);
        System.out.println("secretKey String:" + DatatypeConverter.printHexBinary(bytes));

        bytes = decrytDES (bytes, secretKey);
        System.out.println("decrytDES String:" + new String(bytes));


    }
}

3.非对称加密算法

又称为公开密钥加密算法，需要两个密钥，一个是公开密钥(public key)，一个是私有密钥(private key)，公钥和私钥需要配对使用。

基本过程：甲方生成一对密钥，并将其中的一把作为公钥向其他人公开，得到该公钥的乙方使用该密钥对机密信息进行加密后再发送给甲方，甲方再使用自己保存的另一把密钥（即私钥）对加密后的信息进行解密。如下图所示：

常用的算法：RSA算法

JAVA的例子：

public class RSATest {
    public static KeyPair getKeyPairt() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(512);
        return keyPairGenerator.generateKeyPair();
    }
    public static String getPublicKey(KeyPair keyPair){
        PublicKey publicKey = keyPair.getPublic();
        byte[] bytes = publicKey.getEncoded();
        return DatatypeConverter.printBase64Binary(bytes);
    }
    public static String getPrivateKey(KeyPair keyPair){
        PrivateKey privateKey = keyPair.getPrivate();
        byte[] bytes = privateKey.getEncoded();
        return DatatypeConverter.printBase64Binary(bytes);
    }
    public static PublicKey String2Publickey(String pubStr) throws Exception {
        byte[] bytes = DatatypeConverter.parseBase64Binary(pubStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
        KeyFactory  keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }
    public static PrivateKey String2Privatekey(String privateStr) throws Exception {
        byte[] bytes = DatatypeConverter.parseBase64Binary(privateStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
        KeyFactory  keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privatekey = keyFactory.generatePrivate(keySpec);
        return privatekey;
    }

    public static byte[] publicEncrypt(byte[] content, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        return cipher.doFinal(content);
    }

    public static byte[] privateEncrypt(byte[] content,  PrivateKey privatekey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, privatekey);
        return cipher.doFinal(content);
    }

    public static byte[] publicDecrypt(byte[] content, PublicKey publicKey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, publicKey);
        return cipher.doFinal(content);
    }
    public static byte[] privateDecrypt(byte[] content, PrivateKey privatekey) throws Exception {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privatekey);
        return cipher.doFinal(content);
    }


    public static void main(String[] args) throws Exception {
        String str = "Hello, I am lai xiao hong";
        byte[] bytes = str.getBytes();
        KeyPair keyPair = getKeyPairt();
        String publicKey = getPublicKey(keyPair);
        String privateKey = getPrivateKey(keyPair);
        System.out.println("publicKey:" + publicKey);
        System.out.println("privateKey:" + privateKey);

        //byte[] encBytes = publicEncrypt(bytes, String2Publickey(publicKey));
        //byte[] decBytes = privateDecrypt(encBytes,String2Privatekey(privateKey));
        byte[] encBytes = privateEncrypt(bytes, String2Privatekey(privateKey));
        byte[] decBytes = publicDecrypt(encBytes, String2Publickey(publicKey));

        System.out.println("Decrypt String:" + new String(decBytes));

    }
}

4.数字签名

签名认证是对非对称加密技术和数字摘要技术的综合运用，指的是将通信内容的商要信息使用发送者的私钥进行加密，然后将密文与原文一起传输给信息的接收者，接收者通过发送者的公钥解密被加密的摘要信息，然后使用与发送者相同的摘要算法，对接收的内容采用相同的方式产生摘要串，与解密的摘要串进行对比，如果相同，则说明接收到的内容是完整的，在传输过程中没有受到第五方篡改，否则说明通信内容已被第三方修改。

只有信息的发送者才能产生别人无法篡改的数字签名串，这个串能对信息发送者所发送的内容完整性和发送者的身份进行校验和签别，通信正文经过相应的摘要算法生成摘要后，使用消息发送者的私钥进行加密，生成数字签名如下图所示：

消息的接收端收到信息的正文和对应的数字签名后，使用与发送端相同的摘要算法，生成通信正文的摘要，并且使用发送者的公钥对数字签名进行解密，得到发送商生成的摘要，进行比较后即可验证发送者的身份是否合法，正文内容是否被篡改，如下图所示：

常风的数字数字签名算法包括：MD%withRSA、SHA1withRSA等.

java 例子：

public class SignatureTest {
    private static byte[] sign(byte[] content, PrivateKey privateKey) throws Exception {
        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initSign(privateKey);
        signature.update(content);
        return  signature.sign();
    }
    private static boolean verify(byte[] content,byte[] sign, PublicKey publicKey)  throws Exception{
        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initVerify(publicKey);
        signature.update(content);
        return signature.verify(sign);
    }
}

5.数字证书

也称为电子证书，通常包含如下内容：

对象的名称
证书的过期时间
颁发机构
签名算法
对象的公钥

大多数证书采用X.509的格式来保存证书，数字证书的签发过程实际上就是对数字证书的内容，包括证书所代表对象的公钥进行数字签名，而验证证书的过程，实际上是检验证书的数字签名。

在现实中，网络用户的数字证书需要数字认证机构(Certificate Authority,CA)来进行颁发，只有经过CA颁布的数字证书在网络中才具备认证性。

证书的生成过程如下：

证书的验证过程如下：

要获得数字证书，首先需要使用数字证书管理工具，如keytool,OpenSSL等，然后构建CSR(Certificate Signing Request)数字证书签发申请，提交给数字证书认证机构进行签名，最终形成数字证书。

Java常用的安全算法

猜你喜欢