{
“checks”: {
“ciphertext_sha256”: “0631d4f31b7503e2546ba3cc77a99df87e9fbf9082b5d9b86d42e82722ff1e0a”,
“plaintext_sha256”: “d66f4c70a6f4f9e7062fbfa036ab42cd746310924aff67b26795d75e65227384”
},
“created_at”: “2026-06-12T12:52:56.215597+00:00”,
“encryption”: {
“algorithm”: “AES-256-GCM”,
“associated_data”: “dGltZWxvY2stYXJ0aWNsZS12MQ==”,
“ciphertext”: “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”,
“nonce”: “tHBh9KHUl1CNAMsG”,
“tag”: “yte5RCRnKG5jgWMO/mSUZA==”
},
“format_version”: 1,
“instructions”: [
“Run: python timelock.py solve PACKAGE.json –output article.txt”,
“The solver computes x = a^(2^T) mod N by T repeated squarings.”,
“The AES key is wrapped as key XOR H(x,N,a,T).”,
“The package intentionally does not contain p, q, or the raw AES key.”
],
“scheme”: “RSW-time-lock + AES-256-GCM”,
“target_delay”: “~10 years of sequential computation”,
“timelock”: {
“N”: “0x5b4a5f1e633ded13c8a675ec4f422415f1678a7f870994705a34a5a2ebeaf7895061311cd0d2e61f5d09cbe6d75793de86763c4618f01368ca2415cdb627fa3ea5ee76248ad517bf0fa490fae03f0ef469ac6da1cc2ad53a2963e654bf7564b5fb7bc9cc52ed3202c67470d9c77183634e21d4fc7b2a9ed75b43afa0e353a946abd94624ff40b82b59595d6ace4eec5fe378330785d5c7d799ea7674e2ac0f010d9d2ae2a5f662a0fd168f8213f1d1e9c815a72282589145a37112b98bd70672a81f800f754294e750c6963034bfa81506878f96122d1e8c553e0f117167355b4f0b2b78516d1592282da1e0fb7ae61bb93efa77d87bc24bc3feceee3fb43ff3”,
“T”: “30473866916236”,
“a”: “0x1235bb0009e67a5132ca7ecfafad191e8affd6afaaf94abbabd3e13f50409efff96d614ae66f716c723f98b2c321364287ee2bdd9367e2bbdbff00891a71cfd13235d53779e934357cc4413fdfb14e9bef8ba791a5fb2b904101e32014dcee3203dfd2d4e52898b0fa0c8ab06c8763e08e6ee8372ff633ee1fe6409d57c4a24b80bbe89d26d49dbcd533579c0db5f98bcc89166181fd1785311802cb2cb855d809e2b6aff701d0214b6103a25033d118691a599fc9e30c2cb0da82cd5f04358bcee9cf33073be079cc57a657d032a4fe0d03cae3145304087c8635b6c12711017f07953f90cf5d87861d331de58d32b99555cb422eb004ed0fead1c5d14c145e”,
“key_mask”: “SHA-256 counter mode over solution,N,a,T”,
“wrapped_key”: “qbVLlqCoBeMo4RX9ZA1ZCPcPzxsRVdJvrNA936nquHA=”
},
“warning”: “This is a sequential-computation delay, not calendar-time release. If nobody starts solving, the delay starts later.”
}
#!/usr/bin/env python3
"""RSW time-lock encryption for one-shot public article releases."""
from __future__ import annotations
import argparse
import base64
import dataclasses
import datetime as dt
import hashlib
import json
import math
import os
import secrets
import sys
import time
from pathlib import Path
from typing import Any
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
SCHEME = "RSW-time-lock + AES-256-GCM"
FORMAT_VERSION = 1
DEFAULT_BITS = 2048
DEFAULT_PRIME_ROUNDS = 48
SMALL_PRIMES = (
3,
5,
7,
11,
13,
17,
19,
23,
29,
31,
37,
41,
43,
47,
53,
59,
61,
67,
71,
73,
79,
83,
89,
97,
)
@dataclasses.dataclass(frozen=True)
class Progress:
done: int
total: int
started_at: float
last_report_at: float
def b64e(data: bytes) -> str:
return base64.b64encode(data).decode("ascii")
def b64d(data: str) -> bytes:
return base64.b64decode(data.encode("ascii"), validate=True)
def int_to_hex(value: int) -> str:
return "0x" + value.to_bytes((value.bit_length() + 7) // 8, "big").hex()
def int_from_public(value: str | int) -> int:
if isinstance(value, int):
return value
value = value.strip()
if value.startswith("0x"):
return int(value, 16)
return int(value)
def int_to_min_bytes(value: int) -> bytes:
if value == 0:
return b"\x00"
return value.to_bytes((value.bit_length() + 7) // 8, "big")
def xor_bytes(left: bytes, right: bytes) -> bytes:
if len(left) != len(right):
raise ValueError("xor operands must have the same length")
return bytes(a ^ b for a, b in zip(left, right, strict=True))
def derive_mask(solution: int, n: int, a: int, t: int, length: int) -> bytes:
context = b"|".join(
[
b"timelock-rsw-v1",
int_to_min_bytes(solution),
int_to_min_bytes(n),
int_to_min_bytes(a),
str(t).encode("ascii"),
]
)
output = bytearray()
counter = 0
while len(output) < length:
output.extend(hashlib.sha256(context + counter.to_bytes(4, "big")).digest())
counter += 1
return bytes(output[:length])
def is_probable_prime(candidate: int, rounds: int = DEFAULT_PRIME_ROUNDS) -> bool:
if candidate < 2:
return False
if candidate == 2:
return True
if candidate % 2 == 0:
return False
for prime in SMALL_PRIMES:
if candidate == prime:
return True
if candidate % prime == 0:
return False
d = candidate - 1
s = 0
while d % 2 == 0:
s += 1
d //= 2
for _ in range(rounds):
base = secrets.randbelow(candidate - 3) + 2
x = pow(base, d, candidate)
if x in (1, candidate - 1):
continue
for _ in range(s - 1):
x = pow(x, 2, candidate)
if x == candidate - 1:
break
else:
return False
return True
def generate_prime(bits: int, rounds: int) -> int:
if bits < 512:
raise ValueError("prime size must be at least 512 bits")
while True:
candidate = secrets.randbits(bits)
candidate |= (1 << (bits - 1)) | 1
if is_probable_prime(candidate, rounds):
return candidate
def generate_rsa_modulus(bits: int, rounds: int) -> tuple[int, int, int]:
if bits < 1024 or bits % 2:
raise ValueError("modulus bits must be an even number >= 1024")
half = bits // 2
p = generate_prime(half, rounds)
q = generate_prime(half, rounds)
while q == p:
q = generate_prime(half, rounds)
return p * q, p, q
def choose_base(n: int) -> int:
while True:
a = secrets.randbelow(n - 3) + 2
if math.gcd(a, n) == 1:
return a
def fast_rsw_solution(a: int, t: int, p: int, q: int, n: int) -> int:
carmichael = math.lcm(p - 1, q - 1)
exponent = pow(2, t, carmichael)
return pow(a, exponent, n)
def slow_rsw_solution(
a: int,
t: int,
n: int,
*,
report_seconds: float = 10.0,
checkpoint_path: Path | None = None,
checkpoint_every: int = 100_000,
start_index: int = 0,
) -> int:
x = a
started = time.monotonic()
last_report = started
for i in range(start_index, t):
x = (x * x) % n
done = i + 1
now = time.monotonic()
if checkpoint_path and done % checkpoint_every == 0:
checkpoint_path.write_text(
json.dumps(
{
"done": done,
"x": int_to_hex(x),
"updated_at": dt.datetime.now(dt.UTC).isoformat(),
},
indent=2,
sort_keys=True,
),
encoding="utf-8",
)
if report_seconds > 0 and now - last_report >= report_seconds:
elapsed = now - started
rate = (done - start_index) / elapsed if elapsed else 0.0
remaining = (t - done) / rate if rate else float("inf")
print(
f"progress: {done}/{t} ({done / t:.2%}), "
f"{rate:,.0f} squarings/sec, eta {format_seconds(remaining)}",
file=sys.stderr,
)
last_report = now
if checkpoint_path:
checkpoint_path.write_text(
json.dumps(
{
"done": t,
"x": int_to_hex(x),
"updated_at": dt.datetime.now(dt.UTC).isoformat(),
},
indent=2,
sort_keys=True,
),
encoding="utf-8",
)
return x
def format_seconds(seconds: float) -> str:
if seconds == float("inf"):
return "unknown"
if seconds < 60:
return f"{seconds:.1f}s"
minutes = seconds / 60
if minutes < 60:
return f"{minutes:.1f}m"
hours = minutes / 60
if hours < 48:
return f"{hours:.1f}h"
days = hours / 24
if days < 730:
return f"{days:.1f}d"
return f"{days / 365.2425:.2f}y"
def benchmark_squarings(bits: int, seconds: float) -> dict[str, Any]:
n = secrets.randbits(bits) | (1 << (bits - 1)) | 1
x = secrets.randbelow(n - 3) + 2
end = time.monotonic() + seconds
count = 0
while time.monotonic() < end:
x = (x * x) % n
count += 1
elapsed = seconds
rate = count / elapsed
ten_year_t = int(rate * 365.2425 * 24 * 60 * 60 * 10)
return {
"modulus_bits": bits,
"elapsed_seconds": elapsed,
"squarings": count,
"squarings_per_second": rate,
"estimated_T_for_10_years": ten_year_t,
"note": "Use a lower T if you want a conservative target that may open earlier.",
}
def encrypt_article(args: argparse.Namespace) -> None:
plaintext = Path(args.input).read_bytes()
t = parse_t(args)
n, p, q = generate_rsa_modulus(args.bits, args.prime_rounds)
a = choose_base(n)
solution = fast_rsw_solution(a, t, p, q, n)
key = AESGCM.generate_key(bit_length=256)
nonce = os.urandom(12)
associated_data = b"timelock-article-v1"
encrypted = AESGCM(key).encrypt(nonce, plaintext, associated_data)
ciphertext, tag = encrypted[:-16], encrypted[-16:]
mask = derive_mask(solution, n, a, t, len(key))
wrapped_key = xor_bytes(key, mask)
package = {
"format_version": FORMAT_VERSION,
"scheme": SCHEME,
"created_at": dt.datetime.now(dt.UTC).isoformat(),
"target_delay": args.target_delay,
"warning": (
"This is a sequential-computation delay, not calendar-time release. "
"If nobody starts solving, the delay starts later."
),
"timelock": {
"N": int_to_hex(n),
"a": int_to_hex(a),
"T": str(t),
"wrapped_key": b64e(wrapped_key),
"key_mask": "SHA-256 counter mode over solution,N,a,T",
},
"encryption": {
"algorithm": "AES-256-GCM",
"nonce": b64e(nonce),
"tag": b64e(tag),
"associated_data": b64e(associated_data),
"ciphertext": b64e(ciphertext),
},
"checks": {
"plaintext_sha256": hashlib.sha256(plaintext).hexdigest(),
"ciphertext_sha256": hashlib.sha256(ciphertext).hexdigest(),
},
"instructions": [
"Run: python timelock.py solve PACKAGE.json --output article.txt",
"The solver computes x = a^(2^T) mod N by T repeated squarings.",
"The AES key is wrapped as key XOR H(x,N,a,T).",
"The package intentionally does not contain p, q, or the raw AES key.",
],
}
package_text = json.dumps(package, indent=2, ensure_ascii=False, sort_keys=True)
Path(args.output).write_text(package_text, encoding="utf-8")
if args.reveal_output:
reveal = {
"format_version": FORMAT_VERSION,
"type": "timelock-aes-key-reveal",
"created_at": package["created_at"],
"package_sha256": hashlib.sha256(package_text.encode("utf-8")).hexdigest(),
"plaintext_sha256": package["checks"]["plaintext_sha256"],
"aes_key": b64e(key),
"instructions": [
"Publishing this file unlocks the article immediately.",
"Run: python timelock.py reveal PACKAGE.json REVEAL.json --output article.txt",
"Keep this file private until the intended reveal time.",
],
}
Path(args.reveal_output).write_text(
json.dumps(reveal, indent=2, ensure_ascii=False, sort_keys=True),
encoding="utf-8",
)
print(f"Wrote private reveal key file: {args.reveal_output}")
print(f"Wrote public time-lock package: {args.output}")
if args.reveal_output:
print("Destroyed p and q by not writing them; AES key was saved only in the reveal file.")
else:
print("Destroyed private generation values by not writing p, q, or the AES key.")
def parse_t(args: argparse.Namespace) -> int:
if args.t is not None:
t = int(args.t)
else:
seconds = float(args.years) * 365.2425 * 24 * 60 * 60
t = int(float(args.squarings_per_second) * seconds)
if t <= 0:
raise ValueError("T must be positive")
return t
def solve_package(args: argparse.Namespace) -> None:
package = json.loads(Path(args.package).read_text(encoding="utf-8"))
timelock = package["timelock"]
encryption = package["encryption"]
n = int_from_public(timelock["N"])
a = int_from_public(timelock["a"])
t = int(timelock["T"])
start_index = 0
if args.resume:
checkpoint = json.loads(Path(args.resume).read_text(encoding="utf-8"))
start_index = int(checkpoint["done"])
a = int_from_public(checkpoint["x"])
if start_index > t:
raise ValueError("checkpoint is past package T")
solution = slow_rsw_solution(
a,
t,
n,
report_seconds=args.report_seconds,
checkpoint_path=Path(args.checkpoint) if args.checkpoint else None,
checkpoint_every=args.checkpoint_every,
start_index=start_index,
)
wrapped_key = b64d(timelock["wrapped_key"])
key = xor_bytes(wrapped_key, derive_mask(solution, n, int_from_public(timelock["a"]), t, len(wrapped_key)))
decrypt_package_with_key(package, key, Path(args.output))
def reveal_package(args: argparse.Namespace) -> None:
package_path = Path(args.package)
package_text = package_path.read_text(encoding="utf-8")
package = json.loads(package_text)
reveal = json.loads(Path(args.reveal).read_text(encoding="utf-8"))
if reveal.get("type") != "timelock-aes-key-reveal":
raise ValueError("reveal file has the wrong type")
expected_package_hash = reveal.get("package_sha256")
actual_package_hash = hashlib.sha256(package_text.encode("utf-8")).hexdigest()
if expected_package_hash and expected_package_hash != actual_package_hash:
raise ValueError("reveal file does not match this package")
key = b64d(reveal["aes_key"])
decrypt_package_with_key(package, key, Path(args.output))
def decrypt_package_with_key(package: dict[str, Any], key: bytes, output: Path) -> None:
encryption = package["encryption"]
nonce = b64d(encryption["nonce"])
tag = b64d(encryption["tag"])
ciphertext = b64d(encryption["ciphertext"])
associated_data = b64d(encryption["associated_data"])
plaintext = AESGCM(key).decrypt(nonce, ciphertext + tag, associated_data)
expected_hash = package.get("checks", {}).get("plaintext_sha256")
actual_hash = hashlib.sha256(plaintext).hexdigest()
if expected_hash and expected_hash != actual_hash:
raise ValueError("plaintext hash mismatch after decrypt")
output.write_bytes(plaintext)
print(f"Wrote decrypted article: {output}")
def inspect_package(args: argparse.Namespace) -> None:
package = json.loads(Path(args.package).read_text(encoding="utf-8"))
timelock = package["timelock"]
encryption = package["encryption"]
print(f"scheme: {package.get('scheme')}")
print(f"created_at: {package.get('created_at')}")
print(f"target_delay: {package.get('target_delay')}")
print(f"N bits: {int_from_public(timelock['N']).bit_length()}")
print(f"T: {timelock['T']}")
print(f"ciphertext bytes: {len(b64d(encryption['ciphertext']))}")
print(f"contains p/q/raw key: {contains_secret_fields(package)}")
def contains_secret_fields(value: Any) -> bool:
secret_names = {"p", "q", "prime", "private_key", "raw_key", "aes_key", "key"}
if isinstance(value, dict):
for key, child in value.items():
lowered = str(key).lower()
if lowered in secret_names:
return True
if contains_secret_fields(child):
return True
elif isinstance(value, list):
return any(contains_secret_fields(child) for child in value)
return False
def run_benchmark(args: argparse.Namespace) -> None:
result = benchmark_squarings(args.bits, args.seconds)
print(json.dumps(result, indent=2, sort_keys=True))
def build_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(
description="Create and solve public RSW time-lock encrypted article packages."
)
subparsers = parser.add_subparsers(dest="command", required=True)
benchmark = subparsers.add_parser("benchmark", help="Measure repeated squarings per second")
benchmark.add_argument("--bits", type=int, default=DEFAULT_BITS)
benchmark.add_argument("--seconds", type=float, default=5.0)
benchmark.set_defaults(func=run_benchmark)
encrypt = subparsers.add_parser("encrypt", help="Encrypt an article into a public time-lock package")
encrypt.add_argument("input", help="Plaintext article file")
encrypt.add_argument("--output", "-o", required=True, help="Output JSON package")
encrypt.add_argument("--bits", type=int, default=DEFAULT_BITS, help="RSA modulus size; default 2048")
encrypt.add_argument("--prime-rounds", type=int, default=DEFAULT_PRIME_ROUNDS)
encrypt.add_argument("--t", help="Exact repeated-squaring count")
encrypt.add_argument("--squarings-per-second", type=float, help="Benchmark rate used with --years")
encrypt.add_argument("--years", type=float, default=10.0, help="Target years if --t is omitted")
encrypt.add_argument(
"--reveal-output",
help="Write a private AES-key reveal file for future scheduled publication",
)
encrypt.add_argument(
"--target-delay",
default="~10 years of sequential computation",
help="Human-readable target delay written into the package",
)
encrypt.set_defaults(func=encrypt_article)
solve = subparsers.add_parser("solve", help="Solve a package and decrypt its article")
solve.add_argument("package", help="Public JSON package")
solve.add_argument("--output", "-o", required=True, help="Decrypted article path")
solve.add_argument("--report-seconds", type=float, default=10.0)
solve.add_argument("--checkpoint", help="Write progress checkpoint JSON here")
solve.add_argument("--checkpoint-every", type=int, default=100_000)
solve.add_argument("--resume", help="Resume from a checkpoint JSON")
solve.set_defaults(func=solve_package)
reveal = subparsers.add_parser("reveal", help="Decrypt a package using a published reveal key file")
reveal.add_argument("package", help="Public JSON package")
reveal.add_argument("reveal", help="Reveal key JSON created with encrypt --reveal-output")
reveal.add_argument("--output", "-o", required=True, help="Decrypted article path")
reveal.set_defaults(func=reveal_package)
inspect_cmd = subparsers.add_parser("inspect", help="Summarize a package without solving")
inspect_cmd.add_argument("package")
inspect_cmd.set_defaults(func=inspect_package)
return parser
def main(argv: list[str] | None = None) -> int:
parser = build_parser()
args = parser.parse_args(argv)
if getattr(args, "command", None) == "encrypt" and args.t is None and args.squarings_per_second is None:
parser.error("encrypt requires either --t or --squarings-per-second with --years")
try:
args.func(args)
except KeyboardInterrupt:
print("Interrupted.", file=sys.stderr)
return 130
except Exception as exc:
print(f"error: {exc}", file=sys.stderr)
return 1
return 0
if __name__ == "__main__":
raise SystemExit(main())
cryptography>=42.0.0
# 公开时间锁文章加密工具
这个项目实现一个一次性发布用的 RSW time-lock puzzle 原型：文章先用
`AES-256-GCM` 加密，文章密钥再用 repeated squaring modulo RSA composite
锁住。发布后的 JSON 包只包含公开谜题、密文和校验信息，不包含 `p`、`q`
或原始 AES 密钥。
重要限制：它锁住的是“连续计算量”，不是严格日历时间。如果没有人开始计算，
10 年倒计时不会自动发生；如果未来硬件或算法进步很快，也可能比预期更早打开。
## 安装
“`powershell
python -m pip install -r requirements.txt
“`
## 1. 测基准
先测本机每秒能做多少次 repeated squaring：
“`powershell
python timelock.py benchmark –bits 2048 –seconds 10
“`
输出里的 `estimated_T_for_10_years` 是按当前机器速度估算的 10 年步数。
如果你希望更保守，建议选择低于该值的 `T`，例如 50% 到 80%。
## 2. 加密文章
短测试可以直接指定很小的 `T`：
“`powershell
python timelock.py encrypt article.txt –output timelock_article_2026.json –t 100000
“`
真实发布时，使用基准得到的速度换算：
“`powershell
python timelock.py encrypt article.txt –output timelock_article_2026.json –squarings-per-second 12345 –years 10
“`
生成的 `timelock_article_2026.json` 就是可以发布到网上的单文件包。
如果你想未来通过服务器按时公开密钥，而不是公开明文，可以额外生成一个本地
私有 reveal 文件：
“`powershell
python timelock.py encrypt article.txt –output timelock_article_2026.json –t 30473866916236 –reveal-output reveal_key_private.json
“`
`reveal_key_private.json` 里只保存 AES 文章密钥和校验信息，不保存 `p/q`。
它必须保密；未来一旦公开，任何人都可以立即解密文章。
## 3. 查看发布包
“`powershell
python timelock.py inspect timelock_article_2026.json
“`
确认 `contains p/q/raw key` 显示为 `False`。
## 4. 解密
求解者只需要公开包和这个脚本：
“`powershell
python timelock.py solve timelock_article_2026.json –output article_decrypted.txt
“`
长时间求解建议加 checkpoint：
“`powershell
python timelock.py solve timelock_article_2026.json –output article_decrypted.txt –checkpoint progress.json
“`
中断后继续：
“`powershell
python timelock.py solve timelock_article_2026.json –output article_decrypted.txt –resume progress.json –checkpoint progress.json
“`
如果未来你公开了 reveal 文件，则不需要求解时间锁：
“`powershell
python timelock.py reveal timelock_article_2026.json reveal_key_private.json –output article_decrypted.txt
“`
## 发布建议
– 同时发布 `timelock_article_2026.json`、`timelock.py`、`requirements.txt` 和这份说明。
– 如果你生成了 `reveal_key_private.json`，不要和公开包一起发布；它适合未来定时服务器到点公开。
– 在文章发布说明中写明目标是“约 10 年顺序计算量”，不是精确日期。
– 不要保存或上传明文文章、原始 AES 密钥、`p`、`q` 或任何临时调试文件。
– 先用小 `T` 做一次端到端演练，确认流程能解密，再生成正式包。