NIP-44

Encrypted Payloads (Versioned)

暗号化アルゴリズムをバージョンを管理できるようにした暗号方法を定義する仕様です。

/icons/hr.icon

（バージョン管理された）暗号化されたペイロード

任意

バージョン

現在定義されている暗号化アルゴリズムは以下の通り：

制約

すべてのnostrユーザは自身の公開鍵を持っている。これが他の手段に存在する鍵配送問題を解決している。しかしながら、nostrのリレーを基本とするアーキテクチャがメタデータの隠蔽や前方秘匿性(Forward secrecy)、情報漏洩後の秘匿性を備えたより堅牢なプライベートメッセージプロトコルの実装を困難なものにしている。

自然発生的にこのスキームを用いて送信されたメッセージにはいくつかの重要な欠点がある：

否認性の欠如：イベントが特定のキーで署名されたことを証明することができる

前方秘匿性の欠如：キーが漏洩した場合、以前のすべての会話を復号できる

情報漏洩後の秘匿性の欠如：キーが漏洩した場合、将来のすべての会話を複合できる

量子コンピュータ以降のセキュリティの欠如：強力な量子コンピュータがメッセージを暗号化できることだろう

IPアドレスの漏洩：ユーザのIPはリレーおよびリレーとユーザ間にある中間装置によって観測できる

限定的なメッセージサイズの漏洩：パディングは本当のメッセージ長を部分的に分かりづらくするに過ぎない

添付方法の欠如：サポートされない

前方秘匿性の欠如は信頼できるリレーにのみメッセージを送ること、一定の日数が経過した後に保管したメッセージを削除するようリレーに頼むことで部分的に軽減されるだろう。

バージョン2

NIP-44 バージョン2は次の設計上の特徴がある：

ペイロードは署名後でなく署名前にMACによって認証される。イベントはNIP-01で説明されているとおりに署名されることが想定されているためである。外部の署名はペイロード全体の認証を提供し、復号前に検証されなければならない。

XChaChaは標準化されていないため、ChaChaが代わりに使われる。また、すべてのメッセージが新しいペア（鍵とnonce）を持つため、xChaChaにおけるnonceの衝突耐性の改善は必要とされない。

HMAC-SHA256はPoly1305の代わりに使われる。多項式MACは偽造がより簡単であるためである。

SHA-256がSHA3またはBLAKEの代わりに使われる。nostrで既に利用されているためである。また、BLAKEの速度の利点は非並列環境では小さいため。

カスタムのパディング方式がpadméの代わりに使われる。小さなメッセージにおいてよりよい漏洩軽減を提供するためである。

Base64エンコードが他の圧縮アルゴリズムの代わりに使われる。多くの環境で利用でき、nostrでもすでに使われているためである。

暗号化

1. 対話鍵（convesation key）の計算

2. ランダムな32バイトの nonce の生成

メッセージの内容から nonce を生成してはならない。

別のメッセージの nonce を再利用してはならない。もし再利用すると、2つのメッセージを復号できるようにしてしまう。しかし、長期キーが漏洩するわけではない。

3. メッセージ鍵の算出

4. パディングの追加

内容はUTF-8からバイト配列へとエンコードしなければならない

平文の長さを検証すること。最小は1バイト、最長で65535バイトである。

パディングアルゴリズムは2のべき乗に従い、最小のパディングされたメッセージのサイズは32バイトである。

平文の長さはビッグエンディアンでエンコードされる（パディングされたBLOBの最初の2バイトとして）。

5. パディングされた内容の暗号化

ChaCha20を使用すること。手順3の鍵とnonceを用いること。

6. MAC（メッセージ認証符号）の計算

AAD（nonce）が32バイトであることを検証せよ。

暗号化されたペイロードは、NIP-01で定義されているように、secp256k1のシュノア署名方式を用いて、イベントのペイロードに含められ、ハッシュ化され、署名されなければならない(MUST)。

復号

2. Base64のデコード

バージョンが不明の場合、その暗号化バージョンに未対応であることを示さなければならない。

Base64デコーダに対するDoSを防ぐため、Base64メッセージの長さを検証すること：132〜87472文字の間であること。

デコーダの出力を検証するため、デコード済みメッセージの長さを検証すること：99〜65603バイトの間であること。

3. 対話鍵の計算

暗号化の手順1を参照せよ。

4. メッセージ鍵の計算

暗号化の手順3を参照せよ。

5. AADを伴うMAC(メッセージ認証符号)の計算と比較

MACが手順2のものと一致しない場合、停止してエラーを投げること。

定数時間の比較アルゴリズムを用いること。

6. 暗号文の復号

ChaCha20を使用すること。手順3の鍵とnonceを用いること。

7. パディングの除去

平文の長さに対応する、平文の最初の2バイト（ビッグエンディアン）を読み取ること。

スライスされた平文の長さがその2バイトの値と一致することを検証せよ。

暗号化手順3で計算されたパディングと実際のパディングが一致することを検証せよ。

詳細

暗号のメソッド

演算子

関数

実装の疑似コード

code:_.py

# パディングされた場合のバイト配列の長さを計算する

def calc_padded_len(unpadded_len):

next_power = 1 << (floor(log2(unpadded_len - 1))) + 1

if next_power <= 256:

chunk = 32

else:

chunk = next_power / 8

if unpadded_len <= 32:

return 32

else:

return chunk * (floor((len - 1) / chunk) + 1)

# パディングされてない平文をパディング済みのバイト配列に変換する

def pad(plaintext):

unpadded = utf8_encode(plaintext)

unpadded_len = len(plaintext)

if (unpadded_len < c.min_plaintext_size or

unpadded_len > c.max_plaintext_size): raise Exception('平文の長さが不正')

prefix = write_u16_be(unpadded_len)

suffix = zeros(calc_padded_len(unpadded_len) - unpadded_len)

return concat(prefix, unpadded, suffix)

# パディング済みのバイト配列をパディングされていない平文に変換する

def unpad(padded):

if (unpadded_len == 0 or

len(unpadded) != unpadded_len or

len(padded) != 2 + calc_padded_len(unpadded_len)): raise Exception('不正なパディング')

return utf8_decode(unpadded)

# メタデータ : 常に 65バイト (version: 1バイト, nonce: 32バイト, max: 32バイト)

# 平文 : 1 〜 65535(0xffff)バイト

# パディング済みの平文 : 32 〜 65535(0xffff)バイト

# 暗号文: 32 + 2 〜 65535(0xffff) + 2 バイト

# 生のペイロード: 99 (65+32+2) 〜o 65603 (65+65535(0xffff)+2) バイト

# 圧縮されたペイロード (base64): 132 〜 87472b

def decode_payload(payload):

plen = len(payload)

if plen < 132 or plen > 87472: raise Exception('ペイロード長が不正')

data = base64_decode(payload)

dlen = len(d)

if dlen < 99 or dlen > 65603: raise Exception('データ長が不正');

if vers != 2: raise Exception('未知の―ジョン ' + vers)

return (nonce, ciphertext, mac)

def hmac_aad(key, message, aad):

if len(aad) != 32: raise Exception('AAD関連データは 32 バイトでなければならない');

return hmac(sha256, key, concat(aad, message));

def get_conversation_key(private_key_a, public_key_b):

shared_x = secp256k1_ecdh(private_key_a, public_key_b)

return hkdf_extract(IKM=shared_x, salt=utf8_encode('nip44-v2'))

# Calculates unique per-message key

def get_message_keys(conversation_key, nonce):

if len(conversation_key) != 32: raise Exception('対話鍵(conversation_key)の長さが不正')

if len(nonce) != 32: raise Exception('nonceの長さが不正')

keys = hkdf_expand(OKM=conversation_key, info=nonce, L=76)

return (chacha_key, chacha_nonce, hmac_key)

def encrypt(plaintext, conversation_key, nonce):

(chacha_key, chacha_nonce, hmac_key) = get_message_keys(conversation_key, nonce)

padded = pad(plaintext)

ciphertext = chacha20(key=chacha_key, nonce=chacha_nonce, data=padded)

mac = hmac_aad(key=hmac_key, message=ciphertext, aad=nonce)

return base64_encode(concat(write_u8(2), nonce, ciphertext, mac))

def decrypt(payload, conversation_key):

(nonce, ciphertext, mac) = decode_payload(payload)

(chacha_key, chacha_nonce, hmac_key) = get_message_keys(conversation_key, nonce)

calculated_mac = hmac_aad(key=hmac_key, message=ciphertext, aad=nonce)

if not is_equal_ct(calculated_mac, mac): raise Exception('invalid MAC')

padded_plaintext = chacha20(key=chacha_key, nonce=chacha_nonce, data=ciphertext)

return unpad(padded_plaintext)

# 使用法:

# conversation_key = get_conversation_key(sender_privkey, recipient_pubkey)

# nonce = secure_random_bytes(32)

# payload = encrypt('hello world', conversation_key, nonce)

# 'hello world' == decrypt(payload, conversation_key)

監査

テストとコード

code:sha256sum

269ed0f69e4c192512cc779e78c555090cebc7c785b609e338a62afc3ce25040 nip44.vectors.json

ファイルからのテストベクタの例:

code:_.json

{

"sec1": "0000000000000000000000000000000000000000000000000000000000000001",

"sec2": "0000000000000000000000000000000000000000000000000000000000000002",

"conversation_key": "c41c775356fd92eadc63ff5a0dc1da211b268cbea22316767095b2871ea1412d",

"nonce": "0000000000000000000000000000000000000000000000000000000000000001",

"plaintext": "a",

"payload": "AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABee0G5VSK0/9YypIObAtDKfYEAjD35uVkHyB0F4DwrcNaCXlCWZKaArsGrY6M9wnuTMxWfp1RTN9Xga8no+kF5Vsb"

}

ファイルには中間の値も含まれる。使用法についての手早いガイド:

(訳注: 原文でも未記載)

/icons/hr.icon

特長

Lists

Version: 1のパラメーター

メタデータの漏洩

すべての nostr イベントはインターネット経由で渡されるため、一部のメタデータは常に漏洩する可能性がある。

互換性のあるすべてのクライアントは、メタデータの漏洩を防ぐために次のフローを実装する必要がある。

ユーザーが NIP-65 優先リレーを指定しなかった場合、ダイレクト メッセージを受信すべきではない。 (SHOULD NOT)

バージョン管理

クライアントは、サポートしていないバージョンの NIP44 メッセージを受信した場合、説明的なエラーを返す必要がある。エラーは、メッセージのバージョンがサポートされていないことを示し、アップグレードや別のクライアントへの切り替えなどの適切なアクションを提案する必要がある。 (MUST)

現在定義されている暗号化アルゴリズム:

0x00 - 予約済み

セキュリティに関する警告

この標準は、ピア間の暗号化通信において最先端と考えられているものには程遠いものであり、イベント内のメタデータが漏洩するため、本当に機密にする必要があるものには使用できない。また、kind:4 イベントを取得できるユーザーを制限するために AUTH を使用するリレーでのみ使用すべきである。

クライアント実装に関する警告

アルゴリズム

code: (tsx)

// npm install @noble/curves @noble/hashes @scure/base @stablelib/xchacha20

import {xchacha20} from '@noble/ciphers/chacha'

import {secp256k1} from '@noble/curves/secp256k1'

import {sha256} from '@noble/hashes/sha256'

import {randomBytes} from '@noble/hashes/utils'

import {base64} from '@scure/base'

import {utf8Decoder, utf8Encoder} from './utils.ts'

export function getConversationKey(privkeyA: string, pubkeyB: string): Uint8Array {

const key = secp256k1.getSharedSecret(privkeyA, '02' + pubkeyB)

return sha256(key.subarray(1, 33))

}

export function encrypt(

key: Uint8Array,

text: string,

ver = 1

): string {

if (ver !== 1) throw new Error('NIP44: unknown encryption version')

let nonce = randomBytes(24)

let plaintext = utf8Encoder.encode(text)

let ciphertext = xchacha20(key, nonce, plaintext, plaintext)

}

export function decrypt(key: Uint8Array, data: string): string {

let dt = data.split(',')

if (dt.length !== 3) throw new Error('NIP44: unknown encryption version');

if (v !== 1) throw new Error('NIP44: unknown encryption version')

let plaintext = xchacha20(key, nonce, ciphertext)

let text = utf8Decoder.decode(plaintext)

return text

}