密码技术学习(7.2)-在Java中的使用数字签名算法

最新推荐文章于 2024-08-11 02:24:28 发布
最新推荐文章于 2024-08-11 02:24:28 发布
阅读量430 收藏 1
点赞数
分类专栏： 信息安全 文章标签： 密码学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laozhaishaozuo/article/details/82025695
版权

文章目录

RSA（经典数字签名算法）

RSASignCoder

RSASignCoderTest

DSA（数字签名标准算法）

DSACoder

DSACoderTest

ECDSA（椭圆曲线数字签名算法）

ECDSACoder

ECDSACoderTest

参考资料

本系列其他文章

RSA（经典数字签名算法）

RSA数字签名算法主要可分为MD系列和SHA系列两大类。MD系列主要包括MD2withRSA和MD5withRSA；SHA系列主要包括SHA1withRSA、SHA224withRSA、SHA256withRSA、SHA384withRSA和SHA512withRSA。 
RSA数字签名生成的签名长度与密钥长度相同。

RSASignCoder

import java.security.GeneralSecurityException;
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.Signature;
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;

/**
 * RSA 数字签名
 * 
 * @author shaozuo
 * @date 2018/08/08
 */
public class RSASignCoder {
    public static final String ALGORITHM_NAME = "RSA";

    private RSASignCoder() {

    }

    private static final String SIGNATURE_ALGORITHM = "MD5WithRSA";

    private static final int KEY_SIZE = 512;
    private static final String PUBLIC_KEY = "public_key";
    private static final String PRIVATE_KEY = "private_key";

    /**
     * 初始化公钥
     * 
     * @return Map 密钥map
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM_NAME);
        keyPairGenerator.initialize(KEY_SIZE);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        Map<String, Object> keyMap = new HashMap<>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    public static byte[] getPrivateKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }

    public static byte[] getPublicKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }

    /**
     * 签名
     * 
     * @param data
     *            待签名数据
     * @param encodedPriviteKey
     *            私钥
     * @return byte[] 签名数据
     * @throws GeneralSecurityException
     */
    public static byte[] sign(byte[] data, byte[] encodedPriviteKey)
            throws GeneralSecurityException {
        PKCS8EncodedKeySpec encodedKeySpec = new PKCS8EncodedKeySpec(encodedPriviteKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_NAME);
        PrivateKey privateKey = keyFactory.generatePrivate(encodedKeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateKey);
        signature.update(data);
        return signature.sign();
    }

    /**
     * 校验
     * 
     * @param data
     *            待校验数据
     * @param encodedPublicKey
     *            公钥
     * @param sign
     *            数字签名
     * @return boolean 校验是否通过
     * @throws GeneralSecurityException
     */
    public static boolean verfiy(byte[] data, byte[] encodedPublicKey, byte[] sign)
            throws GeneralSecurityException {
        X509EncodedKeySpec encodedKeySpec = new X509EncodedKeySpec(encodedPublicKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_NAME);
        PublicKey publicKey = keyFactory.generatePublic(encodedKeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicKey);
        signature.update(data);
        return signature.verify(sign);
    }
}

RSASignCoderTest

import static org.junit.Assert.assertTrue;

import java.util.Map;

import org.apache.commons.codec.binary.Base64;
import org.junit.Before;
import org.junit.Test;

public class RSASignCoderTest {
    // 公钥
    private byte[] publicKey;
    // 私钥
    private byte[] privateKey;

    String rawStrForSign = "RSA 数字签名";

    @Before
    public final void initKey() throws Exception {
        Map<String, Object> keyMap = RSACoder.initKey();
        publicKey = RSASignCoder.getPublicKey(keyMap);
        privateKey = RSASignCoder.getPrivateKey(keyMap);

        System.out.println("公钥: " + Base64.encodeBase64String(publicKey));
        System.out.println("私钥: " + Base64.encodeBase64String(privateKey));

    }

    @Test
    public void testSign() throws Exception {
        System.out.println("待签名数据：" + rawStrForSign);
        byte[] data = rawStrForSign.getBytes();
        byte[] sign = RSASignCoder.sign(data, privateKey);
        System.out.println("数字签名: " + Base64.encodeBase64String(sign));

        boolean status = RSASignCoder.verfiy(data, publicKey, sign);
        System.out.println("验证结果是：" + status);

        assertTrue(status);
    }
}

DSA（数字签名标准算法）

与RSA相比，DSA仅包含数字签名算法，使用DSA算法的数字证书无法进行加密通讯；而RSA算法既包含加密/解密算法，同时兼有数字签名算法。 
DSA算法的签名长度与算法无关，且不唯一。

DSACoder

import java.security.GeneralSecurityException;
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.Signature;
import java.security.interfaces.DSAPrivateKey;
import java.security.interfaces.DSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * DSA 数字签名
 * 
 * @author shaozuo
 * @date 2018/08/08
 */
public class DSACoder {
    public static final String ALGORITHM_NAME = "DSA";

    private DSACoder() {

    }

    private static final String SIGNATURE_ALGORITHM = "SHA1WithDSA";

    private static final int KEY_SIZE = 512;
    private static final String PUBLIC_KEY = "public_key";
    private static final String PRIVATE_KEY = "private_key";

    /**
     * 初始化公钥
     * 
     * @return Map 密钥map
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM_NAME);
        keyPairGenerator.initialize(KEY_SIZE);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        DSAPublicKey publicKey = (DSAPublicKey) keyPair.getPublic();
        DSAPrivateKey privateKey = (DSAPrivateKey) keyPair.getPrivate();

        Map<String, Object> keyMap = new HashMap<>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    public static byte[] getPrivateKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }

    public static byte[] getPublicKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }

    /**
     * 签名
     * 
     * @param data
     *            待签名数据
     * @param encodedPriviteKey
     *            私钥
     * @return byte[] 签名数据
     * @throws GeneralSecurityException
     */
    public static byte[] sign(byte[] data, byte[] encodedPriviteKey)
            throws GeneralSecurityException {
        PKCS8EncodedKeySpec encodedKeySpec = new PKCS8EncodedKeySpec(encodedPriviteKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_NAME);
        PrivateKey privateKey = keyFactory.generatePrivate(encodedKeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateKey);
        signature.update(data);
        return signature.sign();
    }

    /**
     * 校验
     * 
     * @param data
     *            待校验数据
     * @param encodedPublicKey
     *            公钥
     * @param sign
     *            数字签名
     * @return boolean 校验是否通过
     * @throws GeneralSecurityException
     */
    public static boolean verfiy(byte[] data, byte[] encodedPublicKey, byte[] sign)
            throws GeneralSecurityException {
        X509EncodedKeySpec encodedKeySpec = new X509EncodedKeySpec(encodedPublicKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_NAME);
        PublicKey publicKey = keyFactory.generatePublic(encodedKeySpec);
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicKey);
        signature.update(data);
        return signature.verify(sign);
    }
}

DSACoderTest

import static org.junit.Assert.assertTrue;

import java.util.Map;

import org.apache.commons.codec.binary.Base64;
import org.junit.Before;
import org.junit.Test;

public class DSACoderTest {
    // 公钥
    private byte[] publicKey;
    // 私钥
    private byte[] privateKey;

    String rawStrForSign = "DSA 数字签名";

    @Before
    public final void initKey() throws Exception {
        Map<String, Object> keyMap = DSACoder.initKey();
        publicKey = DSACoder.getPublicKey(keyMap);
        privateKey = DSACoder.getPrivateKey(keyMap);

        System.out.println("公钥: " + Base64.encodeBase64String(publicKey));
        System.out.println("私钥: " + Base64.encodeBase64String(privateKey));

    }

    @Test
    public void testSign() throws Exception {
        System.out.println("待签名数据：" + rawStrForSign);
        byte[] data = rawStrForSign.getBytes();
        byte[] sign = DSACoder.sign(data, privateKey);
        System.out.println("数字签名: " + Base64.encodeBase64String(sign));

        boolean status = DSACoder.verfiy(data, publicKey, sign);
        System.out.println("验证结果是：" + status);

        assertTrue(status);
    }
}

ECDSA（椭圆曲线数字签名算法）

ECDSA算法可能大家都不熟悉，但是如果提到微软操作系统或办公软件的序列号，大家就应该很熟悉了，而序列号的验证算法就是使用的ECDSA算法。

ECDSACoder

import java.math.BigInteger;
import java.security.GeneralSecurityException;
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.Signature;
import java.security.interfaces.ECPrivateKey;
import java.security.interfaces.ECPublicKey;
import java.security.spec.ECFieldFp;
import java.security.spec.ECParameterSpec;
import java.security.spec.ECPoint;
import java.security.spec.EllipticCurve;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

/**
 * ECDSA 数字签名
 * 
 * @author shaozuo
 * @date 2018/08/08
 */
public class ECDSACoder {
    public static final String ALGORITHM_NAME = "ECDSA";

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

    private ECDSACoder() {

    }

    private static final String SIGNATURE_ALGORITHM = "SHA512WithECDSA";

    private static final int KEY_SIZE = 512;
    private static final String PUBLIC_KEY = "ECDSAPublicKey";
    private static final String PRIVATE_KEY = "ECDSAPrivateKey";

    /**
     * 初始化密钥
     * 
     * @return
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws GeneralSecurityException {
        BigInteger p = new BigInteger(
                "883423532389192164791648750360308885314476597252960362792450860609699839");

        ECFieldFp ecFieldFp = new ECFieldFp(p);

        BigInteger a = new BigInteger(
                "7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc",
                16);

        BigInteger b = new BigInteger(
                "6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a",
                16);

        EllipticCurve ellipticCurve = new EllipticCurve(ecFieldFp, a, b);

        BigInteger x = new BigInteger(
                "110282003749548856476348533541186204577905061504881242240149511594420911");

        BigInteger y = new BigInteger(
                "869078407435509378747351873793058868500210384946040694651368759217025454");

        ECPoint g = new ECPoint(x, y);

        BigInteger n = new BigInteger(
                "883423532389192164791648750360308884807550341691627752275345424702807307");

        ECParameterSpec ecParameterSpec = new ECParameterSpec(ellipticCurve, g,
                n, 1);

        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM_NAME);
        keyPairGenerator.initialize(ecParameterSpec, new SecureRandom());

        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        // 公钥
        ECPublicKey publicKey = (ECPublicKey) keyPair.getPublic();

        // 私钥
        ECPrivateKey privateKey = (ECPrivateKey) keyPair.getPrivate();

        Map<String, Object> keyMap = new HashMap<String, Object>(2);

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

        return keyMap;
    }

    /**
     * 取得私钥
     * 
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static byte[] getPrivateKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }

    /**
     * 取得公钥
     * 
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static byte[] getPublicKey(Map<String, Object> keyMap) {
        Key key = (Key) keyMap.get(PUBLIC_KEY);

        return key.getEncoded();
    }

    /**
     * 签名<br>
     * 用私钥签名
     * 
     * @param data
     * @param encodedPrivateKey
     * @return
     * @throws Exception
     */
    public static byte[] sign(byte[] data, byte[] encodedPrivateKey)
            throws GeneralSecurityException {

        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(encodedPrivateKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_NAME);

        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateKey);
        signature.update(data);
        return signature.sign();

    }

    /**
     * 验证<br>
     * 用公钥验证
     * 
     * @param data
     * @param encodedPublicKey
     * @param sign
     * @return
     * @throws Exception
     */
    public static boolean verify(byte[] data, byte[] encodedPublicKey, byte[] sign)
            throws GeneralSecurityException {
        // 取得公钥
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(encodedPublicKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM_NAME);

        PublicKey publicKey = keyFactory
                .generatePublic(x509KeySpec);

        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicKey);
        signature.update(data);
        return signature.verify(sign);
    }
}

ECDSACoderTest

import static org.junit.Assert.assertTrue;

import java.util.Map;

import org.apache.commons.codec.binary.Base64;
import org.junit.Before;
import org.junit.Test;

public class ECDSACoderTest {
    // 公钥
    private byte[] publicKey;
    // 私钥
    private byte[] privateKey;

    String rawStrForSign = "ECDSA 数字签名";

    @Before
    public final void initKey() throws Exception {
        Map<String, Object> keyMap = ECDSACoder.initKey();
        publicKey = ECDSACoder.getPublicKey(keyMap);
        privateKey = ECDSACoder.getPrivateKey(keyMap);

        System.out.println("公钥: " + Base64.encodeBase64String(publicKey));
        System.out.println("私钥: " + Base64.encodeBase64String(privateKey));

    }

    @Test
    public void testSign() throws Exception {
        System.out.println("待签名数据：" + rawStrForSign);
        byte[] data = rawStrForSign.getBytes();
        byte[] sign = ECDSACoder.sign(data, privateKey);
        System.out.println("数字签名: " + Base64.encodeBase64String(sign));

        boolean status = ECDSACoder.verify(data, publicKey, sign);
        System.out.println("验证结果是：" + status);

        assertTrue(status);
    }
}

参考资料

  1. Java加密与解密的艺术 链接
  2. 数字签名算法 百度百科
  3. Jdk支持的算法官方文档

本系列其他文章

密码技术学习系列文章

醉引花眠
关注
专栏目录
国密算法全解析：Java世界中的安全密码术
java专栏
07-20 891
国密算法，全称国家商用密码算法，是中国自主研发的密码算法。🇨🇳 它们包括SM2、SM3、SM4等，每一种算法都有其独特的功能和应用场景。随着我们一步步深入探索国密算法的世界，从基础概念到实际应用，再到安全性分析和未来展望，我们不仅揭开了国密算法的神秘面纱，也学会了如何将这些强大的工具应用到现实世界中。🚀基础概念：我们了解了国密算法的定义、分类和数学基础。Java实现：我们学习了如何在Java中实现SM2、SM3和SM4算法。实际应用：我们探讨了国密算法在数据传输和身份认证中的应用。安全性分析。
强化学习：在区块链技术中的应用
程序员光剑
05-24 291
强化学习：在区块链技术中的应用 作者：禅与计算机程序设计艺术 1. 背景介绍 1.1 区块链技术概述 区块链技术作为一种去中心化的分布式账本技术，近年来得到了快速发展和广泛应用。其核心特点包括去中心化、透明性、安全性和不可篡改性
java针对sign签名的操作
lzlnd的博客
11-06 1909
package com.jeedan.rest.web; import org.apache.commons.lang3.RandomStringUtils; import java.security.MessageDigest; import java.util.Iterator; import java.util.Map.Entry; import java.util.Set; import java.util.SortedMap; import java.util.TreeMap; publi.
java实现数字签名算法
他叫阿来
02-06 4090
文章目录前言一、数字签名简述二、数字签名算法家谱三、代码实现1.引入jar包2.RSA数字签名实现总结 前言 数字签名是手写签名在计算机软件应用中的一种体现，同样起到了抗否认的作用。本文介绍什么是数字签名，以及如何用java代码实现数字签名。 一、数字签名简述 数字签名算法可以看做是一种带有密钥的消息摘要算法，并且这种密钥包含了公钥和私钥。也就是说，数字签名算法是非对称加密算法和消息摘要算法的结合体。 签名操作只能由甲方完成，验证签名操作则由乙方来完成，用于验证操作的相关信息是由甲方公布给乙方。 与摘要
数字签名算法
weixin_34335458的博客
08-30 486
RSA、DSA和ECDSA三种算法。 通常是先对消息做摘要处理，然后使用私钥对摘要值进行签名处理；验证时，使用公钥验证消息的摘要值。 publicclassRSASin { privatestaticfinalStringKEY_ALGORITHM="RSA"; pub...
rsa签名算法 java_JAVA中RSA签名算法实现
weixin_32367041的博客
02-15 520
import java.security.InvalidKeyException;import java.security.Key;import java.security.KeyFactory;import java.security.KeyPair;import java.security.KeyPairGenerator;import java.security.NoSuchAlgorith...
Java学习笔记
VanMonday的博客
05-12 1090
兰智数加Java学习笔记
Python机器学习实战：采用机器学习技术对网络流量进行分析
最新发布
程序员光剑
08-11 423
1. 背景介绍 1.1 网络流量分析的意义 网络流量分析是网络安全、网络管理和网络优化等领域的关键技术。通过对网络流量进行深入分析，我们可以： 识别网络攻击: 检测恶意软件、DDoS攻击、入侵企图等安全威胁。
AI代理在网络安全中的工作流及应用实践
程序员光剑
08-11 449
1. 背景介绍 1.1 网络安全形势日益严峻 随着互联网的快速发展和普及，网络安全问题日益突出。黑客攻击手段层出不穷，攻击目标也从个人用户扩展到企业、政府等重要机构。传统的网络安全防御手段已经难以应对日益复杂的网络攻击，亟需新的技术手段来提升网络安全防御能力。
JAVA ECC 椭圆曲线加密算法源代码
02-24
JAVA ECC 椭圆曲线加密算法源代码， 公钥 String publicKey = ECCCoder.getPublicKey(keyMap); 私钥 String privateKey = ECCCoder.getPrivateKey(keyMap); 加密 byte[] encodedData = ECCCoder.encrypt(data, publicKey); 解密 byte[] decodedData = ECCCoder.decrypt(encodedData, privateKey);
几个数字签名的算法实现
royu826的专栏
12-11 1235
从今年的7月20号起，开始在北京的一家IC企业实习。刚开始leader给我分配了几个加密解密和数字签名的算法（MD5、SHA2、RSA、ECC），用C语言来实现。呵呵，C的最基本的东西都忘记了。函数定义、调用，参数传递和返回值，这些一一都记不清了！不过没有办法，这是分配给我的任务，我只有努力去做。还好，经过了几个月的编写（10月份之前），不仅算法编写完了，而且对C也由原来肤浅的知识突然觉得自己俨然已经成为一个大虾了，^_^。当我敲完代码运行，结果正确的时候，虽然我在同事前表现地那么平淡，那么自然，但是我的内
RSA签名（0-1）调试过程
weixin_44669831的博客
05-23 393
RSA 加密使用记录 过程中遇到的问题 ##（问题都是小白不懂 一起调试完毕） 首先接口文档中明确指出要使用RSA加密传输 并且data形式传递数据、 在调试时发现我们这是用的RSA签名 ： 所以签名只需要 对数据进行签名 拿到数据进行验签就行（一般都是私钥签名 公钥来验签） 而加密是对传输数据进行加密 接受到的数据进行解密处理 （一般都是公钥加密 私钥解密） 这是具体签名和加密的区别很详细： https://blog.csdn.net/weixin_30827565/article/detail
RSA加密、解密、签名、验签的原理及方法
扛麻袋的少年的博客
04-24 6043
一、RSA加密简介   RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。两者之间有数学相关，该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥，公钥是公开的（可能同时多人持有）。 二、RSA加密、签名区别   加密和签名都是为了安全性考虑，但略有不同。常有人问加密和签名是用私钥还是公钥？其实都是对加密和签名的作用有所混淆。简单的说，加密是为了防
RSA加解密工具类
yuer629
08-07 692
package com.fh.util; import javax.crypto.Cipher; import Decoder.BASE64Decoder; import Decoder.BASE64Encoder; import java.io.ByteArrayOutputStream; import java.security.*; import java.security.inte...
saml 数字签名校验
sping_的专栏
06-04 1399
private String publicKey; 44. private String privateKey; 45. 46. @Before 47. public void setUp() throws Exception { 48. Map keyMap = RSACoder.initKey(); 49. 50...
RSA加密算法补充签名验签部分
程序袁小黑
04-04 7034
小编很早之前写过一篇文章：RSA加密算法 以前封装的这一套还不错。但是缺少网络中经常要使用到的签名验签部分，所以在这里补充一下。 先晒一下总的封装： package com.taldh; /* * Copyright 2013 WeCode authors * * Licensed under the WeCode, Version 1.0 (the "License"); * ...
RSA加密解密及数字签名Java实现
weixin_33906657的博客
10-25 231
2019独角兽企业重金招聘Python工程师标准>>> ...
数字签名算法之RSA
虎哥LoveDroid
10-21 6529
数字签名算法之RSA1.数字签名简述2. 模型分析3. 代码实现3.1 签名算法实现3.2 测试代码3.3 运行结果 1.数字签名简述 数字签名算法可以看做是一种带有密钥的消息摘要算法，并且这种密钥包含了公钥和私钥。也就是说数字签名算法是非对称加密算法和消息摘要算法的结合体。 数字签名算法是公钥基础设施（PKI）以及许多网络安全机制（SSL/TLS、VPN等）的基础。 数字签名算法能够验证数据的完整性、认证性以及抗否认性。 数字签名算法遵循“私钥签名，公钥验证” 的签名/验证方式。 数字签名算法主要包括 R
GP-PROV7.2中文编程软件使用手册
总结来说，GP-PROV7.2中文手册是指导用户有效利用Pro-face人机界面编程软件的重要参考资料，涵盖了软件的使用、版权信息、法律责任以及可能的技术差异，确保用户在遵守规定的同时，能充分利用软件功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值