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に張られている擬似コードがほぼ機械的な修正のみで動くので素晴らしいです。

まずはカリー化を行うcurryという関数。

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
from django.utils.functional import curry
 
def orig(a, b):
    print "a=%(a)s, b=%(b)s" % locals()
 
def orig2(a, b, c):
    print "a=%(a)s, b=%(b)s c=%(c)s" % locals()
 
curried = curry(orig, a="before")
curried(b="try1")
curried(b="try2")
 
curried2 = curry(orig2, a="val_a")
curried2(b="after_b", c="after_c")

wikipediaによるとカリー化は複数引数を持つ関数を、単一引数の関数の組み合わせとして表現することとあるので、多分この関数と上記の使い方は、実際はカリー化じゃなくて引数の部分適用というのが正しそうです。まぁ引数が複数あって、それぞれ評価したいタイミングが異なるというのは良くありますね。もっと早く知りたかった。

後この関数の実装が綺麗で、あぁなるほど！と思いましたので引用します。今上手く言語化できないですが、スコープを上手く制御していますね。

def curry(_curried_func, *args, **kwargs):
    def _curried(*moreargs, **morekwargs):
        return _curried_func(*(args+moreargs), **dict(kwargs, **morekwargs))
    return _curried

次にSimpleLazyObject。オブジェクトの初期化を実際にオブジェクトを利用するタイミングまで遅らせられます。プロパティアクセスする時に初めて初期化されるみたいなノリです。特定のオブジェクトのファクトリ関数をSimpleLazyObjectに渡して利用します。

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
from django.utils.functional import SimpleLazyObject
 
class TargetObject(object):
    def __init__(self, name):
        print "__init__"
        self.name = name
 
    def __eq__(self, other):
        return self.name == other.name
 
    def __hash__(self):
        return hash(self.name)
 
    def __str__(self):
        return "I am %s(%r)" % (self.__class__, self.name)
 
    def __unicode__(self):
        return unicode(self.name)
 
    def __repr__(self):
        return "%s(%r)" % (self.__class__, self.name)
 
create_target = lambda: TargetObject("target1")
 
print "before init lazy_obj"
lazy_obj = SimpleLazyObject(create_target)
print "after init lazy_obj"
 
print "before access prop of lazy_obj"
print lazy_obj.name
print "after access prop of lazy_obj"

先ほどのcurryと組み合わせて、オブジェクトのファクトリ関数をcurryでラップすると便利な気がします。djangoでいうとmiddlewareとかにとりあえず入れとくと便利やけど、毎度呼ばれると重いような処理を軽減できそうです。

次はlazy。関数の実際の呼び出しを遅延させられる関数で、コチラの解説が分かりやすかったです。今のところ便利そうというのは分かりますが、具体的な利用シーンは思いついてないです。まぁ関数がファーストオブジェクトって言うのを活かそうとすると自然と使いそうではあります。

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
from django.utils.functional import lazy
 
def get_value_with_sometime():
    print 'get_value_with_sometime!'
    return 'real val'
 
lazy_get_value = lazy(get_value_with_sometime, str)
 
d = { 'exist_key':'some val' }
value = d.get('exist_key', lazy_get_value('exist_key'))
print value

他にもデコレータのmemoizeとかallow_lazyとかが定義されていて、もっと早く読んどけば良かったなと思った次第です。あと関数型の考え方をちゃんと身につけたくなってきました。

Kayで採用されているjinja2はDjangoの標準テンプレートに良く似せて作られていて、Djangoを触った事があれば違和感無く使い始められます。ところがDjangoでイマイチな部分が解消されていて、一度jinja2を使ってしまうとDjangoに戻ってきた時にイライラしてしまうという問題が生じます。jinja2の何が良いかというと、例えばdjangoのドット記法はヤダとか、テンプレート中で関数呼び出しを見慣れている形で記述できるとか、デフォで{% macro %}が使える等などです。

正直macroなんかは一回使ったらもう同等機能がないテンプレートシステムなんて使えないです。という訳でDjangoでもjinja2を使いたいということで、調べた方法を記録しておきます。

ありがたい事にDjangoにはテンプレートのローダーをプラガブルに設定する仕組みが備わっています。なので下記のようなシンプルな手順でjinja2を使えるようになりました。

1. jinja2用のテンプレートローダを記述
   – jinja2にKayのurl_forにあたるURL逆引き関数を設定
   – jinja2にi18nの設定を行う
2. settings.pyに1のローダを指定

1. jinja2用のローダを記述
ローダはgistに張られていたコチラのコードをほぼ丸パクリさせてもらいました。修正したポイントは上記の2点です。まず今回Kayからの移植という事もあり、URLの逆引き関数が必要だったので、django.core.urlresolvers.reverseをテンプレート中で使えるようにしています。関数名はKayに合わせてurl_forました。もう一点はi18nの設定です。jinja2には国際化を行う為のクラスを指定する仕組みが備わっているので、そこにDjangoの翻訳モジュールを指定します。こうするとDjangoで作成できる.poファイルをjinja2からそのまま利用できます。

あと補足ですが、このローダは拡張子が.htmlのものをロードしません。なのでDjango標準のテンプレートとjinja2のテンプレートを共存させられます。

from django.core.urlresolvers import get_callable
from django.template import TemplateDoesNotExist
from django.template.loader import BaseLoader
from django.template.context import BaseContext
from django.conf import settings
from django.utils import translation
from django.core import urlresolvers
 
import jinja2
 
def monkey_patch_django():
    """
    Patching some django objects to make them "safe" for jinja's escape() function.
    Good for us it uses __html__() method.
    """
    # Django's SafeString and SafeUnicode should not be escaped:
    from django.utils.safestring import SafeData
    SafeData.__html__ = lambda self: self
 
    from jinja2 import escape
    from django.forms import BaseForm, Media
    from django.forms.forms import BoundField
    from django.forms.formsets import BaseFormSet
    from django.forms.util import ErrorDict, ErrorList
 
    for cls in (BaseForm, Media, BoundField, BaseFormSet, ErrorDict, ErrorList):
        cls.__html__ = lambda self: escape(unicode(self))
 
 
class Template(object):
    """
    A container for jinja2 Template class
    """
    def __init__(self, template, origin=None, name='<unknown Template>'):
        self.template = template
        self.origin = origin
        self.name = name
 
    def render(self, context):
        if isinstance(context, BaseContext):
            d = {}
            for u in context.dicts:
                d.update(u)
        else:
            d = context
        return self.template.render(d)
 
class Loader(BaseLoader):
    is_usable = True
 
    def __init__(self, *args, **kwargs):
        """
        Creating jinja2 environment
        """
        assert hasattr(settings, 'TEMPLATE_DIRS'), 'Jinja2 template loader needs TEMPLATE_DIRS setting'
        monkey_patch_django()
 
        extras = self._get_env_extras()
        options = getattr(settings, 'JINJA2_ENVIRONMENT_OPTIONS', {})
        options['extensions'] = extras['extensions']
        options['loader'] = jinja2.FileSystemLoader(settings.TEMPLATE_DIRS)
 
        ### Some special tuning of jinja2 environment goes here
        # Number of compiled jinja2 templates in process memory
        options['cache_size'] = -1
        # Check whether template file is changed only in development
        options['auto_reload'] = settings.DEBUG
        # Use jinja's bytecode cache
        options['bytecode_cache'] = jinja2.FileSystemBytecodeCache(settings.BASE_DIR + '/tmp/jinja_cache')
 
        self.env = jinja2.Environment(**options)
        self.env.filters.update(extras['filters'])
        self.env.globals.update(extras['globals'])
        self.env.tests.update(extras['tests'])
 
        # 1. urlresolvers.reverseをurl_forとして登録
        self.env.globals['url_for'] = urlresolvers.reverse
 
        # 2. djangoの翻訳モジュールをjinjaに登録
        if 'jinja2.ext.i18n' in options['extensions']:
            self.env.install_gettext_translations(translation)
 
    def _get_env_extras(self):
        """
        Creates a dict of extensions, filters, globals and tests from settings
        """
        extensions, filters, objects, tests = [], {}, {}, {}
 
        # add the globally defined extension list
        extensions.extend(list(getattr(settings, 'JINJA2_EXTENSIONS', [])))
 
        # parse filters, globals and tests settings
        def from_setting(setting):
            retval = {}
            setting = getattr(settings, setting, {})
            if isinstance(setting, dict):
                for key, value in setting.iteritems():
                    retval[key] = callable(value) and value or get_callable(value)
            else:
                for value in setting:
                    value = callable(value) and value or get_callable(value)
                    retval[value.__name__] = value
            return retval
 
        filters.update(from_setting('JINJA2_FILTERS'))
        objects.update(from_setting('JINJA2_GLOBALS'))
        tests.update(from_setting('JINJA2_TESTS'))
 
        return dict(
            extensions=extensions,
            filters=filters,
            globals=objects,
            tests=tests,
        )
 
    def load_template(self, template_name, template_dirs=None):
        # Leave .html extension for django template (admin, contrib, etc)
        if template_name.endswith('.html'):
            raise TemplateDoesNotExist(template_name)
        try:
            template = self.env.get_template(template_name)
            return Template(template, None, template_name), None
        except jinja2.TemplateNotFound:
            raise TemplateDoesNotExist(template_name)
 
    def load_template_source(self, template_name, template_dirs=None):
        # Leave .html extension for django template (admin, contrib, etc)
        if template_name.endswith('.html'):
            raise TemplateDoesNotExist(template_name)
        try:
            source, filename, uptodate = self.env.loader.get_source(self.env, template_name)
            return source, filename
        except jinja2.TemplateNotFound:
            raise TemplateDoesNotExist(template_name)
</unknown>

2. settings.pyに1のローダを指定
次に1で作ったローダをsettings.pyに記述しましょう。同時にJINJA2_EXTENSIONSも記述します。
また自分のフィルタを追加する場合はJINJA2_FILTERSに追記すればOKです。

TEMPLATE_LOADERS = (
  'jinjalink_loader.Loader',
  'django.template.loaders.filesystem.Loader',
  'django.template.loaders.app_directories.Loader',
)
 
JINJA2_EXTENSIONS = (
  'jinja2.ext.with_',
  'jinja2.ext.i18n',
)
JINJA2_FILTERS = {
  ...
}
JINJA2_ENVIRONMENT_OPTIONS = {
  ...
}

以上でjinja2をDjangoから使えるようになりました。jinja2は本当に便利で、Django使うのがさらに楽しくなるのでオススメです。あとどうでも良いんですが、jinja2のテンプレートの拡張子って皆さん何使ってるんでしょうか。僕はもっぱら.j2なんですけど。