HIT·信息安全数学基础[实验一]

实验背景

本次实验要求同学们利用 Java 编程语言对经典的有关信息安全的算法进行
实践，包括： 欧几里得算法、快速幂算法、素数判断算法、中国剩余定理， 实现
每一个算法时应该贴合实际需求以支持大数运算。
本次实验的目的包括：

1. 理解并熟悉信息安全算法的基本概念和原理。
2. 掌握实现和应用信息安全算法的方法。
3. 通过实验验证信息安全算法的安全性和有效性。
4. 比较不同信息安全算法的性能和特点。
5. 发现并分析信息安全算法的潜在漏洞和风险。

实验内容

1. java大数运算
2. 欧几里得算法
3. 扩展的欧几里得算法
4. 快速模幂

注意事项

这个课程的实验指导书写的很详细，算法课上几乎都学过，因此我只贴出自己写的代码供大家一起参考学习，能让有些摸不着头脑的孩子在短暂的时间有一个微弱的光芒作为指路明灯，就已经是我最大的开心动力了QAQ。

实验代码

java大数运算

java大数运算就是按照指导书所写的实验一下即可，略。

欧几里得算法

import java.math.BigInteger;
import java.util.Scanner;

public class gcd {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("Enter the first number:");
        BigInteger a = sc.nextBigInteger();

        System.out.println("Enter the second number");
        BigInteger b = sc.nextBigInteger();

        BigInteger result = euclid(a,b);
        System.out.println("The greatest divisor is:"+result);

        sc.close();
    }
    public static BigInteger euclid(BigInteger a,BigInteger b){
        while(!(b.equals(BigInteger.ZERO))){
            BigInteger temp = a;
            a = b;
            b = temp.mod(b);
        }
        if(b.equals(BigInteger.ZERO)){
            return a;
        }
        else {
            return null;
        }
    }
}

扩展的欧几里得算法

import java.math.BigInteger;
import java.util.Scanner;

public class ExtendedEuclideanAlgorithm {

    // 这个方法实现了扩展欧几里得算法，并返回一个包含GCD以及满足方程ax + by = GCD(a, b)的系数x和y的BigInteger数组
    public static BigInteger[] extendedEuclid(BigInteger a, BigInteger b) {
        // x0和y0是方程ax + by = GCD(a, b)中GCD的系数
        BigInteger x0 = BigInteger.ONE; // x0最初设置为1，因为a*1 + b*0 = a
        BigInteger y0 = BigInteger.ZERO; // y0最初设置为0，因为a*0 + b*1 = b

        // x1和y1用于存储上一次迭代的系数
        BigInteger x1 = BigInteger.ZERO;
        BigInteger y1 = BigInteger.ONE;

        // 临时变量用于交换值
        BigInteger temp;

        // q是除法a / b的商
        BigInteger q;

        // 循环继续直到b变为0
        while (!b.equals(BigInteger.ZERO)) {
            // 将a除以b，得到商q和余数r
            BigInteger[] divisionResult = a.divideAndRemainder(b);
            q = divisionResult[0]; // 商
            BigInteger r = divisionResult[1]; // 余数

            // 为下一次迭代更新a和b的值
            // a取b的值，b取余数r的值
            a = b;
            b = r;

            // 更新x0和x1作为a和b的系数
            // 新的x0是旧的x1
            // 新的x1是旧的x0减去商q乘以旧的x1
            temp = x0.subtract(q.multiply(x1));
            x0 = x1;
            x1 = temp;

            // 更新y0和y1作为a和b的系数
            // 新的y0是旧的y1
            // 新的y1是旧的y0减去商q乘以旧的y1
            temp = y0.subtract(q.multiply(y1));
            y0 = y1;
            y1 = temp;
        }

        // 如果GCD是负数，我们将GCD和系数乘以-1
        // 以使GCD为正数，同时保持等式平衡
        if (a.compareTo(BigInteger.ZERO) < 0) {
            a = a.negate(); // 使GCD为正数
            x0 = x0.negate(); // 调整x系数
            y0 = y0.negate(); // 调整y系数
        }

        // 返回GCD以及系数x和y
        return new BigInteger[]{a, x0, y0};
    }

    public static void main(String[] args) {
        // 使用a = 31和b = -13的例子来演示extendedEuclid方法的使用
        Scanner sc = new Scanner(System.in);
        System.out.println("Pleaser enter a:");
        BigInteger a = sc.nextBigInteger();
        System.out.println("Pleaser enter b:");
        BigInteger b = sc.nextBigInteger();

        // 调用extendedEuclid方法并存储结果
        BigInteger[] result = extendedEuclid(a, b);

        // 打印GCD，x和y
        System.out.println("GCD: " + result[0]); // GCD应该是正数
        System.out.println("x: " + result[1]); // a的系数
        System.out.println("y: " + result[2]); // b的系数
    }
}

快速模幂运算

import java.math.BigInteger;
import java.util.Scanner;

public class FastModularExpo {
    public static BigInteger fastModPow(BigInteger base, BigInteger exponent, BigInteger modulus) {
        BigInteger result = BigInteger.ONE;
        base = base.mod(modulus); // 确保底数小于模数

        while (exponent.compareTo(BigInteger.ZERO) > 0) {
            // 如果当前指数位为1，更新结果
            if (exponent.and(BigInteger.ONE).compareTo(BigInteger.ONE) == 0) {
                result = result.multiply(base).mod(modulus);
            }
            // 指数右移一位，底数变为平方
            exponent = exponent.shiftRight(1);
            base = base.multiply(base).mod(modulus);
        }

        return result;
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("pleaser enter base");
        BigInteger base = sc.nextBigInteger();
        System.out.println("pleaser enter expo");
        BigInteger expo = sc.nextBigInteger();
        System.out.println("pleaser enter modular");
        BigInteger m = sc.nextBigInteger();
//        System.out.println(expo.toString(2));
        System.out.println("the result is:\n"+fastModPow(base,expo,m));

        }


}