クライアント/サーバーアーキテクチャでのRSAアルゴリズムの実装

ニーズの出現

この記事は、自分のプロジェクトを開発するときに遭遇した問題の1つに当てられています。 このプロジェクトはクライアント/サーバーアーキテクチャを備えており、ビジネスアプリケーションです。 ネットワークを介したデータ送信の実装とフレームの構築後、ほぼ最初の質問に、送信データの暗号化が必要でした。 最初の可能なアルゴリズム（複数をサポートする計画）はRSA暗号化アルゴリズムを選択しました。

この記事では、クライアント/サーバーアーキテクチャにRSAアルゴリズムを実装するためのオプションと、実際のプロジェクトでのそのような実装の例を検討します。

RSAアルゴリズムの概念

ここでは、このアルゴリズムの機能については説明しませんが、クライアントサーバーアーキテクチャでの使用方法について具体的に説明します。
ちょっとした紹介...実際、 RSA （Rivest-Shamir-Adlemanの名前の文字の省略形）は公開鍵暗号アルゴリズムです。 これは、システムが公開鍵と秘密鍵の2つの異なるキーを生成することを意味します。

• 公開鍵は、開いている（安全でない）チャネルを介して送信され、データの暗号化に使用されます。
• 秘密鍵は所有者によってのみ保存され、公開鍵で暗号化されたデータを復号化するために使用されます。

したがって、公開キーを誰にでも転送し、このキーで暗号化されたメッセージを受信できます。このメッセージは、私たちだけが（秘密キーを使用して）解読できます。



この概念を上図の図1に示します。

ご覧のとおり、 青文字による生成後のキーは、平文の保護されていないチャネルを介して緑文字に送信されます。 誰でも彼を傍受できますが、彼の助けがなければメッセージを暗号化することしかできません。

したがって、 緑のキャラクターは公開鍵を簡単に受け取り、この鍵でメッセージを暗号化します。

その後、彼は暗号化されたメッセージを青文字に送信し、 青文字は秘密鍵を使用して解読します。

2人の中で、このスキームは非常に単純です。 ただし、このようなシステムをクライアント/サーバーアーキテクチャ上で編成する必要がある場合は、以下で検討するいくつかの追加の問題が発生します。

クライアント-サーバー

したがって、最初にキーを決定します。 覚えているように、メッセージを暗号化するには受信者の公開鍵が必要です。 したがって、サーバーにはクライアントの公開鍵が必要であり、クライアントにはサーバーの公開鍵が必要です。 したがって、データ転送を開始する前に、キーを交換する必要があります。 これがどのように発生するかを、キーを交換するプロセスを示す図2で検討します。



1. クライアントはサーバーへの接続を開き、鍵の束を生成します（open-secret）。 次に、パケットをサーバーに送信し、 サーバーで公開キーを転送します。
2. サーバーはパケットを受信し、 クライアントの公開キーを読み取って保存し、独自のキーチェーンを生成します。 その後、彼はパケットをクライアントに送信し、 クライアントで公開鍵を転送します。
3. クライアントはパケットを受信し、 サーバーの公開鍵を読み取って保存します 。


交換は3段階で完了します。 これで、サーバーとクライアントの両方が、「行の反対側に」対談者の公開鍵を持ちます。 ただし、ここでは、サーバーがクライアント用のキーを生成する方法に関する2つの決定のうちの1つを直ちに選択する必要があります。


1. サーバーは、 すべての クライアントに対して1つのキーを生成し ます 。
2. サーバーは、 個々の クライアント ごとに新しいキーを生成します 。

皆さんは、キーが大きいほど、実用性が高いことを知っていると思います。 ただし、RSAアルゴリズムの場合、鍵の生成は主要な計算の複雑さを表すため、それほど単純なタスクではありません。 さらに、アルゴリズムは、キーが大きいほど、より多くのデータを送信する必要があるように設計されています。

たとえば、5バイトの長さのメッセージを送信し、512ビットのキー長を使用すると、暗号化されたメッセージは64kバイトの「重さ」になります。 これは、このようなキーで暗号化できるデータの最大量が64〜11 = 53 kB（ビットシフトに11 kBが使用される）であるためです。 さらに暗号化する必要がある場合は、53 KBのブロックに分割します。 キー= 4096ビットを取得すると、暗号化するのは5バイトのみであるにもかかわらず、最小ブロックは512 kバイトに等しくなります。


したがって、以下を決定する必要があります。

1.すべてのクライアントに対して1つの大きなキーを生成します 。これにより、過剰なトラフィックが発生し、より多くのプロセッサリソースが使用されます（512よりも4096ビットのキーでメッセージを暗号化するのははるかに困難です）が、メモリを消費せず、開発に費やす時間も少なくなります;
2.または、 クライアントごとに小さなキーを生成し、その使用期間が最大許容値を超えないことを確認します （512ビットキーのクラックは長い間現実でした。推奨される長さは少なくとも1024ビットです）。

誰もがそのアカウントについて独自の見解を持つことができますが、どのオプションを好むかは、開発中の製品に大きく依存します。 ただし、このプロジェクトでは、 2番目のオプションを使用することが決定されました 。

キーを生成してサーバーに送信する

このプロジェクトでは、クライアントサーバーデータベースという3層アーキテクチャを使用しています。 サーバーはJavaで記述され、クライアントはC＃で記述されています。 以下では、サーバー側とクライアント側の両方での暗号化の実装について説明します。 ユーザー-クライアントから始めましょう。

したがって、サーバーへの接続は成功し、パケットを受信する準備が整いました。 これを行うには、.NETクラスRSACryptoServiceProvider （C＃）を使用してキーを作成します。

1. プライベート RSACryptoServiceProvider m_Rsa ;
2. プライベート RSAParameters m_ExternKey ;
3. プライベート RSAParameters m_InternKey ;
5. パブリック CryptoRsa （ ）
6. {
7. m_Rsa = 新しい RSACryptoServiceProvider （ 512 ） ;
8. m_InternKey = m_Rsa。 ExportParameters （ true ） ;
9. }

このリストには、 CryptoRsaクラスのコンストラクターがあります。これは、512ビットキーを自動的に生成し、キーパラメーター（パブリックだけでなく秘密キーもエクスポートする必要があることを示す）をm_InternKey変数にエクスポートします。

次に、公開鍵をバイト形式で保存し、サーバーに送信する必要があります。 これを行うには、RSAキーの構成要素を少し理解する必要があります。 要するに、それらはいわゆるパブリック指数とシークレット指数、および両方のキーの単一モジュールで構成されています。 したがって、公開鍵は公開指数とモジュールであり、秘密鍵は秘密指数とモジュールです。 詳細については、「公開キーと秘密キーを作成するためのアルゴリズム」の章を参照してください。

出力バッファにオープン指数を書き込みます（C＃）：

1. //指数の長さを書き込む->指数->モジュール
2. バフ。 Write （ （ Byte ） m_InternKey。Exponent。Length ） ;
3. バフ。 書き込み （ m_InternKey。Exponent ） ;
4. バフ。 Write （ m_InternKey。Modulus ） ;

この場合、指数の終了位置とモジュールの開始位置（サーバー上のデータを読み取るとき）を正確に知るために、指数の長さが必要です。 記録後、データをサーバーに送信します。

サーバーがキー付きのパケットを受信したら、パケットからキーを取得して保存する必要があります。 私たちは見ます（Java）：

1. //指数の長さ
2. int expLength =パケット。 readByte （ ） ;
4. //指数バイトを取得します
5. バイト [ ]指数= 新しい バイト [ expLength ] ;
6. システム arraycopy （ packet。Bytes 、packet。Offset、exponent、 0 、expLength ） ;
8. //モジュールのバイトを取得します
9. バイト [ ]モジュラス= 新しい バイト [ 1 +パケット。 バイト 長さ - （パケット。 オフセット + expLength ） ] ;
10. システム arraycopy （ packet。Bytes、packet。Offset + expLength、modulus、 1 、modulus。length - 1 ） ;
12. //ブードゥーマジック
13. モジュラス[ 0 ] = 0 ;
15. //キーを保存します
16. RSAPublicKeySpec rsaPubKeySpec = 新しい RSAPublicKeySpec （ 新しい BigInteger （モジュラス） 、 新しい BigInteger （指数） ） ;
17. m_ExternPublicKey = （ RSAPublicKey ） KeyFactory 。 getInstance （ "RSA" ） 。 generatePublic （ rsaPubKeySpec ） ;

モジュールの最初のバイトをゼロに設定する「ブードゥーマジック」と呼ばれる奇妙な行を除いて、ここでコードについて特にコメントする必要はないと思います。 そして、ここにあります：私にはわからない理由で、JavaでのRSAの実装では、キーモジュールは常にゼロから開始する必要があります。 おそらく、これはモジュールが0より大きいためです。 大きな数（BigInteger）を使用して自分でJavaにRSAを実装しようとしたときに、最初のバイトがゼロに等しくない場合、負の数が取得されます。 Khabravchanyの紳士、この質問をあなたに任せます。誰かがこの機能を説明してくれたらとてもうれしいです。

次は、サーバーによるキー生成です。 次のコードを検討してください（Java）：

1. //キージェネレーターを取得して初期化します
2. KeyPairGenerator keyGen = KeyPairGenerator 。 getInstance （ "RSA" ） ;
3. keyGen。 初期化 （ Config。CRYPTO_KEY_NUM_BITS ） ;
5. //束を生成します
6. m_KeyPair = keyGen。 genKeyPair （ ） ;
8. //公開鍵と秘密鍵を取得します
9. m_InternPublicKey = （ RSAPublicKey ） KeyFactory 。 getInstance （ "RSA" ） 。 generatePublic （
10. new X509EncodedKeySpec （ m_KeyPair。getPublic （ ） 。 getEncoded （ ） ） ）） ;
12. m_InternPrivateKey = （ RSAPrivateKey ） KeyFactory 。 getInstance （ "RSA" ） 。 generatePrivate （
13. new PKCS8EncodedKeySpec （ m_KeyPair。getPrivate （ ） 。 getEncoded （ ） ） ）） ;

ここではすべてが明確だと思います。 もちろん、もっと深く掘り下げる場合は、 X509やPKCS8 （X509EncodedKeySpecおよびPKCS8EncodedKeySpec）などのクリーチャーの主題をグーグルで検索する必要があります。

次のステップは、キーをサーバーに送信することです。 これは、クライアント（Java）の場合とほぼ同じ方法で行われます。

1. //指数の長さを書き込む->指数->モジュール
2. バオ。 write （ exponent。length ＆ 0xff ） ; //バイトとして書き込む
3. バオ。 書きます （指数） ;
4. バオ。 書き込み （モジュラス） ;

そして最後に、クライアント側でキーを取得し、読み取り、保存します（C＃）：

1. バイト expLength =パケット。 ReadByte （ ） ;
3. バイト [ ]指数= 新しい バイト [ expLength ] ;
4. 緩衝液 BlockCopy （ packet。Bytes 、packet。Offset、exponent、 0 、expLength ） ;
6. バイト [ ]モジュラス= 新しい バイト [パケット。 バイト 長さ - （パケット。 オフセット + expLength ） -1 ] ;
7. 緩衝液 BlockCopy （パケット。 バイト 、パケット。 オフセット + expLength + 1 、モジュラス、 0 、モジュラス。 長さ ） ;
9. m_ExternKey = new RSAParameters （ ） ;
10. m_ExternKey。 指数 =指数;
11. m_ExternKey。 モジュラス =モジュラス;

実際、それがすべてです。 これで、クライアントは変数m_ExternKeyにサーバーの公開鍵を持ち、サーバーは変数m_ExternPublicKeyにクライアントの公開鍵を持ちます。 データ転送自体を整理するためだけに残ります。 これはさらに簡単になります（C＃）：

1. //キーをインポートします
2. m_Rsa。 ImportParameters （ m_ExternKey ） ;
4. //暗号化されたデータを暗号化し、バッファに書き込みます
5. バッファ。 書き込み （ m_Rsa。Encrypt （ bytesToEncrypt、 false ） ） ;

サーバーの場合、もう少し複雑です（Java）：

1. byte [ ] cipherText = null ;
2. 暗号cipher =暗号。 getInstance （ "RSA / ECB / PKCS1Padding" ） ;
3. 暗号。 init （暗号。ENCRYPT_MODE、m_ExternPublicKey ） ;
4. cipherText =暗号。 doFinal （ tempBytes ） ;
6. バオ。 書き込み （ cipherText ） ;

暗号化されたメッセージは、受信者が秘密鍵を使用して送信および復号化する準備ができています。 忘れてはならない唯一のことは、暗号化できる最大メッセージサイズがキーサイズから11バイトを引いたものに等しいことです。 したがって、暗号化するときは、データをブロックに分割して順番に暗号化する必要があります。 C＃の例を次に示します。

1. m_Rsa。 ImportParameters （ m_ExternKey ） ;
2. ByteBuffer buffer = new ByteBuffer （ ） ;
4. int dataLength = bytesToEncrypt。 長さ ;
5. int maxLength = （ m_Rsa。KeySize / 8 ） -12 ;
6. int iterations = （ int ）数学。 天井 （ （ フロート ） bytesToEncrypt。 長さ / maxLength ） ;
8. for （ Int32 i = 0 ; i <繰り返し; i ++ ）
9. {
10. バイト [ ] tempBytes = 新しい バイト [
11. （ dataLength - maxLength * i > maxLength ） ？ maxLength ：
12. dataLength - maxLength * i ] ;
14. 緩衝液 BlockCopy （ bytesToEncrypt、maxLength * i、tempBytes、 0 、
15. tempBytes。 長さ ） ;
17. バッファ。 PutEnd （ m_Rsa。Encrypt （ tempBytes、 false ） ） ;
18. }
20. 戻りバッファ。 配列

自分でJavaに実装します。いくつかの変更があります:)

もちろん、この記事のフレームワークでは、この機能の実装の範囲全体をカバーすることはできませんが、RSAアルゴリズムを使用してクライアントに安全なチャネルを実装する方法についてのアイデアは間違いなくあると思います。