精华内容
下载资源
问答
  • 非对称加密算法之RSA算法实现
    千次阅读
    2018-08-01 00:38:31

    对称加密,非对称加密,公钥,私钥,RSA这些常常听到的,到底是怎么回事

    有个同事问我公钥私钥到底为什么能互相解开,一时语塞,平时都只是知道怎么用,但很少去了解的更细,现在做个整理,记个笔记

    非对称加密简述

    公钥加密后的密文,只有私钥才能解密
    简单来说,A和B要互相通信,A生成一个公钥和一个私钥,
    A将公钥传给B,
    此时B将公钥和真正的数据M加密,生成密文是N,
    B再将N通过网络传给A,
    A再通过秘钥将N解密,得到真正的数据M

    公钥私钥原理(特指RSA算法)

    网上抄的,但要理解
    RSA算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但是想要对其乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥。

     算法描述:
    (1)选择两个不同的大素数p和q;
    // p=3,q=11
    
    (2)计算乘积n=pq和Φ(n)=(p-1)(q-1);
    //n=33,Φ(n)=20
    
    (3)选择大于1小于Φ(n)的随机整数e,使得gcd(e,Φ(n))=1;//gcd即最大公约数。
    //e和Φ(n)的最大公约数为1,也就是e只要不被Φ(n)整除就行,假如取e=3
    
    (4)计算d使得d*e=1mod Φ(n);注:即d*e mod Φ(n) =1。//mod是求余函数
    //d*e与1关于Φ(n)同余,1除以20余数是1,那么说明d*3除以20,余数也是1
    //即3d=20k+1,k是整数,可取得d=7
    
    (5)对每一个密钥k=(n,p,q,d,e),定义加密变换为Ek(x)=xe mod n,
    解密变换为Dk(x)=yd mod n,这里x,y∈Zn;
    
    (6)p,q销毁,以{e,n}为公开密钥,{d,n}为私有密钥。
    
    实例:
    1. 假设p = 3、q = 11(p,q都是素数即可。),则N = pq = 33;
    2. r =Φ(n)= (p-1)(q-1) = (3-1)(11-1) = 20;
    3. 根据gcd(e,Φ(n))=1,即gcd(e,20)=1,令e=3,则,d = 7。
    (两个数交换一下也可以。)
    
    到这里,公钥和密钥已经确定。公钥为(N, e) = (33, 3),密钥为(N, d) = (33, 7)。
    

    扩展:
    1.RSA详解
    2.RSA算法原理一
    3.RSA算法原理二


    java代码简约版实现:

    package com.rsa;
    
    /**
     * Created by zhangshuai on 2018/7/31.
     */
    public class RsaTest {
        /**
         * RSA算法
         * @param baseNum 基数
         * @param key 公钥或密钥
         * @param message 加密或者解密的数据
         * @return
         */
        public static long rsa(int baseNum, int key, long message){
            if(baseNum < 1 || key < 1){
                return 0L;
            }
            //加密或者解密之后的数据
            long rsaMessage = 0L;
            double pow = Math.pow(message, key);
            System.out.println("pow="+pow);
            long round = Math.round(pow);
            System.out.println("roud="+round);
            //核心算法
            rsaMessage = Math.round(Math.pow(message, key)) % baseNum;
            return rsaMessage;
        }
    
        public static void main(String[] args){
            //基数
            int baseNum = 3 * 11;
            //公钥
            int keyPublic = 3;
            //密钥
            int keyPrivate = 7;
            //未加密的数据
            long msg = 24L;
            //获得公钥加密后的数据
            long encodeMsg = rsa(baseNum, keyPublic, msg);
            //获得私钥解密后的数据
            long decodeMsg = rsa(baseNum, keyPrivate, encodeMsg);
    
            System.out.println("加密前:" + msg);
            System.out.println("加密后:" + encodeMsg);
            System.out.println("解密后:" + decodeMsg);
        }
    }
    
    

    结果:

    pow=13824.0
    roud=13824
    pow=2.187E10
    roud=21870000000
    加密前:24
    加密后:30
    解密后:24
    
    更多相关内容
  • 1、实现RSA算法密匙n、e、d 的自动生成; 2、根据当前的密匙对输入数字进行加解密; 3、根据当前的密匙对输入的字符进行加解密(为保证加密的可靠性,加密后原来的一个字符对应5个16进制字符); 4、代码完全...
  • rsa算法实现

    2013-12-13 15:31:17
    rsa算法 openssl实现 C语言 gcc -o HelloPlus HelloPlus.c -lcrypto
  • RSA算法实现

    2019-01-16 14:33:46
    一种RSA实现步骤,实现方法。实现语言可以自行选择。
  • RSA算法C++实现源码

    2016-11-01 15:40:00
    RSA算法C++实现源码
  • 密码学中的RSA 算法的java代码实现,其中有模的重复平方计算法和中国剩余定理
  • 简单的基于数字加解密的RSA算法实现。对于私钥的生成,加、解密的算法还有待改进。
  • RSA实现算法报告关于RSA算法实现代码
  • RSA算法Java实现

    2019-03-23 16:27:06
    RSAPrivateKey prk = (RSAPrivateKey) b.readObject(); BigInteger d = prk.getPrivateExponent(); // 获取私钥参数及解密 BigInteger n = prk.getModulus(); System.out.println("d= " + d); System.out...
  • 编写求最大公因子的函数; 编写求模逆的扩展欧几里得算法函数; 编写rabin-miller素性检测算法函数; 编写生成大素数的算法函数; 编写生成RSA公私钥对的函数; 编写RSA加密和解密函数;

    题目👇

     

    1. 编写求最大公因子的函数;
    2. 编写求模逆的扩展欧几里得算法函数;
    3. 编写rabin-miller素性检测算法函数;
    4. 编写生成大素数的算法函数;
    5. 编写生成RSA公私钥对的函数;
    6. 编写RSA加密和解密函数;

    思路分析👇

    1.这里传进两个参数,我的思路是从较小的数中倒序遍历出最大公因子。

    倒序的原因是你一旦找到某个公因子,那么它一定是最大的公因子,可以节省时间。

    另外还要对异常作出相应处理,如果参数中有0存在就返回-1,如果参数中有负数存在就将其转化成正数来处理。

    2.扩展欧几里得算法的具体步骤如下:

    ①若b≠0,使用带余除法,用b除以a得到余数r;否则转到第③步

    ②用b代替a,用r代替 b,重复第①步

    ③a的值就是最大公约数d

    3.算法基于费马小定理,首先,根据Miller Rabin算法的过程:

    假设需要判断的数是p,我们把p−1分解为2k∗t的形式;

    当p是素数,有a2k∗t≡1(modp),然后随机选择一个数a,计算出at(mod p),让其不断的自乘,同时结合二次探测定理进行判断。

    如果我们自乘后的数(modp)=1,但是之前的数(modp)≠±1,那么这个数就是合数(违背了二次探测定理)。

    这样乘k次,最后得到的数就是ap−1,那么如果最后计算出的数不为1,这个数也是合数(费马小定理)。

    4.生成指定比特位大小的随机数,利用刚才设计的Miller-Rabin算法来检验是否是素数,如果不是素数还需要重新生成一个随机数,如果是素数就返回即可。

    5.过程如下:

    ①选取两个随机的指定比特位大小的素数p,q,这一步自然是由上一个RandomPrime()函数来生成。

    ②计算二者乘积 n=pq。

    ③随机选取选取参数e,并且测试是否满足(e,(p-1)(q-1))=1,不满足重新选取e,如满足则计算d满足ed+x(p-1)(q-1)=1,这一步使用扩展欧几里得算法来实现。

    6.

    ①RSA的加密过程可以使用一个通式来表达

    密文=明文^e mod n

    也就是说RSA加密是对明文的e次方后除以n后求余数的过程。

    从通式可知,只要知道e和n任何人都可以进行RSA加密了,所以说e、n是RSA加密的密钥,也就是说e和n的组合就是公钥,所以我们就用(e,n)来表示公钥=(e,n)

    ②RSA解密过程也可以使用一个通式来表达,类似加密

    明文 = 密文^d mod n

    也就是说对密文进行d次方后除以n的余数就是明文,这就是RSA解密过程。知道d和n就能进行解密密文了,所以d和n的组合就是私钥=(d,n)

    代码示例👇

    #coding:utf-8
    #author:Mitchell
    #date:12.10
    
    #利用math和random模块实现RSA加密算法
    import numpy as np
    import random
    import math
    
    #(1)编写求最大公因子的函数
    def gcd(a,b):
        if a!=0 and b!=0:
            #将负数转化为正数
            if a<0:
                a=-a
            if b<0:
                b=-b
            #从较小的数中倒序遍历出最大公因子
            if a>b:
                #倒序寻找最大公因子
                for i in range(b,0,-1):
                    if a%i==0 and b%i==0:
                        return i
            elif a==b:
                return a
            else:
                #倒序寻找最大公因子
                for i in range(a,0,-1):
                    if a%i==0 and b%i==0:
                        return i
        else:
            return -1
    print('gcd(144,96)=',gcd(144,96))
    
    #(2)编写求模逆的扩展欧几里得算法函数;
    def EXgcd(a,b,x=[1],y=[1]):
        if b==0:
            x[0]=1
            y[0]=0
            return a
        gcd=EXgcd(b,a%b,x,y)
        k=int(a/b)
        temp=x[0]
        x[0]=y[0]
        y[0]=temp-k*y[0]
        return gcd
    x=[0]
    y=[0]
    print('EXgcd(15,6)=',EXgcd(15,6,x,y))
    print('x=',x,'y=',y)
    
    #(3)编写rabin-miller素性检测算法函数;
    def MillerRabin(n):
        if n in {2,3,5,7,11,13}:
            return True
        elif n==1 or n%2==0 or n%3==0 or n%5==0 or n%7==0 or n%11==0 or n%13==0:
            return False
        k=0#判断向右移动位数
        d=n-1#对u分解
        while d%2==0:
            k+=1
            d/=2
        m=d
        a=random.randint(2,n-1)
        r=pow(a,int(m),int(n))#r=a**m%n
        if r==1:
            return True
        else:
            for i in range(k):
                if r==n-1:#r%n==-1
                    return True
                else:
                    r=pow(r,2,n)
            return False
    print('MillerRabin(23)=',MillerRabin(23))
    print('MillerRabin(97)=',MillerRabin(97))
    print('MillerRabin(1024)=',MillerRabin(1024))
    print('MillerRabin(1023)=',MillerRabin(1023))
    
    #(4)编写生成大素数的算法函数;
    def RandomPrime(length):#参数为比特位长度
        n=random.randint(2**(length-1),2**length)
        while(not MillerRabin(n)):
            n=random.randint(2**(length-1),2**length)
        return n 
    print('RandomPrime(4)=',RandomPrime(4))
    print('RandomPrime(16)=',RandomPrime(16))
    print('RandomPrime(64)=',RandomPrime(64))
    
    #(5)编写生成RSA公私钥对的函数;
    def GetKey(length):#参数是比特位长度
        #生成两个指定大小的素数
        p=RandomPrime(length)
        q=RandomPrime(length)
        #print('p=',p,'q=',q)
        n=p*q
        #生成公钥e
        e=RandomPrime(random.randint(10,length%20+11))
        #保证e与(p-1)*(q-1)互素,便于使用扩展欧几里得求其逆
        while gcd(e,(p-1)*(q-1))!=1 or e>=(p-1)*(q-1):
            e=RandomPrime(random.randint(10,length%20+11))
        #利用扩展欧几里得求逆,d即为私钥
        d=[0]
        d_=[0]
        temp=EXgcd((p-1)*(q-1),e,d_,d)
        #函数返回n,公钥e和私钥d构成的列表
        return [n,e,d[0]]
    length=int(input('请输入测试数据的比特位长度:'))
    key=GetKey(length)
    print('n=',key[0],'公钥e=',key[1],'私钥d=',key[2])
    
    #(6)编写RSA加密和解密函数
    def enCrypto(plainText,n,e):
        return pow(plainText,e,n)
    def deCrypto(cryptoText,n,d):
        return pow(cryptoText,d,n)
    #测试,生成随机明文
    plainText=random.randint(2**(length-1),2**length)
    print('plainText=',plainText)
    print('加密结果=',enCrypto(plainText,key[0],key[1]))
    print('解密结果=',deCrypto(enCrypto(plainText,key[0],key[1]),key[0],key[2]))

    展开全文
  • RSA加密算法C语言实现

    2018-11-11 09:38:09
    RSA算法是一种非对称密码算法,所谓非对称,就是指该算法需要一对密钥,使用其中一个加密,则需要用另一个才能解密。 RSA的算法涉及三个参数,n、e1、e2。 其中,n是两个大质数p、q的积,n的二进制表示时所占用的...
  • rsa算法实现系统

    2019-01-06 00:37:13
    里面包括十几个系统,实现rsa的加解密和数字签名,文件和消息都可以加解密,有些系统实现了socket传输,模拟客户端和服务端的模式,可以实现聊天的信息加解密,还有一些rsa系统的论文
  • RSA算法实现非对称加密的一种算法,其用到很多有关数论的内容,在此我们不多讨论。而将目光聚焦于算法的实现过程。RSA过程:第一步:挑选两个质数a,b,比如:a=61和q=53。这两个质数需要通过HD算法(HD算法可以看...

    RSA算法是实现非对称加密的一种算法,其用到很多有关数论的内容,在此我们不多讨论。而将目光聚焦于算法的实现过程。

    RSA过程:

    第一步:挑选两个质数a,b,比如:a=61和q=53。这两个质数需要通过HD算法(HD算法可以看另一篇文章)传送给接收方。

    第二步:计算N=a*b=61*53=3233

    第三步:计算(a-1)*(b-1)=60*52=3120

    第四步:选择与3120互质的一个数e=17,这个e也就是我们的公钥,需要公开在网络上。

    第五步;计算得出d,这个d就是我们的私钥用来解密信息。需要我们自己保存。d的计算方法是求e关于3120的模逆,得出d=2753。具体的计算过程可以使用Euclid算法得到模逆。

    以上我们所得到的公钥和私钥已经可以用来传递密文。

    例如:

    如果要传递的信息为5。那么传递到网上的密文为5^17(mod3233)=3086。接收方收到密文3086,解密3086^2753(mod3233)=5,就可以得到传递的信息5。

    a6f263abb2fbe3672f2dcfc2eab7debf.png
    实际的RSA公钥

    RSA的应用:数字签名。

    展开全文
  • RSA加密算法实现

    2018-11-04 19:27:27
    此算法的根据学习的密码学,按照自我个人多RSA算法的理解,通过编程实现的,有不完善的地方,请多多包含,且代码仅供参考。
  • 经典的对称加密算法RSA算法的C++实现版本,亲测完美运行
  • RSA算法实现c++源码,可在VC++运行
  • VC++实现RSA加密算法

    2018-07-17 00:06:16
    大学期间学习密码学RSA加密解密算法,通过VS MFC编程实现,供初学者参考
  • C语言RSA算法实现(基于Mbedtls)

    千次阅读 2020-01-21 14:25:26
    最近项目中需要通过C语言实现RSA算法,这里我通过Mbedtls库来进行实现。 1、下载Mbedtls 首先我们将Mbedtls代码放入到工程中,相关传送门如下: Mbedtls官方下载地址 官方网址是国外的下载慢,所以也附上本文...

    最近项目中需要通过C语言实现RSA算法,这里我通过Mbedtls库来进行实现。

    1、下载Mbedtls

    首先我们将Mbedtls代码放入到工程中,相关传送门如下:

    Mbedtls官方下载地址

    官方网址是国外的下载慢,所以也附上本文使用到的Mbedtls代码,传送门如下:

    Mbedtls加解密工具代码

    2、引入Mbedtls头文件

    这里我们在工程中的CMakeLists.txt中引入Mbedtls的头文件,代码如下:

    # for debug
    # add_compile_options(-g)
    
    project("device-authentication")
    
    cmake_minimum_required(VERSION 3.5)
    
    INCLUDE_DIRECTORIES(
    	../include/
        ../../src/net/mbedtls/include
    	../../src/smalgo/sms4/include
    )
    
    SET(my_src_crypto
        ../../src/net/mbedtls/library/aes.c
        ../../src/net/mbedtls/library/aesni.c
        ../../src/net/mbedtls/library/base64.c
        ../../src/net/mbedtls/library/rsa.c
        ../../src/net/mbedtls/library/rsa_internal.c
        ../../src/net/mbedtls/library/entropy.c
        ../../src/net/mbedtls/library/entropy_poll.c
        ../../src/net/mbedtls/library/bignum.c
        ../../src/net/mbedtls/library/sha1.c
        ../../src/net/mbedtls/library/sha256.c
        ../../src/net/mbedtls/library/sha512.c
        ../../src/net/mbedtls/library/md.c
        ../../src/net/mbedtls/library/md5.c
        ../../src/net/mbedtls/library/md_wrap.c
        ../../src/net/mbedtls/library/ripemd160.c
        ../../src/net/mbedtls/library/platform_util.c
        ../../src/net/mbedtls/library/oid.c
        ../../src/net/mbedtls/library/timing.c
        ../../src/net/mbedtls/library/net_sockets.c
    	../../src/smalgo/sms4/cbc128.c
    	../../src/smalgo/sms4/sms4_cbc.c
    	../../src/smalgo/sms4/sms4_common.c
    	../../src/smalgo/sms4/sms4_enc.c
    	../../src/smalgo/sms4/sms4_setkey.c
    )
    SET(my_src_crypto_dbg
        ../../src/net/mbedtls/library/ctr_drbg.c
    )
    
    SET(SRC_LIST_ENCRYPT_BIN
    		oem_porting.c
    		sdk_porting.c
    		authref.c
    		test.c
    		${my_src_crypto}
    		${my_src_crypto_dbg}
    		)
    
    SET(SRC_LIST_DECRYPT_LIB 
        oem_porting.c
        sdk_porting.c
        authref.c
        auth.c
        ${my_src_crypto}
        ${my_src_crypto_dbg}
    		)
    
    #SET(SRC_LIST_AUTH_DEV
    #    oem_porting.c
    #    sdk_porting.c
    #    authref.c
    #    ${my_src_crypto}
    #    ${my_src_crypto_dbg}
    #)
    
    add_definitions(-fPIC)
    #ADD_LIBRARY(authd STATIC ${SRC_LIST_AUTH_DEV})
    ADD_LIBRARY(authoal STATIC ${SRC_LIST_DECRYPT_LIB})
    ADD_EXECUTABLE(eaidkAuth ${SRC_LIST_ENCRYPT_BIN})

    工程结构如下:

      

    引入完成之后我们就可以开始RSA代码编写。

    3、RSA代码编写

    authref.h 头文件代码如下:

    #ifndef __AUTHREF_H__
    #define __AUTHREF_H__
    #include <assert.h>
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    
    #undef DEBUG
    
    #define RSA_KEY_SIZE     1024        // RSA 公钥的位数
    #define EXPONENT         65537
    #define BUFFER_SIZE      1024
    #define RSA_KEY_LEN      256
    #define AES_KEY_DEC_LEN  8
    #define LICENSE_DEC_LEN  64
    
    typedef struct __rsa
    {
        uint8_t   buf[BUFFER_SIZE*8];
        uint8_t*  rsa_n;
        uint8_t*  rsa_e;
        uint8_t*  rsa_d;
        uint8_t*  rsa_p;
        uint8_t*  rsa_q;
        uint8_t*  rsa_dp;
        uint8_t*  rsa_dq;
        uint8_t*  rsa_qp;
        uint32_t  n_len;
        uint32_t  e_len;
        uint32_t  d_len;
        uint32_t  p_len;
        uint32_t  q_len;
        uint32_t  dp_len;
        uint32_t  dq_len;
        uint32_t  qp_len;
    }T_rsa;
    
    void generate_rsa(T_rsa* r);
    
    void init_rsa_keys(T_rsa* rsa);
    
    void rsa_encrypt(  const T_rsa *r, 
    	 	const unsigned char* plaintext, 
    		unsigned int plaintext_size, 
    		unsigned char *ciphertext, 
    		size_t *ciphertext_size);
    
    void rsa_decrypt(
    	    	const T_rsa *r, 
    		const unsigned char* ciphertext, 
    		//unsigned int ciphertext_size, 
    		unsigned char *plaintext, 
    		size_t *plaintext_size);
    
    #ifdef __cplusplus
    }
    #endif
    
    #endif //__AUTHREF_H__
    

    authref.c 代码如下: 

    #include "authref.h"
    #include "mbedtls/entropy.h"
    #include "mbedtls/ctr_drbg.h"
    #include "mbedtls/rsa.h"
    
    #define RSA_KEY_SIZE     1024        // RSA 公钥的位数
    #define EXPONENT         65537
    #define BUFFER_SIZE      1024
    #define RSA_KEY_LEN      256
    #define AES_KEY_DEC_LEN  8
    #define LICENSE_DEC_LEN  64
    
    void generate_rsa(T_rsa* r)
    {
        mbedtls_rsa_context    rsa;
        mbedtls_entropy_context    entropy;
        mbedtls_ctr_drbg_context    ctr_drbg;
    
        mbedtls_entropy_init(&entropy);
    
        mbedtls_ctr_drbg_init(&ctr_drbg);
        mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, NULL, 0);
    
        mbedtls_rsa_init(&rsa, MBEDTLS_RSA_PKCS_V15, 0);
    
        mbedtls_rsa_gen_key(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg, RSA_KEY_SIZE, EXPONENT);
    
        mbedtls_mpi_write_binary(&rsa.N, r->rsa_n, BUFFER_SIZE);
        mbedtls_mpi_write_binary(&rsa.E, r->rsa_e, BUFFER_SIZE);
        mbedtls_mpi_write_binary(&rsa.D, r->rsa_d, BUFFER_SIZE);
        mbedtls_mpi_write_binary(&rsa.P, r->rsa_p, BUFFER_SIZE);
        mbedtls_mpi_write_binary(&rsa.Q, r->rsa_q, BUFFER_SIZE);
        mbedtls_mpi_write_binary(&rsa.DP, r->rsa_dp, BUFFER_SIZE);
        mbedtls_mpi_write_binary(&rsa.DQ, r->rsa_dq, BUFFER_SIZE);
        mbedtls_mpi_write_binary(&rsa.QP, r->rsa_qp, BUFFER_SIZE);
        mbedtls_rsa_free(&rsa);
        mbedtls_ctr_drbg_free(&ctr_drbg);
        mbedtls_entropy_free(&entropy);
    }
    
    void init_rsa_keys(T_rsa *rsa) {
        memset(rsa->buf, 0, BUFFER_SIZE * 8);
        rsa->rsa_n = &rsa->buf[BUFFER_SIZE * 0];
        rsa->rsa_e = &rsa->buf[BUFFER_SIZE * 1];
        rsa->rsa_d = &rsa->buf[BUFFER_SIZE * 2];
        rsa->rsa_p = &rsa->buf[BUFFER_SIZE * 3];
        rsa->rsa_q = &rsa->buf[BUFFER_SIZE * 4];
        rsa->rsa_dp = &rsa->buf[BUFFER_SIZE * 5];
        rsa->rsa_dq = &rsa->buf[BUFFER_SIZE * 6];
        rsa->rsa_qp = &rsa->buf[BUFFER_SIZE * 7];
        rsa->n_len = BUFFER_SIZE;
        rsa->e_len = BUFFER_SIZE;
        rsa->d_len = BUFFER_SIZE;
        rsa->p_len = BUFFER_SIZE;
        rsa->q_len = BUFFER_SIZE;
        rsa->dp_len = BUFFER_SIZE;
        rsa->dq_len = BUFFER_SIZE;
        rsa->qp_len = BUFFER_SIZE;
    }
    
    // 加密
    void rsa_encrypt(
            const T_rsa *r,
            const unsigned char *plaintext,
            unsigned int plaintext_size,
            unsigned char *ciphertext,
            size_t *ciphertext_size) {
        mbedtls_rsa_context rsa;
        mbedtls_entropy_context entropy;
        mbedtls_ctr_drbg_context ctr_drbg;
        int rett = 0;
    
        mbedtls_entropy_init(&entropy);
        //assert(mbedtls_ctr_drbg_init(&ctr_drbg, mbedtls_entropy_func, &entropy, nullptr, 0) == 0);
        mbedtls_ctr_drbg_init(&ctr_drbg);
        assert(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, NULL, 0) == 0);
    
        mbedtls_rsa_init(&rsa, MBEDTLS_RSA_PKCS_V15, 0);
        assert(mbedtls_mpi_read_binary(&rsa.N, r->rsa_n, BUFFER_SIZE) == 0);
        assert(mbedtls_mpi_read_binary(&rsa.E, r->rsa_e, BUFFER_SIZE) == 0);
    
        *ciphertext_size = rsa.len = (mbedtls_mpi_bitlen(&rsa.N) + 7) >> 3;
    
        //assert(mbedtls_rsa_pkcs1_encrypt(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg, MBEDTLS_RSA_PUBLIC, plaintext_size, plaintext, ciphertext) == 0);
        rett = mbedtls_rsa_pkcs1_encrypt(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg, MBEDTLS_RSA_PUBLIC, plaintext_size,
                                         plaintext, ciphertext);
        assert(rett == 0);
        mbedtls_rsa_free(&rsa);
        mbedtls_ctr_drbg_free(&ctr_drbg);
        mbedtls_entropy_free(&entropy);
    }
    
    // 解密
    void rsa_decrypt(
            const T_rsa *r,
            const unsigned char *ciphertext,
            //unsigned int ciphertext_size,
            unsigned char *plaintext,
            size_t *plaintext_size) {
        mbedtls_rsa_context rsa;
        mbedtls_entropy_context entropy;
        mbedtls_ctr_drbg_context ctr_drbg;
    
        mbedtls_entropy_init(&entropy);
        //assert(mbedtls_ctr_drbg_init(&ctr_drbg, mbedtls_entropy_func, &entropy, nullptr, 0) == 0);
        mbedtls_ctr_drbg_init(&ctr_drbg);
        assert(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, NULL, 0) == 0);
    
        mbedtls_rsa_init(&rsa, MBEDTLS_RSA_PKCS_V15, 0);
    
        assert(mbedtls_mpi_read_binary(&rsa.N, r->rsa_n, BUFFER_SIZE) == 0);
        assert(mbedtls_mpi_read_binary(&rsa.E, r->rsa_e, BUFFER_SIZE) == 0);
        assert(mbedtls_mpi_read_binary(&rsa.D, r->rsa_d, BUFFER_SIZE) == 0);
        assert(mbedtls_mpi_read_binary(&rsa.P, r->rsa_p, BUFFER_SIZE) == 0);
        assert(mbedtls_mpi_read_binary(&rsa.Q, r->rsa_q, BUFFER_SIZE) == 0);
        assert(mbedtls_mpi_read_binary(&rsa.DP, r->rsa_dp, BUFFER_SIZE) == 0);
        assert(mbedtls_mpi_read_binary(&rsa.DQ, r->rsa_dq, BUFFER_SIZE) == 0);
        assert(mbedtls_mpi_read_binary(&rsa.QP, r->rsa_qp, BUFFER_SIZE) == 0);
    
        rsa.len = (mbedtls_mpi_bitlen(&rsa.N) + 7) >> 3;
    
        assert(mbedtls_rsa_pkcs1_decrypt(&rsa, mbedtls_ctr_drbg_random, &ctr_drbg, MBEDTLS_RSA_PRIVATE, plaintext_size,
                                         ciphertext, plaintext, *plaintext_size) == 0);
    
        mbedtls_rsa_free(&rsa);
        mbedtls_ctr_drbg_free(&ctr_drbg);
        mbedtls_entropy_free(&entropy);
    }
    
    int do_ras_encrypt(authhandle *hdl, uint8_t contract_id[CONTRACTID_LEN], uint8_t user_id[USERID_LEN],
                       uint8_t uid[FINAL_UID_LEN]) {
        T_rsa r;
        uint8_t uid_local[UID_LEN];
        uint8_t ciphertext[SN_LEN];
        size_t ciphertext_len = SN_LEN;
        GenRawUID(hdl, contract_id, user_id, uid_local);
        //encryp UID
        init_rsa_keys(&r);
        if (hdl->callback_func.GetServerPublicKey) {
            hdl->callback_func.GetServerPublicKey(r.buf);
        } else {
            GetServerPublicKey(hdl, r.buf); //load 2048 bytes for public key
        }
        rsa_encrypt(&r, uid_local, UID_LEN, ciphertext, &ciphertext_len);
        //printf("ciphertext_len: %ld\n", ciphertext_len);
        //copy SWID
    #if 0
        int i;
        printf("CipherUID: ");
        for(i = 0; i < FINAL_UID_LEN; ++i){
            printf("%02x, ", uid[i]);
        }
        printf("\n");
    #endif
        return 0; //OK
    
    }
    

    生成RSA公私钥的伪代码如下:

    T_rsa r;
    uint8_t pub_key[2048] = { 0 };
    uint8_t prv_key[8192] = { 0 };
    
    init_rsa_keys(&r);
    generate_rsa(&r);
    
    //1. public key
    memcpy(pub_key, r.buf, 2048);
    
    //2. private key
    memcpy(prv_key, r.buf, 8192);

    RSA加密代码如下:

    int do_ras_encrypt(authhandle *hdl, uint8_t contract_id[CONTRACTID_LEN], uint8_t user_id[USERID_LEN],
                       uint8_t uid[FINAL_UID_LEN]) {
        T_rsa r;
        uint8_t uid_local[UID_LEN];
        uint8_t ciphertext[SN_LEN];
        size_t ciphertext_len = SN_LEN;
        //encryp UID
        init_rsa_keys(&r);
        if (hdl->callback_func.GetServerPublicKey) {
            hdl->callback_func.GetServerPublicKey(r.buf);
        } else {
            GetServerPublicKey(hdl, r.buf); //load 2048 bytes for public key
        }
        rsa_encrypt(&r, uid_local, UID_LEN, ciphertext, &ciphertext_len);
        //printf("ciphertext_len: %ld\n", ciphertext_len);
        //copy SWID
    #if 0
        int i;
        printf("CipherUID: ");
        for(i = 0; i < FINAL_UID_LEN; ++i){
            printf("%02x, ", uid[i]);
        }
        printf("\n");
    #endif
        return 0; //OK
    
    }

    解密代码如下:

    static int SetServerPrivateKey(T_rsa *r, uint8_t *prv_key)
    {
        memcpy(r->buf, prv_key, 8192);
        //memset(&r->buf[0], 0, 1024-128);
        //memset(&r->buf[1024], 0, 1024-4);
        //memset(&r->buf[2048], 0, 1024-128);
        //memset(&r->buf[3072], 0, 1024-64);
        //memset(&r->buf[4096], 0, 1024-64);
        //memset(&r->buf[5120], 0, 1024-64);
        //memset(&r->buf[6144], 0, 1024-64);
        //memset(&r->buf[7168], 0, 1024-64);
        return 0; //OK
    }
    
    JNIEXPORT jbyteArray JNICALL Java_com_openailab_oascloud_security_jni_cloud_CloudAuthJNI_decrypUidOnServer
            (JNIEnv *env, jobject obj, jstring uidEnc, jbyteArray privateKey)
    {
        uint8_t *uid_enc = (*env)->GetStringUTFChars(env, uidEnc, NULL);
        uint8_t *private_key = (*env)->GetByteArrayElements(env, privateKey, NULL);
    
        jbyteArray ret = NULL;
        T_rsa r;
        uint8_t plaintext[UID_LEN];
        size_t plaintext_len = 256;
        uint8_t UID_Recover[SN_LEN];
        uint8_t uid_enc_c[FINAL_UID_LEN];
    
        init_rsa_keys(&r);
        SetServerPrivateKey(&r, private_key);
    
        hex2array(uid_enc, FINAL_UID_LEN * 2, uid_enc_c);
    
        recover(&uid_enc_c[FINAL_UID_LEN - SN_LEN], UID_Recover, SN_LEN);
        rsa_decrypt(&r, UID_Recover, plaintext, &plaintext_len);
    
        /*printf("plaintext=\n");
        for (size_t i = 0; i < UID_LEN; i++)
        {
        if (i > 0 && i % 16 == 0) {
        printf("\n");
        }
        printf("%02x,", plaintext[i]);
        }
        printf("\n");*/
    
        ret = (*env)->NewByteArray(env, UID_LEN);
        (*env)->SetByteArrayRegion(env, ret, 0, UID_LEN, (jbyte*)plaintext);
        (*env)->ReleaseByteArrayElements(env, privateKey, private_key, 0);
        (*env)->ReleaseStringUTFChars(env, uidEnc, uid_enc);
        return ret;
    }

    到此C语言RSA加解密就介绍完毕了。

    展开全文
  • RSA算法c#实现

    2018-04-10 16:18:08
    利用c#简单实现RSA加密算法
  • 利用RSA算法实现数字签名毕业论文.doc
  • 博文---信息安全实践二之密码与隐藏技术2【数字水印&RSA加密算法实现RSA加密算法的实现,利用C语言改正博文中的错误程序。
  • 主要介绍了Java实现RSA算法的方法,结合实例形式分析了RSA算法的原理、实现与使用方法,需要的朋友可以参考下
  • 通过调用openssl 的rsa 算法,封装成Qt版本接口的实现。通过本示例了解rsa 算法,了解密钥如何从字符串和16进制之间的转化。
  • 随机密码 模拟没有加密的简单RSA算法实现随机密码
  • C语言实现RSA加密解密的过程,代码比较简单,容易看懂,我是小白新手,代码生涩,欢迎批评指正,大牛勿喷,感恩戴德

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,584
精华内容 23,833
关键字:

rsa算法实现