24字符外星密码体系
Base-24 × uint64 全栈设计

0124字符外星字母表

ALIEN24_ALPHABET = "0123abcdefghvABCDEFGHU,!"。严格按原文设计，不替换任何字符。符号的索引就是它在 Base-24 中的数值。

四进制数字 0–3小写 4–12大写 13–21标点 22–23

02v ↔ U：手写防呆配对

03键盘黄金区可视化

在 QWERTY 键盘上，24 个符号集中在左手区域：数字键 1 2 3 0、主行 A S D F G H、上行 E、下行 Z 行的 C V B 以及逗号。大写和 ! 都只需要再按 Shift。下图中高亮的键就是“黄金区”。

注意：S 不在字母表中，图中 S 键不高亮。Shift+V 在本体系中按规定输入为 U。

04Base-24 uint64 打包

每个符号的信息量是 \(\log_2 24\approx 4.585\) bit。把长度为 \(n\) 的串当作一个 24 进制整数：

所以一个 uint64 最多装 13 个符号（\(13\log_2 24\approx 59.60\) bit）。另外 \(24^{13}\times 21=18\,406\,255\,107\,772\,514\,304<2^{64}\)，剩余空间可以记录长度：

Python 参考实现（已在服务器端实际运行，与下方 JS 工具结果一致）

import math
ALIEN24_ALPHABET = "0123abcdefghvABCDEFGHU,!"
IDX = {c: i for i, c in enumerate(ALIEN24_ALPHABET)}
H = math.log2(24); MAX_LEN = 13
LEVELS = ["Ⅰ 白", "Ⅱ 浅灰", "Ⅲ 灰", "Ⅳ 深灰", "Ⅴ 黑"]

def normalize(s: str) -> str:
    """v 的大写是 U：'V' -> 'U'，'u' -> 'v'；其他非法字符报错"""
    s = s.replace("V", "U").replace("u", "v")
    bad = [c for c in s if c not in IDX]
    if bad: raise ValueError(f"非法符号: {bad}")
    return s

def to_upper(c): i = IDX[c]; return ALIEN24_ALPHABET[i + 9] if 4 <= i <= 12 else c
def group(c):
    i = IDX[c]; return "digit" if i < 4 else "lower" if i < 13 else "upper" if i < 22 else "punct"

def pack24(s: str) -> int:
    assert 1 <= len(s) <= MAX_LEN
    w = 0
    for c in s: w = w * 24 + IDX[c]          # Horner
    return w * 21 + len(s)                   # 24**13 * 21 < 2**64

def unpack24(w: int) -> str:
    w, n = divmod(w, 21); out = []
    for _ in range(n): w, d = divmod(w, 24); out.append(ALIEN24_ALPHABET[d])
    return "".join(reversed(out))

def cognitive_score(s: str) -> dict:
    groups = {group(c) for c in s}
    sw = sum(group(a) != group(b) for a, b in zip(s, s[1:]))
    rep = sum(a == b for a, b in zip(s, s[1:]))
    pair = sum(to_upper(a) == b for a, b in zip(s, s[1:]) if a != b)
    return {"security": max(0.0, len(s) * H + len(groups) - 3 * rep - 2 * pair),
            "memory": len(s) + 0.5 * sw}

def polar_level(s: str):
    sc = cognitive_score(s)
    x = min(sc["security"] / (MAX_LEN * H + 4), 1.0)
    y = max(0.0, 1 - sc["memory"] / 20)
    r = min(255, int(x * 255))
    theta = int(math.atan2(y, x) / (math.pi / 2) * 255)    # 第一象限
    tier = min(4, r * 5 // 256)
    return (r << 8) | theta, r, theta, LEVELS[tier]

if __name__ == "__main__":
    for p in ["0123", "abcdABCD", "3vA,b2!UhC0gE", "vU", "!!!!", "0aA,"]:
        w = pack24(p); assert w < 2**64 and unpack24(w) == p
        lv, r, t, name = polar_level(p)
        print(f"{p} {w} 0x{w:016x} {cognitive_score(p)['security']:.6f} {cognitive_score(p)['memory']} 0x{lv:04x} {name}")

运行输出（密码、uint64 十进制、十六进制、安全分、认知负荷、Level、阶）：

0123 13171 0x0000000000003373 19.339850 4.0 0x4dc4 Ⅱ 浅灰
abcdABCD 406385424992 0x0000005e9e757a60 38.679700 8.5 0x9b7a Ⅳ 深灰
3vA,b2!UhC0gE 2702787021072332578 0x25823a79c68d7722 63.604513 19.0 0xff08 Ⅴ 黑
vU 6491 0x000000000000195b 9.169925 2.5 0x24e4 Ⅰ 白
!!!! 6967279 0x00000000006a4fef 10.339850 4.0 0x29de Ⅰ 白
0aA, 55402 0x000000000000d86a 20.339850 5.5 0x51bb Ⅱ 浅灰

05在线工具：打包 · 还原 · 打分

全部计算都在浏览器本地完成（BigInt），不会向服务器发送任何输入。

06认知打分器

一个密码同时有两种成本：攻击者要付出的安全成本，用户要付出的认知成本。打分器把两者分开计算：

07第一象限极坐标五阶分级

沿用论文 GP-16 / GP-24a 的等级码 \(\text{Level}=(r\ll 8)\,|\,\theta\)。安全轴 \(x\) 和易记轴 \(y\) 都不小于 0，所以点永远落在第一象限：

0816字符与24字符对比

09彩虹表与安全飞轮

11128KB 度规漂移表

GP-000102 的“零写盘度规漂移”指：代际更新只改变度规参数 \((\alpha_g,\beta_g)\) 与解释表，已写入的记录保持不变；读取时按当代度规重新解释即可，只有状态跨出原胞腔时才追加新记录。

在本方案中，16 位等级码 \(\text{Level}=(r\ll 8)|\theta\) 共有 \(2^{16}=65\,536\) 个胞腔。为每个胞腔存一个 uint16 的“当代解释值”，就得到一张漂移表：

例如：算力提升后，令 \(r^{(g)}=\lfloor \alpha_g r\rfloor\)（\(\alpha_g<1\)），同一密码的阶会自动下降、提示用户升级，而数据库一行都不用改。

12Holon 基因存储

Holon（整体子）指“既是整体又是部分”的单元。延续 GP-000102 的“全息基因”：不存密码本身，而是存生成它的基因，并把基因分片，任意足够多的片段都能复原整体。

Holon 分片提高了可用性，但每个分片都必须当作敏感数据保护；载荷应先加密再分片。本章是概念框架，不是生产级方案。