投稿
  1. 简单一点首页
  2. 编程

rsajava,rsajava实现

小蓝 • • 编程

本文目录一览：

JAVA写RSA加密，公钥私钥都是一样的，为什么每次加密的结果不一样

因为rsa是非对称加密，它使用的是随机大素数的抽取，每次随机生成的，所以每次加密的结果不可能一样

java rsa加密，高并发如何解决

既然高并发了务必要考虑吞吐量吧，进行同步不是一个好的选择。

其实你可以把加密算法与私钥封装进一个类里，然后每次请求实例化这个类，创建一个实体，之后进行解密就行了。

关于java中rsa的问题

【实例下载】本文介绍RSA2加密与解密，RSA2是RSA的加强版本，在密钥长度上采用2048, RSA2比RSA更安全，更可靠, 本人的另一篇文章RSA已经发表，有想了解的可以点开下面的RSA文章

JAVA写RSA加密，公钥私钥都是一样的，为什么每次加密的结果不一样？

JAVA写RSA加密，私钥都是一样的，公钥每次加密的结果不一样跟对数据的padding（填充）有关。

1、Padding (填充)属性定义元素边框与元素内容之间的空间。

2、padding 简写属性在一个声明中设置所有内边距属性。设置所有当前或者指定元素内边距属性。该属性可以有1到4个值。

3、当元素的 Padding(填充)(内边距)被清除时，所”释放”的区域将会受到元素背景颜色的填充。

4、单独使用填充属性是在一个声明中设置元素的所内边距属性。缩写填充属性也可以使用，一旦改变一个数值，则padding对应的距离都会改变。

Java中RSA的方式如何实现非对称加密的示例

代码如下，需要依赖一个jar包commons-codec-1.9.jar，用于Base64转换，请自行下载。

import org.apache.commons.codec.binary.Base64;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import java.io.ByteArrayOutputStream;

import java.io.UnsupportedEncodingException;

import java.security.*;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

public class RSAUtils {

    // 加密方式

    public static final String ALGORITHM = “RSA”;

    // 签名算法

    private static final String SIGNATURE_ALGORITHM = “SHA1WithRSA”;

    // 创建密钥对初始长度

    private static final int KEY_SIZE = 512;

    // 字符编码格式

    private static final String CHARSET = “UTF-8”;

    // RSA最大加密明文大小

    private static final int MAX_ENCRYPT_BLOCK = 117;

    // RSA最大解密密文大小

    private static final int MAX_DECRYPT_BLOCK = 128;

    private KeyFactory keyFactory;

    public RSAUtils() throws NoSuchAlgorithmException {

        keyFactory = KeyFactory.getInstance(ALGORITHM);

    }

    /**

     * 私钥加密

     *

     * @param content    待加密字符串

     * @param privateKey 私钥

     * @return 加密后字符串（BASE64编码）

     */

    public String encryptByPrivateKey(String content, String privateKey) throws Exception {

        String result;

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(privateKey);

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

            PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.ENCRYPT_MODE, pKey);

            byte[] data = content.getBytes(CHARSET);

            write2Stream(cipher, data, out);

            byte[] resultBytes = out.toByteArray();

            result = Base64.encodeBase64String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 公钥解密

     *

     * @param content   已加密字符串（BASE64加密）

     * @param publicKey 公钥

     * @return

     */

    public String decryptByPublicKey(String content, String publicKey) throws Exception {

        String result = “”;

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(publicKey);

            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

            PublicKey pKey = keyFactory.generatePublic(x509KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.DECRYPT_MODE, pKey);

            byte[] data = Base64.decodeBase64(content);

            write2Stream(cipher, data, out);

            byte[] resultBytes = out.toByteArray();

            result = new String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 公钥加密

     *

     * @param content   待加密字符串

     * @param publicKey 公钥

     * @return 加密后字符串（BASE64编码）

     */

    public String encryptByPublicKey(String content, String publicKey) throws Exception {

        String result = “”;

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(publicKey);

            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

            PublicKey pKey = keyFactory.generatePublic(x509KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.ENCRYPT_MODE, pKey);

            byte[] data = content.getBytes(CHARSET);

            write2Stream(cipher,

                    data, out);

            byte[] resultBytes = out.toByteArray();

            result = Base64.encodeBase64String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 私钥解密

     *

     * @param content    已加密字符串

     * @param privateKey 私钥

     * @return 解密后字符串

     */

    public String decryptByPrivateKey(String content, String privateKey) throws Exception {

        String result = “”;

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(privateKey);

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

            PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.DECRYPT_MODE, pKey);

            byte[] data = Base64.decodeBase64(content);

            write2Stream(cipher, data, out);

            byte[] resultBytes = out.toByteArray();

            result = new String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    private static void write2Stream(Cipher cipher, byte[] data, ByteArrayOutputStream out) throws

            BadPaddingException, IllegalBlockSizeException {

        int dataLen = data.length;

        int offSet = 0;

        byte[] cache;

        int i = 0;

        // 对数据分段解密

        while (dataLen – offSet  0) {

            if (dataLen – offSet  MAX_DECRYPT_BLOCK) {

                cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);

            } else {

                cache = cipher.doFinal(data, offSet, dataLen – offSet);

            }

            out.write(cache, 0, cache.length);

            i++;

            offSet = i * MAX_DECRYPT_BLOCK;

        }

    }

    /**

     * 用私钥对信息生成数字签名

     *

     * @param data       已加密数据

     * @param privateKey 私钥(BASE64编码)

     * @return sign

     */

    public String sign(String data, String privateKey) throws Exception {

        String result = “”;

        try {

            byte[] keyBytes = new Base64().decode(privateKey);

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

            PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);

            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

            signature.initSign(privateK);

            signature.update(parse2HexStr(data).getBytes(CHARSET));

            result = new Base64().encodeToString(signature.sign());

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 校验数字签名

     *

     * @param data      已加密数据

     * @param publicKey 公钥(BASE64编码)

     * @param sign      数字签名

     * @return

     * @throws Exception

     */

    public boolean verify(String data, String publicKey, String sign) throws Exception {

        boolean result;

        try {

            byte[] keyBytes = new Base64().decode(publicKey);

            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

            PublicKey publicK = keyFactory.generatePublic(keySpec);

            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

            signature.initVerify(publicK);

            signature.update(parse2HexStr(data).getBytes(CHARSET));

            result = signature.verify(new Base64().decode(sign));

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 将二进制转换成16进制

     *

     * @param data

     * @return

     */

    public static String parse2HexStr(String data) throws Exception {

        String result = “”;

        try {

            byte[] buf = data.getBytes(CHARSET);

            StringBuffer sb = new StringBuffer();

            for (int i = 0; i  buf.length; i++) {

                String hex = Integer.toHexString(buf[i]  0xFF);

                if (hex.length() == 1) {

                    hex = ‘0’ + hex;

                }

                sb.append(hex.toUpperCase());

            }

            result = sb.toString();

        } catch (UnsupportedEncodingException e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 生成公钥与私钥

     */

    public static void createKey() throws Exception {

        try {

            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);

            keyPairGenerator.initialize(KEY_SIZE);

            KeyPair keyPair = keyPairGenerator.generateKeyPair();

            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();

            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

            String publicKey = Base64.encodeBase64String(rsaPublicKey.getEncoded());

            String privateKey = Base64.encodeBase64String(rsaPrivateKey.getEncoded());

            System.out.println(“publicKey=” + publicKey + “\nprivateKey=” + privateKey);

        } catch (NoSuchAlgorithmException e) {

            throw new Exception(e);

        }

    }

    public static void main(String[] args) throws Exception {

        String PRIVATE_KEY = “MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAKeYGXH6Vz+m+KuL11RDRaNdHB4YQeZgqpJGPRSwBelgvEoHu2/fNs1bmgfJhI8lhr/o/Hy8EFB/I/DDyLcCcU4bCLtxpki8edC+KJR2WvyYfnVmWEe/3q2jSVKRf81868q9Cd3MMfrQPMsY4x0TQ0GtOf/nMSMbAltV2W8J86IfAgMBAAECgYEApYu4lr2SMW3ddJZNvQ42W4g9nfyYG9igpJx8+VJmhIDpfLbmjzsOBwvUupx0NHH9CNQ7k3qxItJzzf+W5C+lesEOAqdO5nahRZsL8BIDoxTEn2j+1GXkzQw3vqPY50xqRnZsoP5TyNNsOM7KYaOoz4VFMdVIFwoT3OKM5z7mxgECQQD51r17WZDSa/kucaH7gCOePxJPS6Ust0eVd5tBOMpFzD/VtziogSIWyhGKkLH0SyTJEe91CCpdpxufLSZgIiN5AkEAq7ojtvU4twak1N1/1qX+t8f5wD8i/8GU702PeCwkGI5ymrARq+W2yCuvU1bouXBhjKHV4KhafKYixdHUMg00VwJAYVUjpLaUESY3gbyLWqvlNHVl8LaLtwwAO17JgXNaei7Ef8JNtHf6i95VTyJn8cCEqEDwhSuVNb8wp6azWKh0IQJBAJHrcT2d0bt0IcvfCynRk0eG3WnGPG8mhu9w8GAk4ecb47YdtmZio5YjyK8AQnCQVdOyEJL9eyY/5XxCeBSvs7ECQQCKQ2f5HLDkkHvc6rlaHCJmqNRCS+CxhoaiaSPYLAac7WXmb614ACLECc86C/nkefTq0SNpUDVbGxVpJi9/FOUf”;

        String PUBLIC_KEY = “MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCnmBlx+lc/pviri9dUQ0WjXRweGEHmYKqSRj0UsAXpYLxKB7tv3zbNW5oHyYSPJYa/6Px8vBBQfyPww8i3AnFOGwi7caZIvHnQviiUdlr8mH51ZlhHv96to0lSkX/NfOvKvQndzDH60DzLGOMdE0NBrTn/5zEjGwJbVdlvCfOiHwIDAQAB”;

        RSAUtils rsaUtil = new RSAUtils();

        String encryptByPublicKey = rsaUtil.encryptByPublicKey(“你好！”, PUBLIC_KEY);

        System.out.println(encryptByPublicKey);

        String decryptByPrivateKey = rsaUtil.decryptByPrivateKey(encryptByPublicKey, PRIVATE_KEY);

        System.out.println(decryptByPrivateKey);

        String encryptByPrivateKey = rsaUtil.encryptByPrivateKey(“你好！”, PRIVATE_KEY);

        System.out.println(encryptByPrivateKey);

        String decryptByPublicKey = rsaUtil.decryptByPublicKey(encryptByPrivateKey, PUBLIC_KEY);

        System.out.println(decryptByPublicKey);

        String sign = rsaUtil.sign(“1234”, PRIVATE_KEY);

        System.out.println(“sign:” + sign);

        System.out.println(rsaUtil.verify(“1234”, PUBLIC_KEY, sign));

    }

}

原创文章，作者：小蓝，如若转载，请注明出处：https://www.506064.com/n/206911.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
小蓝的头像小蓝
0 0
上一篇 2024-12-08 14:19
下一篇 2024-12-08 14:19

发表回复

登录后才能评论