（应用密码学实验报告）实验1 密码学数学基础

最新推荐文章于 2024-03-26 10:06:52 发布

gebriella_N12

最新推荐文章于 2024-03-26 10:06:52 发布

阅读量2.4k

点赞数 4

分类专栏：密码学文章标签：密码学

本文链接：https://blog.csdn.net/weixin_52852770/article/details/127479554

版权

密码学专栏收录该内容

3 篇文章 4 订阅

订阅专栏

一、实验目的

理解密码学有关数学基础的原理
能够使用语言实现相关数学算法

二、实验内容

理解掌握欧几里算法和扩展的欧几里得算法
理解掌握有限域运算
理解掌握中国剩余定理
理解掌握素性检测的几种方式

三、实验环境

在Educoder平台进行实验

四、实验要求

根据每个实训的每个关卡要求完成代码提交和测评

五、实验步骤

1：欧几里得和扩展的欧几里得(C语言描述)

第一关：欧几里得算法

实现原理：用较大数除以较小数，再用出现的余数（第一余数）去除除数，再用出现的余数（第二余数）去除第一余数，如此反复，直到最后余数是0为止。如果是求两个数的最大公约数，那么最后的除数就是这两个数的最大公约数。在右侧编辑器补充代码，使用欧几里得算法计算两个正整数的最大公约数。

#include<stdio.h>
#include<stdlib.h>
long Euclid(long a, long b) {

if(b==0)return a;
Euclid(b,a%b);

}
int main(int argc,char *argv[])
{
	long a,b;
	scanf("%ld %ld",&a,&b);//测试集输入
	long t = 0;
	if(a < b) {
		t = a;
		a = b;
		b = t;
	}
	printf("%ld\n", Euclid(a, b));
	return 0;
}

第二关：扩展欧几里得算法

实现原理：我们知道对于任意整数a,b都有ax+by=gcd(a,b)成立，所以得到

1.ax0+by0=gcd(a,b)

2.递归迭代一次得到 bx1+(a%b)y1=gcd(b,a%b)

3.gcd(a,b)=gcd(b,a%b)

由1，2，3式子得ax0+by0=bx1+(a%b)y1，(a%b)y1=(a-a/b*b)*y1

故ax0+by0=bx1+(a-a/b*b)y1，解得x0=y1,y0=x1-(a/b)*y1

不难发现，要得到x0,y0就要先求出下一次迭代的解x1,y1，要得到x1,y1就要再迭代一次求出x2,y2…一直迭代到最后，所以递归迭代到最后ax+by=gcd(a,0)=a, a×1+ b×0=a,所以此时子解为x=1，y=0.然后不断回溯上去就得到了正解x0，y0。

#include<stdio.h>
long exEuclid(long a, long b, long &x, long &y) {
    //printf("%ld %ld %ld %ld\n", a, b, x, y); 

 if(b==0)
    {
        x=1;
        y=0;
        return a;
    }
    int ret = exEuclid(b,a % b, x, y);
    int t=x;
    x=y;
    y = t-a/b * y;
    return ret;


}

int main() {
	long a, b, x = 0, y = 0, t;
	scanf("%ld %ld", &a, &b);  //测试集输入a、b，要求exEuclid函数的输出与a、b输入的顺序无关
	if(a > b) {
		t = a;
		a = b;
		b = t;
	}
	printf("%ld %ld %ld", x, y, exEuclid(a, b, x, y)); 
	//使得函数exEuclid返回gcd(a,b),依次输出x、y、gcd，使得等式a*x+b*y=gcd(a,b)
	return 0;
}

2：欧几里得和扩展的欧几里得

第一关：欧几里得算法

实现原理：主要用于求解两个数a和b的最大公约数,我们不妨设(a>b),其公式为gcd(a,b)=gcd(b,a%b)=gcd(a%b,b%(a%b))=…=gcd(x,0),这里的x即为最大公约数.

def gcd(a,b):
    if a < b:
        t=a
        a=b
        b=t
    while a % b!= 0:
        temp=a%b
        a=b
        b=temp
    return b


def main():
    a = int(input()) 
    b = int(input())
    r = gcd(a,b)
    print(r)
if __name__=='__main__':
    main()

第二关：扩展的欧几里得算法

实现原理：实际是求不定方程ax+by=gcd(a,b)，并且，我们所返回的值，是这组解（x，y）的最大公因数（gcd(x,y)），所以我们最后得到的解，要通过X=x∗k/gcd(a,b)，Y=(k−a∗x)/gcd(a,b)来进行一个小小的转换，得到一组解。

def extendGcd(m,b):

    if m < b:
        t = m
        m = b
        b = t
    x1, x2, x3 = 1, 0, m
    y1, y2, y3 = 0, 1, b
    while True:
        if y3 == 0:
            return 'None'
            break
        elif y3 == 1:
            return y2 % m
            break
        else:
            Q = x3 // y3
            t1, t2, t3 = x1 - Q * y1, x2 - Q * y2, x3 - Q * y3
            x1, x2, x3 = y1, y2, y3
            y1, y2, y3 = t1, t2, t3

def main():
    a = int(input()) 
    b = int(input())
    r = extendGcd(a,b)
    print(r)
    
if __name__=='__main__':
    main()

3.有限域运算

第一关：X-time运算

实现原理：可以通过time()函数来获得计算机系统当前的日历时间(Calendar Time)，处理日期时间的函数都是以本函数的返回值为基础进行运算。

#include <stdio.h>
#include <stdlib.h>
unsigned char XTIME(unsigned char x) 
{
//*******************Begin*******************
unsigned char temp, result;
    int x1 = 0x1b;
    temp = x << 1;
    if (x > 64)
    {
        result = temp ^ x1;
    }
    else
    {
        return temp;
    }
    
    return result;
//*********************End********************
}

int main()
{
	unsigned char a;
	scanf("%x",&a);
	printf("0x%x\n",XTIME(a));
	return 0;
}

第二关：有限域GF(2^8)运算

实现原理：可以先将输入的两个十六进制串转化为二进制，转化完后对它们进行乘法运算（下面会有样例）得到多项式mx，然后找到最高幂的次数，比较一下与8的差值，得到差c，再将不可约多项式乘上x^c，再与mx进行异或运算，再寻找下一个最高项的指数，重复以上运算，直到出现最高项的指数小于8。然后就得到了答案。

#include<stdio.h>

unsigned char XTIME(unsigned char x) {
//*******************Begin*******************
    return ((x << 1) ^ ((x & 0x80) ? 0x1b : 0x00));  
//********************End********************
}

unsigned char multiply(unsigned char a, unsigned char b) {
//*******************Begin*******************
    unsigned char temp[8] = { a };  
        unsigned char tempmultiply = 0x00;  
        int i = 0;  
        for (i = 1; i < 8; i++) {  
            temp[i] = XTIME(temp[i - 1]);  
        }  
        tempmultiply = (b & 0x01) * a;  
        for (i = 1; i <= 7; i++) {  
            tempmultiply ^= (((b >> i) & 0x01) * temp[i]);  
        }  
        return tempmultiply;  
//********************End********************
}

int main() {
    unsigned char array[20];
    scanf("%x%x",&array[0],&array[1]);
    unsigned char q=array[0];
    unsigned char w=array[1];
    printf("%x\n", multiply(q, w));
    return 0;
}

4.中国剩余定理

第一关：中国剩余定理：

实现原理：若某未知数ax与常数b对常数n取模后结果相同，可以表示成ax≡b (mod n)的方程。此方程有解当且仅当 b 能够被 a 与 n 的最大公约数整除(记作 gcd(a,n) | b)。这时，如果 x0 是方程的一个解，那么所有的解可以表示为:{x0+kn/d|(k∈z)}，其中 d 是a 与 n 的最大公约数。在模 n 的完全剩余系 {0,1,…,n-1} 中，恰有 d 个解。

# -*- coding: UTF-8 -*-
def Get_Mi(m_list,M):
    M_list=[]
    for mi in m_list:
        M_list.append(M//mi)
    return M_list

def Get_ei_list(M_list,m_list):
    ei_list=[]
    for i in range(len(M_list)):
        ei_list.append(Get_ei(M_list[i],m_list[i])[0])
    return ei_list
   
def Get_ei(a,b):
    # 计算ei
    #        请在此处添加代码       #
    # *************begin************#
    if 0 == b:
        x = 1;
        y = 0;
        q = a
        return x, y, q
    xyq = Get_ei(b, a % b)
    x = xyq[0];
    y = xyq[1];
    q = xyq[2]
    temp = x;
    x = y;
    y = temp - a // b * y
    return x, y, q
    # **************end*************# 

def crt(a_list,m_list):
    # 计算中国剩余定理，返回计算结果
    #        请在此处添加代码       #
    # *************begin************#
    M = 1 
    for mi in m_list:
        M *= mi
    Mi_list = Get_Mi(m_list, M)
    Mi_inverse = Get_ei_list(Mi_list, m_list)
    x = 0
    for i in range(len(a_list)):  
        x += Mi_list[i] * Mi_inverse[i] * a_list[i]
        x %= M
    return x
    # **************end*************#
    
if __name__=='__main__':
    a_list= list(map(int,input().split(",")))
    m_list= list(map(int,input().split(",")))
    print(crt(a_list,m_list))

5.素性检验

第一关：除余法素性检测

实现原理：素数的因数只有1和它本身，而合数因数取值范围在1~自己。

import math

def is_prime(num):
#***********Begin**************
    if num > 1:
        if num == 2:
            print("Yes")
            return 1
        if num % 2 == 0:
            print("No")
            return 0
        for x in range(3, int(math.sqrt(num) + 1), 2):
            if num % x == 0:
                print("No")
                return 0
        print("Yes")
        return 1
    print("No")
    return 0
    
#************End***************
if __name__ == "__main__":
    number = input()
    is_prime(int(number))

第二关：爱拉托斯散筛法

实现原理：要得到自然数n以内的全部素数，必须把不大于根号n的所有素数的倍数剔除，剩下的就是素数。算法思想：给出要筛数值的范围，找出其以内的素数。先用2去筛，即把2留下，把2的倍数剔除掉；再用下一个质数3去筛，把3留下，把3的倍数剔除掉；接下去用下一个质数5筛，把5留下，把5的倍数剔除掉；不断重复下去.....


import math

def Evidence(number):
#***********Begin**************
    p=[2]
    q=[]
    for i in range(3,int(math.sqrt(number))+1):
        flag=0
        for j in range(2,i):
            if i%j==0:
                flag=1
                break
        if flag==0:
            p.append(i)
    # print(p)
    for k in range(2,number+1):
        q.append(k)
    for i in p:
        for j in q:
            if j % i == 0:
                q.remove(j)
    for i in range(len(q)):
        p.append(q[i])
    print(p)

#************End***************

if __name__ == "__main__":
    number = input()
    Evidence(int(number))

第三关：并发编程判断大素数

实现原理：map 方法会返回一个map(func, *iterables)迭代器，迭代器中的回调执行返回的结果有序的。

from concurrent.futures import ProcessPoolExecutor
import math

# 素性判断函数
def is_prime(num):
    if num > 1:
        if num == 2:
            return True
        if num % 2 == 0:
            return False
        for x in range(3, int(math.sqrt(num) + 1), 2):
            if num % x == 0:
                return False
        return True
    return False

# 通过调用is_prime，设计并发函数实现对多个大素数的判断
def main():
    with ProcessPoolExecutor() as executor:
        for i in executor.map(is_prime, PRIMES):
            print(i)

if __name__ == '__main__':
    PRIMES = list(map(int, input().split(",")))
    main()