使用经典密码算法DES,RSA,SHA-1对字符串进行加解密

最新推荐文章于 2024-07-19 12:07:56 发布
最新推荐文章于 2024-07-19 12:07:56 发布
阅读量513 收藏 3
点赞数 1
分类专栏： Java编程 文章标签： java 开发语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43824515/article/details/128036735
版权
本文详细介绍了三种常见的加密算法：DES、RSA和SHA-1。首先，展示了DES算法的加密和解密过程，然后讲解了RSA非对称加密的实现，包括密钥对的生成、加密和解密。最后，深入探讨了SHA-1哈希算法的摘要计算步骤，提供了一个完整的SHA-1实现示例。这些内容对于理解信息安全和数据加密至关重要。
摘要由CSDN通过智能技术生成

1、DES算法

import java.util.Scanner;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
public class DES {
	public static byte[] initKey() throws Exception {
	    KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
	    keyGenerator.init(56); // 56 可填可不填
	    SecretKey secretKey = keyGenerator.generateKey();
	    return secretKey.getEncoded();
	}
	public static byte[] encryptDES(byte[] key, byte[] data) throws Exception {
        SecretKey secretKey = new SecretKeySpec(key, "DES");
        Cipher cipher = Cipher.getInstance("DES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        byte[] resultBytes = cipher.doFinal(data);
        return resultBytes;

    }
	public static String decryptDES(byte[] key, byte[] data) throws Exception {
        SecretKey secretKey = new SecretKeySpec(key, "DES");
        Cipher cipher = Cipher.getInstance("DES");
        //Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] resultBytes = cipher.doFinal(data);
        return new String(resultBytes);
    }
	public static void main(String[] args) throws Exception {
		System.out.print("请输入要加密的内容：");
		Scanner scan = new Scanner(System.in);
		String data = scan.next();
        byte[] key = initKey();
        byte[] resultBytes = encryptDES(key, data.getBytes());
        String resultString = byteToHexString(resultBytes);
        System.out.println(resultString);
    }
	private static String byteToHexString(byte[] resultBytes) {
		StringBuffer sb = new StringBuffer(resultBytes.length);
	    String sTmp;
	    for (int i = 0; i < resultBytes.length; i++) {
	        sTmp = Integer.toHexString(0xFF & resultBytes[i]);
	        if (sTmp.length() < 2)
	            sb.append(0);
	        sb.append(sTmp.toUpperCase());
	    }
	    return sb.toString();
	}
}

2、RSA算法

package com.fknight.sbsmdemo.tools;
 
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.io.UnsupportedEncodingException;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
public class RSAUtil {
    public static KeyPair getKeyPair() throws NoSuchAlgorithmException, UnsupportedEncodingException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");    // 获得RSA密钥对的生成器实例
        SecureRandom secureRandom = new SecureRandom(String.valueOf(System.currentTimeMillis()).getBytes("utf-8")); // 说的一个安全的随机数
        keyPairGenerator.initialize(2048, secureRandom);    // 这里可以是1024、2048 初始化一个密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();   // 获得密钥对
        return keyPair;
    }
    public static String getPublicKey(KeyPair keyPair){
        PublicKey publicKey = keyPair.getPublic();
        byte[] bytes = publicKey.getEncoded();
        return Base64.getEncoder().encodeToString(bytes);
    }
    public static String getPrivateKey(KeyPair keyPair){
        PrivateKey privateKey = keyPair.getPrivate();
        byte[] bytes = privateKey.getEncoded();
        return Base64.getEncoder().encodeToString(bytes);
    }
    public static PublicKey string2PublicKey(String pubStr) throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] bytes = Base64.getDecoder().decode(pubStr);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey = keyFactory.generatePublic(keySpec);
        return publicKey;
    }
    public static PrivateKey string2Privatekey(String priStr) throws NoSuchAlgorithmException, InvalidKeySpecException {
        byte[] bytes = Base64.getDecoder().decode(priStr);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }
    public static byte[] publicEncrytype(byte[] content, PublicKey publicKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }
    public static byte[] privateDecrypt(byte[] content, PrivateKey privateKey) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] bytes = cipher.doFinal(content);
        return bytes;
    }
}

package com.fknight.sbsmdemo.tools;
 
import java.security.*;
import java.util.Base64;
public class RSAUtilTest {
 
    public static void main(String[] args){
        String content = "20181422+郁文斌";   // 明文内容
        System.out.println("原始字符串是：" + content);
        try {
            // 获得密钥对
            KeyPair keyPair =  RSAUtil.getKeyPair();
            // 获得进行Base64 加密后的公钥和私钥 String
            String privateKeyStr = RSAUtil.getPrivateKey(keyPair);
            String publicKeyStr = RSAUtil.getPublicKey(keyPair);
            System.out.println("Base64处理后的私钥：" + privateKeyStr + "\n"
                + "Base64处理后的公钥：" + publicKeyStr);
 
            // 获得原始的公钥和私钥，并以字符串形式打印出来
            PrivateKey privateKey = RSAUtil.string2Privatekey(privateKeyStr);
            PublicKey publicKey = RSAUtil.string2PublicKey(publicKeyStr);
 
            // 公钥加密/私钥解密
            byte[] publicEncryBytes =  RSAUtil.publicEncrytype(content.getBytes(), publicKey);
            System.out.println("公钥加密后的字符串(经BASE64处理)：" + Base64.getEncoder().encodeToString(publicEncryBytes));
            byte[] privateDecryBytes = RSAUtil.privateDecrypt(publicEncryBytes, privateKey);
            System.out.println("私钥解密后的原始字符串：" + new String(privateDecryBytes));
 
            String privateDecryStr = new String(privateDecryBytes, "utf-8");
            if (content.equals(privateDecryStr)){
                System.out.println("测试通过！");
            }else {
                System.out.println("测试未通过！");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3、SHA-1算法计算摘要值

import java.util.Scanner;

public class SHA1 {
	private final int[] abcde = { 0x67452301, 0xefcdab89, 0x98badcfe,
			0x10325476, 0xc3d2e1f0 };
	// 摘要数据存储数组
	private int[] digestInt = new int[5];
	// 计算过程中的临时数据存储数组
	private int[] tmpData = new int[80];

	// 计算sha-1摘要
	private int process_input_bytes(byte[] bytedata) {
		// 初试化常量
		System.arraycopy(abcde, 0, digestInt, 0, abcde.length);
		// 格式化输入字节数组，补10及长度数据
		byte[] newbyte = byteArrayFormatData(bytedata);
		// 获取数据摘要计算的数据单元个数
		int MCount = newbyte.length / 64;
		// 循环对每个数据单元进行摘要计算
		for (int pos = 0; pos < MCount; pos++) {
			// 将每个单元的数据转换成16个整型数据，并保存到tmpData的前16个数组元素中
			for (int j = 0; j < 16; j++) {
				tmpData[j] = byteArrayToInt(newbyte, (pos * 64) + (j * 4));
			}
			// 摘要计算函数
			encrypt();
		}
		return 20;
	}

	// 格式化输入字节数组格式
	private byte[] byteArrayFormatData(byte[] bytedata) {
		// 补0数量
		int zeros = 0;
		// 补位后总位数
		int size = 0;
		// 原始数据长度
		int n = bytedata.length;
		// 模64后的剩余位数
		int m = n % 64;
		// 计算添加0的个数以及添加10后的总长度
		if (m < 56) {
			zeros = 55 - m;
			size = n - m + 64;
		} else if (m == 56) {
			zeros = 63;
			size = n + 8 + 64;
		} else {
			zeros = 63 - m + 56;
			size = (n + 64) - m + 64;
		}
		// 补位后生成的新数组内容
		byte[] newbyte = new byte[size];
		// 复制数组的前面部分
		System.arraycopy(bytedata, 0, newbyte, 0, n);
		// 获得数组Append数据元素的位置
		int l = n;
		// 补1操作
		newbyte[l++] = (byte) 0x80;
		// 补0操作
		for (int i = 0; i < zeros; i++) {
			newbyte[l++] = (byte) 0x00;
		}
		// 计算数据长度，补数据长度位共8字节，长整型
		long N = (long) n * 8;
		byte h8 = (byte) (N & 0xFF);
		byte h7 = (byte) ((N >> 8) & 0xFF);
		byte h6 = (byte) ((N >> 16) & 0xFF);
		byte h5 = (byte) ((N >> 24) & 0xFF);
		byte h4 = (byte) ((N >> 32) & 0xFF);
		byte h3 = (byte) ((N >> 40) & 0xFF);
		byte h2 = (byte) ((N >> 48) & 0xFF);
		byte h1 = (byte) (N >> 56);
		newbyte[l++] = h1;
		newbyte[l++] = h2;
		newbyte[l++] = h3;
		newbyte[l++] = h4;
		newbyte[l++] = h5;
		newbyte[l++] = h6;
		newbyte[l++] = h7;
		newbyte[l++] = h8;
		return newbyte;
	}

	private int f1(int x, int y, int z) {
		return (x & y) | (~x & z);
	}

	private int f2(int x, int y, int z) {
		return x ^ y ^ z;
	}

	private int f3(int x, int y, int z) {
		return (x & y) | (x & z) | (y & z);
	}

	private int f4(int x, int y) {
		return (x << y) | x >>> (32 - y);
	}

	// 单元摘要计算函数
	private void encrypt() {
		for (int i = 16; i <= 79; i++) {
			tmpData[i] = f4(tmpData[i - 3] ^ tmpData[i - 8] ^ tmpData[i - 14]
					^ tmpData[i - 16], 1);
		}
		int[] tmpabcde = new int[5];
		for (int i1 = 0; i1 < tmpabcde.length; i1++) {
			tmpabcde[i1] = digestInt[i1];
		}
		for (int j = 0; j <= 19; j++) {
			int tmp = f4(tmpabcde[0], 5)
					+ f1(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4]
					+ tmpData[j] + 0x5a827999;
			tmpabcde[4] = tmpabcde[3];
			tmpabcde[3] = tmpabcde[2];
			tmpabcde[2] = f4(tmpabcde[1], 30);
			tmpabcde[1] = tmpabcde[0];
			tmpabcde[0] = tmp;
		}
		for (int k = 20; k <= 39; k++) {
			int tmp = f4(tmpabcde[0], 5)
					+ f2(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4]
					+ tmpData[k] + 0x6ed9eba1;
			tmpabcde[4] = tmpabcde[3];
			tmpabcde[3] = tmpabcde[2];
			tmpabcde[2] = f4(tmpabcde[1], 30);
			tmpabcde[1] = tmpabcde[0];
			tmpabcde[0] = tmp;
		}
		for (int l = 40; l <= 59; l++) {
			int tmp = f4(tmpabcde[0], 5)
					+ f3(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4]
					+ tmpData[l] + 0x8f1bbcdc;
			tmpabcde[4] = tmpabcde[3];
			tmpabcde[3] = tmpabcde[2];
			tmpabcde[2] = f4(tmpabcde[1], 30);
			tmpabcde[1] = tmpabcde[0];
			tmpabcde[0] = tmp;
		}
		for (int m = 60; m <= 79; m++) {
			int tmp = f4(tmpabcde[0], 5)
					+ f2(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4]
					+ tmpData[m] + 0xca62c1d6;
			tmpabcde[4] = tmpabcde[3];
			tmpabcde[3] = tmpabcde[2];
			tmpabcde[2] = f4(tmpabcde[1], 30);
			tmpabcde[1] = tmpabcde[0];
			tmpabcde[0] = tmp;
		}
		for (int i2 = 0; i2 < tmpabcde.length; i2++) {
			digestInt[i2] = digestInt[i2] + tmpabcde[i2];
		}
		for (int n = 0; n < tmpData.length; n++) {
			tmpData[n] = 0;
		}
	}

	// 4字节数组转换为整数
	private int byteArrayToInt(byte[] bytedata, int i) {
		return ((bytedata[i] & 0xff) << 24) | ((bytedata[i + 1] & 0xff) << 16)
				| ((bytedata[i + 2] & 0xff) << 8) | (bytedata[i + 3] & 0xff);
	}

	// 整数转换为4字节数组
	private void intToByteArray(int intValue, byte[] byteData, int i) {
		byteData[i] = (byte) (intValue >>> 24);
		byteData[i + 1] = (byte) (intValue >>> 16);
		byteData[i + 2] = (byte) (intValue >>> 8);
		byteData[i + 3] = (byte) intValue;
	}

	// 将字节转换为十六进制字符串
	private static String byteToHexString(byte ib) {
		char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
				'B', 'C', 'D', 'E', 'F' };
		char[] ob = new char[2];
		ob[0] = Digit[(ib >>> 4) & 0X0F];
		ob[1] = Digit[ib & 0X0F];
		String s = new String(ob);
		return s;
	}

	// 将字节数组转换为十六进制字符串
	private static String byteArrayToHexString(byte[] bytearray) {
		String strDigest = "";
		for (int i = 0; i < bytearray.length; i++) {
			strDigest += byteToHexString(bytearray[i]);
		}
		return strDigest;
	}

	// 计算sha-1摘要，返回相应的字节数组
	public byte[] getDigestOfBytes(byte[] byteData) {
		process_input_bytes(byteData);
		byte[] digest = new byte[20];
		for (int i = 0; i < digestInt.length; i++) {
			intToByteArray(digestInt[i], digest, i * 4);
		}
		return digest;
	}

	// 计算sha-1摘要，返回相应的十六进制字符串
	public String getDigestOfString(byte[] byteData) {
		return byteArrayToHexString(getDigestOfBytes(byteData));
	}

	public static void main(String[] args) {
		System.out.print("请输入要加密的内容：");
		Scanner scan = new Scanner(System.in);
		String data = scan.next();
		String digest = new SHA1().getDigestOfString(data.getBytes());
		System.out.println(digest);
	}
}

嗜甜兔星人
关注
专栏目录
Java中SHA1加密算法
...
04-30 1775
package com.example.test; /**  * SHA1加密  * @author 宋小亮 *  */ public class SHA1 {     private final int[] abcde = {             0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0    
RSA算法的简单实现，对输入的带空格的字符串加密。
weixin_44234110的博客
10-13 1590
简单的RSA加密，没有大整数库，验证RSA算法 code blocks可以直接跑 由于取模的特性，0模任何数得0，不能将空格放在转换数组的第一位，第一位下标为0，加密后可以看出空格位置。 代码如下，测试能运行就直接发了，没有封装好加密解密过程，所以主函数看起来很乱。 大家可以参考一下~ #include<bits/stdc++.h> using namespace std; //单个...
sha1 加密解密
11-29
sha1加密解密的这个不错的，经过测试的，很好的
用标准库进行MD5，sha1加密，AES,DES，RSA加解密代码示例
最新发布
m0_57265868的博客
07-19 203
【代码】用标准库进行MD5，sha1加密，AES,DES，RSA加解密代码示例。
rsa对字符串加密c语言,RSA算法C语言实现
weixin_27977279的博客
05-17 1149
一、源文件三个rsa.h , rsa.c, main.c//rsa.h#include #define MAX_NUM 63001#define MAX_PRIME 251//! 返回代码#define OK 100#define ERROR_NOEACHPRIME 101#define ERROR_NOPUBLICKEY 102#define ERROR_GENERROR 103unsigned...
MD5和SHA-1数字签名加密算法破解全过程
aaaaatiger--寻路
11-17 6524
短短半年的时间，数字签名加密算法的两座大厦先后倒塌——MD5和SHA-1这两种应用最为广泛的数字签名加密算法都被山东大学的王小云教授破解，业界为这次数字签名遭遇的“9.11”事件感到震惊的同时，也开始对今天广泛应用的数字签名算法体系进行反思，我国于2005年4月1日开始实施的《电子签名法》也开始承受各种压力。 　　在8个月以前，人们还以为在全球广泛应用的MD5和SHA-1都是值得信任的安全的数字签
Vue-常用加密(MD5,DES,SHA256,BASE64,SHA1,RSA)
11-29
常见的 Hash 算法包括 MD2、MD4、MD5、HAVAL、SHA、SHA-1、HMAC、HMAC-MD5、HMAC-SHA1 等。 Hash 算法的应用场景包括文件或字符串一致性校验、数字签名、鉴权协议等。 五、加密算法的选择 在选择加密算法时，需要...
java对sha1的解密_java 加密解密算法MD5/SHA1，DSA
weixin_29800319的博客
02-12 5353
通常,使用的加密算法 比较简便高效,密钥简短，加解密速度快，破译极其困难。本文介绍了 MD5/SHA1，DSA，DESede/DES，Diffie-Hellman的使用。第1章基础知识1.1. 单钥密码体制单钥密码体制是一种传统的加密算法，是指信息的发送方和接收方共同使用同一把密钥进行加解密。通常,使用的加密算法比较简便高效,密钥简短，加解密速度快，破译极其困难。但是加密的安全性依靠密钥保管的安全...
易语言字符串加解密源码-易语言
06-13
加解密通常涉及到密码学的一些基础算法，如对称加密（如DES、AES）、非对称加密（如RSA）以及哈希函数（如MD5、SHA-1）等。不过，由于易语言的特性，我们可能会看到一些简化版或自定义的加密算法，这些算法可能并不...
易语言 加解密 算法 嘻哈算法 rsa算法 大全 源码 易语言 JS 加密 解密 算法 都有 源码
11-20
常见的嘻哈算法包括MD5（Message-Digest Algorithm 5）和SHA（Secure Hash Algorithm）家族，如SHA-1、SHA-256等。这些算法将任意长度的数据转化为固定长度的摘要，用于验证数据是否被篡改。在易语言中，实现嘻哈...
rsa-aes-utils:RSA、AES 加解密，支持 JavaScript 、Node.js、Java
05-06
常见的对称加密算法主要有 DES、3DES、AES 等，常见的非对称算法主要有 RSA、DSA 等，散列算法主要有SHA-1、MD5 等。 对称算法又可分为两类。一次只对明文中的单个位（有时对字节）运算的算法称为序列算法或序列密码...
SHA-1加密与解密 特征
01-08
算法简介： 安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于2^64位的消息，SHA1会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。 最初载明的算法于1993年发布，称做安全散列标准 (Secure Hash Standard)，FIPS PUB 180。这个版本常被称为 “SHA-0”
C语言RSA实现对字符串加密,C语言实现RSA加解密算法
weixin_32264185的博客
05-18 2760
http://www.open-open.com/code/view/14357185378882015.071. RSA说明RSA公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在(美国麻省理工学院)开发的。RSA取名来自开发他们三者的名字。RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困难，因此可...
sha1算法破解
热门推荐
Onlyone_1314的博客
10-09 1万+
去https://www.mysterytwisterc3.org/注册一个账号（字母大写），i注册的时候有个Captcha可能要FQ才能显示，账号密码记住以后要用到。 完成关卡Cracking SHA1-Hashed Passwords https://www.mysterytwisterc3.org/en/challenges/level-ii/cracking-sha1-hashed-passwords pdf中键盘上的指纹，它提示我们密码中可能出现的字符有“QWINqwin%(*=2468”，且密
Android SHA1加密解密
zkszk的博客
11-30 5568
SHA1加密解密 public static String jmSha1Key() throws Exception { String jm_key = Sha1Util.encryptToSHA(MD5.md5("Y@WKyzcB9LP7%SEy")); return jm_key; } public class Sha1Util { pub...
使用RSA对字符串进行加密解密
weixin_48285922的博客
04-02 3329
Android RSA对字符串进行加密解密 RSA的应用 RSA是一种非对称加密算法。现在，很多登陆表单的密码的都采用RSA加密，例如京东中的登陆使用公钥对密码进行加密。 RSA加密与解密 使用RSA一般需要产生公钥和私钥，当采用公钥加密时，使用私钥解密；采用私钥加密时，使用公钥解密。以下为Java程序： /** 使用公钥加密 */ public static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Except
数据库的sha1密码破解
Onlyone_1314的博客
10-09 1万+
从前有一个熊孩子入侵了一个网站的数据库，找到了管理员密码，手一抖在数据库中修改了 一下，现在的密码变成了 4B58475789E60DBF1A28GD638B556A938134644C8。 （41位）那个熊孩子其实就是我！肿么办求解原始密码！在线等，挺急的。。 hint：密码长度为5 现在的密码是40位16进制数加上“G”这个多余的非16进制数，可能是题目中说的手抖修改了一下加上了这个，上次预习作业pre0中出现的sha1加密算法，加密后的密文是160位2进制数即40位16进制，所以上面的密码应该是sha
rsa加解密字符串
qq_35279788的博客
08-15 2356
之前在做项目时，客户提了个需求说是对前后台交互进行加密传输，我们给的解决方案是前端进行加密后将加密数据传输给后台，然后后台根据对应的密钥进行解密，当时选择的算法是rsa算法，但是大家都知道rsa算法加解密是有最大长度限制的，加密的最长字符串是117个字节，解密的最大长度是 前端js使用jsencrypt模块进行加密，jsencrypt模块原来只支持不超过117字节的字符串的加密，我对启进行了再次封装，现在支持超长字符串的加密，住最大长度，目前看还没有限制。该方案首先需要下载jsencrypt-master
c语言字符串非对称加密,RSA算法C语言实现（支持任意位密钥）
weixin_34986860的博客
05-17 1393
之前分享过三种常用MD5、SHA2和AES加密算法(点这里)实现源码，前三者分别属于哈希加密和对称加密，而另一种很常用的非对称加密RSA算法实现这次分享出来。RSA算法的原理和用途大家可以网上自行搜索。虽然其算法原理很简单，但是由于其密钥长度很长(一般至少1024位)，所以实际在其相互运算以及大质数查找会牵扯很多算法理论，因此我这里代码实现中数学运算是直接基于GMP(The GNUMultipl...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

嗜甜兔星人

创作不易，球球各位看官支持一下

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

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

打赏作者

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

抵扣说明：

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

余额充值