RSA 16进制加解密和签名

最新推荐文章于 2024-07-12 20:11:27 发布
最新推荐文章于 2024-07-12 20:11:27 发布
阅读量7.7k 收藏 6
点赞数
分类专栏： Rsa 文章标签： rsa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Braveyzx/article/details/105342810
版权

       本文 字数：1619 

  1.  密钥位数：1024。

  2. 密钥格式：PKCS#8。

  3. 数字签名签名/验证算法：SHA1withRSA。

  4. RSA最大加密明文大小：117

    RSA最大解密密文大小：128

       存在: 1、原RSA公私密钥对，转16进制公私密钥。2、自动生成16进制密钥对。3、使用16进制私钥签名。4、使用16进制公钥验证。5、使用16进制私钥进行原数据加密。6、使用16进制公钥进行解密。7、对于16进制公钥加密，16私钥解密本文不说说明，稍微改一下就可以使用。8、完整代码

 

需要对包

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;
import org.springframework.util.StringUtils;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

 

 

1、原RSA公私密钥对，转16进制公私密钥

操作：先进性Base64解码，再把byte数组转成16进制即可。

代码：

//私钥
String privateKeyString = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAMjT4WYC7xFo5CRw\n" +
        "dHSseOsAqZKV2Ksrjp54yysba66TbVJ9Ai1WioCsP7WBkCSnMbECfb1jfJl37km2\n" +
        "moMMrhrKXNmrKhO5kEKLKZQZdg+/wVugFyzRhxEOIBbEQ6mIeyWVee4zkg+R9GIy\n" +
        "gt9mGhrAhBqqO1lZaAn5/iF43seLAgMBAAECgYAWRlH4w5iKoMy1MffovPyIbEFi\n" +
        "rdYjXihqcVFvjZILAfUdMhpctv2Tugcy9ZTsS9MaJAGYUQGP8Bpw+Jz4rh5dTebx\n" +
        "c8cqZ9NhI9h0gceGYJPyvtw7KdUnFRkYnlcj3vOwR9x793nJl1Yo0APCYl4jk7he\n" +
        "sm4YcCGY52uF7dQGuQJBAPQpRp5VJYuLXzsNNVkxIb27gpfTJVaYZoto2FqlpYhV\n" +
        "USRKGuTP+/5BZjJOBTRMaJvDqy15Ev/PrIm+8+5mvxUCQQDSkLazWyzVPfFAWO7I\n" +
        "3ICv/REtNdXkFQ6FYtYLzgusxFaNr75RsJsgeXfSQxD9RmPb2ipKeY3ertU25ZIl\n" +
        "gBQfAkBURKat4N9LcTfV7rIZ7X4iuMPS2LoLUCAcP3xklMUz75ZIuxbbH/luAG5g\n" +
        "MFNVgIWeNQMwd5gaGDgJdpFEF8wdAkAYkOWf2z1Jy6Y/2aBSMteYsK+2VJeVupct\n" +
        "HLDYQ7u89lMayKwtn6sZiNJf548t3W59EeDpO3E/z6n0c6gvU9gFAkBRxq0RXi/2\n" +
        "5wpEjeRd+tL30WrC2PoTVN6San5cPkv2k6vVWmZJAAMB6RKHtp+r7yUYLcEcrZOG\n" +
        "7ARIDVY19ou5";

//公钥
String publicKeyString = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDI0+FmAu8RaOQkcHR0rHjrAKmS\n" +
        "ldirK46eeMsrG2uuk21SfQItVoqArD+1gZAkpzGxAn29Y3yZd+5JtpqDDK4aylzZ\n" +
        "qyoTuZBCiymUGXYPv8FboBcs0YcRDiAWxEOpiHsllXnuM5IPkfRiMoLfZhoawIQa\n" +
        "qjtZWWgJ+f4heN7HiwIDAQAB";

//私钥16进制
byte[] bytes1 = Base64.decodeBase64(privateKeyString);
String pri = byte2Hex(bytes1);

//私钥16进制
byte[] ddd = Base64.decodeBase64(publicKeyString);
String pub = byte2Hex(ddd);

结果：

16进制私钥：30820275020100300d06092a864886f70d01010105000482025f3082025b02010002818100c8d3e16602ef1168e424707474ac78eb00a99295d8ab2b8e9e78cb2b1b6bae936d527d022d568a80ac3fb5819024a731b1027dbd637c9977ee49b69a830cae1aca5cd9ab2a13b990428b299419760fbfc15ba0172cd187110e2016c443a9887b259579ee33920f91f4623282df661a1ac0841aaa3b59596809f9fe2178dec78b0203010001028180164651f8c3988aa0ccb531f7e8bcfc886c4162add6235e286a71516f8d920b01f51d321a5cb6fd93ba0732f594ec4bd31a24019851018ff01a70f89cf8ae1e5d4de6f173c72a67d36123d87481c7866093f2bedc3b29d5271519189e5723def3b047dc7bf779c9975628d003c2625e2393b85eb26e18702198e76b85edd406b9024100f429469e55258b8b5f3b0d35593121bdbb8297d3255698668b68d85aa5a5885551244a1ae4cffbfe4166324e05344c689bc3ab2d7912ffcfac89bef3ee66bf15024100d290b6b35b2cd53df14058eec8dc80affd112d35d5e4150e8562d60bce0bacc4568dafbe51b09b207977d24310fd4663dbda2a4a798ddeaed536e5922580141f02405444a6ade0df4b7137d5eeb219ed7e22b8c3d2d8ba0b50201c3f7c6494c533ef9648bb16db1ff96e006e6030535580859e35033077981a18380976914417cc1d02401890e59fdb3d49cba63fd9a05232d798b0afb6549795ba972d1cb0d843bbbcf6531ac8ac2d9fab1988d25fe78f2ddd6e7d11e0e93b713fcfa9f473a82f53d805024051c6ad115e2ff6e70a448de45dfad2f7d16ac2d8fa1354de926a7e5c3e4bf693abd55a6649000301e91287b69fabef25182dc11cad9386ec04480d5635f68bb9
16进制公钥：30819f300d06092a864886f70d010101050003818d0030818902818100c8d3e16602ef1168e424707474ac78eb00a99295d8ab2b8e9e78cb2b1b6bae936d527d022d568a80ac3fb5819024a731b1027dbd637c9977ee49b69a830cae1aca5cd9ab2a13b990428b299419760fbfc15ba0172cd187110e2016c443a9887b259579ee33920f91f4623282df661a1ac0841aaa3b59596809f9fe2178dec78b0203010001
 

涉及的方法：

Base64：

org.apache.commons.codec.binary.Base64

byte2Hex：

/**
 * @param bytes，输入byte[]数组
 * @return 16进制字符
 * @Description: 将byte[]数组转换成16进制字符。一个byte生成两个字符，长度对应1:2
 * @Author: mastermind
 * @Date: 2020-04-06 12:16
 */
public static String byte2Hex(byte[] bytes) {
    if (bytes == null) {
        return null;
    }
    StringBuilder builder = new StringBuilder();
    // 遍历byte[]数组，将每个byte数字转换成16进制字符，再拼接起来成字符串
    for (int i = 0; i < bytes.length; i++) {
        // 每个byte转换成16进制字符时，bytes[i] & 0xff如果高位是0，输出将会去掉，所以+0x100(在更高位加1)，再截取后两位字符
        builder.append(Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1));
    }
    return builder.toString();
}

扩展：

得到16进制公私密钥，可以提取出指数和系数。

 

2、自动生成16进制密钥对 

操作：有代码直接生成

代码：

/**
 * 生成1024位RSA公私钥对。
 *
 * @return 私钥、公钥
 */
public static String[] genRSAKeyPair() {
    KeyPairGenerator rsaKeyGen = null;
    KeyPair rsaKeyPair = null;
    try {
        log.error("Generating a pair of RSA key ... ");
        rsaKeyGen = KeyPairGenerator.getInstance("RSA");
        SecureRandom random = new SecureRandom();
        random.setSeed(("" + System.currentTimeMillis() * Math.random() * Math.random()).getBytes(Charset
                .forName("UTF-8")));
        rsaKeyGen.initialize(1024, random);
        rsaKeyPair = rsaKeyGen.genKeyPair();
        PublicKey rsaPublic = rsaKeyPair.getPublic();
        PrivateKey rsaPrivate = rsaKeyPair.getPrivate();

        String privateAndPublic[] = new String[2];
        privateAndPublic[0] = byte2Hex(rsaPrivate.getEncoded());
        privateAndPublic[1] = byte2Hex(rsaPublic.getEncoded());
        System.err.println("16私钥:" + privateAndPublic[0]);
        System.err.println("16公钥:" + privateAndPublic[1]);
        return privateAndPublic;
    } catch (Exception e) {
        log.error("genRSAKeyPair error：" + e.getMessage(), e);
        return null;
    }
}

结果：

16私钥:30820275020100300d06092a864886f70d01010105000482025f3082025b02010002818100b0fbba4081656a1cc681315dbd815ee0b198d293def06f2d8d6fb17b64542999a361ec4f7c04e4353aadbf0397169651643d7923e22f038b9b0cafd58c46cd6822ff0e22146612fd872d0b27aa3f1121cc95e144a940de10065c5b261f242f667fccfc5fd5422d82af71d7c4f900843d12949411d726d82ece8b3c8808b4da1d02030100010281807a5c2f72f583260feaf5db299221657537940ed28929f5d3aa9b743b792beeeef7d475caa655c36941be69f79377dc493d627ae462365adf243d6b3bdb1600603e4791eb1700414f189ae1b02b3b40c0093922a5888d1358aec92779546256f5a903a1bb88beacd44514bbd88b18871699a9a1944806bdb783886fcee1a6f349024100e040d5d61bfd4ae8f7b6b93cb6131a5d17dcd1a617032db1d96ee4d4982792e58697e9b67afdb7399b8d673cfb05f911099cc462c30dd932d63b8dbd2bf9e73b024100ca09c80d007e11a29fa7b5d9352c169d98d6def82c473a06687d8eb6589a371923763679c9da6458dd3d7d36bd81aace3236227aa05e86a65ac7773eed491e87024051063bfccb4a1e49c44ec9e8eca4444f4472ed70c439cac5ca98eda6fe7eb5eda64eb70bceae63083672c5cd5ba951cf5d18be402cd7911574203a5b124b8dc702406a15f0c142fcef6da0bf8330e6469c296c53870870d785944fd17dda2973f07276b85faa5b5f1d49bc01c979b0d0214bdbf9a8e912c40f97d21ae2765c4a048902400a02d95a302b6fa69b4da0f146ffdd7ecc0154d852a01023c9af11e13a03ab223ccd26f7be0bfeea4fc5b7904f19880e47c25d31d8f2c43c320b75a50211c9cd
16公钥:30819f300d06092a864886f70d010101050003818d0030818902818100b0fbba4081656a1cc681315dbd815ee0b198d293def06f2d8d6fb17b64542999a361ec4f7c04e4353aadbf0397169651643d7923e22f038b9b0cafd58c46cd6822ff0e22146612fd872d0b27aa3f1121cc95e144a940de10065c5b261f242f667fccfc5fd5422d82af71d7c4f900843d12949411d726d82ece8b3c8808b4da1d0203010001
 

3、使用16进制私钥签名 

 操作：由16进制私钥转成私钥对象，在进行签名运算

代码：

//16进制私钥
String pri = "30820275020100300d06092a864886f70d01010105000482025f3082025b02010002818100c8d3e16602ef1168e424707474ac78eb00a99295d8ab2b8e9e78cb2b1b6bae936d527d022d568a80ac3fb5819024a731b1027dbd637c9977ee49b69a830cae1aca5cd9ab2a13b990428b299419760fbfc15ba0172cd187110e2016c443a9887b259579ee33920f91f4623282df661a1ac0841aaa3b59596809f9fe2178dec78b0203010001028180164651f8c3988aa0ccb531f7e8bcfc886c4162add6235e286a71516f8d920b01f51d321a5cb6fd93ba0732f594ec4bd31a24019851018ff01a70f89cf8ae1e5d4de6f173c72a67d36123d87481c7866093f2bedc3b29d5271519189e5723def3b047dc7bf779c9975628d003c2625e2393b85eb26e18702198e76b85edd406b9024100f429469e55258b8b5f3b0d35593121bdbb8297d3255698668b68d85aa5a5885551244a1ae4cffbfe4166324e05344c689bc3ab2d7912ffcfac89bef3ee66bf15024100d290b6b35b2cd53df14058eec8dc80affd112d35d5e4150e8562d60bce0bacc4568dafbe51b09b207977d24310fd4663dbda2a4a798ddeaed536e5922580141f02405444a6ade0df4b7137d5eeb219ed7e22b8c3d2d8ba0b50201c3f7c6494c533ef9648bb16db1ff96e006e6030535580859e35033077981a18380976914417cc1d02401890e59fdb3d49cba63fd9a05232d798b0afb6549795ba972d1cb0d843bbbcf6531ac8ac2d9fab1988d25fe78f2ddd6e7d11e0e93b713fcfa9f473a82f53d805024051c6ad115e2ff6e70a448de45dfad2f7d16ac2d8fa1354de926a7e5c3e4bf693abd55a6649000301e91287b69fabef25182dc11cad9386ec04480d5635f68bb9";
//原数据
String data = "123456";
System.err.println("代签名数据：" + data);
//签名
String sign = sign(getPrivateKey(pri), data, "utf-8");
System.err.println("私钥16签名:" + sign);

结果：

代签名数据：123456
私钥16签名:885d59e3ff349d7fb03903e2304556ceadfea1bf38c972575d20489e69e4b178bc7076db216a9150e7beac7b263eb967fe9129c6c1d70e127d379d0fe048531e0083fb3cd7e8415f68c91f7f1756c0e50dc98866bb9004c0db402be7f1d8e8acd5d5365bffae1259d3d347f233bebc348e9a52ac4aebaa165eac0269015fc622

 

涉及的方法：

getPrivateKey：

/**
 * 得到私钥对象
 *
 * @param key 密钥字符串（经过16进制编码）
 * @throws Exception
 */
public static PrivateKey getPrivateKey(String key) {
    try {
        byte[] keyBytes = hex2Byte(key);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        return keyFactory.generatePrivate(keySpec);
    } catch (Exception e) {
        String info = "getPrivateKey failed: " + key + " | " + e.getMessage();
        return null;
    }
}

hex2Byte：

/**
 * 将16进制字符转换成byte[]数组。与byte2Hex功能相反。
 *
 * @param string 16进制字符串
 * @return byte[]数组
 */
public static byte[] hex2Byte(String string) {
    if (string == null || string.length() < 1) {
        return null;
    }
    // 因为一个byte生成两个字符，长度对应1:2，所以byte[]数组长度是字符串长度一半
    byte[] bytes = new byte[string.length() / 2];
    // 遍历byte[]数组，遍历次数是字符串长度一半
    for (int i = 0; i < string.length() / 2; i++) {
        // 截取没两个字符的前一个，将其转为int数值
        int high = Integer.parseInt(string.substring(i * 2, i * 2 + 1), 16);
        // 截取没两个字符的后一个，将其转为int数值
        int low = Integer.parseInt(string.substring(i * 2 + 1, i * 2 + 2), 16);
        // 高位字符对应的int值*16+低位的int值，强转成byte数值即可
        // 如dd，高位13*16+低位13=221(强转成byte二进制11011101，对应十进制-35)
        bytes[i] = (byte) (high * 16 + low);
    }
    return bytes;
}

sign：

/**
 * 使用SHA1withRSA签名算法产生签名
 *
 * @param privateKey privateKey 签名时使用的私钥(16进制编码)
 * @param src        src 签名的原字符串
 * @return String 签名的返回结果(16进制编码)。当产生签名出错的时候，返回null。
 */
public static String sign(PrivateKey privateKey, String src, String encode) {
    try {
        Signature sigEng = Signature.getInstance(SIGNATURE_ALGORITHM);
        sigEng.initSign(privateKey);
        sigEng.update(src.getBytes(encode));
        byte[] signature = sigEng.sign();
        return byte2Hex(signature);
    } catch (Exception e) {
        return null;
    }
}

4、使用16进制公钥验证

操作：传入的签名，公钥都是 16进制格式

代码：

//16进制公钥
String pub = "30819f300d06092a864886f70d010101050003818d0030818902818100c8d3e16602ef1168e424707474ac78eb00a99295d8ab2b8e9e78cb2b1b6bae936d527d022d568a80ac3fb5819024a731b1027dbd637c9977ee49b69a830cae1aca5cd9ab2a13b990428b299419760fbfc15ba0172cd187110e2016c443a9887b259579ee33920f91f4623282df661a1ac0841aaa3b59596809f9fe2178dec78b0203010001";
//原数据
String data = "123456";
System.err.println("代签名数据：" + data);
//签名16进制
String sign = "885d59e3ff349d7fb03903e2304556ceadfea1bf38c972575d20489e69e4b178bc7076db216a9150e7beac7b263eb967fe9129c6c1d70e127d379d0fe048531e0083fb3cd7e8415f68c91f7f1756c0e50dc98866bb9004c0db402be7f1d8e8acd5d5365bffae1259d3d347f233bebc348e9a52ac4aebaa165eac0269015fc622";
//验证
verify(getPublicKey(pub), sign, data, "utf-8");

结果：
代签名数据：123456
验证结果：=====true=====

涉及的方法：

 1、getPublicKey：
/**
 * 获取公钥
 *
 * @param publicKey 公钥字符串
 * @return
 */
public static PublicKey getPublicKey(String publicKey) throws Exception {
    KeyFactory keyFactory = KeyFactory.getInstance("RSA");
    byte[] keyBytes = hex2Byte(publicKey);
    X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
    return keyFactory.generatePublic(keySpec);
}
2、verify
/**
 * 使用SHA1withRSA签名算法验证签名
 *
 * @param publicKey pubKey 验证签名时使用的公钥(16进制编码)
 * @param sign      sign 签名结果(16进制编码)
 * @param src       src 签名的原字符串
 */
public static void verify(PublicKey publicKey, String sign, String src, String encode) throws Exception {
    try {
        if (StringUtils.isEmpty(sign) || StringUtils.isEmpty(src)) {
            throw new RuntimeException("sign或内容不容为空");
        }
        Signature sigEng = Signature.getInstance("SHA1withRSA");
        sigEng.initVerify(publicKey);
        sigEng.update(src.getBytes(encode));
        byte[] sign1 = hex2Byte(sign);

        boolean aaa = sigEng.verify(sign1);
        System.out.println("验证结果：=====" + aaa + "=====");
        if (!aaa) {
            throw new Exception("验签失败");
        }
    } catch (Exception e) {
        throw new Exception("验签失败");
    }
}

以下部分全部放在代码中，在main中查找

 

全部代码 

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;
import org.springframework.util.StringUtils;

import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

@Slf4j
public class RSAUtil {

    /**
     * 数字签名，密钥算法
     */
    private static final String RSA_KEY_ALGORITHM = "RSA";
    /**
     * 数字签名签名/验证算法
     */
    private static final String SIGNATURE_ALGORITHM = "SHA1withRSA";
    /**
     * RSA密钥长度，RSA算法的默认密钥长度是1024密钥长度必须是64的倍数，在512到65536位之间
     */
    private static final int KEY_SIZE = 1024;

    /** */
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /** */
    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;


    /**
     * @param bytes，输入byte[]数组
     * @return 16进制字符
     * @Description: 将byte[]数组转换成16进制字符。一个byte生成两个字符，长度对应1:2
     * @Author: mastermind
     * @Date: 2020-04-06 12:16
     */
    public static String byte2Hex(byte[] bytes) {
        if (bytes == null) {
            return null;
        }
        StringBuilder builder = new StringBuilder();
        // 遍历byte[]数组，将每个byte数字转换成16进制字符，再拼接起来成字符串
        for (int i = 0; i < bytes.length; i++) {
            // 每个byte转换成16进制字符时，bytes[i] & 0xff如果高位是0，输出将会去掉，所以+0x100(在更高位加1)，再截取后两位字符
            builder.append(Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1));
        }
        return builder.toString();
    }

    /**
     * 将16进制字符转换成byte[]数组。与byte2Hex功能相反。
     *
     * @param string 16进制字符串
     * @return byte[]数组
     */
    public static byte[] hex2Byte(String string) {
        if (string == null || string.length() < 1) {
            return null;
        }
        // 因为一个byte生成两个字符，长度对应1:2，所以byte[]数组长度是字符串长度一半
        byte[] bytes = new byte[string.length() / 2];
        // 遍历byte[]数组，遍历次数是字符串长度一半
        for (int i = 0; i < string.length() / 2; i++) {
            // 截取没两个字符的前一个，将其转为int数值
            int high = Integer.parseInt(string.substring(i * 2, i * 2 + 1), 16);
            // 截取没两个字符的后一个，将其转为int数值
            int low = Integer.parseInt(string.substring(i * 2 + 1, i * 2 + 2), 16);
            // 高位字符对应的int值*16+低位的int值，强转成byte数值即可
            // 如dd，高位13*16+低位13=221(强转成byte二进制11011101，对应十进制-35)
            bytes[i] = (byte) (high * 16 + low);
        }
        return bytes;
    }

    /**
     * 使用SHA1withRSA签名算法产生签名
     *
     * @param privateKey privateKey 签名时使用的私钥(16进制编码)
     * @param src        src 签名的原字符串
     * @return String 签名的返回结果(16进制编码)。当产生签名出错的时候，返回null。
     */
    public static String sign(PrivateKey privateKey, String src, String encode) {
        try {
            Signature sigEng = Signature.getInstance(SIGNATURE_ALGORITHM);
            sigEng.initSign(privateKey);
            sigEng.update(src.getBytes(encode));
            byte[] signature = sigEng.sign();
            return byte2Hex(signature);
        } catch (Exception e) {
            String info = "sign failed: " + src + " | " + e.getMessage();
            return null;
        }
    }

    /**
     * 本方法使用SHA1withRSA签名算法验证签名
     *
     * @param publicKey pubKey 验证签名时使用的公钥(16进制编码)
     * @param sign      sign 签名结果(16进制编码)
     * @param src       src 签名的原字符串
     */
    public static void verify(PublicKey publicKey, String sign, String src, String encode) throws Exception {
        try {
            if (StringUtils.isEmpty(sign) || StringUtils.isEmpty(src)) {
                throw new RuntimeException("sign或内容不容为空");
            }
            Signature sigEng = Signature.getInstance("SHA1withRSA");
            sigEng.initVerify(publicKey);
            sigEng.update(src.getBytes(encode));
            byte[] sign1 = hex2Byte(sign);

            boolean aaa = sigEng.verify(sign1);
            System.out.println("验证结果：=====" + aaa + "=====");
            if (!aaa) {
                throw new Exception("验签失败");
            }
        } catch (Exception e) {
            throw new Exception("验签失败");
        }
    }

    /**
     * 1024位RSA公私钥对。
     *
     * @return 私钥、公钥
     */
    public static String[] genRSAKeyPair() {
        KeyPairGenerator rsaKeyGen = null;
        KeyPair rsaKeyPair = null;
        try {
            log.error("Generating a pair of RSA key ... ");
            rsaKeyGen = KeyPairGenerator.getInstance("RSA");
            SecureRandom random = new SecureRandom();
            random.setSeed(("" + System.currentTimeMillis() * Math.random() * Math.random()).getBytes(Charset
                    .forName("UTF-8")));
            rsaKeyGen.initialize(1024, random);
            rsaKeyPair = rsaKeyGen.genKeyPair();
            PublicKey rsaPublic = rsaKeyPair.getPublic();
            PrivateKey rsaPrivate = rsaKeyPair.getPrivate();

            String privateAndPublic[] = new String[2];
            privateAndPublic[0] = byte2Hex(rsaPrivate.getEncoded());
            privateAndPublic[1] = byte2Hex(rsaPublic.getEncoded());
            System.err.println("16私钥:" + privateAndPublic[0]);
            System.err.println("16公钥:" + privateAndPublic[1]);
            return privateAndPublic;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 得到私钥对象
     *
     * @param key 密钥字符串（经过16进制编码）
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String key) {
        try {
            byte[] keyBytes = hex2Byte(key);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            return keyFactory.generatePrivate(keySpec);
        } catch (Exception e) {
            String info = "getPrivateKey failed: " + key + " | " + e.getMessage();
            return null;
        }
    }

    /**
     * 获取公钥
     *
     * @param publicKey 公钥字符串
     * @return
     */
    public static PublicKey getPublicKey(String publicKey) throws Exception {
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        byte[] keyBytes = hex2Byte(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        return keyFactory.generatePublic(keySpec);
    }

    /** */
    /**
     * <p>
     * 私钥加密
     * </p>
     *
     * @param str        源数据
     * @param privateKey 私钥(16 进制)
     * @return 16进制加密数据
     * @throws Exception
     */
    public static String encryptByPrivateKey(String str, String privateKey) {

        try {
            byte[] keyBytes = hex2Byte(privateKey);
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PrivateKey privateK = keyFactory.generatePrivate(keySpec);

            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateK);
            byte[] data = str.getBytes("utf-8");
            int inputLen = data.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段加密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                    cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(data, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_ENCRYPT_BLOCK;
            }
            byte[] encryptedData = out.toByteArray();
            out.close();
            //转16进制
            String s = byte2Hex(encryptedData);
            return s;
        } catch (Exception e) {
            throw new RuntimeException("私钥加密错误");
        }
    }


    /** */
    /**
     * <p>
     * 公钥解密
     * </p>
     *
     * @param str       已加密数据(16进制)
     * @param publicKey 公钥(16进制)
     * @return 原数据
     * @throws Exception
     */
    public static String decryptByPublicKey(String str, String publicKey) {

        try {
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            byte[] keyBytes = hex2Byte(publicKey);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
            PublicKey publicK = keyFactory.generatePublic(keySpec);
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicK);
            //16进制数据转byte[]
            byte[] encryptedData = hex2Byte(str);
            int inputLen = encryptedData.length;
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            // 对数据分段解密
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                    cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
                } else {
                    cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * MAX_DECRYPT_BLOCK;
            }
            byte[] decryptedData = out.toByteArray();
            out.close();
            return new String(decryptedData);
        } catch (Exception e) {
            throw new RuntimeException("公钥解密错误");
        }
    }



    public static void main(String[] args) {
        //生成1024位16进制密钥
//        genRSAKeyPair();



//        私钥
        String privateKeyString = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAMjT4WYC7xFo5CRw\n" +
                "dHSseOsAqZKV2Ksrjp54yysba66TbVJ9Ai1WioCsP7WBkCSnMbECfb1jfJl37km2\n" +
                "moMMrhrKXNmrKhO5kEKLKZQZdg+/wVugFyzRhxEOIBbEQ6mIeyWVee4zkg+R9GIy\n" +
                "gt9mGhrAhBqqO1lZaAn5/iF43seLAgMBAAECgYAWRlH4w5iKoMy1MffovPyIbEFi\n" +
                "rdYjXihqcVFvjZILAfUdMhpctv2Tugcy9ZTsS9MaJAGYUQGP8Bpw+Jz4rh5dTebx\n" +
                "c8cqZ9NhI9h0gceGYJPyvtw7KdUnFRkYnlcj3vOwR9x793nJl1Yo0APCYl4jk7he\n" +
                "sm4YcCGY52uF7dQGuQJBAPQpRp5VJYuLXzsNNVkxIb27gpfTJVaYZoto2FqlpYhV\n" +
                "USRKGuTP+/5BZjJOBTRMaJvDqy15Ev/PrIm+8+5mvxUCQQDSkLazWyzVPfFAWO7I\n" +
                "3ICv/REtNdXkFQ6FYtYLzgusxFaNr75RsJsgeXfSQxD9RmPb2ipKeY3ertU25ZIl\n" +
                "gBQfAkBURKat4N9LcTfV7rIZ7X4iuMPS2LoLUCAcP3xklMUz75ZIuxbbH/luAG5g\n" +
                "MFNVgIWeNQMwd5gaGDgJdpFEF8wdAkAYkOWf2z1Jy6Y/2aBSMteYsK+2VJeVupct\n" +
                "HLDYQ7u89lMayKwtn6sZiNJf548t3W59EeDpO3E/z6n0c6gvU9gFAkBRxq0RXi/2\n" +
                "5wpEjeRd+tL30WrC2PoTVN6San5cPkv2k6vVWmZJAAMB6RKHtp+r7yUYLcEcrZOG\n" +
                "7ARIDVY19ou5";

        //公钥
        String publicKeyString = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDI0+FmAu8RaOQkcHR0rHjrAKmS\n" +
                "ldirK46eeMsrG2uuk21SfQItVoqArD+1gZAkpzGxAn29Y3yZd+5JtpqDDK4aylzZ\n" +
                "qyoTuZBCiymUGXYPv8FboBcs0YcRDiAWxEOpiHsllXnuM5IPkfRiMoLfZhoawIQa\n" +
                "qjtZWWgJ+f4heN7HiwIDAQAB";

        //私钥16进制
        byte[] bytes1 = Base64.decodeBase64(privateKeyString);
        String pri = byte2Hex(bytes1);

        //私钥16进制
        byte[] ddd = Base64.decodeBase64(publicKeyString);
        String pub = byte2Hex(ddd);

        try {
            //原数据
            String data = "123456";
            System.err.println("代签名数据：" + data);
            //签名
            String sign = sign(getPrivateKey(pri), data, "utf-8");
            System.err.println("私钥16签名:" + sign);
            //验证
            verify(getPublicKey(pub), sign, data, "utf-8");


            //私钥加密 数据转16进制
            String s = encryptByPrivateKey(data, pri);
            System.err.println("私钥加密：" + s);
            //公钥解密
            String s1 = decryptByPublicKey(s, pub);
            System.err.println("公钥解密：" + s1);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

 main运行后结果

代签名数据：123456
私钥16签名:885d59e3ff349d7fb03903e2304556ceadfea1bf38c972575d20489e69e4b178bc7076db216a9150e7beac7b263eb967fe9129c6c1d70e127d379d0fe048531e0083fb3cd7e8415f68c91f7f1756c0e50dc98866bb9004c0db402be7f1d8e8acd5d5365bffae1259d3d347f233bebc348e9a52ac4aebaa165eac0269015fc622
验证结果：=====true=====
私钥加密：41b200f969b3d25be82d13141c4a0f1c1058f8fd122ed3a19e2a5652a6ae8d7f790c422c29633b92166311322fd5b0e4fd06086c1b4e708b4c38513482a95d8b9f66a2f09ca48c0effd164263a2483e589acc24f30473b56cf78d60af9b66fa8701d8f071c4f197930f2c9abd4e360e356cfdd167fa35d2d6dde5bc5650d5f6f
公钥解密：123456 

Braveyzx
关注
专栏目录
加解密技术基本使用指南（Base64、Hex、AES、SM4、RSA 算法）
墨鸦的博客
04-07 9482
加解密技术基本使用指南（Base64、AES、RSA 算法）
十六进制解密,10进制和16进制之间的加密解密
05-16
软件没什么说明。。大家都是明白人。。 例子： 原始数据：00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 加密后数据：BC 2B 87 75 CF 2B BB 7C 91 55 B6 71 89 6B D6 A2
RSA加密中可加密数据的长度
泛在安防边缘智能视频分析
07-03 843
在RSA加密算法中，要编码的最大块大小取决于所选择的密钥长度。对于1024位密钥，最大块大小为117字节。这意味着，当使用1024位密钥时，您可以加密的最大数据块为117字节。对于2048位密钥，最大块大小为245字节。这意味着，当使用2048位密钥时，您可以加密的最大数据块为245字节。对于4096位密钥，最大块大小为512字节。这意味着，当使用4096位密钥时，您可以加密的最大数据块为512字节。请注意，实际上，您可能需要留出一些空间来容纳填充，因此实际可用的加密数据量可能会略小于上述最大块大小。
16进制解密题目及工具
08-15
16进制解密题目及工具，里面包含题目以及解题用到的工具
字符16进制加密/解密在线工具
热门推荐
WP8HUB
11-23 3万+
字符16进制加密/解密在线工具：http://www.atoolbox.net/Tool.php?Id=816 将文本加密成16进制形式。
AES加解密工具（支持16进制）.zip
07-27
AES加解密工具。网上大部分是文本工具，这个是支持16进制加解密，比较方便。
十六进制解码_快速十六进制编码和解码
cunchi8090的博客
07-18 1万+
十六进制解码 In 在 Easy String Encryption Using CryptoAPI in C++ I described how to encrypt text and recommended that the encrypted text be stored as a series of hexadecimal digits -- b...
RSA加解密与签名验签
人间师格
09-18 1509
1.RSA介绍 1.消息摘要 如果消息改变了，那么改变之后的消息的指纹和原消息的指纹将不匹配，如果消息的指纹和消息是分开传送的。那么接收者就可以检查消息是否被篡改过。但是，如果我同时知道了消息和指纹，就可以对消息重新计算指纹，那么消息接收者就不会知道消息被篡改了。解决这个问题就用到了RSA，公共密钥加密技术。RSA包括公共密钥和私有密钥。公钥可以告诉任何人。这些密钥之间存在一定的数
RSA加密解密及RSA签名和验证
暖暖冬阳
05-16 3538
<br /><br />/// <summary> <br />/// RSA加密解密及RSA签名和验证<br />/// </summary> <br />public class RSACryption <br />{ <br />public RSACryption() <br />{ <br />} <br /><br /> <br />#region RSA 加密解密 <br /> <br />#region RSA 的密钥产生 <br /><br />/// <summary><br />///
sshkey-cn 华为、思科、W3C RSA转16进制
05-24
标题“sshkey-cn 华为、思科、W3C RSA转16进制”暗示了这个工具或教程专注于将RSA密钥转换成16进制格式，特别针对华为、思科和W3C的环境。这可能是因为在特定的网络设备配置或系统集成中，有时需要以16进制的形式来...
PHP应用RSA加密解密和签名验签(复制黏贴就能用)
打代码是一天，不打代码也是一天
10-20 225
1. RSA类 /** * RSA算法类 * 签名及密文编码：base64字符串/十六进制字符串/二进制字符串流 * 填充方式: PKCS1Padding（加解密）/NOPadding（解密） * * Notice:Only accepts a single block. Block size is equal to the RSA key size! * 如密钥长度为1024 bit，则加密时数据需小于128字节，加上PKCS1Padding本身的11字节信息，所以明文需小于117字节 */
OpenSSL 中RSA16进制密钥生成方法
08-25
linux下openssl中非对称加密算法RSA的16进制密钥生成方法
hex:简单的十六进制字符串编码器解码器
06-09
hex - 编码和解码十六进制字符串 用于编码和解码十六进制字符串的简单工具。 用法： var hex = require('hex'); var encodedString = hex.encode('Hello world'); // encodedString == "48656c6c6f20776f726c64" var string = hex.decode('466f6f'); // string == 'Foo'
16进制解码工具
07-29
可以对16进制进行解码，解码成文字形式，可以对URL解码
16位的RSA加密、解密demo
04-04
源码RSADemo，做银行支付相关得会用到，只能在真机上运行，虚拟机上缺少相关得库文件 配置: 1、加入框架 Security.framework 2、添加路劲 在Build Settings ->搜索"search paths"->在Head Search Paths里面加入:$(PROJECT_DIR)/RSADemo/openSSL。
16进制加密_解密源代码和demo.exe
10-26
如题，16进制加密_解密源代码和demo.exe
rsa加解密代码
12-04
本资源包含了C++和Java两种编程语言实现的RSA加解密代码，非常适合学习和参考。 首先，我们来了解一下RSA算法的基本原理。RSA算法是由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出，因此得名RSA。该算法...
DES 与 RSA 加解密算法.ppt
07-03
本文档主要介绍了两种经典的加解密算法——DES（Data Encryption Standard，数据加密标准）和RSA（Rivest-Shamir-Adleman）。 #### 二、对称加密算法 **定义**：对称加密算法是指加密和解密过程中使用相同密钥的一...
RSA算法详解：万字文章详解RSA的加密与解密
最新发布
布啦啦
07-12 360
为了彻彻底底的研究明白RSA算法，真的是。。煞（lei）费（si）苦（wo）心（le），首先我希望自己前前后后、彻彻底底的琢磨明白，其次我也希望我把他分享出来以后，大家都能读得懂，这篇文章真的是我迄今为止写的又臭又长的一篇文章了，但是我能保证的是，你读完了以后，绝对不会再问RSA是啥玩意儿了。。
使用RSA公钥解密算法对一个1217位的公钥对（N，e）和1217位长的密文进行解密，得到10进制串，并转为16进制串，再将得到的16进制串转为中文输出
06-08
因此，我无法使用 RSA 私钥解密算法，只能使用 RSA 公钥加密算法对密文进行解密。 根据 RSA 公钥加密算法的原理，密文 c = m^e mod N，其中 m 为明文。因此，我们只需要使用给定的公钥 N 和 e 对密文进行解密即可...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值