Java 实现RSA非对称加密算法

目录
  •   公钥与私钥
  •   Java实现

  公钥与私钥

  公钥与私钥是成对的,一般的,我们认为的是公钥加密、私钥解密、私钥签名、公钥验证,有人说成私钥加密,公钥解密时不对的。

  公钥与私钥的生成有多种方式,可以通过程序生成(下文具体实现),可以通过openssl工具:  

    # 生成一个私钥,推荐使用1024位的秘钥,秘钥以pem格式保存到-out参数指定的文件中,采用PKCS1格式
    openssl genrsa -out rsa.pem 1024
    # 生成与私钥对应的公钥,生成的是Subject Public Key,一般配合PKCS8格式私钥使用
    openssl rsa -in rsa.pem -pubout -out rsa.pub  

  RSA生成公钥与私钥一般有两种格式:PKCS1和PKCS8,上面的命令生成的秘钥是PKCS1格式的,而公钥是Subject Public Key,一般配合PKCS8格式私钥使用,所以就可能会涉及到PKCS1和PKCS8之间的转换:

    # PKCS1格式私钥转换为PKCS8格式私钥,私钥直接输出到-out参数指定的文件中
    openssl pkcs8 -topk8 -inform PEM -in rsa.pem -outform pem -nocrypt -out rsa_pkcs8.pem
    # PKCS8格式私钥转换为PKCS1格式私钥,私钥直接输出到-out参数指定的文件中
    openssl rsa -in rsa_pkcs8.pem -out rsa_pkcs1.pem

    # PKCS1格式公钥转换为PKCS8格式公钥,转换后的内容直接输出
    openssl rsa -pubin -in rsa.pub -RSAPublicKey_out
    # PKCS8格式公钥转换为PKCS1格式公钥,转换后的内容直接输出
    openssl rsa -RSAPublicKey_in -pubout -in rsa.pub

  现实中,我们往往从pem、crt、pfx文件获取公私和私钥,crt、pfx的制作可以参考:简单的制作ssl证书,并在nginx和IIS中使用,或者使用现成的:https://pan.baidu.com/s/1MJ5YmuZiLBnf-DfNR_6D7A (提取码:c6tj),密码都是:123456

  Java实现

  为简化说明介绍,这里我直接封装了一个工具类,因为要从pem、crt、pfx文件获取公私和私钥,因此引用了一个第三方包:BouncyCastle,可以直接在pom.xml中添加依赖:  

    <dependency>
        <groupId>org.bouncycastle</groupId>
        <artifactId>bcprov-jdk15on</artifactId>
        <version>1.68</version>
    </dependency>

  或者去mvn上下载:跳转

  简单封装的RsaUtil.java:  

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.math.BigInteger;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.cert.Certificate;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.KeySpec;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.RSAPrivateCrtKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Enumeration;

import javax.crypto.Cipher;

import org.bouncycastle.asn1.ASN1Integer;
import org.bouncycastle.asn1.ASN1Primitive;
import org.bouncycastle.asn1.DLSequence;
import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers;
import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.io.pem.PemObject;
import org.bouncycastle.util.io.pem.PemReader;
import org.bouncycastle.util.io.pem.PemWriter;

public class RsaUtil {

    static {
        Security.addProvider(new BouncyCastleProvider());
    }

    /**
     * 随机生成密钥对
     *
     * @param usePKCS8
     *            是否采用PKCS8填充模式
     */
    public static Object[] generateRsaKey(boolean usePKCS8) throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA", BouncyCastleProvider.PROVIDER_NAME);
        // 初始化
        keyPairGen.initialize(1024, new SecureRandom());
        // 生成一个密钥对,保存在keyPair中
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); // 得到私钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); // 得到公钥

        // 这两个公私钥是PKCS8格式的
        byte[] publicKeyBytes = publicKey.getEncoded();
        byte[] privateKeyBytes = privateKey.getEncoded();

        if (!usePKCS8) {
            // 将PSCK8格式公私钥转换为PKCS1格式
            publicKeyBytes = pkcs8ToPkcs1(false, publicKeyBytes);
            privateKeyBytes = pkcs8ToPkcs1(true, privateKeyBytes);
        }

        return new Object[] { publicKeyBytes, privateKeyBytes };
    }

    /**
     * 从Pem文件读取密钥对
     *
     * @param reader
     *            输入流
     * @param pemFileName
     *            pem文件
     */
    public static byte[] readFromPem(String pemFileName) throws Exception {
        PemReader pemReader = new PemReader(new FileReader(pemFileName));
        PemObject pemObject = pemReader.readPemObject();
        byte[] publicKey = pemObject.getContent();
        pemReader.close();
        return publicKey;
    }

    /**
     * 从Pem文件读取密钥
     *
     * @param isPrivateKey
     *            是否是私钥
     * @param buffer
     *            字节
     * @param pemFileName
     *            pem文件
     */
    public static void writeToPem(byte[] buffer, boolean isPrivateKey, String pemFileName) throws Exception {

        PemObject pemObject = new PemObject(isPrivateKey ? "RSA PRIVATE KEY" : "RSA PUBLIC KEY", buffer);
        FileWriter fileWriter = new FileWriter(pemFileName);
        PemWriter pemWriter = new PemWriter(fileWriter);
        pemWriter.writeObject(pemObject);
        pemWriter.close();
    }

    /**
     * 从crt文件读取公钥(pkcs8)
     *
     * @param crtFileName
     *            crt文件
     * @return 公钥
     */
    public static byte[] readPublicKeyFromCrt(String crtFileName) throws Exception {
        CertificateFactory cf = CertificateFactory.getInstance("X.509");
        X509Certificate cert = (X509Certificate) cf.generateCertificate(new FileInputStream(crtFileName));

        PublicKey publicKey = cert.getPublicKey();
        return publicKey.getEncoded();
    }

    /**
     * 从pfx文件读取秘钥对(pkcs8)
     *
     * @param pfxFileName
     *            pfx文件
     * @return 秘钥对
     */
    public static Object[] readFromPfx(String pfxFileName, String password) throws Exception {
        KeyStore keystore = KeyStore.getInstance("PKCS12");
        char[] passwordChars = null;
        if (password == null || password.equals("")) {
            passwordChars = null;
        } else {
            passwordChars = password.toCharArray();
        }
        keystore.load(new FileInputStream(pfxFileName), passwordChars);
        Enumeration<String> enums = keystore.aliases();

        PrivateKey privateKey = null;
        Certificate certificate = null;
        while (enums.hasMoreElements()) {
            String alias = enums.nextElement();
            System.out.println(alias);
            if (keystore.isKeyEntry(alias)) {
                privateKey = (PrivateKey) keystore.getKey(alias, passwordChars);
                certificate = keystore.getCertificate(alias);
            }
            if (privateKey != null && certificate != null)
                break;
        }
        if (privateKey == null || certificate == null) {
            throw new Exception("fail to read key from pfx");
        }

        PublicKey publicKey = certificate.getPublicKey();
        return new Object[] { publicKey.getEncoded(), privateKey.getEncoded() };
    }

    /**
     * Pkcs8转Pkcs1
     *
     * @param isPrivateKey
     *            是否是私钥转换
     * @param buffer
     *            Pkcs1秘钥
     * @return Pkcs8秘钥
     * @throws Exception
     *             加密过程中的异常信息
     */
    public static byte[] pkcs8ToPkcs1(boolean isPrivateKey, byte[] buffer) throws Exception {
        if (isPrivateKey) {
            PrivateKeyInfo privateKeyInfo = PrivateKeyInfo.getInstance(buffer);
            return privateKeyInfo.parsePrivateKey().toASN1Primitive().getEncoded();
        } else {
            SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfo.getInstance(buffer);
            return subjectPublicKeyInfo.parsePublicKey().toASN1Primitive().getEncoded();
        }
    }

    /**
     * Pkcs1转Pkcs8
     *
     * @param isPrivateKey
     *            是否是私钥转换
     * @param buffer
     *            Pkcs1秘钥
     * @return Pkcs8秘钥
     * @throws Exception
     *             加密过程中的异常信息
     */
    public static byte[] pkcs1ToPkcs8(boolean isPrivateKey, byte[] buffer) throws Exception {
        AlgorithmIdentifier algorithmIdentifier = new AlgorithmIdentifier(PKCSObjectIdentifiers.rsaEncryption);
        ASN1Primitive asn1Primitive = ASN1Primitive.fromByteArray(buffer);
        if (isPrivateKey) {
            PrivateKeyInfo privateKeyInfo = new PrivateKeyInfo(algorithmIdentifier, asn1Primitive);
            return privateKeyInfo.getEncoded();
        } else {
            SubjectPublicKeyInfo subjectPublicKeyInfo = new SubjectPublicKeyInfo(algorithmIdentifier, asn1Primitive);
            return subjectPublicKeyInfo.getEncoded();
        }
    }

    /**
     * RSA公钥
     *
     * @param usePKCS8
     *            是否采用PKCS8填充模式
     * @param publicKey
     *            公钥
     * @return 公钥
     * @throws Exception
     *             加密过程中的异常信息
     */
    public static RSAPublicKey generatePublicKey(boolean usePKCS8, byte[] publicKey) throws Exception {
        KeySpec keySpec;
        if (usePKCS8) {
            // PKCS8填充
            keySpec = new X509EncodedKeySpec(publicKey);
        } else {
            // PKCS1填充
            DLSequence sequence = (DLSequence) ASN1Primitive.fromByteArray(publicKey);
            BigInteger v1 = ((ASN1Integer) sequence.getObjectAt(0)).getValue();
            BigInteger v2 = ((ASN1Integer) sequence.getObjectAt(1)).getValue();
            keySpec = new RSAPublicKeySpec(v1, v2);
        }

        RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance("RSA", BouncyCastleProvider.PROVIDER_NAME).generatePublic(keySpec);
        return pubKey;
    }

    /**
     * RSA私钥
     *
     * @param usePKCS8
     *            是否采用PKCS8填充模式
     * @param privateKey
     *            私钥
     * @return 私钥
     * @throws Exception
     *             解密过程中的异常信息
     */
    public static RSAPrivateKey generatePrivateKey(boolean usePKCS8, byte[] privateKey) throws Exception {
        KeySpec keySpec;
        if (usePKCS8) {
            // PKCS8填充
            keySpec = new PKCS8EncodedKeySpec(privateKey);
        } else {
            // PKCS1填充
            DLSequence sequence = (DLSequence) ASN1Primitive.fromByteArray(privateKey);
            // BigInteger v1= ((ASN1Integer)sequence.getObjectAt(0)).getValue();
            BigInteger v2 = ((ASN1Integer) sequence.getObjectAt(1)).getValue();
            BigInteger v3 = ((ASN1Integer) sequence.getObjectAt(2)).getValue();
            BigInteger v4 = ((ASN1Integer) sequence.getObjectAt(3)).getValue();
            BigInteger v5 = ((ASN1Integer) sequence.getObjectAt(4)).getValue();
            BigInteger v6 = ((ASN1Integer) sequence.getObjectAt(5)).getValue();
            BigInteger v7 = ((ASN1Integer) sequence.getObjectAt(6)).getValue();
            BigInteger v8 = ((ASN1Integer) sequence.getObjectAt(7)).getValue();
            BigInteger v9 = ((ASN1Integer) sequence.getObjectAt(8)).getValue();
            keySpec = new RSAPrivateCrtKeySpec(v2, v3, v4, v5, v6, v7, v8, v9);
        }

        RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance("RSA", BouncyCastleProvider.PROVIDER_NAME).generatePrivate(keySpec);
        return priKey;
    }

    /**
     * RSA公钥加密
     *
     * @param value
     *            加密字符串
     * @param publicKey
     *            公钥
     * @return 密文
     * @throws Exception
     *             加密过程中的异常信息
     */
    public static String rsaEncrypt(String value, RSAPublicKey publicKey) throws Exception {
        if (value == null || value.length() == 0)
            return "";

        // RSA加密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] buffer = cipher.doFinal(value.getBytes("utf-8"));

        // 使用hex格式输出公钥
        StringBuffer result = new StringBuffer();
        for (int i = 0; i < buffer.length; i++) {
            result.append(String.format("%02x", buffer[i]));
        }
        return result.toString();
    }

    /**
     * RSA私钥解密
     *
     * @param value
     *            加密字符串
     * @param privateKey
     *            私钥
     * @return 明文
     * @throws Exception
     *             解密过程中的异常信息
     */
    public static String rsaDecrypt(String value, RSAPrivateKey privateKey) throws Exception {
        if (value == null || value.length() == 0)
            return "";

        byte[] buffer = new byte[value.length() / 2];
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) Integer.parseInt(value.substring(i * 2, i * 2 + 2), 16);
        }

        // RSA解密
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        buffer = cipher.doFinal(buffer);
        return new String(buffer, "utf-8");
    }

    /**
     * RSA签名
     *
     * @param value
     *            加密字符串
     * @param privateKey
     *            私钥
     * @param halg
     *            加密算法,如MD5, SHA1, SHA256, SHA384, SHA512等
     * @return 签名
     * @throws Exception
     *             签名过程中的异常信息
     */
    public static String sign(String value, RSAPrivateKey privateKey, String halg) throws Exception {

        Signature s = Signature.getInstance(halg.toUpperCase().endsWith("WithRSA") ? halg : (halg + "WithRSA"));

        s.initSign(privateKey);
        s.update(value.getBytes("utf-8"));

        byte[] buffer = s.sign();

        // 使用hex格式输出公钥
        StringBuffer result = new StringBuffer();
        for (int i = 0; i < buffer.length; i++) {
            result.append(String.format("%02x", buffer[i]));
        }
        return result.toString();
    }

    /**
     * RSA签名验证
     *
     * @param value
     *            加密字符串
     * @param publicKey
     *            公钥
     * @param halg
     *            加密算法,如MD5, SHA1, SHA256, SHA384, SHA512等
     * @return 签名合法则返回true,否则返回false
     * @throws Exception
     *             验证过程中的异常信息
     */
    public static boolean verify(String value, RSAPublicKey publicKey, String signature, String halg) throws Exception {
        Signature s = Signature.getInstance(halg.toUpperCase().endsWith("WithRSA") ? halg : (halg + "WithRSA"));
        s.initVerify(publicKey);
        s.update(value.getBytes("utf-8"));

        byte[] buffer = new byte[signature.length() / 2];
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) Integer.parseInt(signature.substring(i * 2, i * 2 + 2), 16);
        }

        return s.verify(buffer);
    }

}

   生成公钥和私钥:  

    // 生成公私钥
    Object[] rsaKey = RsaUtil.generateRsaKey(usePKCS8); //usePKCS8=true表示是否成PKCS8格式的公私秘钥,否则乘车PKCS1格式的公私秘钥
    byte[] publicKey = (byte[]) rsaKey[0];
    byte[] privateKey = (byte[]) rsaKey[1];

  生成秘钥后,需要保存,一般保存到pem文件中: 

    // 保存到pem文件,filePath是保存目录
    RsaUtil.writeToPem(publicKey, false, filePath + "rsa.pub");
    RsaUtil.writeToPem(privateKey, true, filePath + "rsa.pem");

   可以保存到pem文件中,当然也可以从pem文件中读取了:  

    // 从Pem文件读取公私钥,filePath是文件目录
    byte[] publicKey = RsaUtil.readFromPem(filePath + "rsa.pub");
    byte[] privateKey = RsaUtil.readFromPem(filePath + "rsa.pem");

  还可以从crt证书中读取公钥,而crt文件不包含私钥,因此需要单独获取私钥: 

    // 从crt文件读取公钥(crt文件中不包含私钥),filePath是文件目录
    byte[] publicKey = RsaUtil.readPublicKeyFromCrt(filePath + "demo.crt");
    byte[] privateKey = RsaUtil.readFromPem(filePath + "demo.key");

   pfx文件中包含了公钥和私钥,可以很方便就读取到:  

    // 从pfx文件读取公私钥,filePath是文件目录
    Object[] rsaKey = RsaUtil.readFromPfx(filePath + "demo.pfx", "123456");
    byte[] publicKey = (byte[]) rsaKey[0];
    byte[] privateKey = (byte[]) rsaKey[1];

  有时候我们还可能需要进行秘钥的转换:  

    // Pkcs8格式公钥转换为Pkcs1格式公钥
    publicKey = RsaUtil.pkcs8ToPkcs1(false, publicKey);
    // Pkcs8格式私钥转换为Pkcs1格式私钥
    privateKey = RsaUtil.pkcs8ToPkcs1(true, privateKey);
    // Pkcs1格式公钥转换为Pkcs8格式公钥
    publicKey = RsaUtil.pkcs1ToPkcs8(false, publicKey);
    // Pkcs1格式私钥转换为Pkcs8格式私钥
    privateKey = RsaUtil.pkcs1ToPkcs8(true, privateKey);

  有了公钥和私钥,接下就就能实现加密、解密、签名、验证签名等操作了:  

    RSAPublicKey rsaPublicKey = RsaUtil.generatePublicKey(usePKCS8, publicKey);
    RSAPrivateKey rsaPrivateKey = RsaUtil.generatePrivateKey(usePKCS8, privateKey);

    String encryptText = RsaUtil.rsaEncrypt(text, rsaPublicKey);
    System.out.printf("【%s】经过【RSA】加密后:%s\n", text, encryptText);

    String decryptText = RsaUtil.rsaDecrypt(encryptText, rsaPrivateKey);
    System.out.printf("【%s】经过【RSA】解密后:%s\n", encryptText, decryptText);

    String signature = RsaUtil.sign(text, rsaPrivateKey, "MD5");
    System.out.printf("【%s】经过【RSA】签名后:%s\n", text, signature);

    boolean result = RsaUtil.verify(text, rsaPublicKey, signature, "MD5");
    System.out.printf("【%s】的签名【%s】经过【RSA】验证后结果是:" + result, text, signature);

  这里完整的demo代码:

    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;

    public class RsaMain {

        public static void main(String[] args) {
            try {
                String text = "上山打老虎";
                boolean usePKCS8 = true; // usePKCS8=true表示是否成PKCS8格式的公私秘钥,否则乘车PKCS1格式的公私秘钥
                String filePath = RsaUtil.class.getClassLoader().getResource("").getPath();
                System.out.printf("文件路径:%s\n", filePath);// 存放pem,crt,pfx等文件的目录
                byte[] publicKey, privateKey;// 公钥和私钥

                // 生成公私钥
                Object[] rsaKey = RsaUtil.generateRsaKey(usePKCS8); // usePKCS8=true表示是否成PKCS8格式的公私秘钥,否则乘车PKCS1格式的公私秘钥
                publicKey = (byte[]) rsaKey[0];
                privateKey = (byte[]) rsaKey[1];
                // 从Pem文件读取公私钥,filePath是文件目录
                // publicKey = RsaUtil.readFromPem(filePath + "rsa.pub");
                // privateKey = RsaUtil.readFromPem(filePath + "rsa.pem");
                // 从pfx文件读取公私钥,filePath是文件目录
                // Object[] rsaKey = RsaUtil.readFromPfx(filePath + "demo.pfx",
                // "123456");
                // publicKey = (byte[]) rsaKey[0];
                // privateKey = (byte[]) rsaKey[1];
                // 从crt文件读取公钥(crt文件中不包含私钥),filePath是文件目录
                // publicKey = RsaUtil.readPublicKeyFromCrt(filePath + "demo.crt");
                // privateKey = RsaUtil.readFromPem(filePath + "demo.key");

                // 保存到pem文件,filePath是保存目录
                RsaUtil.writeToPem(publicKey, false, filePath + "rsa.pub");
                RsaUtil.writeToPem(privateKey, true, filePath + "rsa.pem");

                // Pkcs8格式公钥转换为Pkcs1格式公钥
                publicKey = RsaUtil.pkcs8ToPkcs1(false, publicKey);
                // Pkcs8格式私钥转换为Pkcs1格式私钥
                privateKey = RsaUtil.pkcs8ToPkcs1(true, privateKey);
                // Pkcs1格式公钥转换为Pkcs8格式公钥
                publicKey = RsaUtil.pkcs1ToPkcs8(false, publicKey);
                // Pkcs1格式私钥转换为Pkcs8格式私钥
                privateKey = RsaUtil.pkcs1ToPkcs8(true, privateKey);

                RSAPublicKey rsaPublicKey = RsaUtil.generatePublicKey(usePKCS8, publicKey);
                RSAPrivateKey rsaPrivateKey = RsaUtil.generatePrivateKey(usePKCS8, privateKey);

                String encryptText = RsaUtil.rsaEncrypt(text, rsaPublicKey);
                System.out.printf("【%s】经过【RSA】加密后:%s\n", text, encryptText);

                String decryptText = RsaUtil.rsaDecrypt(encryptText, rsaPrivateKey);
                System.out.printf("【%s】经过【RSA】解密后:%s\n", encryptText, decryptText);

                String signature = RsaUtil.sign(text, rsaPrivateKey, "MD5");
                System.out.printf("【%s】经过【RSA】签名后:%s\n", text, signature);

                boolean result = RsaUtil.verify(text, rsaPublicKey, signature, "MD5");
                System.out.printf("【%s】的签名【%s】经过【RSA】验证后结果是:" + result, text, signature);

            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

以上就是Java 实现RSA非对称加密算法的详细内容,更多关于Java RSA非对称加密算法的资料请关注我们其它相关文章!

(0)

相关推荐

  • java RSAUtils 加密工具类操作

    1.RSA加密算法是一种非对称加密算法.在公开密钥加密和电子商业中RSA被广泛使用.RSA公开密钥密码体制.所谓的公开密钥密码体制就是使用不同的加密密钥与解密密钥,是一种"由已知加密密钥推导出解密密钥在计算上是不可行的"密码体制.在公开密钥密码体制中,加密密钥(即公开密钥)PK是公开信息,而解密密钥(即秘密密钥)SK是需要保密的.加密算法E和解密算法D也都是公开的.虽然解密密钥SK是由公开密钥PK决定的,但却不能根据PK计算出SK. 2.本工具类涉及到BASE64编码,所以先展示出BA

  • Java实现RSA加密工具类

    公钥加密算法,也就是 非对称加密算法,这种算法加密和解密的密码不一样,一个是公钥,另一个是私钥: 公钥和私钥成对出现 公开的密钥叫公钥,只有自己知道的叫私钥 用公钥加密的数据只有对应的私钥可以解密 用私钥加密的数据只有对应的公钥可以解密 如果可以用公钥解密,则必然是对应的私钥加的密 如果可以用私钥解密,则必然是对应的公钥加的密 公钥和私钥是相对的,两者本身并没有规定哪一个必须是公钥或私钥. 代码如下 package com.cxy.template.controller.keyTools; im

  • Java加密算法RSA代码实例

    这篇文章主要介绍了Java加密算法RSA代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 代码如下 import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto.NoSuchPaddingException; import java

  • java使用RSA加密方式实现数据加密解密的代码

    RSA的应用 RSA是一种非对称加密算法.现在,很多登陆表单的密码的都采用RSA加密,例如京东中的登陆使用公钥对密码进行加密 java使用RSA加密方式实现数据加密解密,需要首先产生私钥和公钥 测试代码 public static void main(String args[]) { try { RSADemo rsa=new RSADemo(); rsa.generateKey(); byte[] data=rsa.encrypt("luanpeng".getBytes()); by

  • java使用RSA与AES加密解密的实例代码详解

    首先了解下,什么是堆成加密,什么是非对称加密? 对称加密:加密与解密的密钥是相同的,加解密速度很快,比如AES 非对称加密:加密与解密的秘钥是不同的,速度较慢,比如RSA •先看代码(先会用在研究) 相关依赖: <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15on</artifactId> <version>1.58</versio

  • Java实现RSA算法的方法详解

    本文实例讲述了Java实现RSA算法的方法.分享给大家供大家参考,具体如下: 一 介绍 唯一广泛接受并实现 用于数据加密和数字签名 公钥加密.私钥解密 私钥加密.公钥解密 二 RSA参数说明 三 实现 package com.imooc.security.rsa; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.sec

  • 教你用Java实现RSA非对称加密算法

    一.非对称加密 非对称加密算法是一种密钥的保密方法. 非对称加密算法需要两个密钥:公开密钥(publickey:简称公钥)和私有密钥(privatekey:简称私钥).公钥与私钥是一对,如果用公钥对数据进行加密,只有用对应的私钥才能解密.因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法. 非对称加密算法实现机密信息交换的基本过程是:甲方生成一对密钥并将公钥公开,需要向甲方发送信息的其他角色(乙方)使用该密钥(甲方的公钥)对机密信息进行加密后再发送给甲方:甲方再用自己私钥对加密

  • Java实现的数字签名算法RSA完整示例

    本文实例讲述了Java实现的数字签名算法RSA.分享给大家供大家参考,具体如下: 一 背景介绍 数字签名:带有密钥(公钥.私钥)的消息摘要算法. 验证数据完整性.认证数据来源.抗否认. 私钥签名.公钥验证. 常用算法:RSA.DSA.ECDSA 二 RSA介绍 包括MD和SHA两类 三 Java代码实现 package com.imooc.security.rsa2; import java.security.KeyFactory; import java.security.KeyPair; i

  • Java-web中利用RSA进行加密解密操作的方法示例

    前言 最近在看,网络安全方面的问题,我们可以使用RSA进行非对称加密防止,获取用户信息.首先我们看下java下操作RSA进行加密解密算法,代码如下: package com.jb.test; import java.security.InvalidKeyException; import java.security.KeyPair; import java.security.KeyPairGenerator; import java.security.NoSuchAlgorithmExcepti

  • Java 实现RSA非对称加密算法

    目录 公钥与私钥 Java实现 公钥与私钥 公钥与私钥是成对的,一般的,我们认为的是公钥加密.私钥解密.私钥签名.公钥验证,有人说成私钥加密,公钥解密时不对的. 公钥与私钥的生成有多种方式,可以通过程序生成(下文具体实现),可以通过openssl工具: # 生成一个私钥,推荐使用1024位的秘钥,秘钥以pem格式保存到-out参数指定的文件中,采用PKCS1格式 openssl genrsa -out rsa.pem 1024 # 生成与私钥对应的公钥,生成的是Subject Public Ke

  • C#实现简单的RSA非对称加密算法示例

    本文实例讲述了C#实现简单的RSA非对称加密算法.分享给大家供大家参考,具体如下: 界面控件 namespace RSA算法 { partial class Form1 { /// <summary> /// 必需的设计器变量. /// </summary> private System.ComponentModel.IContainer components = null; /// <summary> /// 清理所有正在使用的资源. /// </summary

  • c# 实现RSA非对称加密算法

    目录 公钥与私钥 C#实现 公钥与私钥 公钥与私钥是成对的,一般的,我们认为的是公钥加密.私钥解密.私钥签名.公钥验证,有人说成私钥加密,公钥解密时不对的. 公钥与私钥的生成有多种方式,可以通过程序生成(下文具体实现),可以通过openssl工具: # 生成一个私钥,推荐使用1024位的秘钥,秘钥以pem格式保存到-out参数指定的文件中,采用PKCS1格式 openssl genrsa -out rsa.pem 1024 # 生成与私钥对应的公钥,生成的是Subject Public Key,

  • 使用openssl实现rsa非对称加密算法示例

    复制代码 代码如下: <?php/** * 使用openssl实现非对称加密 * @since 2010-07-08 */class Rsa{    /**     * private key     */        private $_privKey; /**         * public key         */        private $_pubKey; /**         * the keys saving path         */        privat

  • Python3非对称加密算法RSA实例详解

    本文实例讲述了Python3非对称加密算法RSA.分享给大家供大家参考,具体如下: python3 可以使用 Crypto.PublicKey.RSA 和 rsa 生成公钥.私钥. 其中 python3.6 Crypto 库的安装方式请参考前面一篇<Python3对称加密算法AES.DES3> rsa 加解密的库使用 pip3 install rsa 就行了 C:\WINDOWS\system32>pip3 install rsa Collecting rsa   Downloading

  • JAVA加密算法- 非对称加密算法(DH,RSA)的详细介绍

    非对称密码概念 1.与对称加密算法的主要差别在于,加密和解密的密钥不相同,一个公开(公钥),一个保密(私钥).主要解决了对称加密算法密钥分配管理的问题,提高了算法安全性. 2.非对称加密算法的加密.解密的效率比较低.在算法设计上,非对称加密算法对待加密的数据长度有着苛刻的要求.例如RSA算法要求待加密的数据不得大于53个字节. 3.非对称加密算法主要用于 交换对称加密算法的密钥,而非数据交换 4.java6提供实现了DH和RSA两种算法.Bouncy Castle提供了E1Gamal算法支持.除

  • Java 实现常见的非对称加密算法

    概述 非对称加密算法与对称加密算法的主要差别在于非对称加密算法用于加密和解密的密钥不相同,非对称加密算法密钥分为公钥和私钥,公钥加密只能用私钥解密,反之私钥加密只能用公钥解密.相比对称加密算法,非对称加密算法加/解密效率低,但安全性高,这两种算法一般结合使用.常见非对称加密算法有RSA.ECC.Elgamal等. 使用RSA实现加密解密 公钥加密,私钥解密. package com.ss.utils; import javax.crypto.Cipher; import java.securit

  • java 中RSA的方式实现非对称加密的实例

    java 中RSA的方式实现非对称加密的实例 RSA通俗理解: 你只要去想:既然是加密,那肯定是不希望别人知道我的消息,所以只有我才能解密,所以可得出公钥负责加密,私钥负责解密:同理,既然是签名,那肯定是不希望有人冒充我发消息,只有我才能发布这个签名,所以可得出私钥负责签名,公钥负责验证. 实现代码: package com.sahadev; import java.security.KeyFactory; import java.security.KeyPair; import java.se

  • 详解PHP使用非对称加密算法RSA

    加密的类型 在日常设计及开发中,为确保数据传输和数据存储的安全,可通过特定的算法,将数据明文加密成复杂的密文.目前主流加密手段大致可分为单向加密和双向加密. 单向加密:通过对数据进行摘要计算生成密文,密文不可逆推还原.算法代表:Base64,MD5,SHA; 双向加密:与单向加密相反,可以把密文逆推还原成明文,双向加密又分为对称加密和非对称加密. 对称加密:指数据使用者必须拥有相同的密钥才可以进行加密解密,就像彼此约定的一串暗号.算法代表:DES,3DES,AES,IDEA,RC4,RC5; 非

随机推荐