山东大学软件工程应用与实践——GMSSL开源库（十）——重要的大整数

最新推荐文章于 2024-06-10 20:26:24 发布
最新推荐文章于 2024-06-10 20:26:24 发布
阅读量756 收藏
点赞数 1
分类专栏： 2021SC@SDUSC 文章标签： 算法 openssl 密码学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51588039/article/details/121341857
版权

2021SC@SDUSC

文章标题

无论是SM2、SM9等国密算法还是以RSA为代表的国际标准算法或者任何其他密码算法，对于大整数都有一定的要求，例如RSA中公钥的生成，需要用到大素数的乘法模幂等运算。而像1024位这种大整数的运算，肯定不能用普通的整数的加减乘除运算方法，一个是int类型的变量不能容纳这么长的数，另一个是考虑到计算机的计算效率问题。既能实现大整数“big number”加减乘除乘方模幂等运算，还需要保证效率，是对大整数运算程序实现的要求。因为GMSSL是在OPENSSL之上进行的扩充，本篇分析了OPENSSL中bn文件夹中针对大整数的运算方法。

BIGNUM的结构

首先认识一下BIGNUM的结构，源代码来自\openssl-master\crypto\bn\bn_local.h

#define BN_ULONG     unsigned long
struct bignum_st {
    BN_ULONG *d;                /* Pointer to an array of 'BN_BITS2' bit
                                 * chunks. */
    int top;                    /* Index of last used d +1. */
    /* The next are internal book keeping for bn_expand. */
    int dmax;                   /* Size of the d array. */
    int neg;                    /* one if the number is negative */
    int flags;
};
typedef struct bignum_st BIGNUM;

其中
BN_ULONG 32比特无符号数，简称为“字”；
d 指针，指向表示大整数的数组；
dmax 数组的最大长度；
top 大整数的最高字，0≤top≤dmax－1；
neg 标记了大整数的符号，neg为1表示负数，为0则表示正数；
flags 大整数的属性，这一点后面提到时再详细说明。

举个简单的例子进行说明。比如定义一个最长可以表示4个字的大整数，则dmax＝4；但是这个数可能只有低2个字有效，高2个字都为0，即d[3]=d[2]=0，d[1]≠0，则此时top＝1。
原文链接：https://blog.csdn.net/samsho2/article/details/85772221

大整数的加减法（绝对值加减）

openssl-master\crypto\bn\bn_add.c

绝对值加减

int BN_uadd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)//绝对值加
{
    int max, min, dif;
    const BN_ULONG *ap, *bp;
    BN_ULONG *rp, carry, t1, t2;

    bn_check_top(a);
    bn_check_top(b);

    if (a->top < b->top) {
        const BIGNUM *tmp;

        tmp = a;
        a = b;
        b = tmp;
    }
    max = a->top;
    min = b->top;
    dif = max - min;

    if (bn_wexpand(r, max + 1) == NULL)
        return 0;

    r->top = max;

    ap = a->d;
    bp = b->d;
    rp = r->d;

    carry = bn_add_words(rp, ap, bp, min);
    rp += min;
    ap += min;

    while (dif) {
        dif--;
        t1 = *(ap++);
        t2 = (t1 + carry) & BN_MASK2;
        *(rp++) = t2;
        carry &= (t2 == 0);
    }
    *rp = carry;
    r->top += carry;

    r->neg = 0;
    bn_check_top(r);
return 1;
}


int BN_usub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)//绝对值减
{
    int max, min, dif;
    BN_ULONG t1, t2, borrow, *rp;
    const BN_ULONG *ap, *bp;

    bn_check_top(a);
    bn_check_top(b);

    max = a->top;
    min = b->top;
    dif = max - min;

    if (dif < 0) {              /* hmm... should not be happening */
        ERR_raise(ERR_LIB_BN, BN_R_ARG2_LT_ARG3);
        return 0;
    }

    if (bn_wexpand(r, max) == NULL)
        return 0;

    ap = a->d;
    bp = b->d;
    rp = r->d;

    borrow = bn_sub_words(rp, ap, bp, min);
    ap += min;
    rp += min;

    while (dif) {
        dif--;
        t1 = *(ap++);
        t2 = (t1 - borrow) & BN_MASK2;
        *(rp++) = t2;
        borrow &= (t1 == 0);
    }

    while (max && *--rp == 0)
        max--;

    r->top = max;
    r->neg = 0;
    bn_pollute(r);

    return 1;
}

其中BN_ULONG bn_add_words(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b, int n)与BN_ULONG bn_sub_words(BN_ULONG *r, const BN_ULONG *a, const BN_ULONG *b, int n)函数实现了低位的齐字加减法，并返回进位值赋给carry\borrow。算法思想主要利用了整数的加法进位时只可能进一位或者不进位，两大整数相加减时，位数少的与位数多的相同位数进行齐字加减，高位与carry\borrow相加减后放到高位，完成绝对值加减法。

带符号加减

int BN_add(BIGNUM *r, const BIGNUM *a, const BIGNUM *b)//大整数加
{
    int ret, r_neg, cmp_res;

    bn_check_top(a);
    bn_check_top(b);

    if (a->neg == b->neg) {
        r_neg = a->neg;
        ret = BN_uadd(r, a, b);
    } else {
        cmp_res = BN_ucmp(a, b);
        if (cmp_res > 0) {
            r_neg = a->neg;
            ret = BN_usub(r, a, b);
        } else if (cmp_res < 0) {
            r_neg = b->neg;
            ret = BN_usub(r, b, a);
        } else {
            r_neg = 0;
            BN_zero(r);
            ret = 1;
        }
    }

    r->neg = r_neg;
    bn_check_top(r);
    return ret;
}


int BN_sub(BIGNUM *r, const BIGNUM *a, const BIGNUM *b）//大整数减
{
    int ret, r_neg, cmp_res;

    bn_check_top(a);
    bn_check_top(b);

    if (a->neg != b->neg) {
        r_neg = a->neg;
        ret = BN_uadd(r, a, b);
    } else {
        cmp_res = BN_ucmp(a, b);
        if (cmp_res > 0) {
            r_neg = a->neg;
            ret = BN_usub(r, a, b);
        } else if (cmp_res < 0) {
            r_neg = !b->neg;
            ret = BN_usub(r, b, a);
        } else {
            r_neg = 0;
            BN_zero(r);
            ret = 1;
        }
    }

    r->neg = r_neg;
    bn_check_top(r);
    return ret;
}

有了绝对值相加减后，带符号的大整数进行加减运算就变得比较简单了。
先进行判定a、b是否同号，若同号，结果r的符号赋上a的符号，然后进行绝对值加减；否则，进行绝对值比较，r的符号赋上绝对值大的数的符号，然后进行绝对值相减。

大整数的乘法

以下源代码来自openssl-master\crypto\bn\bn_mul.c

经典乘法

Openssl首先实现了最基本的经典乘法方式，也就是类似小学中学到的“竖式计算”的方法，在void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)中实现了该方法。

void bn_mul_normal(BN_ULONG *r, BN_ULONG *a, int na, BN_ULONG *b, int nb)
{
    BN_ULONG *rr;

    if (na < nb) {
        int itmp;
        BN_ULONG *ltmp;

        itmp = na;
        na = nb;
        nb = itmp;
        ltmp = a;
        a = b;
        b = ltmp;

    }
    rr = &(r[na]);
    if (nb <= 0) {
        (void)bn_mul_words(r, a, na, 0);
        return;
    } else
        rr[0] = bn_mul_words(r, a, na, b[0]);

    for (;;) {
        if (--nb <= 0)
            return;
        rr[1] = bn_mul_add_words(&(r[1]), a, na, b[1]);
        if (--nb <= 0)
            return;
        rr[2] = bn_mul_add_words(&(r[2]), a, na, b[2]);
        if (--nb <= 0)
            return;
        rr[3] = bn_mul_add_words(&(r[3]), a, na, b[3]);
        if (--nb <= 0)
            return;
        rr[4] = bn_mul_add_words(&(r[4]), a, na, b[4]);
        rr += 4;
        r += 4;
        b += 4;
    }
}

递归和comba乘法

Openssl使用的环境一般是对信息的加解密，故对大整数的使用一定是不能用int、long等类型进行直接表示的，也就是说普通的数乘方法无法直接在实际场景中使用。上述的bn_mul_normal函数只起到最顶层的作用，实际对大整数的乘法运算使用到了递归乘法和comba乘法。
当然，openssl也实现了大整数的递归乘法和comba乘法。对于大整数来说，递归乘法的时间复杂度要比普通数乘要小。同时，对大整数乘法问题进行分而治之，逐步变成可以解决的数乘问题。
void bn_mul_recursive
void bn_mul_part_recursive
void bn_mul_low_recursive
三个函数实现了对大整数的递归乘法。
void bn_mul_comba8
void bn_mul_comba4
函数实现了对大整数的comba乘法，有关comba算法的具体内容，不在此详细介绍。

通过ctx，使程序自己判断使用递归乘法还是comba乘法：

int bn_mul_fixed_top(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
{
    int ret = 0;
    int top, al, bl;
    BIGNUM *rr;
#if defined(BN_MUL_COMBA) || defined(BN_RECURSION)
    int i;
#endif
#ifdef BN_RECURSION
    BIGNUM *t = NULL;
    int j = 0, k;
#endif

    bn_check_top(a);
    bn_check_top(b);
    bn_check_top(r);

    al = a->top;
    bl = b->top;

    if ((al == 0) || (bl == 0)) {
        BN_zero(r);
        return 1;
    }
    top = al + bl;

    BN_CTX_start(ctx);
    if ((r == a) || (r == b)) {
        if ((rr = BN_CTX_get(ctx)) == NULL)
            goto err;
    } else
        rr = r;

#if defined(BN_MUL_COMBA) || defined(BN_RECURSION)
    i = al - bl;
#endif
#ifdef BN_MUL_COMBA
    if (i == 0) {
# if 0
        if (al == 4) {
            if (bn_wexpand(rr, 8) == NULL)
                goto err;
            rr->top = 8;
            bn_mul_comba4(rr->d, a->d, b->d);
            goto end;
        }
# endif
        if (al == 8) {
            if (bn_wexpand(rr, 16) == NULL)
                goto err;
            rr->top = 16;
            bn_mul_comba8(rr->d, a->d, b->d);
            goto end;
        }
    }
#endif                          /* BN_MUL_COMBA */
#ifdef BN_RECURSION
    if ((al >= BN_MULL_SIZE_NORMAL) && (bl >= BN_MULL_SIZE_NORMAL)) {
        if (i >= -1 && i <= 1) {
            /*
             * Find out the power of two lower or equal to the longest of the
             * two numbers
             */
            if (i >= 0) {
                j = BN_num_bits_word((BN_ULONG)al);
            }
            if (i == -1) {
                j = BN_num_bits_word((BN_ULONG)bl);
            }
            j = 1 << (j - 1);
            assert(j <= al || j <= bl);
            k = j + j;
            t = BN_CTX_get(ctx);
            if (t == NULL)
                goto err;
            if (al > j || bl > j) {
                if (bn_wexpand(t, k * 4) == NULL)
                    goto err;
                if (bn_wexpand(rr, k * 4) == NULL)
                    goto err;
                bn_mul_part_recursive(rr->d, a->d, b->d,
                                      j, al - j, bl - j, t->d);
            } else {            /* al <= j || bl <= j */

                if (bn_wexpand(t, k * 2) == NULL)
                    goto err;
                if (bn_wexpand(rr, k * 2) == NULL)
                    goto err;
                bn_mul_recursive(rr->d, a->d, b->d, j, al - j, bl - j, t->d);
            }
            rr->top = top;
            goto end;
        }
    }
#endif                          /* BN_RECURSION */
    if (bn_wexpand(rr, top) == NULL)
        goto err;
    rr->top = top;
    bn_mul_normal(rr->d, a->d, al, b->d, bl);

#if defined(BN_MUL_COMBA) || defined(BN_RECURSION)
 end:
#endif
    rr->neg = a->neg ^ b->neg;
    rr->flags |= BN_FLG_FIXED_TOP;
    if (r != rr && BN_copy(r, rr) == NULL)
        goto err;

    ret = 1;
 err:
    bn_check_top(r);
    BN_CTX_end(ctx);
    return ret;
}

最后是大整数乘法中最上层的函数，对外只留下了一个乘法的接口，对外只需要输入两个大整数和上下文环境，就返回r=a*b。

int BN_mul(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
{
    int ret = bn_mul_fixed_top(r, a, b, ctx);

    bn_correct_top(r);
    bn_check_top(r);

    return ret;
}

小结

本篇文章主要对大整数的加减法和乘法运算进行了分析。和大整数相关的运算函数一直是底层代码中较为重要的一部分，下面将会对大整数的其他运算的实现进行代码方向的分析与学习。
对于大整数的运算操作，属于openssl甚至是密码学编程较为底层的内容。现阶段使用的密码，大部分都依赖于大整数的产生和运算。理解底层的运算内容可以更好地认识上层的函数实现，同时也进一步了解了底层的算法。

乔未
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Openssl有关大数运算函数列表
Welcome to Vick's home！
08-24 2750
Openssl有关大数运算函数列表1．初始化函数BIGNUM *BN_new(void);   新生成一个BIGNUM结构void BN_free(BIGNUM *a);   释放一个BIGNUM结构，释放完后a=NULL;void BN_init(BIGNUM *);   初始化所有项均为0，一般为BN_ init(&c)void BN_clear(BIGNUM *a); 将a中所有项均赋值为0
[转]Openssl有关大数运算函数介绍
mike861的专栏
11-06 2198
Openssl有关大数运算函数介绍  1．初始化函数 BIGNUM *BN_new(void);    新生成一个BIGNUM结构 void BN_free(BIGNUM *a);   释放一个BIGNUM结构，释放完后a=NULL; void BN_init(BIGNUM *);    初始化所有项均为0，一般为BN_ init(&c) void BN_c
【9】openssl 代码调试
最新发布
司徒荆的博客
06-10 357
​​openssl visual studio 配置
11.openssl编程——大数
艾小小雨的博客
01-17 969
11.1 介绍 大数一般指的是位数很多的数。计算机表示的数的大小是有限的，精度也是有限的，精度也是有限的，它不能支持大数运算。密码学中采用了很多大数计算，为了让计算机实现大数运算，用户需要定义自己的大数表示方式及实现各种大数运算。Openssl为我们提供了这些功能，主要用于非对称算法。   11.2   openssl大数表示 struct bignum_st { BN_ULONG *d...
openssl bignum 大数
ughome的专栏
10-09 472
openssl 大数实现
大数的运算——调用openssl库函数实现（VS2019）
bibohaohao的博客
03-21 2444
大数的加减乘除–调用openssl库函数实现 1.下载openssl 百度网盘链接：openssl-win64 提取码：0626
山东大学数据结构课设——长整数的代数运算
12-21
【标题解析】：“山东大学数据结构课设——长整数的代数运算”指的是一个针对山东大学数据结构课程设计的项目，该项目的核心是实现长整数的代数运算。长整数运算通常涉及到大整数的加减乘除以及可能的其他高级运算，...
标准c语言程序设计和应用——华中科技大学出版社第三章课后题.pdf
06-27
1. 比大小：这个程序通过`scanf`获取用户输入的两个整数，然后使用条件运算符来比较它们的大小，将较大的数存储到`max`变量中，最后输出最大值。这是对条件语句和基础算术操作的基本应用。 2. 三个整数比大小：与上...
Step7——整数INT_时间S5Time及Time相互转换.docx
12-12
在实际应用中，这些转换操作对于在Step7程序和第三方组态软件之间传递时间参数至关重要。例如，客户可能需要在Intouch、iFix或组态王等软件中设定定时器的预设时间或PID控制器的积分时间，而这些软件可能不直接支持...
队列的应用——理发店问题模拟仿真 - 算法与数据结构课程网站.ppt
05-30
队列的应用——理发店问题模拟仿真 - 算法与数据结构课程网站.ppt 本资源主要讲解了队列在算法与数据结构中的应用，通过理发店问题的模拟仿真来演示队列的使用。同时，本资源还涉及到栈的应用、算法与数据结构的...
GILIB:GILIB大整数算法库-开源
05-13
这个库的设计目的是为了处理超出标准整型变量范围的大整数运算，它在计算机科学中有着广泛的应用，尤其是在密码学、数学计算、分布式计算以及任何需要精确处理大数的场景。 在编程中，通常的整型数据类型（如int、...
OpenSSL中的大数接口与基于其的自用RSA加密接口设计
weixin_33739541的博客
06-24 1183
本文记录了初次接触OpenSSL中的大数模块，重温了RSA加密流程，使用OpenSSL的接口包装成自用RSA加密接口，并且利用自己的接口演示了Alice与Bob通过RSA加密进行通讯的一个示例。 概览 自己的库中需要包含的功能有： 构造和对一个大整数对象赋值 (至少支持到2^65536-1) 大整数的加法、乘法、取模、加速乘方等基本算术运算 判断这个大整数是否是素数 ...
山东大学软件工程应用与实践——GMSSL开源库（十三）——总结
m0_51588039的博客
11-29 3878
2021SC@SDUSC 目录关于密码关于OPENSSL\GMSSL关于自己 写了这么多篇文章，也该最后做个总结了。这学期无论是课程也好，写这些文章也好，对密码、对openssl、对gmssl都有了相应的一定的认识。作为软件工程应用与实践这门课的最后一篇文章，我将总结一下我在这学期的所学、所理解、所感悟。 关于密码 有幸认识一位公司里的前辈领导，他曾经问过我：“能用一句话概括密码吗？”我当时想了很久，感觉并没有能得到一个比较合适的答案。最后前辈告诉了我他对于密码的理解，即“让正确的的人看见正确的事”。 回去
Openssl中的BIGNUM运算函数(整理)
热门推荐
jnxxhzz的博客
07-27 5万+
目录       1.初始化函数       2.上下文结构       3.与 字符/位 相关的函数       4.计算类函数       5.随机函数 最近在学习BIGNUM的使用,但是奈何在项目中看到一个函数总是不认识...网上能搜到的表格又极其少... 所以选择自己手动整理一份自认为较为完整的函数表格,不定时更新   1.初始化函数 函数原型 解释 示例 ...
OpenSSL密码库算法笔记——第3章 带模的基本运算
云与山的彼端
02-24 1万+
有了模运算之后，便可以将第一章提到的基本运算（加、减、乘、除）和模运算结合起来形成模加、模减、模乘、模逆运算，这些都是RSA和ECC的基本运算。 第3章 带模的基本运算 3.1 模加、模减和模左移运算 3.1.1 模加 3.1.2 模减 3.1.3 ...
OpenSSL密码库算法笔记——第2.1章 经典模运算
云与山的彼端
01-25 1万+
经典模运算是用除法（见§1.3）计算出商和余数，其中的余数即为所求。该方法对被模数x不加任何限制（Barrett约化和Montgomery约化对被模数x是有限制的）。 由§1.3给出的除法算法知，除法运算需要做预运算（将被除数标准化）和事后运算（将余数去标准化）。不过这个标准化和去标准化的过程比较简单——通常标准化就是将被除数左移某个比特，而去标准化就是将余数右移相同的比特。 有关经典模运算的...
GmSSL 国密MS2/SM3/SM4/SM9/ZUC/SSL密码工具箱
qq_39084128的博客
05-17 3231
GmSSL 国密MS2/SM3/SM4/SM9/ZUC/SSL密码工具箱
再看iOS如何使用SM2/SM3/SM4/SM9 方法二：使用http://gmssl.org这个开源密码箱来实现从编译到使用
qq_15509071的博客
08-06 5942
当时要是知道有下面这个网站，之前也不用那么辛苦了 网上流传的c语言国密核心算法好像至少两种，两种一起使用的话还会出现问题。所以如果某个功能已经有sm算法了，可以直接使用（可以让其提供调用方法名称，或hopper自己看）。 之前写的是一种方法。 今天再看看这个。 在http://gmssl.org/docs/install.html中含有 编译iPhone OS目标文件 的代码 export CC=clang export CROSS_TOP=/Applicati...
OpenSSL/GmSSL 动态引擎
乐于分享
12-02 2623
OpenSSL 简介 OpenSSL 是包含安全套接字层和传输层安全协议的开源软件库，它几乎成为安全领域的事实标准，大部分的服务器和客户端都使用 OpenSSL，一些硬件加密算法的实现通常也需要使用 OpenSSL 的命令行工具进行验证。在实际应用中，OpenSSL可以提供动态引擎框架，可以方便用户使用密码设备完成硬件加速。 GmSSL 简介 国内与OpenSSL相对应的开源项目为 GmSSL，该项目中增加了国密算法，如SM2/SM3/SM4/SM9等，同时也增加了对国家密码标准规范的支持，如SK
无约束优化：最优解分类与条件——LINGO软件应用
这对于解决工程、经济管理、科研等领域中的优化问题至关重要，尤其是在竞赛或实际操作中，如CUMCM赛题，大约有一半以上的问题需要用到优化软件进行求解。 总结来说，无约束优化是寻找函数极值的数学方法，涉及到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值