密码学基础算法(一)基于整数的欧几里得算法和扩展欧几里得算法

最新推荐文章于 2025-04-14 17:25:35 发布
最新推荐文章于 2025-04-14 17:25:35 发布
阅读量2.1k 收藏 20
点赞数 1
分类专栏： 密码学 文章标签： 密码学 欧几里得算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guyongqiangx/article/details/120365239
版权

欧几里得算法

图片来源: 随便谷歌的一个图片
图片地址: https://jason-chen-1992.weebly.com/uploads/1/0/8/5/108557741/euclidean_3_orig.jpg

密码学基础系列:

  • (一) 基于整数的欧几里得算法和扩展欧几里得算法
  • (二) 扩展域 G F ( 2 n ) GF(2^n) GF(2n) 上的多项式运算
  • (三) 扩展域 G F ( 2 n ) GF(2^n) GF(2n) 上的欧几里得算法和扩展欧几里得算法

文章目录


求两个整数的最大公约数，以及求整数的乘法逆元是密码学中最基本的算法。

1. 欧几里得算法求最大公约数

欧几里得算法(Euclidean Algorithm)，即辗转相除算法，是求两个整数最大公约数(GCD, Greatest Common Devisor)最常用和高效的办法。

关于辗转相除的原理和证明这里不再赘述，推荐参考:

  1. 《数论概论》原书第3版，第5章，整除性与最大公因数
  2. 《密码编码学与网络安全》第七版，第2.2节，欧几里得算法
  3. 《深入浅出密码学》，第6.3.1节，欧几里得算法

以下是源码实现的递归和非递归版本。

1. 递归版本

/**
 * @description: 使用欧几里得算法(辗转相除)求最大公约数的递归版本
 * @param {int} a 整数a
 * @param {int} b 整数b
 * @return {*} 返回整数 (a, b) 的最大公约数
 */
int int_gcd(int a, int b)
{
    if (b == 0)
    {
        return a;
    }
    else
    {
        return int_gcd(b, a % b);
    }
}

2. 非递归版本

/**
 * @description: 使用欧几里得算法(辗转相除)求最大公约数的非递归版本
 * @param {int} a 整数a
 * @param {int} b 整数b
 * @return {*} 返回整数 (a, b) 的最大公约数
 */
int int_gcd(int a, int b)
{
    int t;

    while (b != 0)
    {
        t = a % b;
        a = b;
        b = t;
    }

    return a;
}

为了和后面基于多项式的欧几里得算法求最大公因式区分，这里将函数命名为int_gcd，前缀 int 表示 integer

2. 扩展欧几里得算法解线性方程 a x + b y = d = g c d ( a , b ) ax + by = d = gcd(a, b) ax+by=d=gcd(a,b)

扩展欧几里得算法(Extend Euclidean Algorithm)的最大用途就是用于计算整数的乘法逆元。

关于扩展欧几里得算法(EEA)的原理和和推导这里不再赘述，推荐参考:

  1. 《数论概论》原书第3版，第6章，线性方程与最大公因数
  2. 《密码编码学与网络安全》第七版，第2.3.6节，扩展的欧几里得算法
  3. 《深入浅出密码学》，第6.3.2节，扩展的欧几里得算法

以下的源码基于扩展欧几里得算法实现求解线性方程:
a x + b y = d = g c d ( a , b ) , 公式2.1 ax + by = d = gcd(a, b) \text{, 公式2.1} ax+by=d=gcd(a,b), 公式2.1

以下是源码实现的递归和非递归版本。

1. 递归版本

/**
 * @description: 使用扩展欧几里得算法(EEA)计算等式 a x ia + b x ib = gcd(a, b) 中的系数 ia, ib 和 gcd(a, b), 递归版本, 推导和证明参考: https://blog.csdn.net/lincifer/article/details/49391175
 * @param {int} a 整数 a
 * @param {int} b 整数 b
 * @param {int} *ia 整数 a 的系数 ia
 * @param {int} *ib 整数 b 的系数 ib
 * @return {*} 返回整数 (a, b) 的最大公约数 gcd(a, b)
 */
int int_gcd_ex(int a, int b, int *ia, int *ib)
{
    int x, y;
    int q, r;

    if (b == 0)
    {
        *ia = 1;
        *ib = 0;

        return a;
    }

    r = int_gcd_ex(b, a % b, &x, &y);

    *ia = y;
    *ib = x - a / b * y;

    return r;
}

一般的书讲述扩展欧几里得算法(Extend Euclidean Algorithm)都是基于递推原理进行的。
关于递归(非递推)版本的推导和证明，请参考参考:

  • https://blog.csdn.net/lincifer/article/details/49391175
    扩展欧几里得算法的递归证明

2. 非递归版本

/**
 * @description: 使用扩展欧几里得算法: Extend Euclidean Algorithm (EEA) 计算等式 a x ia + b x ib = gcd(a, b) 中的 ia, ib 和 gcd(a, b)
 * @param {int} a 整数 a
 * @param {int} b 整数 b
 * @param {int} *ia 整数 a 的系数 ia
 * @param {int} *ib 整数 b 的系数 ib
 * @return {*} 返回整数 (a, b) 的最大公约数 gcd(a, b)
 */
int int_gcd_ex(int a, int b, int *ia, int *ib)
{
    int x, y, x0, y0, x1, y1;
    int q, r;

    /* 消除警告: "warning: ‘x’/‘y’ may be used uninitialized in this function" */
    x = y = 0;

    /* 初始化最初两项系数 */
    x0 = 1; y0 = 0;
    x1 = 0; y1 = 1;

    q = a / b;
    r = a % b;

    while (r != 0)
    {
        /* 计算当前项 x/y */
        x = x0 - q * x1;
        y = y0 - q * y1;

        /* 依次保存前两项到 x0/y0, x1/y1 */
        x0 = x1; x1 = x;
        y0 = y1; y1 = y;

        a = b;
        b = r; /* 前一次的余数 */

        q = a / b;
        r = a % b;
    }

    *ia = x;
    *ib = y;

    return b;
}

函数int_gcd_ex的返回值和int_gcd一样，都返回其参数 a 和 b 的最大公约数，不同的是，除了返回最大公约数之外，还通过指针参数返回线性方程 2.1 中的 x 和 y值。

二者的函数原型如下:

int int_gcd(int a, int b);
int int_gcd_ex(int a, int b, int *x, int *y);

3. 求整数的乘法逆元

在第2节的公式 2.1 中，当 g c d ( a , b ) = 1 gcd(a, b) = 1 gcd(a,b)=1 时，有:
a x + b y = 1 = g c d ( a , b ) ax + by = 1 = gcd(a, b) ax+by=1=gcd(a,b)

等式两边同时 m o d   b mod\ b mod b，有: a x   m o d   b + b y   m o d   b ≡ 1   m o d   b ax\ mod\ b + by\ mod\ b \equiv 1\ mod\ b ax mod b+by mod b≡1 mod b，而 b y   m o d   b = 0 by\ mod\ b = 0 by mod b=0。
所以:
a x ≡ 1   m o d   b ax \equiv 1\ mod\ b ax≡1 mod b
因此，a 和 x 在模b 的前提下互为逆元。

第2节的函数int_gcd_ex在求整数 a 和整数 b 最大公约数的同事，可以顺带求出 a 和 b 的乘法逆元。

以下代码复用int_gcd_ex，求整数 a 基于整数 b 的乘法逆元:

/**
 * @description: 基于扩展欧几里得算法计算整数 a 关于 整数 b 的乘法逆元
 * @param {int} a 整数 a
 * @param {int} b 整数 b
 * @return {*} 返回整数 a 关于整数 b 的最小正整数乘法逆元, 乘法逆元不存在(gcd(a, b) != 1)则返回 0;
 */
int int_inv(int a, int b)
{
    int res, ia, ib;

    res = int_gcd_ex(a, b, &ia, &ib);

    /* gcd(a, b) != 1, 没有乘法逆元 */
    if (res != 1)
    {
        return 0;
    }

    /* 调整小于 0 的情况 */
    if (ia < 0)
    {
        ia += b;
    }

    return ia;
}

这里的函数名是integer inverse的简写，如果整数 a 和整数 b 的最大公约数为1(互素)，则返回整数 a 关于整数 b 的最小正整数逆元，如果不能满足这个条件，则函数返回 0。

上面的代码中，在求乘法逆元时，通过扩展欧几里得算法int_gcd_ex同时得到了整数 a 和整数 b 的逆元 ia 和 ib，但整数 b 的逆元 ib 并没有被使用，所以可以在int_inv函数中将int_gcd_ex的代码展开，去掉所有整数 b 逆元计算相关代码，得到的新的代码如下:

/**
 * @description: 基于扩展欧几里得算法计算整数 a 关于 整数 b 的乘法逆元(展开 int_gcd_ex 后的优化版本)
 * @param {int} a 整数 a
 * @param {int} b 整数 b
 * @return {*} 返回整数 a 关于整数 b 的最小正整数乘法逆元, 乘法逆元不存在(gcd(a, b) != 1)则返回 0;
 */
int int_inv(int a, int b)
{
    int x, x0, x1;
    int q, r, t;

    /* 消除警告: "warning: ‘x’/‘y’ may be used uninitialized in this function" */
    x = 0;

    /* 初始化最初两项系数 */
    x0 = 1;
    x1 = 0;

    /* 临时保存 b */
    t = b;

    q = a / b;
    r = a % b;

    while (r != 0)
    {
        /* 计算当前项 x */
        x = x0 - q * x1;

        /* 依次保存前两项到 x0, x1 */
        x0 = x1; x1 = x;

        a = b;
        b = r; /* 前一次的余数 */

        q = a / b;
        r = a % b;
    }

    /* gcd(a, b) != 1, 没有乘法逆元 */
    if (b != 1)
    {
        return 0;
    }

    /* 调整小于 0 的情况 */
    if (x < 0)
    {
        x += t;
    }

    return x;
}

优化的内容主要是减少整数 b 计算乘法逆元所使用相关变量 y, y0, y1 的赋值，减少这 3 个变量所占用的空间。实际加解密中，求逆元的代码并不会非常频繁被调用，因此这个优化带来的效率提升我认为比较有限。

相比之下，我还是更喜欢调用int_gcd_ex求乘法逆元的版本，因为这个版本代码更简洁，思路更清晰。

4. 完整代码和测试

4.1 源码

  • 头文件gcd.h:
/*
 * @        file: gcd.h
 * @ description: 整数和扩展域上多项式的最大公约数(gcd), 乘法逆元(multiple reverse)的计算
 * @      author: Yongqiang Gu
 * @        blog: https://blog.csdn.net/guyongqiangx
 */
#ifndef __GCD_H__
#define __GCD_H__
#ifdef __cplusplus
extern "C"
{
#endif

/**
 * @description: 使用欧几里得算法(辗转相除)求最大公约数
 * @param {int} a 整数a
 * @param {int} b 整数b
 * @return {*} 返回整数 (a, b) 的最大公约数
 */
int int_gcd(int a, int b);

/**
 * @description: 使用扩展欧几里得算法: Extend Euclidean Algorithm (EEA) 计算等式 a x ia + b x ib = gcd(a, b) 中的 ia, ib 和 gcd(a, b)
 * @param {int} a 整数 a
 * @param {int} b 整数 b
 * @param {int} *ia 整数 a 的系数 ia
 * @param {int} *ib 整数 b 的系数 ib
 * @return {*} 返回整数 (a, b) 的最大公约数 gcd(a, b)
 */
int int_gcd_ex(int a, int b, int *ia, int *ib);

/**
 * @description: 基于扩展欧几里得算法计算整数 a 关于 整数 b 的乘法逆元
 * @param {int} a 整数 a
 * @param {int} b 整数 b
 * @return {*} 返回整数 a 关于整数 b 的最小正整数乘法逆元, 乘法逆元不存在(gcd(a, b) != 1)则返回 0;
 */
int int_inv(int a, int b);

#ifdef __cplusplus
}
#endif
#endif
  • 源码文件int_gcd.c:
/*
 * @        file: int_gcd.c
 * @ description: 整数的最大公约数(欧几里得算法 Euclidean Algorithm)，和扩展欧几里得算法(Extend Euclidean Algorithm)求乘法逆元的实现
 * @      author: Yongqiang Gu
 * @        blog: https://blog.csdn.net/guyongqiangx
 */
#include "gcd.h"

///**
// * @description: 使用欧几里得算法(辗转相除)求最大公约数的递归版本
// * @param {int} a 整数a
// * @param {int} b 整数b
// * @return {*} 返回整数 (a, b) 的最大公约数
// */
//int int_gcd(int a, int b)
//{
//    if (b == 0)
//    {
//        return a;
//    }
//    else
//    {
//        return int_gcd(b, a % b);
//    }
//}


/**
 * @description: 使用欧几里得算法(辗转相除)求最大公约数的非递归版本
 * @param {int} a 整数a
 * @param {int} b 整数b
 * @return {*} 返回整数 (a, b) 的最大公约数
 */
int int_gcd(int a, int b)
{
    int t;

    while (b != 0)
    {
        t = a % b;
        a = b;
        b = t;
    }

    return a;
}

///**
// * @description: 使用扩展欧几里得算法(EEA)计算等式 a x ia + b x ib = gcd(a, b) 中的系数 ia, ib 和 gcd(a, b), 递归版本, 推导和证明参考: https://blog.csdn.net/lincifer/article/details/49391175
// * @param {int} a 整数 a
// * @param {int} b 整数 b
// * @param {int} *ia 整数 a 的系数 ia
// * @param {int} *ib 整数 b 的系数 ib
// * @return {*} 返回整数 (a, b) 的最大公约数 gcd(a, b)
// */
//int int_gcd_ex(int a, int b, int *ia, int *ib)
//{
//    int x, y;
//    int q, r;
//
//    if (b == 0)
//    {
//        *ia = 1;
//        *ib = 0;
//
//        return a;
//    }
//
//    r = int_gcd_ex(b, a % b, &x, &y);
//
//    *ia = y;
//    *ib = x - a / b * y;
//
//    return r;
//}

/**
 * @description: 使用扩展欧几里得算法(EEA) 计算等式 a x ia + b x ib = gcd(a, b) 中的系数 ia, ib 和 gcd(a, b), 非递归版本
 * @param {int} a 整数 a
 * @param {int} b 整数 b
 * @param {int} *ia 整数 a 的系数 ia
 * @param {int} *ib 整数 b 的系数 ib
 * @return {*} 返回整数 (a, b) 的最大公约数 gcd(a, b)
 */
int int_gcd_ex(int a, int b, int *ia, int *ib)
{
    int x, y, x0, y0, x1, y1;
    int q, r;

    /* 消除警告: "warning: ‘x’/‘y’ may be used uninitialized in this function" */
    x = y = 0;

    /* 初始化最初两项系数 */
    x0 = 1; y0 = 0;
    x1 = 0; y1 = 1;

    q = a / b;
    r = a % b;

    while (r != 0)
    {
        /* 计算当前项 x/y */
        x = x0 - q * x1;
        y = y0 - q * y1;

        /* 依次保存前两项到 x0/y0, x1/y1 */
        x0 = x1; x1 = x;
        y0 = y1; y1 = y;

        a = b;
        b = r; /* 前一次的余数 */

        q = a / b;
        r = a % b;
    }

    *ia = x;
    *ib = y;

    return b;
}

///**
// * @description: 基于扩展欧几里得算法计算整数 a 关于 整数 b 的乘法逆元
// * @param {int} a 整数 a
// * @param {int} b 整数 b
// * @return {*} 返回整数 a 关于整数 b 的最小正整数乘法逆元, 乘法逆元不存在(gcd(a, b) != 1)则返回 0;
// */
//int int_inv(int a, int b)
//{
//    int res, ia, ib;
//
//    res = int_gcd_ex(a, b, &ia, &ib);
//
//    /* gcd(a, b) != 1, 没有乘法逆元 */
//    if (res != 1)
//    {
//        return 0;
//    }
//
//    /* 调整小于 0 的情况 */
//    if (ia < 0)
//    {
//        ia += b;
//    }
//
//    return ia;
//}

/**
 * @description: 基于扩展欧几里得算法计算整数 a 关于 整数 b 的乘法逆元(展开 int_gcd_ex 后的优化版本)
 * @param {int} a 整数 a
 * @param {int} b 整数 b
 * @return {*} 返回整数 a 关于整数 b 的最小正整数乘法逆元, 乘法逆元不存在(gcd(a, b) != 1)则返回 0;
 */
int int_inv(int a, int b)
{
    int x, x0, x1;
    int q, r, t;

    /* 消除警告: "warning: ‘x’ may be used uninitialized in this function" */
    x = 0;

    /* 初始化最初两项系数 */
    x0 = 1;
    x1 = 0;

    /* 临时保存 b */
    t = b;

    q = a / b;
    r = a % b;

    while (r != 0)
    {
        /* 计算当前项 x */
        x = x0 - q * x1;

        /* 依次保存前两项到 x0, x1 */
        x0 = x1; x1 = x;

        a = b;
        b = r; /* 前一次的余数 */

        q = a / b;
        r = a % b;
    }

    /* gcd(a, b) != 1, 没有乘法逆元 */
    if (b != 1)
    {
        return 0;
    }

    /* 调整小于 0 的情况 */
    if (x < 0)
    {
        x += t;
    }

    return x;
}

4.2 基于gtest的单元测试

  • 测试代码

基于gtest的单元测试int_gcd_unittest.cc:

// g++ int_gcd.c int_gcd_unittest.cc -o int_gcd -Igtest/include -Lgtest/lib -lgtest_main -lgtest -lpthread
#include "gcd.h"
#include <gtest/gtest.h>

TEST(IntegerGCDTest, CompositeTest)
{
    /* gcd(60, 0) = 60, gcd(0, 20) = 20 */
    EXPECT_EQ(60, int_gcd(60,  0));
    EXPECT_EQ(20, int_gcd( 0, 20));

    EXPECT_EQ(12, int_gcd(60, 24));
    EXPECT_EQ(11, int_gcd(55, 22));
    EXPECT_EQ( 3, int_gcd(33, 18));
    EXPECT_EQ( 3, int_gcd(27, 21));
    EXPECT_EQ( 6, int_gcd(84, 30));
    EXPECT_EQ(10, int_gcd(50, 30));
    EXPECT_EQ( 7, int_gcd(973, 301));

    EXPECT_EQ(77, int_gcd(7469, 2464));
    EXPECT_EQ(34, int_gcd(24140, 16762));
    EXPECT_EQ(35, int_gcd(4655, 12075));
    EXPECT_EQ(1078, int_gcd(1160718174, 316258250));
}

TEST(IntegerGCDTest, PrimeTest)
{
    EXPECT_EQ(1, int_gcd(67, 12));
    EXPECT_EQ(1, int_gcd(29, 100));
    EXPECT_EQ(1, int_gcd(1759, 550));
    EXPECT_EQ(1, int_gcd(2689, 4001));
}

TEST(IntegerExtEuclideanTest, GCDTest)
{
    int ia, ib;

    EXPECT_EQ(3, int_gcd_ex(33, 18, &ia, &ib));
    EXPECT_EQ(3, int_gcd_ex(18, 33, &ia, &ib));

    EXPECT_EQ(1, int_gcd_ex(100, 29, &ia, &ib));
    EXPECT_EQ(1, int_gcd_ex(29, 100, &ia, &ib));

    EXPECT_EQ(10, int_gcd_ex(50, 30, &ia, &ib));

    EXPECT_EQ(1, int_gcd_ex(1759, 550, &ia, &ib));
}

TEST(IntegerExtEuclideanTest, InverseTest)
{
    int res, ia, ib;

    /* 198 x (-11) + 243 x 9 = 9 = gcd(198, 243) */
    res = int_gcd_ex(198, 243, &ia, &ib);
    EXPECT_EQ(  9, res);
    EXPECT_EQ(-11, ia);
    EXPECT_EQ(  9, ib);

    /* 1819 x 71 + 3587 x (-36) = 17 = gcd(1819, 3587) */
    res = int_gcd_ex(1819, 3587, &ia, &ib);
    EXPECT_EQ( 17, res);
    EXPECT_EQ( 71, ia);
    EXPECT_EQ(-36, ib);

    res = int_gcd_ex(100, 29, &ia, &ib);
    EXPECT_EQ(  1, res);
    EXPECT_EQ(  9, ia);
    EXPECT_EQ(-31, ib);

    res = int_gcd_ex(12, 67, &ia, &ib);
    EXPECT_EQ( 1, res);
    EXPECT_EQ(28, ia);
    EXPECT_EQ(-5, ib);

    res = int_gcd_ex(973, 301, &ia, &ib);
    EXPECT_EQ(  7, res);
    EXPECT_EQ( 13, ia);
    EXPECT_EQ(-42, ib);

    res = int_gcd_ex(1234, 4321, &ia, &ib);
    EXPECT_EQ(    1, res);
    EXPECT_EQ(-1082, ia);
    EXPECT_EQ(  309, ib);

    res = int_gcd_ex(24140, 40902, &ia, &ib);
    EXPECT_EQ(  34, res);
    EXPECT_EQ(-571, ia);
    EXPECT_EQ(337, ib);

    res = int_gcd_ex(1759, 550, &ia, &ib);
    EXPECT_EQ(   1, res);
    EXPECT_EQ(-111, ia);
    EXPECT_EQ( 355, ib);

    res = int_gcd_ex(550, 1769, &ia, &ib);
    EXPECT_EQ(   1, res);
    EXPECT_EQ( 550, ia);
    EXPECT_EQ(-171, ib);
}

TEST(IntegerInverseTest, InverseTest)
{
    /* gcd(33, 18) = 3, no inverse */
    EXPECT_EQ(0, int_inv(33, 18));
    /* gcd(30, 50) = 10, no inverse */
    EXPECT_EQ(0, int_inv(30, 50));

    /* gcd(12, 67) = 1, 12 x 28 mod 67 = 1 */
    EXPECT_EQ(28, int_inv(12, 67));

    /* gcd(1759, 550) = 1, 1759 x 439 mod 550 = 1 */
    EXPECT_EQ(439, int_inv(1759, 550));
    EXPECT_EQ(355, int_inv(550, 1759));

    EXPECT_EQ(3239, int_inv(1234, 4321));
    EXPECT_EQ(0, int_inv(24140, 40902));
    EXPECT_EQ(550, int_inv(550, 1769));

    EXPECT_EQ(69, int_inv(29, 100));
    EXPECT_EQ(9, int_inv(100, 29));
}
  • 测试结果
[==========] Running 5 tests from 3 test suites.
[----------] Global test environment set-up.
[----------] 2 tests from IntegerGCDTest
[ RUN      ] IntegerGCDTest.CompositeTest
[       OK ] IntegerGCDTest.CompositeTest (0 ms)
[ RUN      ] IntegerGCDTest.PrimeTest
[       OK ] IntegerGCDTest.PrimeTest (0 ms)
[----------] 2 tests from IntegerGCDTest (0 ms total)

[----------] 2 tests from IntegerExtEuclideanTest
[ RUN      ] IntegerExtEuclideanTest.GCDTest
[       OK ] IntegerExtEuclideanTest.GCDTest (0 ms)
[ RUN      ] IntegerExtEuclideanTest.InverseTest
[       OK ] IntegerExtEuclideanTest.InverseTest (0 ms)
[----------] 2 tests from IntegerExtEuclideanTest (0 ms total)

[----------] 1 test from IntegerInverseTest
[ RUN      ] IntegerInverseTest.InverseTest
[       OK ] IntegerInverseTest.InverseTest (0 ms)
[----------] 1 test from IntegerInverseTest (0 ms total)

[----------] Global test environment tear-down
[==========] 5 tests from 3 test suites ran. (0 ms total)
[  PASSED  ] 5 tests.

5. 其它

洛奇工作中常常会遇到自己不熟悉的问题，这些问题可能并不难，但因为不了解，找不到人帮忙而瞎折腾，往往导致浪费几天甚至更久的时间。

所以我组建了几个微信讨论群(记得微信我说加哪个群，如何加微信见后面)，欢迎一起讨论:

  • 一个密码编码学讨论组，主要讨论各种加解密，签名校验等算法，请说明加密码学讨论群。
  • 一个Android OTA的讨论组，请说明加Android OTA群。
  • 一个git和repo的讨论组，请说明加git和repo群。

在工作之余，洛奇尽量写一些对大家有用的东西，如果洛奇的这篇文章让您有所收获，解决了您一直以来未能解决的问题，不妨赞赏一下洛奇，这也是对洛奇付出的最大鼓励。扫下面的二维码赞赏洛奇，金额随意：

收钱码

洛奇自己维护了一个公众号“洛奇看世界”，一个很佛系的公众号，不定期瞎逼逼。公号也提供个人联系方式，一些资源，说不定会有意外的收获，详细内容见公号提示。扫下方二维码关注公众号：

公众号

密码【扩展欧几里得】
算法小猪的博客
07-15 409
题目描述 有一个密码箱，000到n−1n-1n−1中的某些整数是它的密码。且满足：如果a和b都是它的密码，那么(a+b)(a+b)%n(a+b)也是它的密码(a,b可以相等，%表示整除取余数)，某人试了kkk次密码，前k−1k-1k−1次都失败了，最后一次成功了。 问：该密码箱最多有多少不同的密码。 输入 第一行两个整数分别表示n，k（1≤k≤250000，k≤n≤10141≤k≤250000，k≤n≤10^{14}1≤k≤250000，k≤n≤1014）。第二行为k个用空格隔开的非负整数，表示每次试的密码
扩展欧几里得算法求逆元---乘法密码
HPU_FRDHR的博客
08-11 6651
背景知识： 欧几里得算法：又叫做辗转相除法，用来求两个数的最大公约数。通过辗转相除，当余数为0的时候，最后的除数就是两个数的最大公约数。 例如：求20和11的最大公约数 每次将除数作为下一个式子的被除数，将余数作为下一个式子的除数。 20➗11=1......9 11➗9=1......2 9➗2=4......1 2➗1=2......0 所以最大公约数为最后一个式子的除数1，即gcd(20，11)=...
密码学 欧几里得算法
m_de_g的博客
04-10 1359
密码学 欧几里得算法，乘法逆元，辗转相除法
扩展欧几里得算法：求解乘法逆元
最新发布
aw2371的博客
04-14 1067
扩展欧几里得算法：求解乘法逆元
【密码学｜算法设计】拓展的欧几里得算法及理论证明 (Extended Euclidean Algorithm)
Mart_inn的博客
12-18 971
拓展的欧几里得算法及理论证明
密码学学习之旅--欧几里得算法
林林子的博客
04-20 1019
在用欧几里得算法以前先得说说整除，最小公倍数，最大公因数 1.整除：a=bq，则称b整除a，或者a能被b整除。记为: b|a 。若b 不能被a整除则：b|/a(这里的|/是穿过那一竖的，因为某些原因不能打出来) 2.最大公因数：a1,a2,a3…an为n个不全为0 的整数，d是其中每个数的因数，则称d为a1,a2,a3,…,an的公因数所有公因数中最大的称为最大公因数。记为：gcd(a1,a2,a...
《应用密码学》 欧几里得算法-Euclid
xfmeng17的专栏
11-06 1335
代码： /* ID: 53101304 PROG: Euclid LANG: C TIME:2012/11/6 */ #include<stdio.h> #include<time.h> int Euclid(unsigned int f,unsigned int d) { unsigned int x=f; unsigned int y=d; if( (x==...
扩展欧几里得算法实验实现
11-30
在密码学中，扩展欧几里得算法常用于计算模逆元素，即给定两个正整数a和n，找到一个整数x使得ax≡1(mod n)成立。如果存在这样的x，则称a对于模n有逆元素，也称a模n乘法可逆。这是公钥加密和密钥交换协议中的一个重要...
C语言 扩展欧几里得算法代码
09-05
扩展欧几里得算法，也称为扩展gcd（Greatest Common Divisor）算法，是一种用于求解最大公约数以及其...通过这个算法，我们可以高效地找到满足特定线性关系的整数对，这对密码学、模逆运算和数论等领域都有重要应用。
东南大学密码学实验——扩展欧几里得算法
07-02
本实验“东南大学密码学实验——扩展欧几里得算法”是针对该领域的一次实践教学，旨在让学生深入理解并掌握扩展欧几里得算法这一基础数学工具。本文将详细解析该算法及其在密码学中的应用。 扩展欧几里得算法是基于...
rsa.rar_扩展欧几里得 算法
09-24
扩展欧几里得算法是数论中的一个基本算法，用于求解最大公约数（Greatest Common Divisor, GCD）以及找到整数a、b的乘积x和y，使得ax + by = gcd(a, b)。这个算法在密码学、计算机科学等领域有广泛应用，特别是在RSA...
密码学考试复习（关于快速指数算法和扩展欧几里得求逆元）
09-23
密码学考试复习（关于快速指数算法和扩展欧几里得求逆元），之前考试自己整理的，今天又要学了。里面的算法还能看，还整理的比较透彻当时。备用了留在这。不知道为什么之前上传的xmind一点就跳转到别的页面了，这次压缩下。
欧几里得算法及扩展的欧几里得算法的C++实现
03-25
欧几里得算法及扩展的欧几里得算法的C++实现。包括.cpp,.exe可执行文件。我的作业。对于密码学和C++初学者有用处，希望对大家有帮助。
c语言实现扩展的欧几里得算法
12-10
包括完整的c语言实现扩展的欧几里得算法代码截图和相关代码说明以及程序截图
欧几里得算法的应用1
08-03
摘要辗转相除法求两个数的最大公约数是最早被数学家研究的算法之一，并且和数论中如连分数，丢番图方程有着紧密的联系。本文从基本的欧几里得算法谈起，涉及了几个数论问题
扩展欧几里得算法及应用(密码学数学基础)
Vincent_zhang1949的博客
03-29 640
当A×B mod N = 1，(A,N)=1时，用扩展的欧几里得算法可求得A关于N的逆。 欧几里得算法： N = A × a0 + r0 A = r0 × a1 + r1 r0 = r1 × a2 + r2 … rn-2 = rn-1 × an + rn rn-1 = rn × an+1 + 0 将a逆序排列 an an-1 an-2 … a3 a2 a1 a0 推导逆元： b-1 =...
应用密码学-扩展的欧几里得算法（The Extended Euclidean Algorithm）简单理解
谁月
10-12 1299
扩展的欧几里得算法的应用： 1.能够确定两个正整数的最大公约数 2.如果这两个正整数互素（互质），还能确定他们的逆元 如果整数n≥1，且gcd(a,n)=1,那么a有一个模n的乘法逆元a-1。即对小于n的正整数a，存在一个小于n的整数a，存在一个小于n的整数a-1，使得a * a-1≡1 mod n。 以上是教材内的定义，有点晦涩难懂，可以暂且不深入理解，我们先来看看扩展的欧几里得算法的描述：...
欧几里德与扩展欧几里德算法——密码学笔记（五）
傲娇的萌、的博客
04-04 1186
一、欧几里德算法又称辗转相除法，用于计算两个整数a,b的最大公约数。基本算法：设a=qb+r，其中a，b，q，r都是整数，则gcd（a,b）=gcd（b，r），即gcd（a，b）=gcd（b，a%b）整除：若整数a除以非零整数b，商为整数，且余数为零，我们就说a能被b整除（或说b能整除a），a为被除数，b为除数，即b|a（“|”是整除符号），读作“b整除a”或“a能被b整除”。a叫做b的倍数，b叫...
欧几里得算法
、moddemod
12-12 469
欧几里得算法是初等数论中的一个基本算法，也是密码学中最常用的算法之一，它利用辗转相除法求得给定整数a、b的最打公约数，还可以将辗转相除的过程倒推回去，用a与b的一种线性组合表示其最大公约数。一种特殊情况是当a与b互素时，可以求得a mod b或者b mod a的乘法逆元，这个过程也称为扩展的欧几里得算法。 辗转相除 给定两个数a与b，求最大公约数： #include <stdio.h>...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

洛奇看世界

一分也是爱~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值