Android Rsaデータの復号化の紹介と使用例
Rsa暗号化
RSAは現在最も影響力のある公開鍵暗号アルゴリズムであり、RSAはデータ暗号化にもデジタル署名にも使える最初のアルゴリズムでもある。このアルゴリズムは、2つの大きな素数を乗算するのが非常に簡単であるが、その積を因数分解するのは極めて困難であるため、積を暗号鍵、すなわち公開鍵として公開し、2つの大きな素数配列を秘密鍵として合成することができる。公開鍵は公開可能な誰が使用しますか?秘密鍵は自分の所有です。
RSAアルゴリズムの原理
1.ランダムに2つの大きな素数pとqを選択し、pはqに等しくなく、N=pqを計算する。
2.1より大きい自然数eを選択し、eは(p-1)(q-1)と相互素養しなければなりません。
3.数式でd:dを計算します。×e=1(mod(p-1)(q-1)です。
4.pとqを廃棄する。
最終的に得られたNとeは「公開鍵」であり、dは「秘密鍵」であり、送信者はNを使ってデータを暗号化し、受信者はdを使ってのみデータの内容を解くことができる。
RSAの安全性は、大きな数の分解に依存しています。1024ビット未満のNは安全ではないことが証明されました。RSAアルゴリズムは大きな数の計算を行うので、RSAが最も速い場合もDESより倍遅くなります。これはRSAの最大の欠陥です。したがって、通常は少量のデータまたは暗号化鍵を暗号化するためにのみ使用されますが、RSAは依然として高い強度のアルゴリズムとなります。
Rsa使用
まず秘密鍵ペアを生成します。
公開鍵の暗号化
これらの操作がRSAの復号化を実現できると思っていましたが、万事大吉です。ほほほ、これはまだ終わっていません。Android側で暗号化されたデータはサーバー側では復号できません。androidシステムのRSA実現は「RSA/None/Nopadding」です。標準JDK実現は「RSA/None/PKCS 1 Padding」です。これは、Androidマシンで暗号化されてサーバーで復号できない原因になりますので、実現時にはこれに注意してください。
セグメント暗号化を実現
充填方式をクリアした後、自信を持って万事大吉と判断しましたが、意外にも発生しました。RSAの非対称暗号化内容の長さに制限があり、1024ビットkeyの最大127ビットのデータしか暗号化できません。そうでないとエラーが発生します。RSAは一般的な非対称暗号化アルゴリズムです。最近の使用では「不正な長さ」という異常があり、暗号化されているデータが長すぎていることが判明しました。RSAアルゴリズムは、暗号化されているバイト数は、鍵の長さ値を8で割ってから11を減算してはいけません。暗号化された後、暗号文のバイト数が得られ、ちょうど鍵の長さ値が8で除算されます。
公開鍵のセグメント暗号化
第一歩:対象データを100個用意する
対照的に発見された:秘密鍵の復号化は時間がかかりますので、必要に応じて解決できない方式を採用して復号することができます。個人的には、サーバーが復号効率が高く、クライアントの秘密鍵が暗号化され、サーバの公開鍵が復号されるほうがいいと思います。
暗号化後のデータサイズの変化:データ量はほぼ暗号化前の1.5倍です。
締め括りをつける
以上はAndroid Rsaデータの解読に関するすべての内容です。この文章の内容は皆さんの学習や仕事に一定の助けを与えてくれると思います。もし疑問があれば、メッセージを残して交流してください。
RSAは現在最も影響力のある公開鍵暗号アルゴリズムであり、RSAはデータ暗号化にもデジタル署名にも使える最初のアルゴリズムでもある。このアルゴリズムは、2つの大きな素数を乗算するのが非常に簡単であるが、その積を因数分解するのは極めて困難であるため、積を暗号鍵、すなわち公開鍵として公開し、2つの大きな素数配列を秘密鍵として合成することができる。公開鍵は公開可能な誰が使用しますか?秘密鍵は自分の所有です。
RSAアルゴリズムの原理
1.ランダムに2つの大きな素数pとqを選択し、pはqに等しくなく、N=pqを計算する。
2.1より大きい自然数eを選択し、eは(p-1)(q-1)と相互素養しなければなりません。
3.数式でd:dを計算します。×e=1(mod(p-1)(q-1)です。
4.pとqを廃棄する。
最終的に得られたNとeは「公開鍵」であり、dは「秘密鍵」であり、送信者はNを使ってデータを暗号化し、受信者はdを使ってのみデータの内容を解くことができる。
RSAの安全性は、大きな数の分解に依存しています。1024ビット未満のNは安全ではないことが証明されました。RSAアルゴリズムは大きな数の計算を行うので、RSAが最も速い場合もDESより倍遅くなります。これはRSAの最大の欠陥です。したがって、通常は少量のデータまたは暗号化鍵を暗号化するためにのみ使用されますが、RSAは依然として高い強度のアルゴリズムとなります。
Rsa使用
まず秘密鍵ペアを生成します。
/**
* RSA
*
* @param keyLength , :512~2048
* 1024
* @return
*/
public static KeyPair generateRSAKeyPair(int keyLength) {
try {
KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);
kpg.initialize(keyLength);
return kpg.genKeyPair();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
}
具体的な暗号化の実現:公開鍵の暗号化
/**
*
*
* @param data
*/
public static byte[] encryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
//
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PublicKey keyPublic = kf.generatePublic(keySpec);
//
Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
cp.init(Cipher.ENCRYPT_MODE, keyPublic);
return cp.doFinal(data);
}
秘密鍵の暗号化
/**
*
*
* @param data
* @param privateKey
* @return byte[]
*/
public static byte[] encryptByPrivateKey(byte[] data, byte[] privateKey) throws Exception {
//
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PrivateKey keyPrivate = kf.generatePrivate(keySpec);
//
Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
cipher.init(Cipher.ENCRYPT_MODE, keyPrivate);
return cipher.doFinal(data);
}
公開鍵の復号
/**
*
*
* @param data
* @param publicKey
* @return byte[]
*/
public static byte[] decryptByPublicKey(byte[] data, byte[] publicKey) throws Exception {
//
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PublicKey keyPublic = kf.generatePublic(keySpec);
//
Cipher cipher = Cipher.getInstance(ECB_PKCS1_PADDING);
cipher.init(Cipher.DECRYPT_MODE, keyPublic);
return cipher.doFinal(data);
}
秘密鍵の復号
/**
*
*/
public static byte[] decryptByPrivateKey(byte[] encrypted, byte[] privateKey) throws Exception {
//
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
KeyFactory kf = KeyFactory.getInstance(RSA);
PrivateKey keyPrivate = kf.generatePrivate(keySpec);
//
Cipher cp = Cipher.getInstance(ECB_PKCS1_PADDING);
cp.init(Cipher.DECRYPT_MODE, keyPrivate);
byte[] arr = cp.doFinal(encrypted);
return arr;
}
いくつかのグローバル変数の解説:
public static final String RSA = "RSA";//
public static final String ECB_PKCS1_PADDING = "RSA/ECB/PKCS1Padding";//
public static final int DEFAULT_KEY_SIZE = 2048;//
public static final byte[] DEFAULT_SPLIT = "#PART#".getBytes(); // bufferSize, partSplit
public static final int DEFAULT_BUFFERSIZE = (DEFAULT_KEY_SIZE / 8) - 11;//
暗号化された塗りつぶし方法これらの操作がRSAの復号化を実現できると思っていましたが、万事大吉です。ほほほ、これはまだ終わっていません。Android側で暗号化されたデータはサーバー側では復号できません。androidシステムのRSA実現は「RSA/None/Nopadding」です。標準JDK実現は「RSA/None/PKCS 1 Padding」です。これは、Androidマシンで暗号化されてサーバーで復号できない原因になりますので、実現時にはこれに注意してください。
セグメント暗号化を実現
充填方式をクリアした後、自信を持って万事大吉と判断しましたが、意外にも発生しました。RSAの非対称暗号化内容の長さに制限があり、1024ビットkeyの最大127ビットのデータしか暗号化できません。そうでないとエラーが発生します。RSAは一般的な非対称暗号化アルゴリズムです。最近の使用では「不正な長さ」という異常があり、暗号化されているデータが長すぎていることが判明しました。RSAアルゴリズムは、暗号化されているバイト数は、鍵の長さ値を8で割ってから11を減算してはいけません。暗号化された後、暗号文のバイト数が得られ、ちょうど鍵の長さ値が8で除算されます。
公開鍵のセグメント暗号化
/**
*
*
*/
public static byte[] encryptByPublicKeyForSpilt(byte[] data, byte[] publicKey) throws Exception {
int dataLen = data.length;
if (dataLen <= DEFAULT_BUFFERSIZE) {
return encryptByPublicKey(data, publicKey);
}
List<Byte> allBytes = new ArrayList<Byte>(2048);
int bufIndex = 0;
int subDataLoop = 0;
byte[] buf = new byte[DEFAULT_BUFFERSIZE];
for (int i = 0; i < dataLen; i++) {
buf[bufIndex] = data[i];
if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {
subDataLoop++;
if (subDataLoop != 1) {
for (byte b : DEFAULT_SPLIT) {
allBytes.add(b);
}
}
byte[] encryptBytes = encryptByPublicKey(buf, publicKey);
for (byte b : encryptBytes) {
allBytes.add(b);
}
bufIndex = 0;
if (i == dataLen - 1) {
buf = null;
} else {
buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];
}
}
}
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
秘密鍵のセグメント暗号化
/**
*
*
* @param data
* @param privateKey
*/
public static byte[] encryptByPrivateKeyForSpilt(byte[] data, byte[] privateKey) throws Exception {
int dataLen = data.length;
if (dataLen <= DEFAULT_BUFFERSIZE) {
return encryptByPrivateKey(data, privateKey);
}
List<Byte> allBytes = new ArrayList<Byte>(2048);
int bufIndex = 0;
int subDataLoop = 0;
byte[] buf = new byte[DEFAULT_BUFFERSIZE];
for (int i = 0; i < dataLen; i++) {
buf[bufIndex] = data[i];
if (++bufIndex == DEFAULT_BUFFERSIZE || i == dataLen - 1) {
subDataLoop++;
if (subDataLoop != 1) {
for (byte b : DEFAULT_SPLIT) {
allBytes.add(b);
}
}
byte[] encryptBytes = encryptByPrivateKey(buf, privateKey);
for (byte b : encryptBytes) {
allBytes.add(b);
}
bufIndex = 0;
if (i == dataLen - 1) {
buf = null;
} else {
buf = new byte[Math.min(DEFAULT_BUFFERSIZE, dataLen - i - 1)];
}
}
}
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
公開鍵のセグメント解読
/**
*
*
* @param encrypted
* @param publicKey
*/
public static byte[] decryptByPublicKeyForSpilt(byte[] encrypted, byte[] publicKey) throws Exception {
int splitLen = DEFAULT_SPLIT.length;
if (splitLen <= 0) {
return decryptByPublicKey(encrypted, publicKey);
}
int dataLen = encrypted.length;
List<Byte> allBytes = new ArrayList<Byte>(1024);
int latestStartIndex = 0;
for (int i = 0; i < dataLen; i++) {
byte bt = encrypted[i];
boolean isMatchSplit = false;
if (i == dataLen - 1) {
// data
byte[] part = new byte[dataLen - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPublicKey(part, publicKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
} else if (bt == DEFAULT_SPLIT[0]) {
// split[0]
if (splitLen > 1) {
if (i + splitLen < dataLen) {
// data
for (int j = 1; j < splitLen; j++) {
if (DEFAULT_SPLIT[j] != encrypted[i + j]) {
break;
}
if (j == splitLen - 1) {
// split , break, split
isMatchSplit = true;
}
}
}
} else {
// split ,
isMatchSplit = true;
}
}
if (isMatchSplit) {
byte[] part = new byte[i - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPublicKey(part, publicKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
}
}
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
秘密鍵のセグメント解読
/**
*
*
*/
public static byte[] decryptByPrivateKeyForSpilt(byte[] encrypted, byte[] privateKey) throws Exception {
int splitLen = DEFAULT_SPLIT.length;
if (splitLen <= 0) {
return decryptByPrivateKey(encrypted, privateKey);
}
int dataLen = encrypted.length;
List<Byte> allBytes = new ArrayList<Byte>(1024);
int latestStartIndex = 0;
for (int i = 0; i < dataLen; i++) {
byte bt = encrypted[i];
boolean isMatchSplit = false;
if (i == dataLen - 1) {
// data
byte[] part = new byte[dataLen - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPrivateKey(part, privateKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
} else if (bt == DEFAULT_SPLIT[0]) {
// split[0]
if (splitLen > 1) {
if (i + splitLen < dataLen) {
// data
for (int j = 1; j < splitLen; j++) {
if (DEFAULT_SPLIT[j] != encrypted[i + j]) {
break;
}
if (j == splitLen - 1) {
// split , break, split
isMatchSplit = true;
}
}
}
} else {
// split ,
isMatchSplit = true;
}
}
if (isMatchSplit) {
byte[] part = new byte[i - latestStartIndex];
System.arraycopy(encrypted, latestStartIndex, part, 0, part.length);
byte[] decryptPart = decryptByPrivateKey(part, privateKey);
for (byte b : decryptPart) {
allBytes.add(b);
}
latestStartIndex = i + splitLen;
i = latestStartIndex - 1;
}
}
byte[] bytes = new byte[allBytes.size()];
{
int i = 0;
for (Byte b : allBytes) {
bytes[i++] = b.byteValue();
}
}
return bytes;
}
このようにしてようやく出会った問題を解決しました。プロジェクトで使っている案はクライアントの公開鍵を暗号化し、サーバの秘密鍵を復号します。サーバー開発者は効率的に考えていると言っています。やはり自分でプログラムを書いて、本当の効率をテストしてみました。第一歩:対象データを100個用意する
List<Person> personList=new ArrayList<>();
int testMaxCount=100;//
//
for(int i=0;i<testMaxCount;i++){
Person person =new Person();
person.setAge(i);
person.setName(String.valueOf(i));
personList.add(person);
}
//FastJson json
String jsonData=JsonUtils.objectToJsonForFastJson(personList);
Log.e("MainActivity"," json ---->"+jsonData);
Log.e("MainActivity"," json ---->"+jsonData.length());
秘密鍵ペアを生成します。
KeyPair keyPair=RSAUtils.generateRSAKeyPair(RSAUtils.DEFAULT_KEY_SIZE);
//
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
//
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
//
long start=System.currentTimeMillis();
byte[] encryptBytes= RSAUtils.encryptByPublicKeyForSpilt(jsonData.getBytes(),publicKey.getEncoded());
long end=System.currentTimeMillis();
Log.e("MainActivity"," cost time---->"+(end-start));
String encryStr=Base64Encoder.encode(encryptBytes);
Log.e("MainActivity"," json --1-->"+encryStr);
Log.e("MainActivity"," json --1-->"+encryStr.length());
//
start=System.currentTimeMillis();
byte[] decryptBytes= RSAUtils.decryptByPrivateKeyForSpilt(Base64Decoder.decodeToBytes(encryStr),privateKey.getEncoded());
String decryStr=new String(decryptBytes);
end=System.currentTimeMillis();
Log.e("MainActivity"," cost time---->"+(end-start));
Log.e("MainActivity"," json --1-->"+decryStr);
//
start=System.currentTimeMillis();
encryptBytes= RSAUtils.encryptByPrivateKeyForSpilt(jsonData.getBytes(),privateKey.getEncoded());
end=System.currentTimeMillis();
Log.e("MainActivity"," cost time---->"+(end-start));
encryStr=Base64Encoder.encode(encryptBytes);
Log.e("MainActivity"," json --2-->"+encryStr);
Log.e("MainActivity"," json --2-->"+encryStr.length());
//
start=System.currentTimeMillis();
decryptBytes= RSAUtils.decryptByPublicKeyForSpilt(Base64Decoder.decodeToBytes(encryStr),publicKey.getEncoded());
decryStr=new String(decryptBytes);
end=System.currentTimeMillis();
Log.e("MainActivity"," cost time---->"+(end-start));
Log.e("MainActivity"," json --2-->"+decryStr);
実行結果:対照的に発見された:秘密鍵の復号化は時間がかかりますので、必要に応じて解決できない方式を採用して復号することができます。個人的には、サーバーが復号効率が高く、クライアントの秘密鍵が暗号化され、サーバの公開鍵が復号されるほうがいいと思います。
暗号化後のデータサイズの変化:データ量はほぼ暗号化前の1.5倍です。
締め括りをつける
以上はAndroid Rsaデータの解読に関するすべての内容です。この文章の内容は皆さんの学習や仕事に一定の助けを与えてくれると思います。もし疑問があれば、メッセージを残して交流してください。