1. 鍵の生成をサーバで行って公開鍵をJSのコードに埋める
2. JS側で公開鍵を使って暗号化したデータをサーバに送る
3. サーバで受け取ったデータをPythonで復号

単純な話なはずだったんですけど、上手く行かずにハマりました。

結論から書くと、PyCryptoモジュールがPKCS#1で規定されているのパディング/アンパディングに対応してなかったので自前でアンパディング処理を追加したら上手く行ったという事ですが、学習をかねてもう少し詳しく書いておきます。

本エントリ中の公開鍵・秘密鍵は以下のものを使用しています。他の鍵を使った場合は文中の値は異なります。

PRIVATE KEY:
  p=312812244098101569570522771086507368199
  q=261732496899955705693539027437044751693
  n=81873129708674556552097159647951377728324724985548367405770094930146879610907
  d=61350191904775909756579327908681267205274632675124298948670533913070326529385
  e=65537
PUBLIC KEY:
  n=81873129708674556552097159647951377728324724985548367405770094930146879610907
  e=65537

結局コード見るのがはやいです。まずはPython側ですが、PyCryptoから暗号化処理部分の抜粋したコードを以下に示します。

# pubkey.pyから抜粋
def encrypt(self, plaintext, K):
    """encrypt(plaintext:string|long, K:string|long) : tuple
    Encrypt the string or integer plaintext.  K is a random
    parameter required by some algorithms.
    """
    wasString=0
    if isinstance(plaintext, types.StringType):
        plaintext=bytes_to_long(plaintext) ; wasString=1
    if isinstance(K, types.StringType):
        K=bytes_to_long(K)
    ciphertext=self._encrypt(plaintext, K)
    if wasString: return tuple(map(long_to_bytes, ciphertext))
    else: return ciphertext

# _slowmath.pyから抜粋
def _encrypt(self, m):
    # compute m**d (mod n)
    return pow(m, self.e, self.n)

直線的で解りやすいコードですね。理解の為にencrypt関数に”a”を一文字だけ入れた場合の暗号化の流れを観察すると以下のようになります。

a
=> bytes_to_long (バイト列を数値に)
97
=> _encrypt (中でpow。これがいわゆる公開鍵による暗号化)
(52050588761940096487735844075636185108122635599049953266504222754946145963317L,)
=> long_to_bytes (数値を再度バイト列に)
('s\x13\x96\xd7\xd3\xaf\x92\xf2V\xa3]\x1d:;9O3\xd2\x91\xb7;"\x16\xde\xe7\xf5 \x8a\xdd\x1d\xcd5',)

バイト列を数値に直してから公開鍵による暗号化を行い、再度バイト列に直しています。復号時はこれを逆順で行うわけですね。(もちろん暗号化処理は秘密鍵による復号処理になります。)ここまでは僕の理解通りの処理になっていて何の問題もありませんでした。

一方でJavascriptで行われていた処理を見てみます。ライブラリはコチラのrsa.jsを使わせて頂いています。色々検索した結果pemをロードできるのはこれしか見つかりませんでした。下記に対応する部分のコードを抜粋します。

encrypt: function($data, $pubkey) {
    if (!$pubkey) return false;
    $data = this.pkcs1pad2($data,($pubkey.modulus.bitLength()+7)>>3);
    if(!$data) return false;
    $data = $data.modPowInt($pubkey.encryptionExponent, $pubkey.modulus);
    if(!$data) return false;
    $data = $data.toString(16);
    $data = Hex.decode($data);
    return Base64.encode($data);
},
pkcs1pad2: function($data, $keysize) {
    if($keysize < $data.length + 11)
        return null;
    var $buffer = [];
    var $i = $data.length - 1;
    while($i >= 0 && $keysize > 0)
        $buffer[--$keysize] = $data.charCodeAt($i--);
    $buffer[--$keysize] = 0;
    while($keysize > 2)
        $buffer[--$keysize] = Math.floor(Math.random()*254) + 1;
    $buffer[--$keysize] = 2;
    $buffer[--$keysize] = 0;
    return new BigInteger($buffer);
}

encrypt関数の冒頭で既に様子が違います。暗号化する前の元のデータにpkcs1pad2とかいう謎の処理をかませて、データが変更されています。そしてpkcs1pad2の関数を見ても何をやっているのか全然解りません。関数名からパディングでもやってんのかな位しかわかりません。わずかな希望を胸に、データの暗号化の流れを見てみます。

a
=> pkcs1pad2 (パディング)
3758866564912349439687065567220758327058221768110629839398887525335105633
=> modPowInt (公開鍵暗号化)
14633336708515644111578124792772238970855809995718279846212374275613915803829
=> toString(16)
205a2cd13e395895de49814ec6f9c424f4622f1ffa722f1c88ee23aa521af0b5
=> Hex.decode
バイト列(HTMLで上手く表示できません)
=> Base64.encode
IFos0T45WJXeSYFOxvnEJPRiLx/6ci8ciO4jqlIa8LU=

もしかしたらデータは一致するかもという希望は失われました。全然違ったデータになっていますね。困りましたね。要は一口にRSA暗号化といっても、実装によって暗号化・復号処理以外の部分で、データの扱いに違いがあって必ずしも相互にデータを受け渡せるとは限らないという事ですね。

仕方が無いのでpkcs1pad2関数について調べてみると、PKCSというのはPublic-Key Cryptography Standardsの略で、公開鍵暗号の分野のRFCのようなもののようです。そしてpkcs1というのはPKCS#1のことで、特定の標準仕様を指していて、この中でパディングの方法についても規定されています。

んじゃあ、このPKCSってどの位採用されてんの？と思うわけですが、ざっと調べた感じ事実上デファクトで、perlやrubyのモジュールでは当然のように対応されています。何故かPythonのPyCryptoだけ対応してないという話のようです。

ちょっと調べてみるとPyCryptoでPKCS#1のデータ復号するときはこうしろという記事が見つかったので、解決しました。まとめがてらPyCryptoでrsa.jsで暗号化したデータを復号する処理を書いておきます。

import Crypto
from Crypto.PublicKey import RSA
import base64

def pkcs1_unpad(text):
    if len(text) > 0 and text[0] == '\x02':
        # Find end of padding marked by nul
        pos = text.find('\x00')
        if pos > 0:
            return text[pos+1:]
    return None

priv = RSA.importKey(open('priv.pem', 'r').read())
data = 'aoNFe/Y/Nae0wmeY1DUuMTP4bDe4Tib0/fQZynL7UFc=' # encrypted data from js with base 64 encoded
data = base64.b64decode(data)
data = priv.decrypt(data)
data = pkcs1_unpad(data)    # a

以上で、Javascriptで暗号化したデータをPythonで復号できました。○○暗号化と一口に言っても実装によって差異があるというのが解って、まぁ良かったと言えば良かったです。PyCryptoでも早く対応して欲しいところです。あと、pkcs1pad2の”2″が何を意味しているのか解らないので、誰か知ってたら教えてください。

まず概要の把握ですが、僕は「サルにもわかるRSA暗号」を流してから、「RSA暗号体験入門」を読んだらとりあえず解った気になりました。

次に処理の流れをopensslコマンドで確認してみます。ここでは鍵を生成 => テキストを暗号化 => 復号を確認しました。なお秘密鍵を生成する際のビット数はデフォルトでは512で、普通は1024以上指定するようですが、数が大きくなると確認しづらいので256ビットを指定しています。

$ openssl genrsa -out priv.pem 256
Generating RSA private key, 256 bit long modulus
.+++++++++++++++++++++++++++
.................+++++++++++++++++++++++++++
e is 65537 (0x10001)
$ openssl rsa -in priv.pem -pubout -out pub.pem
writing RSA key
$ echo "hello rsa" > hello.txt
$ openssl rsautl -encrypt -pubin  -inkey pub.pem -in hello.txt -out hello.txt.crypto
$ openssl rsautl -decrypt -inkey priv.pem -in hello.txt.crypto
hello rsa

なんとなく流れは掴めた気がしますね。

さて鍵の生成はopensslコマンドでやれば良いとして、それを使って暗号化・復号をプログラムからやりたいですね。そこで次に上で作った秘密鍵・公開鍵をPythonから使ってみます。名前的にはrsaモジュールを使いたいのですが、手元では色々と怪しい動きをしていたので、おとなしくPyCryptoを使うのが良さそうです。

import Crypto
from Crypto.PublicKey import RSA

pub = RSA.importKey(open('pub.pem', 'r').read())
priv = RSA.importKey(open('priv.pem', 'r').read())

text = open('hello.txt', 'r').read()
crypto = pub.encrypt(text, '')
print priv.decrypt(crypto)

print 'PRIVATE KEY:\n  p=%s, \n  q=%s, \n  n=%s, \n  d=%s, \n  e=%s' % (priv.p, priv.q, priv.n, priv.d, priv.e)
print 'PUBLIC KEY:\n  n=%s, \n  e=%s' % (pub.n, pub.e)

これを実行すると以下のようになります。数が大きすぎて良く解らないですが、何となく正常に動いてる気がしますね。

hello rsa world

PRIVATE KEY:
  p=312812244098101569570522771086507368199,
  q=261732496899955705693539027437044751693,
  n=81873129708674556552097159647951377728324724985548367405770094930146879610907,
  d=61350191904775909756579327908681267205274632675124298948670533913070326529385,
  e=65537
PUBLIC KEY:
  n=81873129708674556552097159647951377728324724985548367405770094930146879610907,
  e=65537

折角なので学習のため先ほどのエントリで書いたmodinvを使って自分でも計算してみます。

>> def calc(base, exp, modulus):
>>     ans = 1
>>     while exp < 0:
>>         if exp & 1:
>>             ans = (ans * base) % modulus
>>         exp >>= 1
>>         exp = int(exp)
>>         base = (base * base) % modulus
>>     return ans
>>
>> (p, q) = (65537, 55079)
>> m = p * q
>> phi = (p - 1) * (q - 1)
>> e = 65537
>> d = modinv(e, phi)
>> orig = 2900
>> encoded = calc(orig, e, m)
>> print encoded
60945415393350116455581236569596858319975698828166554225855598846369380497015
>> decoded = calc(encoded, d, m)
>> print decoded
2900

値が大きくなるのでベキ乗計算が少し面倒ですが、暗号化と復号ができました。まだ文字列をどうやって暗号化可能な数値に変換してるのかとか細かくは理解してないですけど何となくつかめた気がしてます。

さて最後にフォーマットについて確認します。opensslで生成した鍵(priv.pem, pub.pem)はPEM形式というやつで、中身はDER形式のデータをbase64でエンコードしたもののようです。例えば上で生成したファイルは下記のような姿をしています。

-----BEGIN RSA PRIVATE KEY-----
MIGqAgEAAiEAtQKMmuoZNSc0jZe/TDf1p3bQraYwXvBkOdFSwJAkIBsCAwEAAQIh
AIei+mOXKf53e1ziqhleEXgAni7HKueUV/bWLRzb+D1pAhEA61VyYLHy31RSLJ3l
aWXfBwIRAMTn2GbiUscRRmBm9aiR3U0CEDnyEzS9/EiDUayMwHVAUTcCEBgXDWC4
+8ujD2sn7ZIsFlkCECAVBGiJ4VrYG6HTGgTflU4=
-----END RSA PRIVATE KEY-----

このファイルをDER形式に変換してみます。やはりopensslコマンドを使用します。

$ openssl rsa -inform PEM -outform DER -in priv.pem -out priv.der

変換後のDERファイルの内容をやはりopensslコマンドで読みます。この数値が大きい時に使われる表現をもとの数字に戻す方法が解らないのでどなたかご存知であれば教えてください。

$ openssl rsa -inform DER -in priv.der -text -noout
Private-Key: (256 bit)
modulus:
    00:b5:02:8c:9a:ea:19:35:27:34:8d:97:bf:4c:37:
    f5:a7:76:d0:ad:a6:30:5e:f0:64:39:d1:52:c0:90:
    24:20:1b
publicExponent: 65537 (0x10001)
privateExponent:
    00:87:a2:fa:63:97:29:fe:77:7b:5c:e2:aa:19:5e:
    11:78:00:9e:2e:c7:2a:e7:94:57:f6:d6:2d:1c:db:
    f8:3d:69
prime1:
    00:eb:55:72:60:b1:f2:df:54:52:2c:9d:e5:69:65:
    df:07
prime2:
    00:c4:e7:d8:66:e2:52:c7:11:46:60:66:f5:a8:91:
    dd:4d
exponent1:
    39:f2:13:34:bd:fc:48:83:51:ac:8c:c0:75:40:51:
    37
exponent2:
    18:17:0d:60:b8:fb:cb:a3:0f:6b:27:ed:92:2c:16:
    59
coefficient:
    20:15:04:68:89:e1:5a:d8:1b:a1:d3:1a:04:df:95:
    4e

全然細かい事は調べれてないのですが、何となくRSAの概要が把握できた気になっていて、コード追うくらいはできそうなのでこの辺にしておきます。

一応解きたい式を書いておくと以下になります。

まず拡張ユークリッドの互除法をWikipedia通りに書きます。Wikipediaの擬似コードは何故かgcdの値を返してなかったのでgcdも返すように変更しました。

def egcd(a, b):
    (x, lastx) = (0, 1)
    (y, lasty) = (1, 0)
    while b != 0:
        q = a // b
        (a, b) = (b, a % b)
        (x, lastx) = (lastx - q * x, x)
        (y, lasty) = (lasty - q * y, y)
    return (lastx, lasty, a)

次にこのegcdを使って合同式の逆元を求める訳ですが、どうにも解りやすい説明が見つからなくて困りました。色々見て回った結果、ここでもWikipediaの「Modular multiplicative inverse」が一番解りやすかったです。ページに書かれている通りegcdを使って逆元を求めます。

# ax ≡ 1 (mod m)
def modinv(a, m):
    (inv, q, gcd_val) = egcd(a, m)
    return inv % m

上記のmodinvで冒頭の式中のxを求められました。結果だけ見るとなんでもないですね。アルゴリズムが苦手なのでもっと精進します。

アルゴリズム系はWikipediaが便利すぎますね。そしてPythonはWikipediaに張られている擬似コードがほぼ機械的な修正のみで動くので素晴らしいです。

これはちょっと習得しておきたいなと思うものの、上述のような特定の処理以外は他の言語と比べてあまりに貧弱です。今回使用した処理系の標準ライブラリはこれだけしかありません。

なので必要に応じてPrologを別の言語から使うという方が現実的なのかなということで、とりあえずPythonインターフェースを試したのですが、動かなかったので仕方なしにC言語から使ってみる事にしました。なお処理系はSWI-Prologというのを使う事にしました。(手元だとGNU Prologが日本語で文字化けを起こしました。)

まず以下のPrologのコードを見てください。ドラクエの道具屋(アリアハン)です。

% shop.pl
item(やくそう, 8).
item(どくけしそう, 10).
item(キメラのつばさ, 25).
item(おなべのフタ, 50).
 
available(G, X) :-
	item(X, G0),
	G0 =＜ G.

availableという述語を定義していて、持ち金(G)を指定してクエリを投げると、購入可能なアイテムが得られます。Prologからの実行は以下のようになります。

?- ['shop.pl'].
% shop.pl compiled 0.00 sec, 2,216 bytes
true.

?- available(10, X).
X = やくそう;
X = どくけしそう;
false.

?- available(100, X).
X = やくそう;
X = どくけしそう;
X = キメラのつばさ;
X = おなべのフタ.

これをC言語から使う訳ですが、公式ドキュメントによると以下のような手順になります。

1. C言語から使用したいPrologの述語が記述されたplファイルを準備する(今回はshop.pl)
2. Prologを叩くC言語のファイルを準備する(今回はmain.cpp)
3. SWI-Prologにバンドルされているswipl-ldというツールでビルドして実行ファイルを作成

本来はPrologで使用する述語もC言語側から追加したいのですが、今回はまぁ良しとします。さて手順1のshop.plはもう準備できているので手順2から進める事にします。

手順2
C言語のコードを書きます。大した処理でもないのですが、まぁ情報が無いので苦労しました。処理の流れは、PL_initializeで初期化して、PL_Predicateでクエリに必要なpredicate_tオブジェクト(SQLみたいなイメージ)を構築します。作成したpredicateをPL_open_queryでPrologにクエリを投げて、PL_get_charsなんかで結果を取得するというものです。

#include <stdio.h>
#include <string.h>
#include <SWI-Prolog.h>

int main(int argc, char **argv) {
    if (argc == 1) {
        printf("Usage: shop [持ち金]\n");
        exit(0);
    }

    // initialize
    char* program = argv[0];
    char* plav[2] = { program, NULL };
    if (!PL_initialise(1, plav)) {
        PL_halt(1);
    }

    // build query
    int money = atoi(argv[1]);
    predicate_t pred = PL_predicate("available", 2, NULL);
    term_t h0 = PL_new_term_refs(2);
    term_t h1 = h0 + 1;
    PL_put_integer(h0, money);

    // exec query
    qid_t qid = PL_open_query(NULL, PL_Q_NORMAL, pred, h0);
    while (PL_next_solution((qid))) {
        char *s = NULL;
        PL_get_chars(h1, &s, CVT_ALL|REP_UTF8);
        printf("%s\n", s);
    }
    PL_close_query(qid);

    // cleanup
    PL_cleanup(1);

    return 0;
}

とにかく情報が無いのが一番困りました。唯一サンプルコードが見つかったのがコチラのページです。フランス語ですけど。少しハマったのがPL_get_charsで文字列を取得する際には上記のフラグを指定しないと文字列として取得できないという事です。あとPL_open_queryからPL_close_queryまでを一纏めにしたPL_call_predicateを使うと、何故か想定通りの挙動をしませんでした。

手順3
次にビルドします。これは簡単ですね。

$ swipl-ld -o shop main.cpp shop.pl
$ ls
main.cpp        shop            shop.pl

ところでswipl-ldは幾つかのビルド処理を一纏めにしているユーティリティです。内部で何が起こっているかは-vオプションを追加すると見れます。詳細は調べてませんがswiplに何やら怪しい処理をさせていますね。気が向いたらもう少し突っ込みたいところです。

$ swipl-ld -v -o shop main.cpp shop.pl
        eval `swipl --dump-runtime-variables`
                CC="gcc"
                PLBASE="/usr/lib/swipl-5.6.63"
                PLARCH="i386-darwin10.8.0"
                PLLIBS="-lpl"
                PLLIB="-lpl"
                PLCFLAGS="-no-cpp-precomp -pthread -fno-common"
                PLLDFLAGS="-O3 -pthread"
                PLSOEXT="dylib"
                PLTHREADS="yes"
        g++ -c -no-cpp-precomp -pthread -fno-common -D_REENTRANT -D__SWI_PROLOG__ -D__SWI_EMBEDDED__ -I/usr/lib/swipl-5.6.63/include -o main.o main.cpp
        g++ -o shop -O3 -pthread main.o -L/usr/lib/swipl-5.6.63/lib/i386-darwin10.8.0 -lpl -lpl
        swipl -f none -F none -g true -t "consult(['shop.pl']),qsave_program('pltmp-98271',[goal='\$welcome',toplevel=prolog,init_file=none])"
% shop.pl compiled 0.00 sec, 5,272 bytes
% halt
        cat pltmp-98271 >> shop
        chmod 755 shop
        rm main.o
        rm pltmp-98271

以上で実行ファイルshopが生成されました。早速実行してみます。ライセンスとかが出力されて不満ですが、まぁ最低限の挙動は示していますね。

$ ./shop 10
Welcome to SWI-Prolog (Multi-threaded, 64 bits, Version 5.6.63)
Copyright (c) 1990-2008 University of Amsterdam.
SWI-Prolog comes with ABSOLUTELY NO WARRANTY. This is free software,
and you are welcome to redistribute it under certain conditions.
Please visit http://www.swi-prolog.org for details.

For help, use ?- help(Topic). or ?- apropos(Word).

やくそう
どくけしそう

以上、SWI-PrologをC言語から触ってみました。GNU Prologの場合は少しインターフェースが異なるようなので注意してください。まぁ正直Cから使えても仕方が無いのでPythonから使えない理由を少し探ってみたいと思います。Pythonの他に、Perlにもインターフェースが用意されているようですね。

まずdylib側のコードです。ただのHelloWorldですね。

/**
 * hello.c
 */
#include <stdio.h>

void hello_dylib() {
    printf("hello dylib world!\n");
}

これをdylibにコンパイルします。-dynamiclibオプションを指定すると直接dylibを生成できます。簡単ですね。一応otoolでできたdylibを確認するとfiletypeがDYLIBになっています。

$ gcc -dynamiclib hello.c -o libhello.dylib
$ ls
hello.c libhello.dylib
$ otool -vh libhello.dylib
libhello.dylib:
Mach header
      magic cputype cpusubtype  caps    filetype ncmds sizeofcmds      flags
MH_MAGIC_64  X86_64        ALL  0x00       DYLIB     9       1128   NOUNDEFS DYLDLINK TWOLEVEL NO_REEXPORTED_DYLIBS

できたdylibを実際に使ってみます。dlopen, dlsymでdylibをロード、関数ポインタを取得して実行しているだけです。

/**
 * main.c
 */
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>

typedef void (*func)();

int main() {
    void* module = dlopen("libhello.dylib", RTLD_LAZY);
    if (!module) {
	exit(EXIT_FAILURE);
    }

    func f = dlsym(module, "hello_dylib");
    if (dlerror()) {
	goto ERR;
    }

    printf("hello_dylib loaded \n");
    f();    // 実行

    dlclose(module);
    return 0;

  ERR:
    dlclose(module);
    exit(EXIT_FAILURE);
}

ビルドして実行します。

$ gcc main.c
$ ./a.out
hello_dylib loaded
hello dylib world!

上記ドキュメントを眺めると、きちんと使うには色々課題があるようですが、とりあえず雰囲気だけはつかめたので良しとします。