RSA加密算法

最新推荐文章于 2024-05-14 21:30:00 发布
最新推荐文章于 2024-05-14 21:30:00 发布
阅读量6k 收藏 8
点赞数
分类专栏： 信息安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ydonghao2/article/details/11069269
版权

        RSA公钥加密算法是1977年由RonRivest、Adi Shamirh和LenAdleman在（美国麻省理工学院）开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的所有密码攻击，已被ISO推荐为公钥数据加密标准。RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

         SET(Secure Electronic Transaction）协议中要求CA采用2048bits长的密钥，其他实体使用1024比特的密钥。RSA密钥长度随着保密级别提高，增加很快。下表xxx列出了对同一安全级别所对应的密钥长度。

             表xxx    同一安全级别所对应的密钥长度

保密级别

对称密钥长度（bit）

RSA密钥长度（bit）

ECC密钥长度（bit）

保密年限

80

80

1024

160

2010

112

112

2048

224

2030

128

128

3072

256

2040

192

192

7680

384

2080

256

256

15360

512

2120


            有关于RSA算法实现Java 6实现与Bouncy Castle实现细节如下表xxx所示：

 

                   表xxx      RSA算法

算法

密钥长度

默认密钥长度

工作模式

填充方式

备注

RSA

512~65536位

（密钥必须

是64的倍数）

1024

ECB

NoPadding、PKCS1Padding、

OAEPWITHMD5AndMGF1Padding、

OAEPWITHSHA1AndMGF1Padding、

OAEPWITHSHA256AndMGF1Padding、

OAEPWITHSHA384AndMGF1Padding、

OAEPWITHSHA512AndMGF1Padding

Java6实现

2048

NONE

NoPadding、PKCS1Padding、

OAEPWITHMD5AndMGF1Padding、

OAEPWITHSHA1AndMGF1Padding、

OAEPWITHSHA256AndMGF1Padding、

OAEPWITHSHA384AndMGF1Padding、

OAEPWITHSHA512AndMGF1Padding、

ISO9796-1Padding

bouncy castle实现

主要代码如下：


RSECoder.java

/*
 * Copyright 2013 WeCode authors
 * 
 *  Licensed under the WeCode, Version 1.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License from ydonghao2@gmail.com
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package com.wecode.security.algorithes;

import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

import org.apache.commons.codec.binary.Hex;

/**
 * RSA加密组件
 * 
 * @author ydonghao2
 * @version 2.0
 */

public abstract class RSACoder {
	// 非对称加密算法
	public static final String KEY_ALGORITHM = "RSA";
	// 公钥
	private static final String PUBLIC_KEY = "RSAPublicKey";
	// 私钥
	private static final String PRIVATE_KEY = "RSAPrivateKey";
	// RSA密钥长度 2048
	private static final int KEY_SIZE = 2048;

	/**
	 * 私钥解密
	 * 
	 * @param data
	 *            待解密 数据
	 * @param key
	 *            私钥
	 * @return byte[] 解密数据
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] data, byte[] key)
			throws Exception {
		// 取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		// 生成私钥
		PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
		// 对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, privateKey);
		return cipher.doFinal(data);
	}

	/**
	 * 公钥解密
	 * 
	 * @param data
	 *            待解密数据
	 * @param key
	 *            公钥
	 * @return byte[] 解密数据
	 * @throws Exception
	 */
	public static byte[] decryptByPublicKey(byte[] data, byte[] key)
			throws Exception {
		// 取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		// 生成公钥
		PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
		// 对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, publicKey);
		return cipher.doFinal(data);
	}

	/**
	 * 公钥加密
	 * 
	 * @param data
	 *            待加密数据
	 * @param key
	 *            公钥
	 * @return byte[] 加密数据
	 * @throws Exception
	 */
	public static byte[] encryptByPublicKey(byte[] data, byte[] key)
			throws Exception {
		// 取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);
		return cipher.doFinal(data);
	}

	/**
	 * 私钥加密
	 * 
	 * @param data
	 *            待加密 数据
	 * @param key
	 *            私钥
	 * @return byte[] 加密数据
	 * @throws Exception
	 */
	public static byte[] encryptByPrivateKey(byte[] data, byte[] key)
			throws Exception {
		// 取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		// 生成私钥
		PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, privateKey);
		return cipher.doFinal(data);
	}

	/**
	 * 取得私钥
	 * 
	 * @param keyMap
	 *            密钥Map
	 * @return byte[] 私钥
	 * @throws Exception
	 */
	public static byte[] getPrivateKey(Map<String, Object> keyMap)
			throws Exception {
		Key key = (Key) keyMap.get(PRIVATE_KEY);
		return key.getEncoded();
	}

	/**
	 * 取得公钥
	 * 
	 * @param keyMap
	 *            密钥Map
	 * @return byte[] 私钥
	 * @throws Exception
	 */
	public static byte[] getPublicKey(Map<String, Object> keyMap)
			throws Exception {
		Key key = (Key) keyMap.get(PUBLIC_KEY);
		return key.getEncoded();
	}

	/**
	 * 初始化密钥
	 * 
	 * @return 密钥Map
	 * @throws Exception
	 */
	public static Map<String, Object> initKey() throws Exception {
		// 实例化密钥对生成器
		KeyPairGenerator keyPairGen = KeyPairGenerator
				.getInstance(KEY_ALGORITHM);
		// 初始化密钥对的生成
		keyPairGen.initialize(KEY_SIZE);
		// 生成密钥对
		KeyPair keyPair = keyPairGen.generateKeyPair();
		// 公钥
		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
		// 私钥
		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
		// 封装密钥
		Map<String, Object> keyMap = new HashMap<String, Object>(2);
		keyMap.put(PUBLIC_KEY, publicKey);
		keyMap.put(PRIVATE_KEY, privateKey);
		return keyMap;
	}

	/**
	 * 私钥解密
	 * 
	 * @param data
	 *            待解密 数据
	 * @param key
	 *            私钥
	 * @return byte[] 解密数据
	 * @throws Exception
	 */
	public static byte[] encryByPrivateKey(byte[] data, String key)
			throws Exception {
		return encryptByPrivateKey(data, getKey(key));
	}

	/**
	 * 公钥加密
	 * 
	 * @param data
	 *            待加密数据
	 * @param key
	 *            公钥
	 * @return byte[] 加密数据
	 * @throws Exception
	 */
	public static byte[] encryptByPublicKey(byte[] data, String key)
			throws Exception {
		return encryptByPublicKey(data, getKey(key));
	}

	/**
	 * 私钥解密
	 * 
	 * @param data
	 *            待解密 数据
	 * @param key
	 *            私钥
	 * @return byte[] 解密数据
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] data, String key)
			throws Exception {
		return decryptByPrivateKey(data, getKey(key));
	}

	/**
	 * 公钥解密
	 * 
	 * @param data
	 *            待解密数据
	 * @param key
	 *            公钥
	 * @return byte[] 解密数据
	 * @throws Exception
	 */
	public static byte[] decryptByPublicKey(byte[] data, String key)
			throws Exception {
		return decryptByPublicKey(data, getKey(key));
	}
	
	/**
	 * 初始化密钥
	 * @param 密钥Map
	 * @return String 16进制编码密钥
	 * @throws Exception
	 */
	public static String getPrivateKeyString(Map<String,Object> keyMap) throws Exception {
		return Hex.encodeHexString(getPrivateKey(keyMap));
	}
	/**
	 * 初始化密钥
	 * @param 密钥Map
	 * @return String 16进制编码密钥
	 * @throws Exception
	 */
	public static String getPublicKeyString(Map<String , Object> keyMap) throws Exception {
		return Hex.encodeHexString(getPublicKey(keyMap));
	}
	
	public static byte[] getKey(String key) throws Exception {
		return Hex.decodeHex(key.toCharArray());
	}
}


KEY_ALGORITHM指明非对称加密算法“RSA”；PUBLIC_KEY指明非对称算法的公钥，私钥指明非对称算法的私钥。

public static finalString KEY_ALGORITHM = "RSA";
private static finalString PUBLIC_KEY = "RSAPublicKey";
private static finalString PRIVATE_KEY = "RSAPrivateKey";

KEY_SIZE指明本系统此处RSA密钥长度为2048

private static final intKEY_SIZE = 2048;

私钥解密

参数:

        data - 待解密 数据

         key - 私钥

返回:

        byte[] 解密数据

抛出:

        java.lang.Exception

        PKCS8EncodedKeySpec pkcs8KeySpec = newPKCS8EncodedKeySpec(key);用于取得私钥。 PKCS8EncodedKeySpec类用于转换私钥编码。它继承EncodedKeySpec类，以编码格式表示私钥。PKCS8EncodedKeySpec类使用PKCS#8标准展位密钥规范管理的编码格式。

public static byte[]decryptByPrivateKey(byte[] data, byte[] key)
        throws Exception {
    PKCS8EncodedKeySpecpkcs8KeySpec = new PKCS8EncodedKeySpec(key);
    KeyFactory keyFactory= KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成私钥
    PrivateKey privateKey= keyFactory.generatePrivate(pkcs8KeySpec);
    // 对数据解密
    Cipher cipher =Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE,privateKey);
    returncipher.doFinal(data);
}

私钥解密

参数:

        data - 待解密 数据

        key - 私钥

返回:

        byte[] 解密数据

抛出:

        java.lang.Exception

public static byte[] decryptByPrivateKey(byte[] data,

                        java.lang.String key)  throwsjava.lang.Exception

公钥解密

参数:

         data - 待解密数据

         key - 公钥

返回:

         byte[] 解密数据

抛出:

        java.lang.Exception

X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);用于取得公钥。X509EncodedKeySpec类使用X.509标准作为密钥规范的编码格式。通过如下方法实例化：

public X509EncodedKeySpec(byte[] encodedKey)

根据给定的编码密钥创建一个新的 X509EncodedKeySpec。

public static byte[]decryptByPublicKey(byte[] data, byte[] key)
        throws Exception {
    X509EncodedKeySpecx509KeySpec = new X509EncodedKeySpec(key);
    KeyFactory keyFactory= KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成公钥
    PublicKey publicKey =keyFactory.generatePublic(x509KeySpec);
    // 对数据解密
    Cipher cipher =Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE,publicKey);
    returncipher.doFinal(data);
}

公钥解密

参数:

       data - 待解密数据

       key - 公钥

返回:

        byte[] 解密数据

抛出:

      java.lang.Exception 

  • public static byte[] decryptByPublicKey(byte[] data,

         java.lang.String key)  throws java.lang.Exception

公钥加密

参数:

       data - 待加密数据

       key - 公钥

返回:

       byte[] 加密数据

抛出:

       java.lang.Exception

      KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);获得实例化对象。KeyFactory类也是用来生成密钥（公钥和私钥）的引擎类。用于产生公钥/私钥，或者说它的作用是通过密钥规范还原密钥。

public static byte[]encryptByPublicKey(byte[] data, byte[] key)
        throws Exception {
    // 取得公钥
    X509EncodedKeySpecx509KeySpec = new X509EncodedKeySpec(key);
    KeyFactory keyFactory= KeyFactory.getInstance(KEY_ALGORITHM);
    PublicKey publicKey =keyFactory.generatePublic(x509KeySpec);
    // 对数据加密
    Cipher cipher =Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE,publicKey);
    returncipher.doFinal(data);
}


公钥加密

参数:

        data - 待加密数据

        key - 公钥

返回:

        byte[] 加密数据

抛出:

       java.lang.Exception

  • public static byte[] encryptByPublicKey(byte[] data,java.lang.String key)

                                throws java.lang.Exception

  • public static byte[] encryptByPrivateKey(byte[] data,byte[] key)

                                  throwsjava.lang.Exception

私钥加密

参数:

        data - 待加密 数据

        key - 私钥

返回:

        byte[] 加密数据

抛出:

java.lang.Exception

public static byte[]encryptByPrivateKey(byte[] data, byte[] key)
        throws Exception {
    // 取得私钥
    PKCS8EncodedKeySpecpkcs8KeySpec = new PKCS8EncodedKeySpec(key);
    KeyFactory keyFactory= KeyFactory.getInstance(KEY_ALGORITHM);
    // 生成私钥
    PrivateKey privateKey= keyFactory.generatePrivate(pkcs8KeySpec);
    // 对数据加密
    Cipher cipher =Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.ENCRYPT_MODE,privateKey);
    returncipher.doFinal(data);
}

初始化密钥

返回:

        密钥Map

抛出:

        java.lang.Exception

        KeyPairGenerator是个抽象类。公钥和私钥的生成是由KeyPairGenerator类来实现的。KeyPairGenerator也是通过getInstance()方法来实现实例化的。

public staticMap<String, Object> initKey() throws Exception {
    // 实例化密钥对生成器
    KeyPairGeneratorkeyPairGen = KeyPairGenerator
           .getInstance(KEY_ALGORITHM);
    // 初始化密钥对的生成
    keyPairGen.initialize(KEY_SIZE);
    // 生成密钥对
    KeyPair keyPair =keyPairGen.generateKeyPair();
    // 公钥
    RSAPublicKey publicKey= (RSAPublicKey) keyPair.getPublic();
    // 私钥
    RSAPrivateKeyprivateKey = (RSAPrivateKey) keyPair.getPrivate();
    // 封装密钥
    Map<String,Object> keyMap = new HashMap<String, Object>(2);
    keyMap.put(PUBLIC_KEY,publicKey);
    keyMap.put(PRIVATE_KEY,privateKey);
    return keyMap;
}


测试RSACoder.java：
RSAcoderTest.java 

package com.wecode.security.algorithes;

import static org.junit.Assert.*;

import java.util.Map;

import org.apache.commons.codec.binary.Base64;
import org.junit.Before;
import org.junit.Test;

/**
 * RSA校验
 * 
 * @author ydonghao2
 * 
 */

public class RSACoderTest {
	// 公钥
	private static byte[] publicKey;
	// 私钥
	private static byte[] privateKey;

	/**
	 * 初始化密钥
	 */
	
	/**
	 * 测试的时候把@Before,@Test去掉
	 * 把：private byte[] publicKey;
	 * 改成：private static byte[] publicKey;
	 * 把：private byte[] privateKey;
	 * 改成：private static byte[] privateKey;
	 * 把：public void initKey() throws Exception {
	 * 改成：public void static initKey() throws Exception {
	 * 把：public void test() throws Exception {
	 * 改成：改成：public static void main(String[] args) throws Exception {
	 * 在main函数中加入：initKey();
	 * @return 
	 * @throws Exception
	 */
	//@Before
	 public static void initKey() throws Exception {
		// 初始化密钥
		Map<String, Object> keyMap = RSACoder.initKey();
		publicKey = RSACoder.getPublicKey(keyMap);
		privateKey = RSACoder.getPrivateKey(keyMap);
		System.err.println("公钥：\t" + Base64.encodeBase64String(publicKey));
		System.err.println("公钥：\t" + publicKey.toString());
		System.err.println("私钥：\t" + Base64.encodeBase64String(privateKey));
		System.err.println("公钥：\t" + privateKey.toString());
	}

	/**
	 * 校验
	 * 
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {
		initKey();
		System.err.println("---私钥加密----公钥解密----");
		String inputStr1 = "RSA";
		byte[] data1 = inputStr1.getBytes();
		System.err.println("原文：\t" + inputStr1);
		// 加密
		byte[] encodedData1 = RSACoder.encryptByPrivateKey(data1, privateKey);
		System.err.println("加密后:\t" + Base64.encodeBase64String(encodedData1));
		// 解密
		byte[] decodedData1 = RSACoder.decryptByPublicKey(encodedData1,
				publicKey);
		String outputStr1 = new String(decodedData1);
		System.err.println("解密后：\t" + outputStr1);

		// 校验
		assertEquals(inputStr1, outputStr1);
	}

}


袁小黑
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RSA+ECB+OAEPWithSHA-256AndMGF1Padding
01-07
选择RsA算法进行非对称加密，密钥长度为2048位及以上位数，使用oAEP填充方式。
java的RSA/ECB/OAEPWithSHA-1AndMGF1Padding在js写法
sinat_25052547的博客
10-12 2305
How to encode using RSA/NONE/OAEPWithSHA-1AndMGF1Padding? · Issue #464 · digitalbazaar/forge · GitHub 参考了上面的链接 js加密代码 var forge = require('node-forge'); var base64 = require('Base64'); var pki = forge.pki; publicKey = pki.publicKeyFromPem("-----BEGIN
加密与安全_使用Java代码操作RSA算法生成的密钥对
最新发布
Karka_的博客
05-14 716
在数字化时代，网络通信的安全性是必须关注的重要问题之一。非对称加密算法作为现代密码学的重要组成部分，为保护通信的隐私提供了一种可靠的解决方案。非对称加密算法，又称为公钥加密算法，是一种密码学中的重要概念。它与传统的对称加密算法不同，需要一对密钥：公钥和私钥。这对密钥之间存在着特殊的数学关系，但无法通过公钥推导出私钥，从而保证了通信的安全性。
RSA算法加密和签名详解---java实现
霓虹深处
06-04 2553
简介 RSA加密算法是一种非对称加密算法。在公开密钥加密和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。 算法分类信息： 算法 密钥长度 默认长度 签名长...
前端匹配java的RSA/ECB/OAEPWITHSHA-256ANDMGF1PADDING规范
qq_39232387的博客
11-29 2260
vue匹配java的RSA/ECB/OAEPWITHSHA-256ANDMGF1PADDING规范
javascript RSA算法（三）
weixin_34114823的博客
02-02 326
// RSA, a suite of routines for performing RSA public-key computations in // JavaScript. // // Requires BigInt.js and Barrett.js. // // Copyright 1998-2005 David Shapiro. // // You may use, r...
RSA加密算法c++实现
04-07
RSA加密算法的实现，使用c++语言编程，使用dev c++平台编码，文件为cpp格式。经过反复测试代码正确，可搭配RSA讲解教程一起使用，讲解教程点击我的个人主页即可查看，希望能够对你有帮助，谢谢。
java实现的RSA加密算法详解
08-30
java实现的RSA加密算法详解 RSA加密算法是一种非对称加密算法，使用公钥和私钥对来实现加密和解密。下面是java实现的RSA加密算法的详细介绍： 一、什么是非对称加密 非对称加密是指使用一对密钥，一个公钥和一个...
python实现rsa加密算法
06-01
这个算法非原创，真心不错，所以上传分享出来．实测过，满足需求
RSA加密算法实验报告.pdf
11-21
"RSA加密算法实验报告.pdf" 本实验报告主要介绍了RSA加密算法的实现和原理，包括密钥对的产生、加密和解密过程、数字签名等。下面是该实验报告的详细知识点总结： 一、RSA加密算法的原理 RSA加密算法是基于大数...
RSA加密算法.ppt
05-25
RSA加密算法.ppt
RSA加密算法java简单实现方法(必看)
09-01
RSA加密算法是一种非对称加密技术，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出，因其三位发明者的名字首字母命名。它基于大整数因子分解的数学难题，使得加密过程对于不知道密钥的人来说几乎是不可能...
Python实现的rsa加密算法详解
09-20
主要介绍了Python实现的rsa加密算法,结合完整实例形式分析了Python实现rsa加密算法的原理、步骤与相关操作技巧,需要的朋友可以参考下
rsa加密算法（Delphi实现）.zip
09-22
RSA公钥加密算法是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。1987年首次公布，当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏...
RSA加密算法源码
02-23
RSA加密算法是公钥密码学领域的一个里程碑，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年共同提出，因此得名RSA。它是一种非对称加密算法，即加密和解密使用的是两把不同的密钥，一把是公开的公钥，另一把是...
Javascript RSA加密密码Java JSP解密示例
allway2的博客
07-10 863
<%@ page language="java" pageEncoding="UTF-8"%> <%@ page contentType="text/html;charset=UTF-8"%> <% request.setCharacterEncoding("UTF-8"); response.setCharacterEncoding("UTF-8"); response.setContentType("text/html; charset=UTF-8"); %> &.
RSA前后端加密
椰汁菠萝
12-07 4515
一、RSA算法 1977年，三位数学家Rivest、Shamir 和 Adleman 设计了一种算法，可以实现非对称加密。这种算法用他们三个人的名字命名，叫做RSA算法。从那时直到现在，RSA算法一直是最广为使用的"非对称加密算法"。毫不夸张地说，只要有计算机网络的地方，就有RSA算法。 这种算法非常可靠，密钥越长，它就越难破解。根据已经披露的文献，目前被破解的最...
JavaScript的CryptoJS AES/ECB/NoPadding加密，可与JAVA objective-c 进行同步加解密
秋水浮萍任飘渺
08-12 9109
公司一个蓝牙锁需要把重要协议进行加密传输，硬件结构、加密模式不变，微信小程序、安卓、IOS三端同步加解密。百度谷歌资料查了不少，都是用CryptoJS。加解密是没什么问题，只是跟我想要的有点不一样，我们的加密不需要偏移量，所以得稍做修改。加密模式使用AES/ECB/NoPadding需要用到网上找到的aes.js mode-ecb.js pad-nopadding.js文件实际项目用在小程序 这里用
基于python的RSA加密算法软件设计与实现.docx
08-17
基于python的RSA加密算法软件设计与实现

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值