android 和服务端rsa,android(客户端)和PC(服务器端)通信RSA 加密解密

最新推荐文章于 2022-02-23 15:19:11 发布
最新推荐文章于 2022-02-23 15:19:11 发布
阅读量349 收藏 1
点赞数
文章标签： android 和服务端rsa

android客户端代码：

package com.suning.reminder.util;

import java.io.BufferedReader;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.security.Key;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.SecureRandom;

import java.security.Security;

import java.security.Signature;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.InvalidKeySpecException;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import java.util.Arrays;

import java.util.HashMap;

import java.util.Map;

import javax.crypto.Cipher;

import

org.apache.commons.configuration.ConfigurationException;

import

org.apache.commons.configuration.PropertiesConfiguration;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import org.bouncycastle.openssl.PEMReader;

import org.bouncycastle.openssl.PasswordFinder;

public class RSAUtil {

public static final String KEY_ALGORITHM =

"RSA";

public static final String SIGNATURE_ALGORITHM =

"MD5withRSA";

private static final String PUBLIC_KEY =

"RSAPublicKey";

private static final String PRIVATE_KEY =

"RSAPrivateKey";

private static final int MAX_ENCRYPT_BLOCK =

117;

private static final int MAX_DECRYPT_BLOCK =

128;

public static String

privateKeyPath="private_key.pem";

public static String

publicKeyPath="public_key.pem";

public static File getFile(){

String

p=RSAUtil.class.getClassLoader().getResource(privateKeyPath).getPath();

return new

File(Escape.(p));

}

public static File getPublicFile(){

String

p=RSAUtil.class.getClassLoader().getResource(publicKeyPath).getPath();

return new

File(Escape.(p));

}

public static KeyPair generateKey() throws

NoSuchAlgorithmException{

KeyPairGenerator keyPairGen =

KeyPairGenerator.getInstance(KEY_ALGORITHM);

keyPairGen.initialize(1024, new

SecureRandom());

KeyPair keyPair =

keyPairGen.generateKeyPair();

return keyPair;

}

public static void saveKey(KeyPair keyPair,

String publicKeyFile,

String

privateKeyFile) throws ConfigurationException {

PublicKey pubkey =

keyPair.getPublic();

PrivateKey prikey =

keyPair.getPrivate();

// save public key

PropertiesConfiguration

publicConfig = new PropertiesConfiguration(

publicKeyFile);

publicConfig.setProperty("PULIICKEY",

toHexString(pubkey.getEncoded()));

publicConfig.save();

// save private key

PropertiesConfiguration

privateConfig = new PropertiesConfiguration(

privateKeyFile);

privateConfig.setProperty("PRIVATEKEY",

toHexString(prikey.getEncoded()));

privateConfig.save();

}

public static PrivateKey loadKeyPRI(String

filename)

throws

ConfigurationException, NoSuchAlgorithmException,

InvalidKeySpecException

{

PropertiesConfiguration config

= new PropertiesConfiguration(filename);

KeyFactory keyFactory =

KeyFactory.getInstance(KEY_ALGORITHM,

new

BouncyCastleProvider());

// privateKey

String privateKeyValue =

config.getString("PRIVATEKEY");

PKCS8EncodedKeySpec priPKCS8 =

new PKCS8EncodedKeySpec(

toBytes(privateKeyValue));

PrivateKey privateKey =

keyFactory.generatePrivate(priPKCS8);

return privateKey;

}

public static PublicKey loadKeyPUB(String

filename)

throws

ConfigurationException, NoSuchAlgorithmException,

InvalidKeySpecException

{

PropertiesConfiguration config

= new PropertiesConfiguration(filename);

KeyFactory keyFactory =

KeyFactory.getInstance(KEY_ALGORITHM,

new

BouncyCastleProvider());

// publicKey

String privateKeyValue =

config.getString("PULIICKEY");

X509EncodedKeySpec

bobPubKeySpec = new X509EncodedKeySpec(

toBytes(privateKeyValue));

PublicKey publicKey =

keyFactory.generatePublic(bobPubKeySpec);

return publicKey;

}

public static byte[] encrypt(RSAPublicKey

publicKey, byte[] data) {

if (publicKey != null) {

try {

Cipher

cipher = Cipher.getInstance(KEY_ALGORITHM,

new

BouncyCastleProvider());

cipher.init(Cipher.ENCRYPT_MODE,

publicKey);

return

cipher.doFinal(data);

} catch

(Exception e) {

e.printStackTrace();

}

}

return null;

}

public static byte[] decrypt(RSAPrivateKey

privateKey, byte[] raw) {

if (privateKey != null) {

try {

Cipher

cipher = Cipher.getInstance(KEY_ALGORITHM,

new

BouncyCastleProvider());

cipher.init(Cipher.DECRYPT_MODE,

privateKey);

return

cipher.doFinal(raw);

} catch

(Exception e) {

e.printStackTrace();

}

}

return null;

}

public static String toHexString(byte[] b)

{

StringBuilder sb = new

StringBuilder(b.length * 2);

for (int i = 0; i <

b.length; i++) {

sb.append(HEXCHAR[(b[i]

& 0xf0) >>> 4]);

sb.append(HEXCHAR[b[i]

& 0x0f]);

}

return sb.toString();

}

public static final byte[] toBytes(String s)

{

byte[] bytes;

bytes = new byte[s.length() /

2];

for (int i = 0; i <

bytes.length; i++) {

bytes[i] =

(byte) Integer.parseInt(s.substring(2 * i, 2 * i + 2),

16);

}

return bytes;

}

private static char[] HEXCHAR = { '0', '1', '2',

'3', '4', '5', '6', '7',

'8', '9',

'a', 'b', 'c', 'd', 'e', 'f' };

public static Map genKeyPair() throws Exception

{

KeyPair keyPair =

generateKey();

RSAPublicKey publicKey =

(RSAPublicKey) keyPair.getPublic();

RSAPrivateKey privateKey =

(RSAPrivateKey) keyPair.getPrivate();

Map keyMap = new

HashMap(2);

keyMap.put(PUBLIC_KEY,

publicKey);

keyMap.put(PRIVATE_KEY,

privateKey);

return keyMap;

}

public static String sign(byte[] data, String

privateKey) throws Exception {

byte[] keyBytes =

Base64Utils.decode(privateKey);

PKCS8EncodedKeySpec

pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory keyFactory =

KeyFactory.getInstance(KEY_ALGORITHM);

PrivateKey privateK =

keyFactory.generatePrivate(pkcs8KeySpec);

Signature signature =

Signature.getInstance(SIGNATURE_ALGORITHM);

signature.initSign(privateK);

signature.update(data);

return

Base64Utils.encode(signature.sign());

}

public static boolean verify(byte[] data, String

publicKey, String sign)

throws

Exception {

byte[] keyBytes =

Base64Utils.decode(publicKey);

X509EncodedKeySpec keySpec =

new X509EncodedKeySpec(keyBytes);

KeyFactory keyFactory =

KeyFactory.getInstance(KEY_ALGORITHM);

PublicKey publicK =

keyFactory.generatePublic(keySpec);

Signature signature =

Signature.getInstance(SIGNATURE_ALGORITHM);

signature.initVerify(publicK);

signature.update(data);

return

signature.verify(Base64Utils.decode(sign));

}

public static byte[] decryptByPrivateKey(byte[]

encryptedData,

String

privateKey) throws Exception {

byte[] keyBytes =

Base64Utils.decode(privateKey);

PKCS8EncodedKeySpec

pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory keyFactory =

KeyFactory.getInstance(KEY_ALGORITHM);

Key privateK =

keyFactory.generatePrivate(pkcs8KeySpec);

Cipher cipher =

Cipher.getInstance(keyFactory.getAlgorithm());

cipher.init(Cipher.DECRYPT_MODE,

privateK);

int inputLen =

encryptedData.length;

ByteArrayOutputStream out = new

ByteArrayOutputStream();

int offSet = 0;

byte[] cache;

int i = 0;

// 对数据分段解密

while (inputLen - offSet >

0) {

if (inputLen

- offSet > MAX_DECRYPT_BLOCK) {

cache

= cipher

.doFinal(encryptedData,

offSet, MAX_DECRYPT_BLOCK);

} else

{

cache

= cipher

.doFinal(encryptedData,

offSet, inputLen - offSet);

}

out.write(cache,

0, cache.length);

i++;

offSet = i *

MAX_DECRYPT_BLOCK;

}

byte[] decryptedData =

out.toByteArray();

out.close();

return decryptedData;

}

public static byte[] decryptByPublicKey(byte[]

encryptedData,

String

publicKey) throws Exception {

byte[] keyBytes =

Base64Utils.decode(publicKey);

X509EncodedKeySpec x509KeySpec

= new X509EncodedKeySpec(keyBytes);

KeyFactory keyFactory =

KeyFactory.getInstance(KEY_ALGORITHM);

Key publicK =

keyFactory.generatePublic(x509KeySpec);

Cipher cipher =

Cipher.getInstance(keyFactory.getAlgorithm());

cipher.init(Cipher.DECRYPT_MODE,

publicK);

int inputLen =

encryptedData.length;

ByteArrayOutputStream out = new

ByteArrayOutputStream();

int offSet = 0;

byte[] cache;

int i = 0;

// 对数据分段解密

while (inputLen - offSet >

0) {

if (inputLen

- offSet > MAX_DECRYPT_BLOCK) {

cache

= cipher

.doFinal(encryptedData,

offSet, MAX_DECRYPT_BLOCK);

} else

{

cache

= cipher

.doFinal(encryptedData,

offSet, inputLen - offSet);

}

out.write(cache,

0, cache.length);

i++;

offSet = i *

MAX_DECRYPT_BLOCK;

}

byte[] decryptedData =

out.toByteArray();

out.close();

return decryptedData;

}

public static byte[] encryptByPublicKey(byte[]

data, String publicKey)

throws

Exception {

byte[] keyBytes =

Base64Utils.decode(publicKey);

X509EncodedKeySpec x509KeySpec

= new X509EncodedKeySpec(keyBytes);

KeyFactory keyFactory =

KeyFactory.getInstance(KEY_ALGORITHM);

Key publicK =

keyFactory.generatePublic(x509KeySpec);

// 对数据加密

Cipher cipher =

Cipher.getInstance("RSA/None/PKCS1Padding");//keyFactory.getAlgorithm()解决javax.crypto.BadPaddingException:

Blocktype异常的几种解决办法

cipher.init(Cipher.ENCRYPT_MODE,

publicK);

int inputLen =

data.length;

ByteArrayOutputStream out = new

ByteArrayOutputStream();

int offSet = 0;

byte[] cache;

int i = 0;

// 对数据分段加密

while (inputLen - offSet >

0) {

if (inputLen

- offSet > MAX_ENCRYPT_BLOCK) {

cache

= cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);

} else

{

cache

= cipher.doFinal(data, offSet, inputLen - offSet);

}

out.write(cache,

0, cache.length);

i++;

offSet = i *

MAX_ENCRYPT_BLOCK;

}

byte[] encryptedData =

out.toByteArray();

out.close();

return encryptedData;

}

public static byte[] encryptByPrivateKey(byte[]

data, String privateKey)

throws

Exception {

byte[] keyBytes =

Base64Utils.decode(privateKey);

PKCS8EncodedKeySpec

pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory keyFactory =

KeyFactory.getInstance(KEY_ALGORITHM);

Key privateK =

keyFactory.generatePrivate(pkcs8KeySpec);

Cipher cipher =

Cipher.getInstance(keyFactory.getAlgorithm());

cipher.init(Cipher.ENCRYPT_MODE,

privateK);

int inputLen =

data.length;

ByteArrayOutputStream out = new

ByteArrayOutputStream();

int offSet = 0;

byte[] cache;

int i = 0;

// 对数据分段加密

while (inputLen - offSet >

0) {

if (inputLen

- offSet > MAX_ENCRYPT_BLOCK) {

cache

= cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);

} else

{

cache

= cipher.doFinal(data, offSet, inputLen - offSet);

}

out.write(cache,

0, cache.length);

i++;

offSet = i *

MAX_ENCRYPT_BLOCK;

}

byte[] encryptedData =

out.toByteArray();

out.close();

return encryptedData;

}

public static String getPrivateKey(Map

keyMap)

throws

Exception {

Key key = (Key)

keyMap.get(PRIVATE_KEY);

return

Base64Utils.encode(key.getEncoded());

}

public static String getPublicKey(Map

keyMap)

throws

Exception {

Key key = (Key)

keyMap.get(PUBLIC_KEY);

return

Base64Utils.encode(key.getEncoded());

}

public static PublicKey getPublicKey(String key) throws Exception

{ byte[]

keyBytes; keyBytes =Base64Utils.decode(key);

X509EncodedKeySpec keySpec = new

X509EncodedKeySpec(keyBytes); KeyFactory keyFactory =

KeyFactory.getInstance(KEY_ALGORITHM); PublicKey publicKey =

keyFactory.generatePublic(keySpec); return publicKey; } public

static byte[] encrypt(PublicKey pubkey, String text) {

try {

Cipher

rsa;

rsa =

Cipher.getInstance(KEY_ALGORITHM);

rsa.init(Cipher.ENCRYPT_MODE,

pubkey);

return

rsa.doFinal(text.getBytes());

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

public static String decrypt(PrivateKey

decryptionKey, byte[] buffer) {

try {

Cipher

rsa;

rsa =

Cipher.getInstance(KEY_ALGORITHM);

rsa.init(Cipher.DECRYPT_MODE,

decryptionKey);

byte[] utf8 =

rsa.doFinal(buffer);

return new

String(utf8, "UTF8");

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

public static KeyPair readKeyPair(File

privateKey, String keyPassword)

throws

IOException {

FileReader fileReader = new

FileReader(privateKey);

PEMReader r = new

PEMReader(fileReader, new DefaultPasswordFinder(

keyPassword.toCharArray()));

try {

return

(KeyPair) r.readObject();

} catch (IOException ex)

{

throw

ex;

} finally {

r.close();

fileReader.close();

}

}

public static Key readPublicKey(File privateKey,

String keyPassword)

throws

IOException {

FileReader fileReader = new

FileReader(privateKey);

PEMReader r = new

PEMReader(fileReader, new DefaultPasswordFinder(

keyPassword.toCharArray()));

try {

return

(RSAPublicKey) r.readObject();

} catch (IOException ex)

{

throw

ex;

} finally {

r.close();

fileReader.close();

}

}

public static class DefaultPasswordFinder

implements PasswordFinder {

private final char[]

password;

private

DefaultPasswordFinder(char[] password) {

this.password

= password;

}

@Override

public char[] getPassword()

{

return

Arrays.copyOf(password, password.length);

}

}

//

----------------------------------------------------------

// 测试

public static void main(String args[]) throws

Exception {

Security.addProvider(new

BouncyCastleProvider());

Security.addProvider(new

BouncyCastleProvider());

String userInfo=null;

//userInfo="logonId="+loginBackBean.getLogonId()+"&userId="+loginBackBean.getUserId()+"&phoneNo="+loginBackBean.getPhoneNo();

userInfo="logonId=15510717593&userId=34006452405&phoneNo=18801148262";

PublicKey publicKey =

RSAUtil.getPublicKey(getFromAssets("D:\workspace\PBR_SERVICE\src\main\resources\public_key.pem"));

System.out.println("r加密前文字：rn"

+ userInfo);

byte[] encodedData =

RSAUtil.encryptByPublicKey(userInfo.getBytes(), Base64Utils

.encode(publicKey.getEncoded()));

userInfo=Base64Utils.encode(encodedData);

System.out.println("加密后文字：rn" +

userInfo);

File privateKey =

RSAUtil.getFile();

Security.addProvider(new

BouncyCastleProvider());

KeyPair keyPair =

RSAUtil.readKeyPair(privateKey, "1234");

PrivateKey prikey =

keyPair.getPrivate();

byte[] decodedData =

RSAUtil.decryptByPrivateKey(

Base64Utils.decode(userInfo),

Base64Utils.encode(prikey.getEncoded()));

String target = new

String(decodedData);

System.out.println("解密后文字: rn"

+ target);

}

public void testSign() throws Exception {

// System.err.println("私钥加密——公钥解密");

// String source =

"这是一行测试RSA数字签名的无意义文字";

// System.out.println("原文字：rn" +

source);

// byte[] data =

source.getBytes();

// byte[] encodedData =

encryptByPrivateKey(data, privateKey);

// System.out.println("加密后：rn" +

new String(encodedData));

// byte[] decodedData =

decryptByPublicKey(encodedData, publicKey);

// String target = new

String(decodedData);

// System.out.println("解密后: rn"

+ target);

// System.err.println("私钥签名——公钥验证签名");

// String sign =

sign(encodedData, privateKey);

// System.err.println("签名:r" +

sign);

// boolean status =

verify(encodedData, publicKey, sign);

// System.err.println("验证结果:r" +

status);

}

public

String getFromAssets(String fileName){

String

result=""; try

{ InputStreamReader

inputReader = new

InputStreamReader(getAssets().open(fileName));

BufferedReader

bufReader = new

BufferedReader(inputReader); String

line=""; while((line =

bufReader.readLine()) != null) {

result +=

line; }

} catch

(Exception e) { e.printStackTrace(); } return

result; } }

发送请求：

PublicKey

publicKey =

RSAUtil.getPublicKey(getFromAssets(RSAUtil.publicKeyPath));

System.out.println("r加密前文字：rn"

+ userInfo);

//PublicKey

pubkey = (PublicKey)RSAUtil.encryptByPublicKey(publicKey);

byte[]

encodedData = RSAUtil.encryptByPublicKey(userInfo.getBytes(),

Base64Utils

.encode(publicKey.getEncoded()));

userInfo=Base64Utils.encode(encodedData);

System.out.println("加密后文字：rn"

+ userInfo);

服务器端主要代码：

public static byte[] decryptByPrivateKey(byte[]

encryptedData,

String

privateKey) throws Exception {

byte[] keyBytes =

Base64Utils.decode(privateKey);

PKCS8EncodedKeySpec

pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory keyFactory =

KeyFactory.getInstance("RSA"); Key

privateK = keyFactory.generatePrivate(pkcs8KeySpec);

Cipher cipher =

Cipher.getInstance(keyFactory.getAlgorithm());

cipher.init(Cipher.DECRYPT_MODE,

privateK);

int inputLen =

encryptedData.length;

ByteArrayOutputStream out = new

ByteArrayOutputStream();

int offSet = 0;

byte[] cache;

int i = 0;

// 对数据分段解密

while (inputLen - offSet >

0) {

if (inputLen

- offSet > MAX_DECRYPT_BLOCK) {

cache

= cipher

.doFinal(encryptedData,

offSet, MAX_DECRYPT_BLOCK);

} else

{

cache

= cipher

.doFinal(encryptedData,

offSet, inputLen - offSet);

}

out.write(cache,

0, cache.length);

i++;

offSet = i *

MAX_DECRYPT_BLOCK;

}

byte[] decryptedData =

out.toByteArray();

out.close();

return decryptedData;

}

接收请求，处理私钥解密

File privateKey = RSAUtil.getFile();

Security.addProvider(new

BouncyCastleProvider()); KeyPair

keyPair = RSAUtil.readKeyPair(privateKey, "1234");

PrivateKey prikey =

keyPair.getPrivate();

byte[] decodedData =

RSAUtil.decryptByPrivateKey(

Base64Utils.decode(userInfo),

Base64Utils.encode(prikey.getEncoded()));

String target = new

String(decodedData);

System.out.println("解密后文字: rn"

+ target);

return target;

android客户端加密和pc服务器端解密需要注意事项：javax.crypto.BadPaddingException:

Blocktype

1.异常描述：最近做项目为了增强数据传输的安全性用到了RSA加密。即android客户端将要传送的信息，用私钥通过RSA非对称加密算法加密后，传到服务器端(PC端)。服务器端用对应(密钥)的公钥来解密时解密失败，抛出“javax.crypto.BadPaddingException:

Blocktype”异常。

2.异常原因：Android系统使用的虚拟机(dalvik)跟SUN标准JDK是有所区别的，其中他们默认的RSA实现就不同。即Android端用Cipher.getInstance("RSA")方法进行加密时，使用的provider是Bouncycastle

Security provider，Bouncycastle Security

provider默认实现的是“RSA/None/NoPadding”算法，而服务器(PC)端用Cipher.getInstance("RSA")进行解密时，使用的是Sun的security

provider，实现的是“RSA/None/PKCS1Padding”算法，所以，解密时会失败。

3.解决办法：我这里提供三种解决办法：

第一种：将服务器(pc)端的Cipher.getInstance("RSA")方法改为Cipher.getInstance("RSA/ECB/NoPadding")。但这种改法有一个缺点就是解密后的明文比加密之前多了很多空格。(空格的长度个数+原来的明文字符数=产生密钥时采用的bit数/8)

第二种：将Android端的Cipher.getInstance("RSA")方法改为Cipher.getInstance("RSA/None/PKCS1Padding")。这种方法解密后的明文和加密前的明文是对应的，不会出现第一种方法中的现象，推荐这种方法。

第三种：在服务器(pc)端的jdk中加入Bouncycastle Security provider，关于Bouncycastle

JCE的安装配置及验证请参看http://blog.csdn.net/caoshichao520326/article/details/8732670，

配置好Bouncycastle Security

provider后，将服务器(pc)端的Cipher.getInstance("RSA")方法改为Cipher.getInstance("RSA"，"BC")。

薛从豪
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RSA客户端（android/ios）与服务端的通信实现
看！有只程序猿！
07-28 2676
RSA是什么玩意这里就不再说了，大家可以自己搜索，不说废话，直接上正文 需求 客户端（android/ios）向服务端发送一串已经协议好的公钥加密数据到服务端，服务端使用私钥对公钥进行解码 思路 我们知道spring中我们有Filter HandlerInterceptorAdapter这些关于AOP方面的操作，所以各位童鞋如果不想在业务层面进行解码，可以从这些方面入手解码，具体方式自行操
android 和服务端rsa,Android---解密服务器RSA内容
weixin_31710909的博客
05-25 154
重点：1.加密内容/key转byte数组，用Base64工具；2.获取私钥key，规则是 KeyFactory.getInstance("RSA", "BC");// 入参“BC”不可以省略;3.解密的时候，规则是Cipher.getInstance("RSA/ECB/PKCS1Padding");4.返回的byte数组，用new String(byte[]);打印public void doSo...
Android客户端与服务器端RSA加密通讯加密字符不一致相关问题
daxiang409609532的专栏
12-10 2601
RSA非对称加密算法 ，适用于数据量较小的情况，比如一般的用法： 1、生成RSA密钥对，公钥发给客户端使用，私钥由服务器使用； 2、客户端用公钥加密所有发出的数据，也用公钥解密所有收到的数据； 3、服务器用私钥加密所有发出的数据，也用私钥解密所有收到的数据； 但Android 客户端 在与 服务器端 通讯时 会遇到这样的问题：服务器无法解密客户端发送的加密数据，客户端可以解密服务器发送的加
服务器与客户端RSA加密解密通讯
qq_42289686的博客
06-11 2578
class Events { /** * 解密操作 * @param 密匙 */ static function rsakey(){ return '-----BEGIN PRIVATE KEY----- MIIJQQIBADANBgkqhkiG9w0BAQEFAASCCSswggknAgEAAoICAQCsoY531mLvCqmh Ev...
Android RSA加密解密，用于和服务器交互时的请求
Leaning_wk的专栏
10-12 2985
概述 RSA是目前最有影响力的公钥加密算法，该算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但那时想要对其乘积进行因式分解却极其困 难，因此可以将乘积公开作为加密密钥，即公钥，而两个大素数组合成私钥。公钥是可发布的供任何人使用，私钥则为自己所有，供解密之用。关于RSA其它需要了解的知识，参考维基百科:http://zh.wikipedia.org/zh-cn/RSA%E5%8
RSA加密 js客户端加密 java服务端servlet解密
12-05
提供加密，解密，生成密钥对等方法。js客户端用公钥加密 java服务端servlet堆用私钥解密 完整的代码 直接可以部署运行
java模仿QQ通信实现RSA加密解密
07-17
java 模仿QQ通信 socket编程，多个客户端与服务端连接，服务端起转发作用，客户端可与另外一个指定客户端通信 RSA加密解密 消息摘要 数字签名
RSA加密解密 JS加密 JAVA解密 【完美版】
12-12
经过本人修改，简化并完善了别人的代码，使其更加的容易理解和学习！ 此为一个完整的项目，...功能：服务端随机生成密钥，JS用公钥加密，服务端用私钥解密。用到的JS加密文件是从官网下载的最新版，速度快，稳定性好！
RSA和AES工具 java、android.rar
05-11
使用RSA加密和解密（客户端传输重要信息给服务端，服务端返回的信息不需加密的情况、）使用AES加密解密（客户端传输重要信息给服务端，服务端返回的信息需加密的情况），java ,android 项目都通用
PHP rsa加密解密使用方法
12-18
php服务端与客户端交互、提供开放api时，通常需要对敏感的部分api数据传输进行数据加密，这时候rsa非对称加密就能派上用处了，下面通过一个例子来说明如何用php来实现数据的加密解密 1、加密解密的第一步是生成公钥...
Android RSA加密在项目中的应用
qq_32886769的博客
04-12 628
由于项目安全考虑，需要对关键数据进行加密；本文就RSA加密进行再次学习,本文就文中的工具类进行简单说明；如有不足之处，希望大家予以反馈，便于互相学习； 先说下RSA加密的优缺点： 优点：安全性好。非对称加密使用一对秘钥，一个用来加密（publicKey），一个用来解密（privateKey）；而且公钥（publicKey）是公开的（前后台的公钥是一致的），私钥只在需要做解密的一端保存（一般来讲...
java android rsa加密解密_Android RSA数据加密与Java服务端RSA私钥解密出错问题
weixin_30929623的博客
02-15 599
1. 出错描述：服务RSA解密抛出javax.crypto.BadPaddingException: Decryption error2.出错原因：Android系统使用的虚拟机(dalvik)跟SUN标准JDK是有所区别的，其中他们默认的RSA实现就不同。即Android端用Cipher.getInstance("RSA")方法进行加密时，使用的provider是Bouncycastle Sec...
Android中自带的RSA加密算法和JAVA中的不是一个标准的吗？
大海蓝天的专栏
11-20 497
客户端和服务器加解密。。乱码或是服务端报：javax.crypto.BadPaddingException: Blocktype mismatch: 0。。。。。I am using RSA to encrypt username and password on Android and decrypt them on server (tomcat 6, java 1.6). Android Enc
rsa java服务器_如何解决openss与java服务器rsa不匹配
weixin_29009401的博客
02-13 202
展开全部android和java webservice RSA处理的不同andorid机器上生成的(密钥对62616964757a686964616fe78988e69d8331333363386162由服务器在windows xp下生成并将公钥发给客户端保存)密码无法在服务器通过私钥解密。2.为了测试，在服务器本地加解密正常，另外，在android上加解密也正常，但是在服务器中加密(使用相同公钥...
android客户端与php服务端res公钥私钥互加解密,Android使用RSA加密和解密的示例代码...
weixin_39827589的博客
04-11 457
一、公钥加密和私钥解密/**RSA算法*/public static final String RSA = "RSA";/**加密方式，android的*/// public static final String TRANSFORMATION = "RSA/None/NoPadding";/**加密方式，标准jdk的*/public static final String TRANSFORMAT...
RSA加密及在Android中的使用
tlaqcxb的博客
08-19 4046
1. RSA简介 RSA是一种常用的非对称加密算法，所谓非对称加密是指使用一对密钥（公钥和私钥）进行加密和解密，公钥人人都可以获得，用于加密数据，私钥保存在服务器中，用于解密数据。加密解密过程如下： 使用RSA进行加密解密，其优点是非常不容易破解，缺点是和对称加密（如AES）相比，加密速度较慢。因此，实际使用中，常常将对称加密和非对称加密结合使用，即使用非对称加密协商对称加密的密钥，使用对称加密密钥加密传输内容。 2. 在Android中使用RSA Java中已内置RSA支持，示例代码如下： 2.1 生成
android数据库文件是否加密存储,详解Android数据存储之SQLCipher数据库加密
weixin_28709715的博客
05-26 478
前言：最近研究了Android Sqlite数据库以及ContentProvider程序间数据共享，我们清晰的知道Sqlite数据库默认存放位置data/data/pakage/database目录下，对于已经ROOT的手机来说的没有任何安全性可以，一旦被利用将会导致数据库数据的泄漏，所以我们该如何避免这种事情的发生呢？我们尝试这对数据库进行加密。选择加密方案：1.)第一种方案我们可以对数据的数据...
安卓密码校验
u013628092的博客
11-23 1803
public static void main(String[] args) { isPassword("1234561zZ12"); } private static boolean isPassword(String password) { String regex = "^[0-9A-Za-z]{6,16}$"; Pattern p = Pattern.compile(regex); Matcher m =...
Android和JAVA后台实现RSA加解密
weixin_42872539的博客
02-23 713
Android和JAVA后台实现RSA加解密
python实现socket的rsa加密通信，分客户端代码和服务端代码
最新发布
05-09
客户端代码： ```python import socket import rsa # 生成公钥和私钥 (pubkey, privkey) = rsa.newkeys(512) # 连接服务器 host = '127.0.0.1' port = 12345 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((host, port)) # 发送公钥给服务器 s.send(pubkey.save_pkcs1()) # 接收加密消息 msg = s.recv(1024) # 使用私钥解密 msg = rsa.decrypt(msg, privkey).decode('utf-8') print('Received from server:', msg) # 发送消息给服务器 msg = 'Hello, server!' # 使用服务器的公钥加密 msg = rsa.encrypt(msg.encode('utf-8'), rsa.PublicKey.load_pkcs1(s.recv(1024))) s.send(msg) s.close() ``` 服务端代码： ```python import socket import rsa # 生成公钥和私钥 (pubkey, privkey) = rsa.newkeys(512) # 创建服务器 host = '127.0.0.1' port = 12345 s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind((host, port)) s.listen(1) print('Waiting for client...') # 等待客户端连接 conn, addr = s.accept() print('Connected by', addr) # 接收客户端公钥 pubkey_client = rsa.PublicKey.load_pkcs1(conn.recv(1024)) # 发送加密消息给客户端 msg = 'Hello, client!' # 使用客户端的公钥加密 msg = rsa.encrypt(msg.encode('utf-8'), pubkey_client) conn.send(msg) # 接收客户端消息 msg = conn.recv(1024) # 使用私钥解密 msg = rsa.decrypt(msg, privkey).decode('utf-8') print('Received from client:', msg) conn.close() s.close() ``` 注意，这里的RSA加密只是为了演示如何使用RSA加密通信，实际应用中需要考虑安全性，并采用更加复杂的加密算法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值