HIT·信息安全数学基础·实验二

最新推荐文章于 2024-07-25 00:08:05 发布
最新推荐文章于 2024-07-25 00:08:05 发布
阅读量23 收藏
点赞数
文章标签： python java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22607673/article/details/135169747
版权

实验背景

RSA 算法是一种公开密钥算法，由 Ron Rivest、Adi Shamir 和 Leonard Adleman
于 1977 年共同提出。该算法旨在解决利用公开信道传输、分发私钥的难题，还
可以用于保护数据信息的完整性，能够抵抗目前已知的绝大多数密码攻击，已被
国际标准化组织推荐为公钥数据加密标准。
本次实验要求同学们利用 Java 或者其它编程语言对经典的 RSA 算法和
RSA-OAEP 算法进行实践。
本次实验的目的包括：

  1. 理解和掌握 RSA 算法和 RSA-OAEP 算法的原理和流程：通过实验，学习
    RSA 算法和 RSA-OAEP 算法的基本原理和流程，了解公钥加密、私钥解密的过
    程，并理解其安全性和适用性。
  2. 了解加密算法的性能和效率：实验中可以对比 RSA 算法和 RSA-OAEP 算
    法在不同输入大小和密钥长度下的加密和解密性能，对比它们的效率和时间复杂
    度，评估其在实际应用中的可行性。
  3. 实践加密和解密过程：通过实验，实际进行 RSA 算法和 RSA-OAEP 算法
    的加密和解密操作，加深对于加密和解密过程的理解，并掌握编写相关代码的技
    巧和经验。
  4. 评估算法的安全性：通过实验，了解 RSA 算法和 RSA-OAEP 算法的安全
    性，对比它们的安全性级别，例如密钥长度、抵御常见攻击方式等，评估其在实
    际应用中的安全性。
  5. 探索实际应用场景：通过实验，尝试将 RSA 算法和 RSA-OAEP 算法应用
    于实际场景，例如加密通信、数字签名等，评估它们的适用性和效果，并思考如
    何结合其他技术改进和扩展算法的应用。

实验内容

RSA算法

  1. 实现密钥生成
  2. 实现加密
  3. 实现解密

OAEP算法

  1. 填充算法
  2. 加密算法
  3. 解密算法

注意事项

本次实验的算法是要求用到实验一种写到的快速幂、欧几里得、扩展的欧几里得算法的，因此需要考虑自己实验所写的代码的接口

实验代码

RSA

package myRSA;

import java.math.BigInteger;
import java.util.Random;
import java.util.Scanner;
import myFast.FastModularExpo;
public class RSA {

    // 生成大素数
    public static BigInteger getPrime(int bitCount) {
        return BigInteger.probablePrime(bitCount, new Random());//随机生成一个大素数，bitCount对位数进行定义
    }

    // 生成公私钥
    public static BigInteger[] generateKey(int bits) {
        BigInteger p = getPrime(bits / 2);
        BigInteger q = getPrime(bits / 2);
        BigInteger n = p.multiply(q);
        BigInteger phi = p.subtract(BigInteger.ONE).multiply(q.subtract(BigInteger.ONE));

        BigInteger e = BigInteger.valueOf(65537); // 公钥值取65537
        while (phi.gcd(e).intValue() > 1) {
            e = e.add(new BigInteger("2"));
        }

        BigInteger d = e.modInverse(phi);

        return new BigInteger[]{e, d, n};
    }

    // 加密
    public static BigInteger encrypt(BigInteger plaintext, BigInteger e, BigInteger n) {
        return FastModularExpo.fastModPow(plaintext, e, n);
    }

    // 解密
    public static BigInteger decrypt(BigInteger ciphertext, BigInteger d, BigInteger n) {
        return FastModularExpo.fastModPow(ciphertext, d, n);
    }

    // 主函数
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入安全参数 bits: ");
        int bits = scanner.nextInt();

        System.out.print("请输入要加密的明文: ");
        BigInteger plaintext = scanner.nextBigInteger();

        BigInteger[] keys = generateKey(bits);
        BigInteger e = keys[0];
        BigInteger d = keys[1];
        BigInteger n = keys[2];

        System.out.println("公钥 (e, n): (" + e + ", " + n + ")");
        System.out.println("私钥 (d, n): (" + d + ", " + n + ")");

        BigInteger ciphertext = encrypt(plaintext, e, n);
        System.out.println("加密后的密文: " + ciphertext);

        BigInteger decryptedText = decrypt(ciphertext, d, n);
        System.out.println("解密后的明文: " + decryptedText);

        scanner.close();
    }
}

RSA-OAEP

import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;
import myRSA.RSA;//自己写的RSA算法

public class RSA_OAEP {

    // 生成指定长度的大素数
    public BigInteger getPrime(int bitCount) {
        return BigInteger.probablePrime(bitCount, new Random());//同样的，生成一个大素数
    }

    // 生成加密解密所需要的公、私密钥对
    public BigInteger[] generateKey(int bits) {
       return RSA.generateKey(bits);//调用刚才写的RSA函数的生成密钥方法
    }

    // 生成掩码
    public byte[] MGF(byte[] X, int maskLen) throws NoSuchAlgorithmException {//错误的时候要抛出异常才行
        //X是seed，masklen是掩码长度
        MessageDigest md = MessageDigest.getInstance("SHA-256");//用SHA-256算法进行生成一个消息摘要
        byte[] T = new byte[maskLen];//存储最终的掩码
        int counter = 0;
        byte[] C = new byte[4];
        int hLen = md.getDigestLength();//获取digest的长度

        while (counter < (maskLen / hLen)) {
            ByteBuffer.wrap(C).putInt(counter);//将计数器的值转换为字节然后存储在C中
            md.update(X);//更新消息摘要，加入输入种子，然后加入C
            md.update(C);
            System.arraycopy(md.digest(), 0, T, counter * hLen, hLen);//把消息摘要复制到T
            counter++;
        }

        if (maskLen % hLen != 0) {//处理最后部分
            ByteBuffer.wrap(C).putInt(counter);
            md.update(X);
            md.update(C);
            System.arraycopy(md.digest(), 0, T, counter * hLen, maskLen % hLen);
        }

        return T;
    }

    // 消息填充算法
    public byte[] encode(byte[] plainOAEP/*原始参数*/, String L, int k/*RSA秘钥长度*/) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-256");//初始化消息摘要
        byte[] lHash = md.digest(L.getBytes());//计算md的hash值
        int hLen = lHash.length;
        int mLen = plainOAEP.length;

        if (k < (mLen + 2 * hLen + 2)) {
            throw new IllegalArgumentException("Encoding error, message too long.");
        }

        byte[] PS = new byte[k - mLen - 2 * hLen - 2];
        byte[] DB = ByteBuffer.allocate(k - hLen - 1)
                .put(lHash)
                .put(PS)
                .put((byte) 0x01)
                .put(plainOAEP)
                .array();
        //创建数据块 `DB`，包含 `lHash`、`PS`、一个字节的 `0x01` 和原始消息。
        byte[] seed = new byte[hLen];//创建种子
        new SecureRandom().nextBytes(seed);//随机填充种子
        byte[] dbMask = MGF(seed, k - hLen - 1);//用MGF生成数据块掩码
        byte[] maskedDB = new byte[dbMask.length];

        for (int i = 0; i < dbMask.length; i++) {
            maskedDB[i] = (byte) (DB[i] ^ dbMask[i]);//异或操作将dbMask应用于DB
        }
        //掩码种子
        byte[] seedMask = MGF(maskedDB, hLen);
        byte[] maskedSeed = new byte[seed.length];

        for (int i = 0; i < seed.length; i++) {
            maskedSeed[i] = (byte) (seed[i] ^ seedMask[i]);
        }

        return ByteBuffer.allocate(1 + maskedSeed.length + maskedDB.length)
                .put((byte) 0x00)
                .put(maskedSeed)
                .put(maskedDB)
                .array();
    }

    // OAEP 加密
//    public BigInteger encryptOAEP(byte[] plainOAEP, String L, int k, BigInteger e, BigInteger n) throws NoSuchAlgorithmException {
//        byte[] EM = encode(plainOAEP, L, k);
//        BigInteger m = new BigInteger(1, EM); // 确保 BigInteger 是正数
//        BigInteger c = m.modPow(e, n);
//
//        // 将 BigInteger 转换为字节数组，并确保长度与 k 相匹配
//        byte[] cipherBytes = c.toByteArray();
//        if (cipherBytes.length < k) {
//            byte[] temp = new byte[k];
//            System.arraycopy(cipherBytes, 0, temp, k - cipherBytes.length, cipherBytes.length);
//            cipherBytes = temp;
//        }
//
//        return new BigInteger(cipherBytes);
//    }
    public BigInteger encryptOAEP(byte[] plainOAEP, String L, int k, BigInteger e, BigInteger n) throws NoSuchAlgorithmException {
        byte[] EM = encode(plainOAEP, L, k);
        BigInteger m = new BigInteger(1, EM); // 确保 BigInteger 是正数

        // 使用自己写的 RSA 加密方法
        BigInteger c = RSA.encrypt(m, e, n);

        // 将 BigInteger 转换为字节数组，并确保长度与 k 相匹配
        byte[] cipherBytes = c.toByteArray();
        if (cipherBytes.length < k) {
            byte[] temp = new byte[k];
            System.arraycopy(cipherBytes, 0, temp, k - cipherBytes.length, cipherBytes.length);
            cipherBytes = temp;
        }

        return new BigInteger(cipherBytes);
    }

    // 解码（去掉填充）
    public byte[] decode(byte[] EM/*加密后的消息*/, String L, int k/*秘钥的长度*/) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("SHA-256");
        byte[] lHash = md.digest(L.getBytes());
        int hLen = lHash.length;

        if (EM.length != k || k < 2 * hLen + 2) {
            throw new IllegalArgumentException("Decoding error, incorrect message length.");
        }

        byte Y = EM[0];//提取第一个字节0x00
        byte[] maskedSeed = Arrays.copyOfRange(EM, 1, hLen + 1);//根据算法 提取掩码后的种子
        byte[] maskedDB = Arrays.copyOfRange(EM, hLen + 1, EM.length);//提取掩码后的数据块

        byte[] seedMask = MGF(maskedDB, hLen);//利用MGF和maskedDB生成种子掩码
        byte[] seed = new byte[hLen];
        for (int i = 0; i < hLen; i++) {//还原db
            seed[i] = (byte) (maskedSeed[i] ^ seedMask[i]);
        }

        byte[] dbMask = MGF(seed, k - hLen - 1);
        byte[] DB = new byte[dbMask.length];
        for (int i = 0; i < dbMask.length; i++) {
            DB[i] = (byte) (maskedDB[i] ^ dbMask[i]);
        }
        //vertify the hash
        if (!Arrays.equals(Arrays.copyOfRange(DB, 0, hLen), lHash)) {
            throw new IllegalArgumentException("Decoding error, lHash mismatch.");
        }

        int index = hLen;
        while (index < DB.length && DB[index] == 0) {
            index++;
        }
        //找到DB第一个非零字节后的部分，就是原始消息
        if (index == DB.length || DB[index] != 1) {
            throw new IllegalArgumentException("Decoding error, incorrect padding.");
        }

        return Arrays.copyOfRange(DB, index + 1, DB.length);
    }

    //解密
    public byte[] decrypt(BigInteger cipherOAEP, String L, int k, BigInteger d, BigInteger n) throws NoSuchAlgorithmException {
        BigInteger c = cipherOAEP;
//        BigInteger m = c.modPow(d, n);
        BigInteger m = RSA.decrypt(c,d,n);
        byte[] decryptedBytes = m.toByteArray();
        if (decryptedBytes.length < k) {
            byte[] temp = new byte[k];
            System.arraycopy(decryptedBytes, 0, temp, k - decryptedBytes.length, decryptedBytes.length);
            decryptedBytes = temp;
        }

        return decode(decryptedBytes, L, k);
    }

    public static void main(String[] args) throws NoSuchAlgorithmException {
        RSA_OAEP rsa = new RSA_OAEP();
        Scanner scanner = new Scanner(System.in);

        // 输入比特数
        System.out.print("Enter the bit count for RSA key generation: ");
        int bitCount = scanner.nextInt();

        // 生成公钥和私钥
        BigInteger[] keys = rsa.generateKey(bitCount);
        BigInteger e = keys[0]; // 公钥 e
        BigInteger d = keys[1]; // 私钥 d
        BigInteger n = keys[2]; // 公钥和私钥共用 n

        System.out.print("Enter the message to encrypt: ");
        scanner.nextLine();
        String message = scanner.nextLine();

        // 加密
        byte[] encrypted = rsa.encryptOAEP(message.getBytes(), "", n.bitLength() / 8, e, n).toByteArray();
        System.out.println("Encrypted message: " + Arrays.toString(encrypted));

        // 解密
        byte[] decrypted = rsa.decrypt(new BigInteger(encrypted), "", n.bitLength() / 8, d, n);
        System.out.println("Decrypted message: " + new String(decrypted));
    }
}
西风三级#3
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
哈尔滨工业大学（HIT）人工智能数学基础实验二
01-19
在哈尔滨工业大学（HIT）的人工智能数学基础课程中，实验二是学习者深入理解与应用数学基础知识的关键环节。这个实验主要关注的是如何将数学理论应用于实际的人工智能问题，特别是那些涉及深度学习、机器学习以及...
哈尔滨工业大学（HIT）人智数学基础实验3
06-22
【哈工大（HIT）人智数学基础实验3】是针对在校学生设计的一个课程实践环节，旨在深化理解和应用数学基础知识。在这个实验中，学生将有机会通过编程和理论分析来解决数学问题，提升数学思维与实际操作能力。下面将...
HIT·信息安全数学基础[实验一]
qq_22607673的博客
12-23 34
HIT信息安全数学基础实验一
HIT·信息安全数学基础·实验
qq_22607673的博客
12-23 21
HIT信息安全数学基础实验
HIT·信息安全数学基础·实验四
qq_22607673的博客
12-23 86
HIT·信息安全数学基础·实验四
HIT·信息安全数学基础·实验三
qq_22607673的博客
12-23 24
HIT·信息安全数学基础·实验三
哈尔滨工业大学（HIT）人工智能数学基础实验1
05-24
在哈尔滨工业大学（HIT）的人工智能数学基础实验1中，学生将深入探索人工智能与数学的紧密联系，这是构建高效AI系统的基础。本实验旨在帮助学生掌握必要的数学工具，为后续的人工智能学习打下坚实的基础。以下是实验...
HIT哈工大软件构造实验lab2
06-17
实验环境配置是实验的基础，学生需要熟悉Java开发环境和Git版本控制系统。在实验中，学生需要使用Java语言实现图形数据结构和诗歌走步算法，并使用Git版本控制系统来管理代码。 三、实验过程 实验过程可以分为四个...
哈尔滨工业大学（HIT）人工智能数学基础ppt课件
06-15
《哈尔滨工业大学（HIT）人工智能数学基础》课程涵盖了人工智能领域必不可少的数学知识，旨在为学生构建坚实的数学基础，以理解并应用到复杂的人工智能算法中。以下是对压缩包内各部分主要内容的详细阐述： 1. **第...
使用Python的Turtle库绘制动态风车
爱写代码的小朋友
07-20 436
python绘制风车
随机数种子的作用
帆的博客
07-23 761
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
【Python如何将字符串连接在一起并使用`join()`方法】
qq_36253366的博客
07-19 471
方法是字符串对象的方法，而不是列表或元组等序列类型的方法。因此，你需要先指定一个用作分隔符的字符串，然后调用这个字符串的。方法将字符串连接在一起，你需要首先确保这些字符串被存储在一个序列类型中（如列表或元组），然后调用这个序列的。方法是一个字符串方法，它用于将序列（如列表、元组等）中的元素以指定的字符连接生成一个新的字符串。列表中的所有字符串元素使用空格作为分隔符连接成一个新的字符串。方法，并将你想要作为分隔符的字符串作为参数传递给。方法，并将包含要连接字符串的序列作为参数传递。
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
使用9种方法隐藏和显示元素
lulei5153的博客
07-21 178
【代码】使用9种方法隐藏和显示元素。
【Python 中的内存管理有哪些优缺点】
qq_36253366的博客
07-19 471
Python中的内存管理是一个复杂而高效的系统，它通过自动化和抽象化的方式极大地简化了程序员的内存管理负担，但同时也存在一些潜在的缺点。
ChatGPT对话：关于训练模型h5格式和SavedModel格式的问题
最新发布
uestcai的博客
07-25 1100
适用于h5和SavedModel格式的 Keras 模型。加载模型后直接使用，接口简单方便。主要用于本地推理和评估。适用于SavedModel格式的模型，需要通过签名访问和使用，更灵活但也更复杂。主要用于部署和远程推理，如在 TensorFlow Serving 中使用。
提取autocad2024图形中图块的属性的代码-统计选中图块长度属性的总长度
VB973490770的专栏
07-24 95
阀门位号：XV-123。
python-快速上手爬虫
纸上得来终觉浅
07-19 899
道路千万条，安全第一条 。爬虫不谨慎，亲人两行泪
"【2018hit计算机系统安全】实验一：文件权限管理和沙盒环境搭建
【2018hit计算机系统安全】实验一：文件权限管理及搭建虚拟环境；【2018hit计算机学院系统安全】实验一：文件权限管理及搭建虚拟环境 本次实验主要涉及文件权限管理和搭建虚拟环境。首先，我们需要设计程序实现euid...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值