第184回では、Ed25519署名付き承認へ開始時刻と終了時刻を含め、not_before <= checked_at < expires_atの範囲だけを受理しました。
ただし、期限内でも承認を止めたい場合があります。誤った承認の撤回、担当者の権限変更、秘密鍵の漏えいなどです。署名と期限が正しければ、前回までの検証だけでは拒否できません。
今回は、承認IDまたは署名鍵IDを記録した取消一覧へ、承認用とは別のEd25519鍵で署名します。検証側は一覧の署名、有効期間、取消時刻を調べ、有効な取消項目に一致した対象を拒否します。
これは本稿独自のアプリケーション用JSON形式です。X.509の証明書失効リストやオンライン失効確認サービスではありません。すでに実行した送信や更新を元に戻す機能もありません。
期限切れと取消を分ける
| 状態 | 署名 | 承認の期限 | 判定 |
|---|---|---|---|
| 承認期限を過ぎた | 正しい場合がある | 期限外 | 第184回の検証で拒否 |
| 承認IDを取り消した | 正しい | 期限内でもよい | 承認全体を拒否 |
| 署名鍵IDを取り消した | 正しい | 期限内でもよい | その鍵による署名を有効数へ含めない |
| 取消時刻より前 | 正しい | 期限内 | その取消項目には一致しない |
| 取消一覧が期限切れ | 正しい場合がある | 判定不能 | 未取消とは扱わず、入力エラーで停止 |
取消はrevoked_at <= checked_atで有効になります。秘密鍵が漏えいした時点より前の署名かどうかは、通常の署名だけでは信頼できる形で証明できません。本稿では、取消時刻以後の検証で、その鍵による署名を保守的に除外します。
今回の実行契約
| 項目 | 仕様 |
|---|---|
| 動作環境 | Python 3.11以上、cryptography 50.0.2。コマンド例はPOSIXシェル向け |
| 取消一覧 | BOMなしUTF-8のJSON。32,768バイト以下、最大128項目 |
| 一覧の有効期間 | issued_at <= checked_at < expires_at。期間は最大48時間 |
| 取消対象 | 承認ID、または32バイトの生公開鍵へSHA-256を適用した64桁の小文字16進数 |
| 署名 | 64バイトのEd25519署名を標準Base64でJSONへ格納 |
| 公開鍵 | 取消一覧専用のEd25519公開鍵PEM。4,096バイト以下 |
| 終了コード0 | 検証時刻で有効な取消項目に一致しない |
| 終了コード1 | 承認IDまたは署名鍵IDが有効な取消項目に一致した |
| 終了コード2 | 入力形式、署名、一覧の有効期間などを検証できない |
終了コード2を「未取消」と読み替えてはいけません。新しい一覧を取得できない場合の待機時間や停止手順は、業務側で別に決めます。--helpの表示と、OSによる強制終了は1行JSONの判定契約に含めません。
このCLIは承認文書そのものを検証しません。--approval-idと--signing-key-idは、署名検証を終えた承認文書と実際に検証した公開鍵から、呼び出し側が渡す値です。承認文書に自己申告された鍵IDや、外部利用者が選んだ値をそのまま渡してはいけません。
署名する取消一覧
テストでは次の一覧を使います。fが64個並ぶ署名鍵IDは、実在の鍵を示さないテスト値です。
{
"entries": [
{
"reason_code": "approval_withdrawn",
"revoked_at": "2026-11-09T01:30:00Z",
"target": "APR-2026-0042",
"target_type": "approval_id"
},
{
"reason_code": "key_retired",
"revoked_at": "2026-11-09T02:00:00Z",
"target": "ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
"target_type": "signing_key_id"
}
],
"expires_at": "2026-11-11T00:00:00Z",
"issued_at": "2026-11-09T00:00:00Z",
"schema": "approval-revocations-v1",
"sequence": 7
}
sequenceは一覧の更新順です。ただし、今回のCLIは前回受理した値を保存しません。期限内の古い署名済み一覧を再提示されても、単体では最新版との違いを判断できません。
署名対象は、解析したJSONをキー順、空白なし、ASCII表現へ変換したバイト列です。これは本稿の制約付き形式専用で、汎用的なJSON正規化規格ではありません。識別子、時刻、列挙値をASCIIへ限定し、重複キー、浮動小数、NaNなどを拒否します。
cryptography 50.0.2のEd25519 APIでは、sign()が64バイトの署名を返し、検証できない署名に対してverify()がInvalidSignatureを発生させます。Base64は、非アルファベット文字を捨てないようにvalidate=Trueで復号します。
JSONの重複キーは、Python 3.11のjsonモジュールが提供するobject_pairs_hookで検出します。
テスト用の鍵、一覧、署名を作る
空の作業ディレクトリで仮想環境を作り、使用する版を固定します。
python3.11 -m venv .venv
.venv/bin/python -m pip install 'cryptography==50.0.2'
次のコードをmake_demo_revocations.pyとして保存します。生成する秘密鍵は暗号化されていないテスト専用品です。業務用の取消鍵では、この保存方法をそのまま使わず、承認鍵と分離した保管・利用手順を決めてください。
#!/usr/bin/env python3
import base64
import json
import os
import sys
from cryptography.exceptions import UnsupportedAlgorithm
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
OUTPUTS = (
"revocation-private.pem",
"revocation-public.pem",
"revocations.json",
"revocations.sig.json",
)
def canonical_json_bytes(value):
text = json.dumps(
value,
ensure_ascii=True,
sort_keys=True,
separators=(",", ":"),
allow_nan=False,
)
return text.encode("ascii")
def emit(stream, payload):
stream.write(json.dumps(
payload,
ensure_ascii=True,
sort_keys=True,
separators=(",", ":"),
) + "\n")
def write_new(path, data, mode):
flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL
descriptor = os.open(path, flags, mode)
with os.fdopen(descriptor, "wb") as destination:
destination.write(data)
destination.flush()
os.fsync(destination.fileno())
def main():
if any(os.path.lexists(path) for path in OUTPUTS):
emit(sys.stderr, {"error": "output_exists", "ok": False})
return 2
document = {
"schema": "approval-revocations-v1",
"sequence": 7,
"issued_at": "2026-11-09T00:00:00Z",
"expires_at": "2026-11-11T00:00:00Z",
"entries": [
{
"target_type": "approval_id",
"target": "APR-2026-0042",
"revoked_at": "2026-11-09T01:30:00Z",
"reason_code": "approval_withdrawn",
},
{
"target_type": "signing_key_id",
"target": "f" * 64,
"revoked_at": "2026-11-09T02:00:00Z",
"reason_code": "key_retired",
},
],
}
try:
private_key = Ed25519PrivateKey.generate()
private_pem = private_key.private_bytes(
serialization.Encoding.PEM,
serialization.PrivateFormat.PKCS8,
serialization.NoEncryption(),
)
public_pem = private_key.public_key().public_bytes(
serialization.Encoding.PEM,
serialization.PublicFormat.SubjectPublicKeyInfo,
)
signed_payload = canonical_json_bytes(document)
signature = private_key.sign(signed_payload)
signature_document = {
"algorithm": "Ed25519",
"signature_b64": base64.b64encode(signature).decode("ascii"),
}
list_bytes = (json.dumps(
document,
ensure_ascii=True,
sort_keys=True,
indent=2,
allow_nan=False,
) + "\n").encode("ascii")
signature_bytes = (json.dumps(
signature_document,
ensure_ascii=True,
sort_keys=True,
separators=(",", ":"),
) + "\n").encode("ascii")
write_new(OUTPUTS[0], private_pem, 0o600)
write_new(OUTPUTS[1], public_pem, 0o644)
write_new(OUTPUTS[2], list_bytes, 0o644)
write_new(OUTPUTS[3], signature_bytes, 0o644)
except (OSError, UnsupportedAlgorithm):
emit(sys.stderr, {"error": "setup_failed", "ok": False})
return 2
emit(sys.stdout, {"created": list(OUTPUTS), "ok": True})
return 0
if __name__ == "__main__":
raise SystemExit(main())
既存ファイルは上書きしません。途中で書き込みに失敗すると一部のファイルが残る場合があります。そのファイルを再利用せず、新しい空ディレクトリでやり直します。
.venv/bin/python make_demo_revocations.py
成功時の標準出力は次の1行です。
{"created":["revocation-private.pem","revocation-public.pem","revocations.json","revocations.sig.json"],"ok":true}
署名と取消時刻を検証するCLI
次のコードをcheck_revocation.pyとして保存します。
#!/usr/bin/env python3
import argparse
import base64
import binascii
import hashlib
import json
import re
import sys
from datetime import datetime, timedelta, timezone
from cryptography.exceptions import InvalidSignature, UnsupportedAlgorithm
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
MAX_LIST_BYTES = 32_768
MAX_SIGNATURE_BYTES = 1_024
MAX_PUBLIC_KEY_BYTES = 4_096
MAX_LIST_WINDOW = timedelta(hours=48)
MAX_ENTRIES = 128
ID_PATTERN = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:-]{0,127}")
KEY_ID_PATTERN = re.compile(r"[0-9a-f]{64}")
TIMESTAMP_PATTERN = re.compile(
r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z"
)
REASON_CODES = {
"approval_withdrawn",
"authorization_removed",
"key_compromised",
"key_retired",
}
class InputError(Exception):
pass
class JsonArgumentParser(argparse.ArgumentParser):
def error(self, message):
raise InputError("invalid_arguments")
def emit(stream, payload):
stream.write(json.dumps(
payload,
ensure_ascii=True,
sort_keys=True,
separators=(",", ":"),
) + "\n")
def read_limited(path, limit, label):
try:
with open(path, "rb") as source:
data = source.read(limit + 1)
except OSError as exc:
raise InputError(f"cannot_read_{label}") from exc
if len(data) > limit:
raise InputError(f"{label}_too_large")
return data
def no_duplicate_object(pairs):
result = {}
for key, value in pairs:
if key in result:
raise InputError(f"duplicate_json_key:{key}")
result[key] = value
return result
def reject_float(value):
raise InputError("floating_point_not_allowed")
def parse_integer(value):
if len(value.lstrip("-")) > 19:
raise InputError("integer_too_long")
return int(value)
def reject_constant(value):
raise InputError(f"non_finite_number:{value}")
def load_json(data, label):
if data.startswith(b"\xef\xbb\xbf"):
raise InputError(f"bom_not_allowed:{label}")
try:
text = data.decode("utf-8", errors="strict")
return json.loads(
text,
object_pairs_hook=no_duplicate_object,
parse_float=reject_float,
parse_int=parse_integer,
parse_constant=reject_constant,
)
except UnicodeDecodeError as exc:
raise InputError(f"invalid_utf8:{label}") from exc
except json.JSONDecodeError as exc:
raise InputError(f"invalid_json:{label}") from exc
except RecursionError as exc:
raise InputError(f"json_too_deep:{label}") from exc
def canonical_json_bytes(value):
try:
text = json.dumps(
value,
ensure_ascii=True,
sort_keys=True,
separators=(",", ":"),
allow_nan=False,
)
except (TypeError, ValueError, RecursionError) as exc:
raise InputError("cannot_canonicalize_json") from exc
return text.encode("ascii")
def require_exact_keys(value, expected, label):
if not isinstance(value, dict) or set(value) != expected:
raise InputError(f"invalid_fields:{label}")
def parse_utc(value, label):
if not isinstance(value, str) or not TIMESTAMP_PATTERN.fullmatch(value):
raise InputError(f"invalid_timestamp:{label}")
try:
parsed = datetime.strptime(value, "%Y-%m-%dT%H:%M:%SZ")
except ValueError as exc:
raise InputError(f"invalid_timestamp:{label}") from exc
return parsed.replace(tzinfo=timezone.utc)
def validate_identifier(value, pattern, label):
if not isinstance(value, str) or not pattern.fullmatch(value):
raise InputError(f"invalid_identifier:{label}")
def validate_document(document):
require_exact_keys(
document,
{"schema", "sequence", "issued_at", "expires_at", "entries"},
"document",
)
if document["schema"] != "approval-revocations-v1":
raise InputError("unsupported_schema")
sequence = document["sequence"]
if type(sequence) is not int or not 1 <= sequence <= 2**63 - 1:
raise InputError("invalid_sequence")
issued_at = parse_utc(document["issued_at"], "issued_at")
expires_at = parse_utc(document["expires_at"], "expires_at")
if not issued_at < expires_at:
raise InputError("invalid_list_window")
if expires_at - issued_at > MAX_LIST_WINDOW:
raise InputError("list_window_too_long")
entries = document["entries"]
if not isinstance(entries, list) or len(entries) > MAX_ENTRIES:
raise InputError("invalid_entries")
seen = set()
validated = []
for index, entry in enumerate(entries):
label = f"entries[{index}]"
require_exact_keys(
entry,
{"target_type", "target", "revoked_at", "reason_code"},
label,
)
target_type = entry["target_type"]
target = entry["target"]
if target_type == "approval_id":
validate_identifier(target, ID_PATTERN, f"{label}.target")
elif target_type == "signing_key_id":
validate_identifier(target, KEY_ID_PATTERN, f"{label}.target")
else:
raise InputError(f"invalid_target_type:{label}")
revoked_at = parse_utc(
entry["revoked_at"],
f"{label}.revoked_at",
)
if revoked_at >= expires_at:
raise InputError(f"revocation_outside_list_window:{label}")
reason_code = entry["reason_code"]
if not isinstance(reason_code, str) or reason_code not in REASON_CODES:
raise InputError(f"invalid_reason_code:{label}")
identity = (target_type, target)
if identity in seen:
raise InputError(f"duplicate_revocation:{label}")
seen.add(identity)
validated.append((target_type, target, revoked_at, reason_code))
return sequence, issued_at, expires_at, validated
def load_signature(data):
document = load_json(data, "signature")
require_exact_keys(
document,
{"algorithm", "signature_b64"},
"signature",
)
if document["algorithm"] != "Ed25519":
raise InputError("unsupported_signature_algorithm")
encoded = document["signature_b64"]
if not isinstance(encoded, str):
raise InputError("invalid_signature_encoding")
try:
signature = base64.b64decode(encoded, validate=True)
except (binascii.Error, ValueError) as exc:
raise InputError("invalid_signature_encoding") from exc
if len(signature) != 64:
raise InputError("invalid_signature_length")
return signature
def load_public_key(data):
try:
key = serialization.load_pem_public_key(data)
except (ValueError, TypeError, UnsupportedAlgorithm) as exc:
raise InputError("invalid_public_key") from exc
if not isinstance(key, Ed25519PublicKey):
raise InputError("public_key_is_not_ed25519")
return key
def build_parser():
parser = JsonArgumentParser()
parser.add_argument("--revocations", required=True)
parser.add_argument("--signature", required=True)
parser.add_argument("--public-key", required=True)
parser.add_argument("--approval-id", required=True)
parser.add_argument("--signing-key-id", required=True)
parser.add_argument("--checked-at", required=True)
return parser
def main():
try:
args = build_parser().parse_args()
validate_identifier(
args.approval_id,
ID_PATTERN,
"approval_id_argument",
)
validate_identifier(
args.signing_key_id,
KEY_ID_PATTERN,
"signing_key_id_argument",
)
checked_at = parse_utc(args.checked_at, "checked_at")
document = load_json(
read_limited(
args.revocations,
MAX_LIST_BYTES,
"revocation_list",
),
"revocation_list",
)
signed_payload = canonical_json_bytes(document)
signature = load_signature(read_limited(
args.signature,
MAX_SIGNATURE_BYTES,
"signature",
))
public_key = load_public_key(read_limited(
args.public_key,
MAX_PUBLIC_KEY_BYTES,
"public_key",
))
try:
public_key.verify(signature, signed_payload)
except InvalidSignature as exc:
raise InputError("invalid_revocation_signature") from exc
sequence, issued_at, expires_at, entries = validate_document(document)
if checked_at < issued_at:
raise InputError("revocation_list_not_yet_valid")
if checked_at >= expires_at:
raise InputError("revocation_list_expired")
matches = []
for target_type, target, revoked_at, reason_code in entries:
expected = (
args.approval_id
if target_type == "approval_id"
else args.signing_key_id
)
if target == expected and revoked_at <= checked_at:
matches.append({
"reason_code": reason_code,
"revoked_at": revoked_at.strftime(
"%Y-%m-%dT%H:%M:%SZ"
),
"target_type": target_type,
})
payload_hash = hashlib.sha256(signed_payload).hexdigest()
if matches:
emit(sys.stderr, {
"error": "revocation_match",
"matches": matches,
"ok": False,
"sequence": sequence,
"signed_payload_sha256": payload_hash,
})
return 1
emit(sys.stdout, {
"ok": True,
"sequence": sequence,
"signed_payload_sha256": payload_hash,
"status": "no_effective_revocation",
})
return 0
except InputError as exc:
emit(sys.stderr, {"error": str(exc), "ok": False})
return 2
if __name__ == "__main__":
raise SystemExit(main())
取消時刻の前後を試す
最初は、承認IDの取消時刻より前である01:00:00Zを指定します。64個の0は、一覧にない署名鍵IDのテスト値です。
.venv/bin/python check_revocation.py \
--revocations revocations.json \
--signature revocations.sig.json \
--public-key revocation-public.pem \
--approval-id APR-2026-0042 \
--signing-key-id 0000000000000000000000000000000000000000000000000000000000000000 \
--checked-at 2026-11-09T01:00:00Z
echo $?
標準出力と終了コードは次のとおりです。
{"ok":true,"sequence":7,"signed_payload_sha256":"57dc5ec4a5e898010026033af3594155a8a9a6a98ef14df8ca1b66db65bf9f91","status":"no_effective_revocation"}
0
次に、取消時刻より後の01:45:00Zで同じ承認IDを調べます。
.venv/bin/python check_revocation.py \
--revocations revocations.json \
--signature revocations.sig.json \
--public-key revocation-public.pem \
--approval-id APR-2026-0042 \
--signing-key-id 0000000000000000000000000000000000000000000000000000000000000000 \
--checked-at 2026-11-09T01:45:00Z
echo $?
取消項目は標準エラー出力へ出され、終了コードは1です。
{"error":"revocation_match","matches":[{"reason_code":"approval_withdrawn","revoked_at":"2026-11-09T01:30:00Z","target_type":"approval_id"}],"ok":false,"sequence":7,"signed_payload_sha256":"57dc5ec4a5e898010026033af3594155a8a9a6a98ef14df8ca1b66db65bf9f91"}
1
checked_atが一覧のexpires_atと等しい場合は、半開区間の外側です。CLIはrevocation_list_expiredで終了コード2を返します。署名後に一覧の値だけを変更した場合も、invalid_revocation_signatureで終了コード2になります。
第184回の期限検証へ組み込む
- 承認文書の構造と署名を検証する。
- 承認ID、成果物ハッシュ、ポリシー、役割などを照合する。
- 承認の
not_beforeとexpires_atを検証環境の時刻で確認する。 - 取消一覧の署名と有効期間を検証する。
- 検証済みの承認IDを取消一覧へ照合する。
- 署名検証に使用した公開鍵をRaw形式の32バイトへ変換し、そのSHA-256を署名鍵IDとして照合する。
- 有効な取消対象がなければ後続処理へ進む。
承認の期限と取消一覧は、同じchecked_atで判定します。例の引数は境界を再現するためのものです。実運用では、承認文書に書かれた時刻や外部利用者の入力を使わず、検証環境が取得した信頼できる時刻を渡します。
第183回のような役割別の複数署名では、承認IDの一致は文書全体の拒否です。署名鍵IDだけが一致した場合は、その鍵の署名を有効数へ含めず、残った署名で必要な役割や閾値を満たすか再判定します。
今回のCLIは一度に一つの署名鍵IDを調べます。複数鍵を扱う場合は検証関数として組み込み、取消一覧の署名検証を一度だけ行います。単一署名の経路では、終了コード1と2のどちらでも後続処理を停止します。
署名付き一覧でも残る制約
- 一覧の巻き戻し:以前の一覧にも正しい署名があります。期限は古い一覧を使える期間に上限を設けますが、同じ有効期間内の最新版までは証明しません。前回受理した
sequenceと署名対象のSHA-256を、保護された状態へ保存する必要があります。 - 公開鍵の置換:取消一覧、署名、公開鍵を一緒に差し替えられる環境では検証になりません。取消一覧用公開鍵を信頼できる方法で固定します。
- 取消鍵の漏えい:取消一覧用秘密鍵が漏えいすれば、偽の一覧を作成できます。鍵の更新手順は今回の実装に含みません。
- 一覧の取得:CLIはローカルファイルだけを読みます。配布、再取得、キャッシュ、取得元の認証は行いません。
- 時計の誤差:一覧と取消の判定は検証環境の時計に依存します。時刻同期と許容差は運用側で決めます。
- 過去の副作用:取消後の受理は止められても、取消前に実行した支払い、通知、ファイル更新などは元に戻りません。
まず、単一署名の検証経路へ接続し、取消一致と検証不能のどちらでも処理が進まないことを試します。次に、受理済みのsequenceと署名対象ハッシュを保存し、署名済みの古い一覧へ戻れない状態管理を加えます。