精华内容
下载资源
问答
  • 数字签名算法

    2013-04-19 13:44:55
    纤细介绍了信息安全中的主要数字签名算法。RSA,DSS,ElGamal,Schnorr,Ecdsa等算法。
  • 实现数字签名算法以及验证数字签名算法的正确性。本程序经本人验证
  • 主要介绍了Java数字签名算法DSA,结合实例形式分析了Java数字签名算法DSA具体定义与使用技巧,需要的朋友可以参考下
  • 数字签名算法RSA

    2017-12-18 10:54:35
    1、数字签名算法可以看做是一个带有密钥的消息摘要算法,并且这个密钥包括了公钥和私钥。他是非对称加密算法和消息摘要算法的结合体 2、数字签名算法是公钥基础设施(PKI),以及许多网络安全机制的基础 3、...

    文章转自:http://blog.csdn.net/kongqz/article/details/6305548

    一、概述

    1、数字签名算法可以看做是一个带有密钥的消息摘要算法,并且这个密钥包括了公钥和私钥。他是非对称加密算法和消息摘要算法的结合体

    2、数字签名算法是公钥基础设施(PKI),以及许多网络安全机制的基础

    3、数字签名算法有抗否认的作用

    4、遵循“私钥签名,公钥验证”规则

    5、常见的数字签名算法有RSA/DSA/ECDSA

    6、java6支持实现了DSA算法、部分RSA算法需要bouncycastle支持,最牛的ECDSA算法(微软用来做操作系统序列号的那个)完全需要Bouncycastle支持


    二、模型分析

    1、甲方构造密钥对(公钥+私钥),公布公钥给乙方

    2、甲方使用私钥对数据进行签名,然后将“签名+数据” 发送给乙方

    3、乙方使用公钥+数字签名 验证数据

     

    三、代码分析

    package com.pptv.activityapi.util.rsa;
    
    import org.apache.commons.codec.binary.Base64;
    
    import java.security.*;
    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 kongqz
     * */
    public class RSACoder {
        //数字签名,密钥算法
        public static final String KEY_ALGORITHM="RSA";
    
        /**
         * 数字签名
         * 签名/验证算法
         * */
        public static final String SIGNATURE_ALGORITHM="MD5withRSA";
    
        /**
         * RSA密钥长度,RSA算法的默认密钥长度是1024
         * 密钥长度必须是64的倍数,在512到65536位之间
         * */
        private static final int KEY_SIZE=512;
        //公钥
        private static final String PUBLIC_KEY="RSAPublicKey";
    
        //私钥
        private static final String PRIVATE_KEY="RSAPrivateKey";
    
        /**
         * 初始化密钥对
         * @return Map 甲方密钥的Map
         * */
        public static Map<String,Object> initKey() throws Exception{
            //实例化密钥生成器
            KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance(KEY_ALGORITHM);
            //初始化密钥生成器
            keyPairGenerator.initialize(KEY_SIZE);
            //生成密钥对
            KeyPair keyPair=keyPairGenerator.generateKeyPair();
            //甲方公钥
            RSAPublicKey publicKey=(RSAPublicKey) keyPair.getPublic();
            //甲方私钥
            RSAPrivateKey privateKey=(RSAPrivateKey) keyPair.getPrivate();
            //将密钥存储在map中
            Map<String,Object> keyMap=new HashMap<String,Object>();
            keyMap.put(PUBLIC_KEY, publicKey);
            keyMap.put(PRIVATE_KEY, privateKey);
            return keyMap;
    
        }
    
    
        /**
         * 签名
         * @param data 待签名数据
         * @param privateKey 密钥
         * @return byte[] 数字签名
         * */
        public static byte[] sign(byte[] data,byte[] privateKey) throws Exception{
    
            //取得私钥
            PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(privateKey);
            KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
            //生成私钥
            PrivateKey priKey=keyFactory.generatePrivate(pkcs8KeySpec);
            //实例化Signature
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            //初始化Signature
            signature.initSign(priKey);
            //更新
            signature.update(data);
            return signature.sign();
        }
        /**
         * 校验数字签名
         * @param data 待校验数据
         * @param publicKey 公钥
         * @param sign 数字签名
         * @return boolean 校验成功返回true,失败返回false
         * */
        public static boolean verify(byte[] data,byte[] publicKey,byte[] sign) throws Exception{
            //转换公钥材料
            //实例化密钥工厂
            KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
            //初始化公钥
            //密钥材料转换
            X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(publicKey);
            //产生公钥
            PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);
            //实例化Signature
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            //初始化Signature
            signature.initVerify(pubKey);
            //更新
            signature.update(data);
            //验证
            return signature.verify(sign);
        }
        /**
         * 取得私钥
         * @param keyMap 密钥map
         * @return byte[] 私钥
         * */
        public static byte[] getPrivateKey(Map<String,Object> keyMap){
            Key key=(Key)keyMap.get(PRIVATE_KEY);
            return key.getEncoded();
        }
        /**
         * 取得公钥
         * @param keyMap 密钥map
         * @return byte[] 公钥
         * */
        public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{
            Key key=(Key) keyMap.get(PUBLIC_KEY);
            return key.getEncoded();
        }
        /**
         * @param args
         * @throws Exception
         */
        public static void main(String[] args) throws Exception {
            //初始化密钥
            //生成密钥对
            Map<String,Object> keyMap=RSACoder.initKey();
            //公钥
            byte[] publicKey=RSACoder.getPublicKey(keyMap);
    
            //私钥
            byte[] privateKey=RSACoder.getPrivateKey(keyMap);
            System.out.println("公钥:/n"+Base64.encodeBase64String(publicKey));
            System.out.println("私钥:/n"+Base64.encodeBase64String(privateKey));
    
            System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方,开始进行加密数据的传输=============");
            String str="RSA数字签名算法";
            System.out.println("原文:"+str);
            //甲方进行数据的加密
            byte[] sign=RSACoder.sign(str.getBytes(), privateKey);
            System.out.println("产生签名:"+Base64.encodeBase64String(sign));
            //验证签名
            boolean status=RSACoder.verify(str.getBytes(), publicKey, sign);
            System.out.println("状态:"+status+"/n/n");
    
    
        }
    }
    控制台输出:  
    公钥:  
    MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAJXmcnNTaWUnib5uMMQI2VCAq/rCPoFonlGHBVhDatRH  
    GLEkZ2z/PiT1RxrmBdRxAb50LoNYGUOvOCieOJqU4B8CAwEAAQ==  
    私钥:  
    MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAleZyc1NpZSeJvm4wxAjZUICr+sI+  
    gWieUYcFWENq1EcYsSRnbP8+JPVHGuYF1HEBvnQug1gZQ684KJ44mpTgHwIDAQABAkBUaU3f5YO/  
    Q7GMe+6YJceCTsMJ1WJvayNkE52N44EAAhkfmbpmhwdcRgo0CnzAsiXdPeB1inynbnv1ornu/AlZ  
    AiEA/iTqVvxeYFjaYfvi38OxfNNeqpBMiPjv3XlYzEs4vR0CIQCW/qm+3Lv9YpLlqWGipBBrHGfu  
    yv4spXxiY/mkbh4ZawIhAO14JvOSqsjSHXSS/WHipFSj2H/9h1YxbUf/3AZAf0rNAiA88cTpuIZY  
    G3VXJSq3Tqkh0nFQvLYipxixTdDxQVD8yQIhAIgXKKDfKeEXdmx3untvAo1zh3//MhVoo3JygBsR  
    gSYn  
    ================密钥对构造完毕,甲方将公钥公布给乙方,开始进行加密数据的传输=============  
    原文:RSA数字签名算法  
    产生签名:dxlBzv3voS7YDaaNCrUaIw7ITfHHDrdfwry9d5gSbMhKPWWfBecx0jA8jPmRuYQW2iViCDHUs3n7  
    Smu3VZDuZw==  
    状态:true  

    四、总结

    1、签名算法对非对称加密算法RSA的公钥私钥的使用是核心,配合信息摘要算法完成签名操作。其实签名看起来就是信息的摘要而已

    2、密钥处理方面和非对称加密算法无异,只是将加密、解密换成签名、验证

    3、RSA的数字签名算法的密钥实现与RSA加密算法一致。所以签名算法可以分为MD系列和SHA系列

    展开全文
  • 为此,在环签名理论、 Elgamal数字签名算法与PBFT算法的基础上,提出一种基于 Elgamal数字签名算法的环签名改进方案。对环签名算法进行正确性及匿名性分析,运用环签名方案改进PBFT算法的签名及验证过程,使用 ...
  • dsa数字签名算法Digital Signature Algorithm (DSA) is one of the Federal Information Processing Standard for making digital signatures depends on the mathematical concept or we can say the formulas of ...

    dsa数字签名算法

    Digital Signature Algorithm (DSA) is one of the Federal Information Processing Standard for making digital signatures depends on the mathematical concept or we can say the formulas of modular exponentiation and the discrete logarithm problem to cryptograph the signature digitally in this algorithm.

    数字签名算法(DSA)是使数字签名依赖于数学概念的联邦信息处理标准之一,或者我们可以说模幂运算的公式和离散对数问题,用于在该算法中对数字进行数字加密。

    It is Digital signatures are the public-key primitives of message authentication in cryptography. In fact, in the physical world, it is common to use handwritten signatures on handwritten or typed messages at this time. Mainly, they are used to bind signatory to the message to secure the message.

    数字签名是加密中消息身份验证的公钥原语。 实际上,在物理世界中,此时通常在手写或键入的消息上使用手写签名。 主要是,它们用于将签名者绑定到消息以保护消息。

    Therefore, a digital signature is a technique that binds a person or entity to the digital data of the signature. Now, this will binding can be independently verified by the receiver as well as any third party to access that data.

    因此,数字签名是一种将人或实体绑定到签名的数字数据的技术。 现在,此绑定将可以由接收者以及访问该数据的任何第三方独立验证。

    Here, Digital signature is a cryptographic value that is calculated from the data and a secret key known only by the signer or the person whose signature is that.

    在此, 数字签名是根据数据和仅由签名者或签名者知道的秘密密钥计算出的密码值。

    In fact, in the real world, the receiver of message needs assurance that the message belongs to the sender and he should not be able to hack the origination of that message for misuse or anything. Their requirement is very crucial in business applications or any other things since the likelihood of a dispute over exchanged data is very high to secure that data.

    实际上,在现实世界中,消息的接收者需要确保该消息属于发送者,并且他不应因滥用或其他任何原因而破解该消息的来源。 他们的要求在业务应用程序或其他任何事情中都至关重要,因为对交换数据进行争执的可能性很高,以确保数据的安全。

    数字签名框图 (Block Diagram of Digital Signature)

    The digital signature scheme depends on public-key cryptography in this algorithm.

    在此算法中,数字签名方案取决于公钥加密。

    DSA (1)

    框图说明 (Explanation of the block diagram)

    • Firstly, each person adopting this scheme has a public-private key pair in cryptography.

      首先,采用此方案的每个人在密码学上都有一个公私钥对。

    • The key pairs used for encryption or decryption and signing or verifying are different for every signature. Here, the private key used for signing is referred to as the signature key and the public key as the verification key in this algorithm.

      每个签名用于加密或解密以及签名或验证的密钥对都不相同。 在此算法中,用于签名的私钥称为签名密钥,公钥称为验证密钥。

    • Then, people take the signer feeds data to the hash function and generates a hash of data of that message.

      然后,人们将签名者的提要数据输入哈希函数,并生成该消息的数据哈希。

    • Now, the Hash value and signature key are then fed to the signature algorithm which produces the digital signature on a given hash of that message. This signature is appended to the data and then both are sent to the verifier to secure that message.

      现在,哈希值和签名密钥随后被馈送到签名算法,该算法在该消息的给定哈希值上生成数字签名。 该签名被附加到数据中,然后两者都发送到验证者以保护该消息。

    • Then, the verifier feeds the digital signature and the verification key into the verification algorithm in this DSA. Thus, the verification algorithm gives some value as output as a ciphertext.

      然后,验证者将数字签名和验证密钥输入此DSA中的验证算法。 因此,验证算法将一些值作为密文输出。

    • Thus, the verifier also runs the same hash function on received data to generate hash value in this algorithm.

      因此,验证程序还在此算法上对接收到的数据运行相同的哈希函数,以生成哈希值。

    • Now, for verification, the signature, this hash value, and output of verification algorithm are compared with each variable. Based on the comparison result, the verifier decides whether the digital signature is valid for this or invalid.

      现在,为了进行验证,将签名,此哈希值以及验证算法的输出与每个变量进行比较。 根据比较结果,验证者确定数字签名对此有效还是无效。

    • Therefore, the digital signature is generated by the 'private' key of the signer and no one else can have this key to secure the data, the signer cannot repudiate signing the data in the future to secure that data by the cryptography.

      因此,数字签名是由签名者的“私钥”生成的,没有其他人可以拥有此密钥来保护数据,签名者以后将无法否认对数据的签名以通过密码保护该数据。

    数字签名的重要性 (Importance of Digital Signature)

    Therefore, all cryptographic analysis of the digital signature using public-key cryptography is considered a very important or main and useful tool to achieve information security in cryptography in cryptoanalysis.

    因此,使用公钥密码术对数字签名进行的所有密码分析被认为是在密码分析中实现密码学信息安全性的非常重要或主要和有用的工具。

    Thus, apart from the ability to provide non-repudiation of the message, the digital signature also provides message authentication and data integrity in cryptography.

    因此,除了提供消息不可否认性的能力之外,数字签名还提供了加密中的消息认证和数据完整性。

    This is achieved by the digital signature are,

    这是通过数字签名实现的,

    • Message authentication: Therefore, when the verifier validates the digital signature using the public key of a sender, he is assured that signature has been created only by a sender who possesses the corresponding secret private key and no one else does by this algorithm.

      消息身份验证 :因此,当验证者使用发送方的公钥验证数字签名时,可以确保签名仅由拥有相应私钥的发送方创建,而该算法没有其他人创建。

    • Data Integrity: In fact, in this case, an attacker has access to the data and modifies it, the digital signature verification at the receiver end fails in this algorithm, Thus, the hash of modified data and the output provided by the verification algorithm will not match the signature by this algorithm. Now, the receiver can safely deny the message assuming that data integrity has been breached for this algorithm.

      数据完整性 :实际上,在这种情况下,攻击者可以访问数据并对其进行修改,该算法在接收方端的数字签名验证失败,因此,修改后的数据的哈希值和验证算法提供的输出将与该算法的签名不匹配。 现在,假设此算法已破坏数据完整性,则接收方可以安全地拒绝该消息。

    • Non-repudiation: Hence, it is just a number that only the signer knows the signature key, he can only create a unique signature on a given data of that message to change in cryptography. Thus, the receiver can present data and the digital signature to a third party as evidence if any dispute arises in the future to secure the data.

      不可否认性 :因此,只有签名者才知道签名密钥的数字,他只能在该消息的给定数据上创建唯一签名以更改密码。 因此,如果将来发生任何争议以保护数据,则接收方可以将数据和数字签名提供给第三方作为证据。

    带有数字签名的加密 (Encryption with Digital Signature)

    It is desirable to exchange encrypted messages than plaintext to achieve confidentiality in cryptography. In fact, in the public key encryption scheme, this is a public or encryption key of the sender is available in the open domain, and hence anyone can spoof his identity and send an encrypted message to the receiver in this algorithm.

    期望交换加密消息而不是明文以实现加密的机密性。 实际上,在公共密钥加密方案中,这是发件人的公共或加密密钥在开放域中可用,因此任何人都可以通过此算法欺骗其身份并将加密的消息发送给接收者。

    DSA (2)

    DSA算法步骤 (DSA Algorithm Steps)

    The first part of the DSA algorithm is the public key and private key generation through some steps, which can be told as:

    DSA算法的第一部分是通过一些步骤生成公钥和私钥,可以将其描述为:

    • Firstly, choose a prime number q, which is called the prime divisor in this.

      首先,选择质数q,在此称为质数除数。

    • Then, choose another primer number p, such that p-1 mod q = 0. p is called the prime modulus in this.

      然后,选择另一个引物编号p,以使p-1 mod q =0。在此将p称为质数模数。

    • Then, choose an integer g, such that 1 < g < p, g**q mod p = 1 and g = h**((p–1)/q) mod p. q is also called g's multiplicative order modulo p in this algorithm.

      然后,选择一个整数g,使得1 <g <p,g ** q mod p = 1且g = h **((p-1)/ q)mod p。 q在此算法中也称为g的乘数模p。

    • Then, choose an integer, such that 0 < x < q for this.

      然后,选择一个整数,例如0 <x <q。

    • Now, compute y as g**x mod p.

      现在,将y计算为g ** x mod p。

    • Thus, Package the public key as {p,q,g,y} is this.

      因此,将公钥打包为{p,q,g,y}就是这个。

    • And, Package the private key as {p,q,g,x} is this.

      并且,将私钥打包为{p,q,g,x}就是这个。

    Then, the second part of the DSA algorithm is the signature generation and signature verification in this algorithm, which can be told as:

    然后,DSA算法的第二部分是该算法中的签名生成和签名验证,可以这样说:

    Firstly, to generate a message signature, the sender can follow these further steps:

    首先,要生成消息签名,发送者可以按照以下进一步步骤操作:

    • Firstly, generate the message digest h, using a hash algorithm like SHA1.

      首先,使用类似于SHA1的哈希算法生成消息摘要h。

    • Then, generate a random number k, such that 0 < k < q.

      然后,生成一个随机数k,使得0 <k <q。

    • Then, Computer as (g**k mod p) mod q. If r = 0, select a different k.

      然后,将计算机作为(g ** k mod p)mod q。 如果r = 0,则选择另一个k。

    • And, Compute i, such that k*i mod q = 1. i is called the modular multiplicative inverse of k modulo q in this.

      并且,计算i,使得k * i mod q =1。在此,i被称为k模q的模乘逆。

    • Then, Compute s = i*(h+r*x) mod q. If s = 0, select a different k.

      然后,计算s = i *(h + r * x)mod q。 如果s = 0,则选择另一个k。

    • Thus, Package the digital signature as {r,s}.

      因此,将数字签名打包为{r,s}。

    Then, to verify a message signature, the receiver of the message and the digital signature can follow these further steps as:

    然后,为了验证消息签名,消息的接收者和数字签名可以按照以下其他步骤操作:

    • Firstly, Generate the message digest h, using the same hash algorithm.

      首先,使用相同的哈希算法生成消息摘要h。

    • Then, Compute w, such that s*w mod q = 1. w is called the modular multiplicative inverse of s modulo q in this.

      然后,计算w,使得s * w mod q =1。w在此称为s模q的模乘逆。

    • Then, Compute u1 = h*w mod q.

      然后,计算u1 = h * w mod q。

    • And, Compute u2 = r*w mod q.

      并且,计算u2 = r * w mod q。

    • Then, Compute v = (((g**u1)*(y**u2)) mod p) mod q.

      然后,计算v =((((g ** u1)*(y ** u2))mod p)mod q。

    • Wherever, If v == r, the digital signature is valid.

      无论何时,如果v == r,则数字签名均有效。

    Image Reference: https://www.tutorialspoint.com/cryptography/cryptography_digital_signatures.htm

    图片参考: https : //www.tutorialspoint.com/cryptography/cryptography_digital_signatures.htm

    翻译自: https://www.includehelp.com/cryptography/digital-signature-algorithm-dsa.aspx

    dsa数字签名算法

    展开全文
  • 数字签名算法DSA.pdf

    2021-09-14 17:37:20
    数字签名算法DSA.pdf
  • 数字签名算法ECDSA.pdf

    2021-09-14 17:37:20
    数字签名算法ECDSA.pdf
  • 数字签名算法RSA.pdf

    2021-09-14 17:37:20
    数字签名算法RSA.pdf
  • dsa数字签名算法.doc

    2020-08-01 00:13:52
    DSA数字签名算法 1 引言 为了确保数据传输的安全性不得不采取一系列的安全技术如加密技术数字签名身份认证密钥管理防火墙安全协议等其中数字签名就是实现网上交易安全的核心技术之一它可以保证信息传输的保密性数据...
  • ;消息认证码算法MAC(Message Authentication Code是含有密钥散列函数算法兼容了MD和SHA算法的特性并在此基础上加上了密钥;谢谢
  • 数字签名算法之RSA

    2020-10-21 14:33:38
    数字签名算法之RSA1.数字签名简述2. 模型分析3. 代码实现3.1 签名算法实现3.2 测试代码3.3 运行结果 1.数字签名简述 数字签名算法可以看做是一种带有密钥的消息摘要算法,并且这种密钥包含了公钥和私钥。也就是说...

    1.数字签名简述

    数字签名算法可以看做是一种带有密钥的消息摘要算法,并且这种密钥包含了公钥和私钥。也就是说数字签名算法是非对称加密算法和消息摘要算法的结合体。

    数字签名算法是公钥基础设施(PKI)以及许多网络安全机制(SSL/TLS、VPN等)的基础。

    数字签名算法能够验证数据的完整性、认证性以及抗否认性。

    数字签名算法遵循“私钥签名,公钥验证” 的签名/验证方式。

    数字签名算法主要包括 RSA、DSA和ECDSA共3种算法。其中,RSA算法源于整数因子分解问题,DSA和ECDSA算法源于离散对数问题。

    RSA既是加密/解密算法, 也是签名算法。

    DSA只有签名算法,其基于DSS算法。

    ECDSA算法是ECC算法与DSA算法的结合,想对于传统签名算法,具有速度快、强度高、签名短等优点,被广泛应用。

    2. 模型分析

    Alice作为发送方,Bob作为接收方,交互流程如下所示。
    在这里插入图片描述

    3. 代码实现

    Java与Bouncy Castle对RSA签名算法均有实现,具体细节如下表所示。

    算法密钥长度密钥长度默认值签名长度备注
    MD2withRSA、MD5withRSA、SHA1withRSA512~65536位(密钥长度必须是64的倍数)1024与密钥长度相同Java
    SHA224withRSA、SHA256withRSA、SHA384withRSA、SHA512withRSA 、RIPEMD128withRSA、RIPEMD160withRSA512~65536位(密钥长度必须是64的倍数)2048与密钥长度相同Bouncy Castle实现

    3.1 签名算法实现

    下面是Java对RSA数字签名的实现

    
    /**
         * 数字签名密钥算法
         */
        public static final String KEY_ALGORITHM = "RSA";
    
        /**
         * 数字签名
         * 签名/验证算法
         */
        public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    
        //公钥 Map Key
        private static final String PUBLIC_KEY = "RSAPublicKey";
        //私钥Map key
        private static final String PRIVATE_KEY = "RSAPrivateKey";
    
        /**
         * RSA密钥长度,默认1024位,密钥长度必须是64的倍数,范围512~65536位之间
         */
        private static final int KEY_SIZE = 512;
        
     public static byte[] sign(byte[] data, byte[] privateKey) throws Exception {
            //转换私钥材料
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privateKey);
            //实例化密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            //取私钥对象
            PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
            //实例化Signature
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            //初始化Signature
            signature.initSign(priKey);
            //更新
            signature.update(data);
            //签名
            return signature.sign();
        }
    
        public static boolean verity(byte[] data, byte[] publicKey, byte[] sign) throws  Exception{
            //转换公钥材料
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
            //实例化密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            //生成公钥
            PublicKey pubKey = keyFactory.generatePublic(keySpec);
            //实例化Signature
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
            //初始化Signature
            signature.initVerify(pubKey);
            //更新
            signature.update(data);
            //校验证
            return signature.verify(sign);
        }
    

    3.2 测试代码

     @Test
        public void rsaSignTest() throws Exception {
            //初始化密钥
            Map<String, Object> keyMap = RSACoder.initKey();
            byte[] publicKey = RSACoder.getPublicKey(keyMap);
            byte[] privateKey = RSACoder.getPrivateKey(keyMap);
            System.out.println("公钥:\n"+Base64.encodeToString(publicKey, Base64.DEFAULT));
            System.out.println("私钥:\n"+Base64.encodeToString(privateKey, Base64.DEFAULT));
    
            String inputStr = "RSA数字签名";
            byte[] data = inputStr.getBytes();
            //产生签名
            byte[] sign = RSACoder.sign(data, privateKey);
            System.out.println("签名:\t"+ Hex.toHexString(sign));
            //验证签名
            boolean status = RSACoder.verity(data, publicKey, sign);
            System.out.println("验签状态:\t"+ status);
            assertTrue(status);
        }
    

    3.3 运行结果

    2020-10-21 14:28:20.130 15667-15682/com.calvin.android.demo2 I/System.out: 公钥:
    2020-10-21 14:28:20.130 15667-15682/com.calvin.android.demo2 I/System.out: MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBALVI158wtZj4N7Fhndfr0SxspYaoVJAYTcgR1czsgnTy
    2020-10-21 14:28:20.130 15667-15682/com.calvin.android.demo2 I/System.out: Qz0cjuyVWqXFlxK3ZitLvuzuQqEKAHZkBSggBPxA660CAwEAAQ==
    2020-10-21 14:28:20.130 15667-15682/com.calvin.android.demo2 I/System.out: 私钥:
    2020-10-21 14:28:20.130 15667-15682/com.calvin.android.demo2 I/System.out: MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAtUjXnzC1mPg3sWGd1+vRLGylhqhU
    2020-10-21 14:28:20.130 15667-15682/com.calvin.android.demo2 I/System.out: kBhNyBHVzOyCdPJDPRyO7JVapcWXErdmK0u+7O5CoQoAdmQFKCAE/EDrrQIDAQABAkEApjyaxXbE
    2020-10-21 14:28:20.130 15667-15682/com.calvin.android.demo2 I/System.out: P/b2EynhtXugf61NiJLZoJ04zktUlCsZYiSu2V575e1uRahiv9Z9tO6otYbBQDb8DwtdjlgH0usw
    2020-10-21 14:28:20.131 15667-15682/com.calvin.android.demo2 I/System.out: 4QIhANlMi777d9j+QVB1tw16FblEXm1YFBAW4WxAoAtFkM4ZAiEA1ZJD+A3wlhNLe5L9Zo9t7dHm
    2020-10-21 14:28:20.131 15667-15682/com.calvin.android.demo2 I/System.out: qlrlyxDY5MOBq40XVLUCIFylfDeTM8f6r5JEfiVq1fRFqBTqprMtbjMfYp0rrc+RAiBPDGkt6fLv
    2020-10-21 14:28:20.131 15667-15682/com.calvin.android.demo2 I/System.out: iUq5/WjfSh01FijbSvOc2qp82cQn+/vztQIhAIe/Rez3m7xmEzvL45IOVxfw7x0dwexDXdGdIIjo
    2020-10-21 14:28:20.131 15667-15682/com.calvin.android.demo2 I/System.out: o9ak
    2020-10-21 14:28:20.135 15667-15682/com.calvin.android.demo2 I/System.out: 签名:	612945943b56154cc6dce2bb13597ca734f6be79ea6e86191d34378271143a65405feeb9cbec9a1327166efa285ca117123a5bb26f0eb900e161b3ceb7b35224
    2020-10-21 14:28:20.136 15667-15682/com.calvin.android.demo2 I/System.out: 验签状态:	true
    
    展开全文
  • RSA算法和RSA数字签名算法的实现

    热门讨论 2011-05-29 14:01:52
    RSA算法和RSA数字签名算法的实现,RSA算法和RSA数字签名算法的实现,RSA算法和RSA数字签名算法的实现
  • RSA数字签名算法

    千次阅读 2016-12-08 21:18:22
    数字签名算法签名具有安全性、抗否认性的特点 ,数字签名——带有密钥(公钥、私钥)的消息摘要算法,用于验证数据完整性、认证数据来源、抗否认,遵循OSI参考模型、私钥签名和公钥验证。常用数字签名算法RSA、DSA、...

    1、概述

    数字签名算法

    签名具有安全性、抗否认性的特点
    ,数字签名——带有密钥(公钥、私钥)的消息摘要算法,用于验证数据完整性、认证数据来源、抗否认,遵循OSI参考模型、私钥签名和公钥验证。常用数字签名算法RSA、DSA、ECDSA。

    RSA算法包括MD、SHA经典算法两类如下
    RSA分类
    DSA:仅包含数字签名,不能进行加密通信的。
    RSA:既能加解密,也包含数字签名。
    DSA
    ECDSA全名 Elliptic Curve Digital Signature Algorithm ,椭圆曲线数字签名算法
    优点:速度快、强度高、签名短

    2、模型

    rsa模型

    3、实现

    RSAUtil.java

    package com.pro.rsa;
    
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    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 org.apache.commons.codec.binary.Hex;
    
    public class RSAUtil {
        /**
         * 生成公钥和私钥
         * @return
         * @throws NoSuchAlgorithmException
         */
        public static HashMap<String, Object> getKeys() {
            HashMap<String, Object> map = new HashMap<String, Object>();
            KeyPairGenerator generator = null;
            try {
                generator = KeyPairGenerator.getInstance("RSA");
            } catch (Exception e) {
                return null;
            }
            generator.initialize(1024);
            KeyPair keyPair = generator.generateKeyPair();
            RSAPublicKey rsapubKey = (RSAPublicKey)keyPair.getPublic();
            RSAPrivateKey rsapriKey = (RSAPrivateKey)keyPair.getPrivate();
            map.put("pubKey", rsapubKey);
            map.put("priKey", rsapriKey);
            return map;
        }
        /**
         * 私密加密
         * @param data
         * @param priKey
         * @return
         * @throws Exception
         */
        public static String encryptByPriKey(String data, RSAPrivateKey priKey){
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(priKey.getEncoded());
            KeyFactory keyFactory;
            PrivateKey key;
            Signature sign;
            byte[] result = null;
            try {
                keyFactory = KeyFactory.getInstance("RSA");
                key = keyFactory.generatePrivate(keySpec);
                sign = Signature.getInstance("MD5withRSA");
                sign.initSign(key);
                sign.update(data.getBytes());// 处理的内容
                result = sign.sign();
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("rsa sign:"+Hex.encodeHexString(result));
            System.out.println("sign len:"+result.length+",str hex:"+Hex.encodeHexString(result).length());
            return Hex.encodeHexString(result);
        }
        /**
         * 公钥验证
         * @param data
         * @param pubKey
         * @param res
         * @return
         * @throws Exception
         */
        public static boolean decryptByPubKey(String data, RSAPublicKey pubKey, String res) {
            System.out.println("res len:"+res.length());
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey.getEncoded());
            KeyFactory keyFactory;
            PublicKey key;
            Signature sign;
            boolean result = false;
            try {
                keyFactory = KeyFactory.getInstance("RSA");
                key = keyFactory.generatePublic(x509KeySpec);
                sign = Signature.getInstance("MD5withRSA");
                sign.initVerify(key);
                sign.update(data.getBytes());
                result = sign.verify(Hex.decodeHex(res.toCharArray()));
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("rsa verify:"+result);
            return result;
        }    
    }

    RSA.java

    package com.pro.rsa;
    
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.util.HashMap;
    
    public class RSA {
    
        public final static String src = "hello world hello world hello world hello world hello world hello worldhello worldhello world hello world hello world hello world hello worldhello world hello world hello world hello world v hello world hello world hello world vhello world hello world";
        public final static String _src = "hello world hello world hello world hello world hello world hello worldhello worldhello world hello world hello world hello world hello worldhello world hello world hello world hello world v hello world hello world hello world vhello world hello world";
        public static void main(String[] args) {
            // 登录rosp返回给客户端
            HashMap<String, Object> map = RSAUtil.getKeys();
            RSAPublicKey pubKey = (RSAPublicKey) map.get("pubKey");
            RSAPrivateKey priKey = (RSAPrivateKey) map.get("priKey");
            // 客户端get提交给服务器
            String res= RSAUtil.encryptByPriKey(src, priKey);
            // 服务端验证
            RSAUtil.decryptByPubKey(_src, pubKey, res);
        }
    }
    
    展开全文
  • 国密SM2数字签名算法文档
  • 数字签名算法DSA

    千次阅读 2017-12-10 06:08:58
    一 介绍 ...DSA:Digital Signature Algorithm 数字签名算法 DSA仅包含数字签名 二 参数说明 三 代码实现 package com.imooc.security.dsa; import java.security.KeyFactory; import java
  • java 非对称加密算法 数字签名算法
  • 主要介绍了Java实现的数字签名算法RSA,结合完整实例形式详细分析了RSA算法的相关概念、原理、实现方法及操作技巧,需要的朋友可以参考下
  • 包含Base64 包含对称加密算法:DES,3DEA,AES,PBE 包含对称加密算法:DH,RAS,ElGamal 包含摘要算法:MD2,MD4...数字签名算法:RSA,DSA,ECDSA 详情请查看:http://blog.csdn.net/baidu_34012226/article/details/53331147
  • ECDSA数字签名算法

    千次阅读 2019-06-06 14:34:37
    ECDSA数字签名算法 2018年05月09日 10:42:19jacky_jin1阅读数:5349 一、ECDSA概述 椭圆曲线数字签名算法(ECDSA)是使用椭圆曲线密码(ECC)对数字签名算法(DSA)的模拟。ECDSA于1999年成为ANSI标准,并于2000年...
  • 密 码 学 原 理 高级密码算法之 SM9数字签名算法 1 符号及辅助算法 C O 目 2 数字签名算法 N T E N T 3 数字签名验证算法 录 1.符号及辅助算法 1.符号及辅助算法 1.符号及辅助算法 2. 数 字 签 名 算 法 3. 数 字 签...
  • 椭圆曲线数字签名算法(ECDSA)是使用椭圆曲线对数字签名算法(DSA)的模拟。ECDSA于1999年成为ANSI标准,并于2000年成为IEEE和NIST标准。椭圆曲线密码的单位比特强度要高于其他公钥体制。本文将详细论述ANSI X9.62...
  • RSA数字签名算法的具体实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,167
精华内容 29,266
关键字:

数字签名算法