高等数据加密——非对称加密算法

最新推荐文章于 2021-12-17 16:59:22 发布
最新推荐文章于 2021-12-17 16:59:22 发布
阅读量453 收藏 1
点赞数
分类专栏： java加密与解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heng615975867/article/details/105385069
版权

对称加密算法仅有一个密钥，既可用于加密，亦可用于解密。而非对称加密算法拥有两个密钥，一个用于加密，另一个则用于解密。相比对称加密算法的单钥体系，非对称加密算法的双钥体系更为安全。但非对称加密的缺点是加解密速度要远远慢于对称加密。

目前，Java 6中仅仅提供了DH和RSA两种算法实现。通过Boucy Castle可以获得ElGamal算法支持。

DH算法的使用

DH（Diffie-Hellman，密钥交换）算法，是第一个密钥协商算法，仅能用于密钥分配，不能用于加密或解密消息。下面整理DH算法时序：

初始化DH算法密钥对

 

甲乙双方构建DH算法本地密钥

 

DH算法加密消息传递

下面是对该算法JAVA实现的信息汇总：

算法密钥长度密钥长度默认值工作模式填充方式备注
DH512至1024位（密钥长度为64的倍数，范围在521~1024位之间）1024无无Java 6实现

下面给出一个使用DH算法的示例：

 

import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PublicKey;
import java.security.PrivateKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public abstract class DHCoder {

    /**
     * 非对称加密密钥算法
     */
    public static final String KEY_ALGORITHM = "DH";

    /**
     * 本地密钥算法，即对称加密密钥算法，可选DES、DESede和AES算法
     */
    public static final String SECRET_KEY_ALGORITHM = "AES";

    /**
     * 默认密钥长度
     * 
     * DH算法默认密钥长度为1024 密钥长度必须是64的倍数，其范围在512到1024位之间。
     */
    private static final int KEY_SIZE = 512;

    /**
     * 公钥
     */
    private static final String PUBLIC_KEY = "DHPublicKey";

    /**
     * 私钥
     */
    private static final String PRIVATE_KEY = "DHPrivateKey";

    /**
     * 初始化甲方密钥
     * 
     * @return Map 甲方密钥Map
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws Exception {

        // 实例化密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator
                .getInstance(KEY_ALGORITHM);

        // 初始化密钥对生成器
        keyPairGenerator.initialize(KEY_SIZE);

        // 生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        // 甲方公钥
        DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();

        // 甲方私钥
        DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();

        // 将密钥对存储在Map中
        Map<String, Object> keyMap = new HashMap<String, Object>(2);

        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);

        return keyMap;
    }

    /**
     * 初始化乙方密钥
     * 
     * @param key
     *            甲方公钥
     * @return Map 乙方密钥Map
     * @throws Exception
     */
    public static Map<String, Object> initKey(byte[] key) throws Exception {

        // 解析甲方公钥
        // 转换公钥材料
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);

        // 实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

        // 产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

        // 由甲方公钥构建乙方密钥
        DHParameterSpec dhParamSpec = ((DHPublicKey) pubKey).getParams();

        // 实例化密钥对生成器
        KeyPairGenerator keyPairGenerator = KeyPairGenerator
                .getInstance(keyFactory.getAlgorithm());

        // 初始化密钥对生成器
        keyPairGenerator.initialize(dhParamSpec);

        // 产生密钥对
        KeyPair keyPair = keyPairGenerator.genKeyPair();

        // 乙方公钥
        DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();

        // 乙方私钥
        DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();

        // 将密钥对存储在Map中
        Map<String, Object> keyMap = new HashMap<String, Object>(2);

        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);

        return keyMap;
    }

    /**
     * 加密
     * 
     * @param data
     *            待加密数据
     * @param key
     *            密钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] encrypt(byte[] data, byte[] key) throws Exception {

        // 生成本地密钥
        SecretKey secretKey = new SecretKeySpec(key, SECRET_KEY_ALGORITHM);

        // 数据加密
        Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());

        cipher.init(Cipher.ENCRYPT_MODE, secretKey);

        return cipher.doFinal(data);
    }

    /**
     * 解密<br>
     * 
     * @param data
     *            待解密数据
     * @param key
     *            密钥
     * @return byte[] 解密数据
     * @throws Exception
     */
    public static byte[] decrypt(byte[] data, byte[] key) throws Exception {

        // 生成本地密钥
        SecretKey secretKey = new SecretKeySpec(key, SECRET_KEY_ALGORITHM);

        // 数据解密
        Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());

        cipher.init(Cipher.DECRYPT_MODE, secretKey);

        return cipher.doFinal(data);
    }

    /**
     * 构建密钥
     * 
     * @param publicKey
     *            公钥
     * @param privateKey
     *            私钥
     * @return byte[] 本地密钥
     * @throws Exception
     */
    public static byte[] getSecretKey(byte[] publicKey, byte[] privateKey)
            throws Exception {

        // 实例化密钥工厂
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

        // 初始化公钥
        // 密钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(publicKey);

        // 产生公钥
        PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);

        // 初始化私钥
        // 密钥材料转换
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey);

        // 产生私钥
        PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);

        // 实例化
        KeyAgreement keyAgree = KeyAgreement.getInstance(keyFactory
                .getAlgorithm());

        // 初始化
        keyAgree.init(priKey);

        keyAgree.doPhase(pubKey, true);

        // 生成本地密钥
        SecretKey secretKey = keyAgree.generateSecret(SECRET_KEY_ALGORITHM);

        return secretKey.getEncoded();
    }

    /**
     * 取得私钥
     * 
     * @param keyMap
     *            密钥Map
     * @return byte[] 私钥
     * @throws Exception
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap)
            throws Exception {

        Key key = (Key) keyMap.get(PRIVATE_KEY);

        return key.getEncoded();
    }

    /**
     * 取得公钥
     * 
     * @param keyMap
     *            密钥Map
     * @return byte[] 公钥
     * @throws Exception
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap)
            throws Exception {

        Key key = (Key) keyMap.get(PUBLIC_KEY);

        return key.getEncoded();
    }
}

DHCoder的单元测试用例：

 

import static org.junit.Assert.*;
import java.util.Map;
import org.apache.commons.codec.binary.Base64;
import org.junit.Before;
import org.junit.Test;

public class DHCoderTest {

    /**
     * 甲方公钥
     */
    private byte[] publicKey1;
    /**
     * 甲方私钥
     */
    private byte[] privateKey1;

    /**
     * 甲方本地密钥
     */
    private byte[] key1;

    /**
     * 乙方公钥
     */
    private byte[] publicKey2;

    /**
     * 乙方私钥
     */
    private byte[] privateKey2;

    /**
     * 乙方本地密钥
     */
    private byte[] key2;

    /**
     * 初始化密钥
     * 
     * @throws Exception
     */
    @Before
    public final void initKey() throws Exception {

        // 生成甲方密钥对儿
        Map<String, Object> keyMap1 = DHCoder.initKey();

        publicKey1 = DHCoder.getPublicKey(keyMap1);
        privateKey1 = DHCoder.getPrivateKey(keyMap1);

        System.err.println("甲方公钥:\n" + Base64.encodeBase64String(publicKey1));
        System.err.println("甲方私钥:\n" + Base64.encodeBase64String(privateKey1));

        // 由甲方公钥产生本地密钥对儿
        Map<String, Object> keyMap2 = DHCoder.initKey(publicKey1);

        publicKey2 = DHCoder.getPublicKey(keyMap2);
        privateKey2 = DHCoder.getPrivateKey(keyMap2);

        System.err.println("乙方公钥:\n" + Base64.encodeBase64String(publicKey2));
        System.err.println("乙方私钥:\n" + Base64.encodeBase64String(privateKey2));

        key1 = DHCoder.getSecretKey(publicKey2, privateKey1);
        System.err.println("甲方本地密钥:\n" + Base64.encodeBase64String(key1));

        key2 = DHCoder.getSecretKey(publicKey1, privateKey2);
        System.err.println("乙方本地密钥:\n" + Base64.encodeBase64String(key2));

        assertArrayEquals(key1, key2);
    }

    /**
     * 校验
     * 
     * @throws Exception
     */
    @Test
    public final void test() throws Exception {

        System.err.println("\n=====甲方向乙方发送加密数据=====");
        String input1 = "密码交换算法 ";
        System.err.println("原文: " + input1);

        System.err.println("---使用甲方本地密钥对数据加密---");

        // 使用甲方本地密钥对数据加密
        byte[] code1 = DHCoder.encrypt(input1.getBytes(), key1);

        System.err.println("加密: " + Base64.encodeBase64String(code1));

        System.err.println("---使用乙方本地密钥对数据解密---");

        // 使用乙方本地密钥对数据解密
        byte[] decode1 = DHCoder.decrypt(code1, key2);
        String output1 = (new String(decode1));

        System.err.println("解密: " + output1);

        assertEquals(input1, output1);

        System.err.println("\n=====乙方向甲方发送加密数据=====");
        String input2 = "DH";
        System.err.println("原文: " + input2);

        System.err.println("---使用乙方本地密钥对数据加密---");

        // 使用乙方本地密钥对数据加密
        byte[] code2 = DHCoder.encrypt(input2.getBytes(), key2);

        System.err.println("加密: " + Base64.encodeBase64String(code2));

        System.err.println("---使用甲方本地密钥对数据解密---");

        // 使用甲方本地密钥对数据解密
        byte[] decode2 = DHCoder.decrypt(code2, key1);
        String output2 = (new String(decode2));

        System.err.println("解密: " + output2);

        // 校验
        assertEquals(input2, output2);
    }
}

RSA算法的使用

RSA典型非对称加密算法，基于大数因子分解难题。甲方构建密钥对，发送公钥给乙方；甲方使用私钥加密，乙方使用公钥解密；乙方使用公钥加密，甲方使用私钥解密。

 

构建RSA算法密钥对

RSA算法加密解密

下面是对该算法JAVA实现的信息汇总：

算法密钥长度密钥长度默认值工作模式填充方式备注
RSA512~65536位（密钥长度为64的倍数）1024ECBNoPadding、PKCS1Padding、OAEPWITHMD5AndMGF1Padding、OAEPWITHSHA1AndMGF1Padding、OAEPWITHSHA256AndMGF1Padding、OAEPWITHSHA384AndMGF1Padding、OAEPWITHSHA512AndMGF1PaddingJava 6实现
RSA同上2048NONENoPadding、PKCS1Padding、OAEPWITHMD5AndMGF1Padding、OAEPWITHSHA1AndMGF1Padding、OAEPWITHSHA256AndMGF1Padding、OAEPWITHSHA384AndMGF1Padding、OAEPWITHSHA512AndMGF1Padding、ISO9796-1PaddingBC实现

下面给出一个使用RSA算法的示例：

 

import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;

public abstract class RSACoder {

    /**
     * 非对称加密密钥算法
     */
    public static final String KEY_ALGORITHM = "RSA";

    /**
     * 公钥
     */
    private static final String PUBLIC_KEY = "RSAPublicKey";

    /**
     * 私钥
     */
    private static final String PRIVATE_KEY = "RSAPrivateKey";

    /**
     * RSA密钥长度 
     * 默认1024位，
     * 密钥长度必须是64的倍数， 
     * 范围在512至65536位之间。
     */
    private static final int KEY_SIZE = 512;

    /**
     * 私钥解密
     * 
     * @param data
     *            待解密数据
     * @param key
     *            私钥
     * @return byte[] 解密数据
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key)
            throws Exception {

        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);

        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

        // 生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

        // 对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.DECRYPT_MODE, privateKey);

        return cipher.doFinal(data);
    }

    /**
     * 公钥解密
     * 
     * @param data
     *            待解密数据
     * @param key
     *            公钥
     * @return byte[] 解密数据
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] data, byte[] key)
            throws Exception {

        // 取得公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);

        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

        // 生成公钥
        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);

        // 对数据解密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.DECRYPT_MODE, publicKey);

        return cipher.doFinal(data);
    }

    /**
     * 公钥加密
     * 
     * @param data
     *            待加密数据
     * @param key
     *            公钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] key)
            throws Exception {

        // 取得公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);

        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

        PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);

        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        return cipher.doFinal(data);
    }

    /**
     * 私钥加密
     * 
     * @param data
     *            待加密数据
     * @param key
     *            私钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] key)
            throws Exception {

        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);

        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

        // 生成私钥
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

        cipher.init(Cipher.ENCRYPT_MODE, privateKey);

        return cipher.doFinal(data);
    }

    /**
     * 取得私钥
     * 
     * @param keyMap
     *            密钥Map
     * @return byte[] 私钥
     * @throws Exception
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap)
            throws Exception {

        Key key = (Key) keyMap.get(PRIVATE_KEY);

        return key.getEncoded();
    }

    /**
     * 取得公钥
     * 
     * @param keyMap
     *            密钥Map
     * @return byte[] 公钥
     * @throws Exception
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap)
            throws Exception {

        Key key = (Key) keyMap.get(PUBLIC_KEY);

        return key.getEncoded();
    }

    /**
     * 初始化密钥
     * 
     * @return Map 密钥Map
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws Exception {

        // 实例化密钥对生成器
        KeyPairGenerator keyPairGen = KeyPairGenerator
                .getInstance(KEY_ALGORITHM);

        // 初始化密钥对生成器
        keyPairGen.initialize(KEY_SIZE);

        // 生成密钥对
        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;
    }
}

RSA单元测试用例：

 

import static org.junit.Assert.*;
import org.apache.commons.codec.binary.Base64;
import org.junit.Before;
import org.junit.Test;
import java.util.Map;

public class RSACoderTest {

    /**
     * 公钥
     */
    private byte[] publicKey;

    /**
     * 私钥
     */
    private byte[] privateKey;

    /**
     * 初始化密钥
     * 
     * @throws Exception
     */
    @Before
    public void initKey() throws Exception {

        // 初始化密钥
        Map<String, Object> keyMap = RSACoder.initKey();

        publicKey = RSACoder.getPublicKey(keyMap);
        privateKey = RSACoder.getPrivateKey(keyMap);

        System.err.println("公钥: \n" + Base64.encodeBase64String(publicKey));
        System.err.println("私钥： \n" + Base64.encodeBase64String(privateKey));
    }

    /**
     * 校验
     * 
     * @throws Exception
     */
    @Test
    public void test() throws Exception {

        System.err.println("\n---私钥加密——公钥解密---");

        String inputStr1 = "RSA加密算法";
        byte[] data1 = inputStr1.getBytes();
        System.err.println("原文:\n" + inputStr1);

        // 加密
        byte[] encodedData1 = RSACoder.encryptByPrivateKey(data1, privateKey);
        System.err.println("加密后:\n" + Base64.encodeBase64String(encodedData1));

        // 解密
        byte[] decodedData1 = RSACoder.decryptByPublicKey(encodedData1,
                publicKey);
        String outputStr1 = new String(decodedData1);
        System.err.println("解密后:\n" + outputStr1);

        // 校验
        assertEquals(inputStr1, outputStr1);

        System.err.println("\n---公钥加密——私钥解密---");
        String inputStr2 = "RSA Encypt Algorithm";
        byte[] data2 = inputStr2.getBytes();
        System.err.println("原文:\n" + inputStr2);

        // 加密
        byte[] encodedData2 = RSACoder.encryptByPublicKey(data2, publicKey);
        System.err.println("加密后:\n" + Base64.encodeBase64String(encodedData2));

        // 解密
        byte[] decodedData2 = RSACoder.decryptByPrivateKey(encodedData2,
                privateKey);
        String outputStr2 = new String(decodedData2);
        System.err.println("解密后: " + outputStr2);

        // 校验
        assertEquals(inputStr2, outputStr2);
    }

}

ElGamal算法的使用

ElGamal算法，是一种基于离散对数问题的非对称加密算法，该算法即可用于加密，又可用于数字签名。ElGamal具有较好的安全性，但它的密文会成倍的扩张。该算法遵循“公钥加密，私钥解密”。

ElGamal加密数据传输

下面是对该算法JAVA实现的信息汇总：

算法密钥长度密钥长度默认值工作模式填充方式备注
ElGamal160~16384位（密钥长度为8的倍数）1024ECB、NONENoPadding、PKCS1Padding、OAEPWITHMD5AndMGF1Padding、OAEPWITHSHA1AndMGF1Padding、OAEPWITHSHA224AndMGF1Padding、OAEPWITHSHA256AndMGF1Padding、OAEPWITHSHA384AndMGF1Padding、OAEPWITHSHA512AndMGF1Padding、ISO9796-1PaddingBC实现

下面是实现ElGamal算法的一个示例：

 

import java.security.AlgorithmParameterGenerator;
import java.security.AlgorithmParameters;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;
import javax.crypto.spec.DHParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

public abstract class ElGamalCoder {

    /**
     * 非对称加密密钥算法
     */
    public static final String KEY_ALGORITHM = "ElGamal";

    /**
     * 密钥长度
     * 
     * ElGamal算法默认密钥长度为1024 
     * 密钥长度范围在160位至16,384位不等。
     */
    private static final int KEY_SIZE = 256;

    /**
     * 公钥
     */
    private static final String PUBLIC_KEY = "ElGamalPublicKey";

    /**
     * 私钥
     */
    private static final String PRIVATE_KEY = "ElGamalPrivateKey";

    /**
     * 用私钥解密
     * 
     * @param data
     *            待解密数据
     * @param key
     *            私钥
     * @return byte[] 解密数据
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key)
            throws Exception {

        // 加入BouncyCastleProvider支持
        Security.addProvider(new BouncyCastleProvider());

        // 私钥材料转换
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);

        // 实例化密钥工厂
        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);
    }

    /**
     * 用公钥加密
     * 
     * @param data
     *            待加密数据
     * @param key
     *            公钥
     * @return byte[] 加密数据
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, byte[] key)
            throws Exception {

        // 加入BouncyCastleProvider支持
        Security.addProvider(new BouncyCastleProvider());

        // 公钥材料转换
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);

        // 实例化密钥工厂
        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);
    }

    /**
     * 生成密钥
     * 
     * @return Map 密钥Map
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws Exception {

        // 加入BouncyCastleProvider支持
        Security.addProvider(new BouncyCastleProvider());

        // 实例化算法参数生成器
        AlgorithmParameterGenerator apg = AlgorithmParameterGenerator
                .getInstance(KEY_ALGORITHM);

        // 初始化算法参数生成器
        apg.init(KEY_SIZE);

        // 生成算法参数
        AlgorithmParameters params = apg.generateParameters();

        // 构建参数材料
        DHParameterSpec elParams = (DHParameterSpec) params
                .getParameterSpec(DHParameterSpec.class);

        // 实例化密钥对儿生成器
        KeyPairGenerator kpg = KeyPairGenerator.getInstance(KEY_ALGORITHM);

        // 初始化密钥对儿生成器
        kpg.initialize(elParams, new SecureRandom());

        // 生成密钥对儿
        KeyPair keys = kpg.genKeyPair();

        // 取得密钥
        PublicKey publicKey = keys.getPublic();

        PrivateKey privateKey = keys.getPrivate();

        // 封装密钥
        Map<String, Object> map = new HashMap<String, Object>(2);

        map.put(PUBLIC_KEY, publicKey);

        map.put(PRIVATE_KEY, privateKey);

        return map;
    }

    /**
     * 取得私钥
     * 
     * @param keyMap
     *            密钥Map
     * @return byte[] 私钥
     * @throws Exception
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap)
            throws Exception {

        Key key = (Key) keyMap.get(PRIVATE_KEY);

        return key.getEncoded();
    }

    /**
     * 取得公钥
     * 
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap)
            throws Exception {

        Key key = (Key) keyMap.get(PUBLIC_KEY);

        return key.getEncoded();
    }
}

并给出相应的单元测试用例：

 

import static org.junit.Assert.*;
import java.util.Map;
import org.apache.commons.codec.binary.Base64;
import org.junit.Before;
import org.junit.Test;

public class ElGamalCoderTest {

    /**
     * 公钥
     */
    private byte[] publicKey;

    /**
     * 私钥
     */
    private byte[] privateKey;

    /**
     * 初始化密钥
     * 
     * @throws Exception
     */
    @Before
    public void initKey() throws Exception {
        
        Map<String, Object> keyMap = ElGamalCoder.initKey();

        publicKey = ElGamalCoder.getPublicKey(keyMap);
        privateKey = ElGamalCoder.getPrivateKey(keyMap);

        System.err.println("公钥: \n" + Base64.encodeBase64String(publicKey));
        System.err.println("私钥： \n" + Base64.encodeBase64String(privateKey));
    }

    /**
     * 校验
     * 
     * @throws Exception
     */
    @Test
    public void test() throws Exception {

        String inputStr = "ElGamal加密";

        byte[] data = inputStr.getBytes();

        System.err.println("原文: \n" + inputStr);

        byte[] encodedData = ElGamalCoder.encryptByPublicKey(data, publicKey);

        System.err.println("加密后: \n" + Base64.encodeBase64String(encodedData));

        byte[] decodedData = ElGamalCoder.decryptByPrivateKey(encodedData,
                privateKey);

        String outputStr = new String(decodedData);

        System.err.println("解密后: \n" + outputStr);

        assertEquals(inputStr, outputStr);
    }

}

 

Loong.xu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
密码学：一文看懂初等数据加密一对称加密算法
Shujie
01-05 1362
我们都有使用密码保护私密信息的经历，甚至可以说是习惯。我们往往不希望无关的人窥探我们的隐私，从孩童时代就知道用“密码日记本”记录自己的一些隐私。密码日记本无非是一个带锁的日记本。不管是读日记还是写日记都离不开这个密码。上述情形就好比我们应用黑匣子，需要读写操作，需要同一套密钥。写操作伴随加读操作伴随解密。加密和解密操作使用同一套密钥，这就是对称加密算法的核心。
非对称加密算法/现代加密算法
qq_45679015的博客
09-04 795
非对称加密算法 加密和解密使用不同的密钥，这种算法称为非对称加密算法 特点： 必须有两个密钥，一个公钥，一个私钥 公钥和私钥是一对，称为密钥对 如果使用公钥加密，必须使用私钥解密 如果使用私钥加密，必须使用公钥解密 处理数据速度慢 安全级别高 -举个例子： 首先生成密钥对, 公钥为(5,14), 私钥为(11,14) 现在A希望将原文2发送给B A使用公钥加密数据. 2的5次方mod 14 = 4 , 将密文4发送给B B使用私钥解密数据. 4的11次方mod14 = 2, 得到原文
非对称密码的编程使用
阿骏的专栏
03-05 612
非对称密码的概念： 1.对称密码中的密钥配送问题 一旦黑客截取到你的密钥，你的数据也就泄露了。2.非对称密码通信模型 说明：接收方已生成自己的公钥和私钥，私钥自己保存，而私钥则广播出去,发送方甲收到乙方的公钥，对需要传输的数据用公钥进行加密，乙方收到数据后用私钥进行解密恢复到原始数据。经过公钥加密过的数据只有私钥才能破解，所以即使加密过后的数据被截取到没有私钥也
JAVA使用RSA/ECB/OAEPWITHSHA-256ANDMGF1PADDING加密解密
daggerin7的博客
12-17 6961
RSA/ECB/OAEPWITHSHA-256ANDMGF1PADDING解密例子
代码审计For小白
qq_28083513的博客
02-22 1768
前言：对于没从事过开发的人来说，代码审计是有不小的挑战的，要快速上手，就需要一些小技巧了。详情请看“审计关键”。 Java常见漏洞Top10： 日志伪造Log Forging：将未经验证的用户输入写入日志文件可致使攻击者伪造日志条目或将恶意信息内容注入日志。 示例代码： public void risk(HttpServletRequest request, HttpServletRespons...
Java RSA算法加密
hezelike的专栏
12-22 655
<br /><br />这种算法1978年就出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字命名：Ron Rivest， AdiShamir 和Leonard Adleman.这种加密算法的特点主要是密钥的变化，上文我们看到DES只有一个密钥。相当于只有一把钥匙，如果这把钥匙丢了，数据也就不安全了。RSA同时有两把钥匙，公钥与私钥。同时支持数字签名。数字签名的意义在于，对传输过来的数据进行校验。确保数据在传输工程中不被修改。<br />    流
RSA加密
qq_39790910的博客
04-18 180
package com.uns.mpos.ins.util;import java.security.InvalidKeyException;import java.security.Key;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;impor...
智能卡的非对称加密算法
11-14
非对称加密算法在智能卡中尤其重要，因为智能卡通常存储敏感信息，如金融交易数据、身份验证信息等。通过使用非对称加密，智能卡可以提供高级别的安全性，防止未经授权的访问和数据泄露。同时，非对称加密也是HTTPS...
RSA.rar_非对称加密_非对称算法
最新发布
09-24
非对称加密是一种重要的信息安全技术，它在网络安全中扮演着至关重要的角色...通过对"RSA.rar_非对称加密_非对称算法"的探索，我们可以进一步掌握这一核心加密技术，并能将其应用到实际的项目中，确保数据的安全传输。
java 非对称加密算法RSA实现详解
08-25
Java 非对称加密算法RSA实现详解是 Java 语言中的一种常用加密算法，主要用于保护数据的安全性。 RSA 算法是一种基于大数分解的加密算法，它的安全性取决于大数分解的难度。在 Java 中，RSA 加密算法可以用来实现...
C#实现简单的RSA非对称加密算法示例
08-29
C#实现简单的RSA非对称加密算法示例 本文主要介绍了C#实现简单的RSA非对称加密算法，结合实例形式分析了C#实现RSA加密的具体步骤与相关操作技巧。 RSA非对称加密算法是公钥密码体制中的一种，使用了一对密钥，一个...
java 非对称加密算法DH实现详解
08-25
Java 非对称加密算法 DH 实现详解是一种基于 Diffie-Hellman 密钥交换算法的非对称加密算法实现，主要用于保证数据的安全传输。该算法可以使用 Java 中的 `KeyPairGenerator` 和 `KeyFactory` 类来实现，但同时也...
js java 加密算法_RSA算法 JS加密 JAVA解密
weixin_39962199的博客
02-17 92
import org.apache.commons.codec.binary.Base64;import javax.crypto.Cipher;import java.security.*;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.u...
java公钥加密私钥解密_JAVA公钥加密，私钥解密，该怎么解决
weixin_32667439的博客
02-12 513
展开全部publicabstractclassRSACoderextendsCoder{publicstaticfinalStringKEY_ALGORITHM="RSA";publicstaticfinalStringSIGNATURE_ALGORITHM="MD5withRSA";privatestaticfinalStringPUBLIC_KEY...
RSA加密算法
程序袁小黑
09-04 6066
RSA公钥加密算法是1977年由RonRivest、Adi Shamirh和LenAdleman在（美国麻省理工学院）开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的所有密码攻击，已被ISO推荐为公钥数据加密标准。RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为
OAEPWithSHA-512AndMGF1Padding
waterif的专栏
11-30 3960
基于PKCS#1 V2.1规范的OAEPWithSHA-512AndMGF1Padding算法实现 java中可以直接使用RSA/ECB/OAEPWithSHA-512AndMGF1Padding来完成公钥加密数据。 例如： public static byte[] encode(byte[] data) throws Exception { byte[] keyBytes = Ba
provider.BouncyCastleProvider库导入用于算法和生成证书
热门推荐
heng615975867的专栏
04-06 2万+
关于使用算法找不到类org.bouncycastle.jce.provider.BouncyCastleProvider的问题，本人尝试了网上N多方法都不行后，自己尝试解决了问题，以分享出来。没有JAVA_HOME的需要配置环境，JDK环境变量的配置 1、网上搜索的方法基本都是这种，本人没有解决问题 找到JAVA_HOME路径 将bcprov-jdk14-145.jar放入JAVA_HOME...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值