entropy-protocol 0.1.0__py3-none-any.whl

entropy_protocol/__init__.py

@@ -0,0 +1,11 @@
+"""Entropy Protocol — reference implementation (ep1).
+
+Seal AI-generated text at the moment of generation; verify it anywhere, without revealing it.
+Verdicts are determinations, not probabilities: VERIFIED, MODIFIED (with character ranges),
+INDETERMINATE, or NOT_VERIFIABLE.
+
+Apache-2.0; see LICENSE, NOTICE and PATENTS.md.
+"""
+
+__version__ = "0.1.0"
+ENGINE = f"entropy-protocol/{__version__}"

entropy_protocol/_unicode14.py

@@ -0,0 +1,120 @@
+"""Code points assigned in Unicode 14.0, from DerivedAge-17.0.0.txt (sha256
+    f8ecdf768bdc210f201abd271d9bc587825618a86a7046a8146cc816393f1998), by spec/make_unicode14.py: 706 ranges. Generated
+    - do not edit."""
+from __future__ import annotations
+
+from bisect import bisect_right
+
+STARTS = (0x0, 0x37A, 0x384, 0x38C, 0x38E, 0x3A3, 0x531, 0x559, 0x58D, 0x591, 0x5D0, 0x5EF, 0x600, 0x70F, 0x74D, 0x7C0,
+    0x7FD, 0x830, 0x840, 0x85E, 0x860, 0x870, 0x890, 0x898, 0x985, 0x98F, 0x993, 0x9AA, 0x9B2, 0x9B6, 0x9BC, 0x9C7,
+    0x9CB, 0x9D7, 0x9DC, 0x9DF, 0x9E6, 0xA01, 0xA05, 0xA0F, 0xA13, 0xA2A, 0xA32, 0xA35, 0xA38, 0xA3C, 0xA3E, 0xA47,
+    0xA4B, 0xA51, 0xA59, 0xA5E, 0xA66, 0xA81, 0xA85, 0xA8F, 0xA93, 0xAAA, 0xAB2, 0xAB5, 0xABC, 0xAC7, 0xACB, 0xAD0,
+    0xAE0, 0xAE6, 0xAF9, 0xB01, 0xB05, 0xB0F, 0xB13, 0xB2A, 0xB32, 0xB35, 0xB3C, 0xB47, 0xB4B, 0xB55, 0xB5C, 0xB5F,
+    0xB66, 0xB82, 0xB85, 0xB8E, 0xB92, 0xB99, 0xB9C, 0xB9E, 0xBA3, 0xBA8, 0xBAE, 0xBBE, 0xBC6, 0xBCA, 0xBD0, 0xBD7,
+    0xBE6, 0xC00, 0xC0E, 0xC12, 0xC2A, 0xC3C, 0xC46, 0xC4A, 0xC55, 0xC58, 0xC5D, 0xC60, 0xC66, 0xC77, 0xC8E, 0xC92,
+    0xCAA, 0xCB5, 0xCBC, 0xCC6, 0xCCA, 0xCD5, 0xCDD, 0xCE0, 0xCE6, 0xCF1, 0xD00, 0xD0E, 0xD12, 0xD46, 0xD4A, 0xD54,
+    0xD66, 0xD81, 0xD85, 0xD9A, 0xDB3, 0xDBD, 0xDC0, 0xDCA, 0xDCF, 0xDD6, 0xDD8, 0xDE6, 0xDF2, 0xE01, 0xE3F, 0xE81,
+    0xE84, 0xE86, 0xE8C, 0xEA5, 0xEA7, 0xEC0, 0xEC6, 0xEC8, 0xED0, 0xEDC, 0xF00, 0xF49, 0xF71, 0xF99, 0xFBE, 0xFCE,
+    0x1000, 0x10C7, 0x10CD, 0x10D0, 0x124A, 0x1250, 0x1258, 0x125A, 0x1260, 0x128A, 0x1290, 0x12B2, 0x12B8, 0x12C0,
+    0x12C2, 0x12C8, 0x12D8, 0x1312, 0x1318, 0x135D, 0x1380, 0x13A0, 0x13F8, 0x1400, 0x16A0, 0x1700, 0x171F, 0x1740,
+    0x1760, 0x176E, 0x1772, 0x1780, 0x17E0, 0x17F0, 0x1800, 0x1820, 0x1880, 0x18B0, 0x1900, 0x1920, 0x1930, 0x1940,
+    0x1944, 0x1970, 0x1980, 0x19B0, 0x19D0, 0x19DE, 0x1A1E, 0x1A60, 0x1A7F, 0x1A90, 0x1AA0, 0x1AB0, 0x1B00, 0x1B50,
+    0x1B80, 0x1BFC, 0x1C3B, 0x1C4D, 0x1C90, 0x1CBD, 0x1CD0, 0x1D00, 0x1F18, 0x1F20, 0x1F48, 0x1F50, 0x1F59, 0x1F5B,
+    0x1F5D, 0x1F5F, 0x1F80, 0x1FB6, 0x1FC6, 0x1FD6, 0x1FDD, 0x1FF2, 0x1FF6, 0x2000, 0x2066, 0x2074, 0x2090, 0x20A0,
+    0x20D0, 0x2100, 0x2190, 0x2440, 0x2460, 0x2B76, 0x2B97, 0x2CF9, 0x2D27, 0x2D2D, 0x2D30, 0x2D6F, 0x2D7F, 0x2DA0,
+    0x2DA8, 0x2DB0, 0x2DB8, 0x2DC0, 0x2DC8, 0x2DD0, 0x2DD8, 0x2DE0, 0x2E80, 0x2E9B, 0x2F00, 0x2FF0, 0x3000, 0x3041,
+    0x3099, 0x3105, 0x3131, 0x3190, 0x31F0, 0x3220, 0xA490, 0xA4D0, 0xA640, 0xA700, 0xA7D0, 0xA7D3, 0xA7D5, 0xA7F2,
+    0xA830, 0xA840, 0xA880, 0xA8CE, 0xA8E0, 0xA95F, 0xA980, 0xA9CF, 0xA9DE, 0xAA00, 0xAA40, 0xAA50, 0xAA5C, 0xAADB,
+    0xAB01, 0xAB09, 0xAB11, 0xAB20, 0xAB28, 0xAB30, 0xAB70, 0xABF0, 0xAC00, 0xD7B0, 0xD7CB, 0xD800, 0xFA70, 0xFB00,
+    0xFB13, 0xFB1D, 0xFB38, 0xFB3E, 0xFB40, 0xFB43, 0xFB46, 0xFBD3, 0xFD92, 0xFDCF, 0xFE20, 0xFE54, 0xFE68, 0xFE70,
+    0xFE76, 0xFEFF, 0xFF01, 0xFFC2, 0xFFCA, 0xFFD2, 0xFFDA, 0xFFE0, 0xFFE8, 0xFFF9, 0x1000D, 0x10028, 0x1003C, 0x1003F,
+    0x10050, 0x10080, 0x10100, 0x10107, 0x10137, 0x10190, 0x101A0, 0x101D0, 0x10280, 0x102A0, 0x102E0, 0x10300,
+    0x1032D, 0x10350, 0x10380, 0x1039F, 0x103C8, 0x10400, 0x104A0, 0x104B0, 0x104D8, 0x10500, 0x10530, 0x1056F,
+    0x1057C, 0x1058C, 0x10594, 0x10597, 0x105A3, 0x105B3, 0x105BB, 0x10600, 0x10740, 0x10760, 0x10780, 0x10787,
+    0x107B2, 0x10800, 0x10808, 0x1080A, 0x10837, 0x1083C, 0x1083F, 0x10857, 0x108A7, 0x108E0, 0x108F4, 0x108FB,
+    0x1091F, 0x1093F, 0x10980, 0x109BC, 0x109D2, 0x10A05, 0x10A0C, 0x10A15, 0x10A19, 0x10A38, 0x10A3F, 0x10A50,
+    0x10A60, 0x10AC0, 0x10AEB, 0x10B00, 0x10B39, 0x10B58, 0x10B78, 0x10B99, 0x10BA9, 0x10C00, 0x10C80, 0x10CC0,
+    0x10CFA, 0x10D30, 0x10E60, 0x10E80, 0x10EAB, 0x10EB0, 0x10F00, 0x10F30, 0x10F70, 0x10FB0, 0x10FE0, 0x11000,
+    0x11052, 0x1107F, 0x110CD, 0x110D0, 0x110F0, 0x11100, 0x11136, 0x11150, 0x11180, 0x111E1, 0x11200, 0x11213,
+    0x11280, 0x11288, 0x1128A, 0x1128F, 0x1129F, 0x112B0, 0x112F0, 0x11300, 0x11305, 0x1130F, 0x11313, 0x1132A,
+    0x11332, 0x11335, 0x1133B, 0x11347, 0x1134B, 0x11350, 0x11357, 0x1135D, 0x11366, 0x11370, 0x11400, 0x1145D,
+    0x11480, 0x114D0, 0x11580, 0x115B8, 0x11600, 0x11650, 0x11660, 0x11680, 0x116C0, 0x11700, 0x1171D, 0x11730,
+    0x11800, 0x118A0, 0x118FF, 0x11909, 0x1190C, 0x11915, 0x11918, 0x11937, 0x1193B, 0x11950, 0x119A0, 0x119AA,
+    0x119DA, 0x11A00, 0x11A50, 0x11AB0, 0x11C00, 0x11C0A, 0x11C38, 0x11C50, 0x11C70, 0x11C92, 0x11CA9, 0x11D00,
+    0x11D08, 0x11D0B, 0x11D3A, 0x11D3C, 0x11D3F, 0x11D50, 0x11D60, 0x11D67, 0x11D6A, 0x11D90, 0x11D93, 0x11DA0,
+    0x11EE0, 0x11FB0, 0x11FC0, 0x11FFF, 0x12400, 0x12470, 0x12480, 0x12F90, 0x13000, 0x13430, 0x14400, 0x16800,
+    0x16A40, 0x16A60, 0x16A6E, 0x16AC0, 0x16AD0, 0x16AF0, 0x16B00, 0x16B50, 0x16B5B, 0x16B63, 0x16B7D, 0x16E40,
+    0x16F00, 0x16F4F, 0x16F8F, 0x16FE0, 0x16FF0, 0x17000, 0x18800, 0x18D00, 0x1AFF0, 0x1AFF5, 0x1AFFD, 0x1B000,
+    0x1B150, 0x1B164, 0x1B170, 0x1BC00, 0x1BC70, 0x1BC80, 0x1BC90, 0x1BC9C, 0x1CF00, 0x1CF30, 0x1CF50, 0x1D000,
+    0x1D100, 0x1D129, 0x1D200, 0x1D2E0, 0x1D300, 0x1D360, 0x1D400, 0x1D456, 0x1D49E, 0x1D4A2, 0x1D4A5, 0x1D4A9,
+    0x1D4AE, 0x1D4BB, 0x1D4BD, 0x1D4C5, 0x1D507, 0x1D50D, 0x1D516, 0x1D51E, 0x1D53B, 0x1D540, 0x1D546, 0x1D54A,
+    0x1D552, 0x1D6A8, 0x1D7CE, 0x1DA9B, 0x1DAA1, 0x1DF00, 0x1E000, 0x1E008, 0x1E01B, 0x1E023, 0x1E026, 0x1E100,
+    0x1E130, 0x1E140, 0x1E14E, 0x1E290, 0x1E2C0, 0x1E2FF, 0x1E7E0, 0x1E7E8, 0x1E7ED, 0x1E7F0, 0x1E800, 0x1E8C7,
+    0x1E900, 0x1E950, 0x1E95E, 0x1EC71, 0x1ED01, 0x1EE00, 0x1EE05, 0x1EE21, 0x1EE24, 0x1EE27, 0x1EE29, 0x1EE34,
+    0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE4D, 0x1EE51, 0x1EE54, 0x1EE57, 0x1EE59, 0x1EE5B,
+    0x1EE5D, 0x1EE5F, 0x1EE61, 0x1EE64, 0x1EE67, 0x1EE6C, 0x1EE74, 0x1EE79, 0x1EE7E, 0x1EE80, 0x1EE8B, 0x1EEA1,
+    0x1EEA5, 0x1EEAB, 0x1EEF0, 0x1F000, 0x1F030, 0x1F0A0, 0x1F0B1, 0x1F0C1, 0x1F0D1, 0x1F100, 0x1F1E6, 0x1F210,
+    0x1F240, 0x1F250, 0x1F260, 0x1F300, 0x1F6DD, 0x1F6F0, 0x1F700, 0x1F780, 0x1F7E0, 0x1F7F0, 0x1F800, 0x1F810,
+    0x1F850, 0x1F860, 0x1F890, 0x1F8B0, 0x1F900, 0x1FA60, 0x1FA70, 0x1FA78, 0x1FA80, 0x1FA90, 0x1FAB0, 0x1FAC0,
+    0x1FAD0, 0x1FAE0, 0x1FAF0, 0x1FB00, 0x1FB94, 0x1FBF0, 0x1FFFE, 0x2A700, 0x2B740, 0x2B820, 0x2CEB0, 0x2F800,
+    0x2FFFE, 0x3FFFE, 0x4FFFE, 0x5FFFE, 0x6FFFE, 0x7FFFE, 0x8FFFE, 0x9FFFE, 0xAFFFE, 0xBFFFE, 0xCFFFE, 0xDFFFE,
+    0xE0001, 0xE0020, 0xE0100, 0xEFFFE,)
+ENDS = (0x377, 0x37F, 0x38A, 0x38C, 0x3A1, 0x52F, 0x556, 0x58A, 0x58F, 0x5C7, 0x5EA, 0x5F4, 0x70D, 0x74A, 0x7B1, 0x7FA,
+    0x82D, 0x83E, 0x85B, 0x85E, 0x86A, 0x88E, 0x891, 0x983, 0x98C, 0x990, 0x9A8, 0x9B0, 0x9B2, 0x9B9, 0x9C4, 0x9C8,
+    0x9CE, 0x9D7, 0x9DD, 0x9E3, 0x9FE, 0xA03, 0xA0A, 0xA10, 0xA28, 0xA30, 0xA33, 0xA36, 0xA39, 0xA3C, 0xA42, 0xA48,
+    0xA4D, 0xA51, 0xA5C, 0xA5E, 0xA76, 0xA83, 0xA8D, 0xA91, 0xAA8, 0xAB0, 0xAB3, 0xAB9, 0xAC5, 0xAC9, 0xACD, 0xAD0,
+    0xAE3, 0xAF1, 0xAFF, 0xB03, 0xB0C, 0xB10, 0xB28, 0xB30, 0xB33, 0xB39, 0xB44, 0xB48, 0xB4D, 0xB57, 0xB5D, 0xB63,
+    0xB77, 0xB83, 0xB8A, 0xB90, 0xB95, 0xB9A, 0xB9C, 0xB9F, 0xBA4, 0xBAA, 0xBB9, 0xBC2, 0xBC8, 0xBCD, 0xBD0, 0xBD7,
+    0xBFA, 0xC0C, 0xC10, 0xC28, 0xC39, 0xC44, 0xC48, 0xC4D, 0xC56, 0xC5A, 0xC5D, 0xC63, 0xC6F, 0xC8C, 0xC90, 0xCA8,
+    0xCB3, 0xCB9, 0xCC4, 0xCC8, 0xCCD, 0xCD6, 0xCDE, 0xCE3, 0xCEF, 0xCF2, 0xD0C, 0xD10, 0xD44, 0xD48, 0xD4F, 0xD63,
+    0xD7F, 0xD83, 0xD96, 0xDB1, 0xDBB, 0xDBD, 0xDC6, 0xDCA, 0xDD4, 0xDD6, 0xDDF, 0xDEF, 0xDF4, 0xE3A, 0xE5B, 0xE82,
+    0xE84, 0xE8A, 0xEA3, 0xEA5, 0xEBD, 0xEC4, 0xEC6, 0xECD, 0xED9, 0xEDF, 0xF47, 0xF6C, 0xF97, 0xFBC, 0xFCC, 0xFDA,
+    0x10C5, 0x10C7, 0x10CD, 0x1248, 0x124D, 0x1256, 0x1258, 0x125D, 0x1288, 0x128D, 0x12B0, 0x12B5, 0x12BE, 0x12C0,
+    0x12C5, 0x12D6, 0x1310, 0x1315, 0x135A, 0x137C, 0x1399, 0x13F5, 0x13FD, 0x169C, 0x16F8, 0x1715, 0x1736, 0x1753,
+    0x176C, 0x1770, 0x1773, 0x17DD, 0x17E9, 0x17F9, 0x1819, 0x1878, 0x18AA, 0x18F5, 0x191E, 0x192B, 0x193B, 0x1940,
+    0x196D, 0x1974, 0x19AB, 0x19C9, 0x19DA, 0x1A1B, 0x1A5E, 0x1A7C, 0x1A89, 0x1A99, 0x1AAD, 0x1ACE, 0x1B4C, 0x1B7E,
+    0x1BF3, 0x1C37, 0x1C49, 0x1C88, 0x1CBA, 0x1CC7, 0x1CFA, 0x1F15, 0x1F1D, 0x1F45, 0x1F4D, 0x1F57, 0x1F59, 0x1F5B,
+    0x1F5D, 0x1F7D, 0x1FB4, 0x1FC4, 0x1FD3, 0x1FDB, 0x1FEF, 0x1FF4, 0x1FFE, 0x2064, 0x2071, 0x208E, 0x209C, 0x20C0,
+    0x20F0, 0x218B, 0x2426, 0x244A, 0x2B73, 0x2B95, 0x2CF3, 0x2D25, 0x2D27, 0x2D2D, 0x2D67, 0x2D70, 0x2D96, 0x2DA6,
+    0x2DAE, 0x2DB6, 0x2DBE, 0x2DC6, 0x2DCE, 0x2DD6, 0x2DDE, 0x2E5D, 0x2E99, 0x2EF3, 0x2FD5, 0x2FFB, 0x303F, 0x3096,
+    0x30FF, 0x312F, 0x318E, 0x31E3, 0x321E, 0xA48C, 0xA4C6, 0xA62B, 0xA6F7, 0xA7CA, 0xA7D1, 0xA7D3, 0xA7D9, 0xA82C,
+    0xA839, 0xA877, 0xA8C5, 0xA8D9, 0xA953, 0xA97C, 0xA9CD, 0xA9D9, 0xA9FE, 0xAA36, 0xAA4D, 0xAA59, 0xAAC2, 0xAAF6,
+    0xAB06, 0xAB0E, 0xAB16, 0xAB26, 0xAB2E, 0xAB6B, 0xABED, 0xABF9, 0xD7A3, 0xD7C6, 0xD7FB, 0xFA6D, 0xFAD9, 0xFB06,
+    0xFB17, 0xFB36, 0xFB3C, 0xFB3E, 0xFB41, 0xFB44, 0xFBC2, 0xFD8F, 0xFDC7, 0xFE19, 0xFE52, 0xFE66, 0xFE6B, 0xFE74,
+    0xFEFC, 0xFEFF, 0xFFBE, 0xFFC7, 0xFFCF, 0xFFD7, 0xFFDC, 0xFFE6, 0xFFEE, 0x1000B, 0x10026, 0x1003A, 0x1003D,
+    0x1004D, 0x1005D, 0x100FA, 0x10102, 0x10133, 0x1018E, 0x1019C, 0x101A0, 0x101FD, 0x1029C, 0x102D0, 0x102FB,
+    0x10323, 0x1034A, 0x1037A, 0x1039D, 0x103C3, 0x103D5, 0x1049D, 0x104A9, 0x104D3, 0x104FB, 0x10527, 0x10563,
+    0x1057A, 0x1058A, 0x10592, 0x10595, 0x105A1, 0x105B1, 0x105B9, 0x105BC, 0x10736, 0x10755, 0x10767, 0x10785,
+    0x107B0, 0x107BA, 0x10805, 0x10808, 0x10835, 0x10838, 0x1083C, 0x10855, 0x1089E, 0x108AF, 0x108F2, 0x108F5,
+    0x1091B, 0x10939, 0x1093F, 0x109B7, 0x109CF, 0x10A03, 0x10A06, 0x10A13, 0x10A17, 0x10A35, 0x10A3A, 0x10A48,
+    0x10A58, 0x10A9F, 0x10AE6, 0x10AF6, 0x10B35, 0x10B55, 0x10B72, 0x10B91, 0x10B9C, 0x10BAF, 0x10C48, 0x10CB2,
+    0x10CF2, 0x10D27, 0x10D39, 0x10E7E, 0x10EA9, 0x10EAD, 0x10EB1, 0x10F27, 0x10F59, 0x10F89, 0x10FCB, 0x10FF6,
+    0x1104D, 0x11075, 0x110C2, 0x110CD, 0x110E8, 0x110F9, 0x11134, 0x11147, 0x11176, 0x111DF, 0x111F4, 0x11211,
+    0x1123E, 0x11286, 0x11288, 0x1128D, 0x1129D, 0x112A9, 0x112EA, 0x112F9, 0x11303, 0x1130C, 0x11310, 0x11328,
+    0x11330, 0x11333, 0x11339, 0x11344, 0x11348, 0x1134D, 0x11350, 0x11357, 0x11363, 0x1136C, 0x11374, 0x1145B,
+    0x11461, 0x114C7, 0x114D9, 0x115B5, 0x115DD, 0x11644, 0x11659, 0x1166C, 0x116B9, 0x116C9, 0x1171A, 0x1172B,
+    0x11746, 0x1183B, 0x118F2, 0x11906, 0x11909, 0x11913, 0x11916, 0x11935, 0x11938, 0x11946, 0x11959, 0x119A7,
+    0x119D7, 0x119E4, 0x11A47, 0x11AA2, 0x11AF8, 0x11C08, 0x11C36, 0x11C45, 0x11C6C, 0x11C8F, 0x11CA7, 0x11CB6,
+    0x11D06, 0x11D09, 0x11D36, 0x11D3A, 0x11D3D, 0x11D47, 0x11D59, 0x11D65, 0x11D68, 0x11D8E, 0x11D91, 0x11D98,
+    0x11DA9, 0x11EF8, 0x11FB0, 0x11FF1, 0x12399, 0x1246E, 0x12474, 0x12543, 0x12FF2, 0x1342E, 0x13438, 0x14646,
+    0x16A38, 0x16A5E, 0x16A69, 0x16ABE, 0x16AC9, 0x16AED, 0x16AF5, 0x16B45, 0x16B59, 0x16B61, 0x16B77, 0x16B8F,
+    0x16E9A, 0x16F4A, 0x16F87, 0x16F9F, 0x16FE4, 0x16FF1, 0x187F7, 0x18CD5, 0x18D08, 0x1AFF3, 0x1AFFB, 0x1AFFE,
+    0x1B122, 0x1B152, 0x1B167, 0x1B2FB, 0x1BC6A, 0x1BC7C, 0x1BC88, 0x1BC99, 0x1BCA3, 0x1CF2D, 0x1CF46, 0x1CFC3,
+    0x1D0F5, 0x1D126, 0x1D1EA, 0x1D245, 0x1D2F3, 0x1D356, 0x1D378, 0x1D454, 0x1D49C, 0x1D49F, 0x1D4A2, 0x1D4A6,
+    0x1D4AC, 0x1D4B9, 0x1D4BB, 0x1D4C3, 0x1D505, 0x1D50A, 0x1D514, 0x1D51C, 0x1D539, 0x1D53E, 0x1D544, 0x1D546,
+    0x1D550, 0x1D6A5, 0x1D7CB, 0x1DA8B, 0x1DA9F, 0x1DAAF, 0x1DF1E, 0x1E006, 0x1E018, 0x1E021, 0x1E024, 0x1E02A,
+    0x1E12C, 0x1E13D, 0x1E149, 0x1E14F, 0x1E2AE, 0x1E2F9, 0x1E2FF, 0x1E7E6, 0x1E7EB, 0x1E7EE, 0x1E7FE, 0x1E8C4,
+    0x1E8D6, 0x1E94B, 0x1E959, 0x1E95F, 0x1ECB4, 0x1ED3D, 0x1EE03, 0x1EE1F, 0x1EE22, 0x1EE24, 0x1EE27, 0x1EE32,
+    0x1EE37, 0x1EE39, 0x1EE3B, 0x1EE42, 0x1EE47, 0x1EE49, 0x1EE4B, 0x1EE4F, 0x1EE52, 0x1EE54, 0x1EE57, 0x1EE59,
+    0x1EE5B, 0x1EE5D, 0x1EE5F, 0x1EE62, 0x1EE64, 0x1EE6A, 0x1EE72, 0x1EE77, 0x1EE7C, 0x1EE7E, 0x1EE89, 0x1EE9B,
+    0x1EEA3, 0x1EEA9, 0x1EEBB, 0x1EEF1, 0x1F02B, 0x1F093, 0x1F0AE, 0x1F0BF, 0x1F0CF, 0x1F0F5, 0x1F1AD, 0x1F202,
+    0x1F23B, 0x1F248, 0x1F251, 0x1F265, 0x1F6D7, 0x1F6EC, 0x1F6FC, 0x1F773, 0x1F7D8, 0x1F7EB, 0x1F7F0, 0x1F80B,
+    0x1F847, 0x1F859, 0x1F887, 0x1F8AD, 0x1F8B1, 0x1FA53, 0x1FA6D, 0x1FA74, 0x1FA7C, 0x1FA86, 0x1FAAC, 0x1FABA,
+    0x1FAC5, 0x1FAD9, 0x1FAE7, 0x1FAF6, 0x1FB92, 0x1FBCA, 0x1FBF9, 0x2A6DF, 0x2B738, 0x2B81D, 0x2CEA1, 0x2EBE0,
+    0x2FA1D, 0x3134A, 0x3FFFF, 0x4FFFF, 0x5FFFF, 0x6FFFF, 0x7FFFF, 0x8FFFF, 0x9FFFF, 0xAFFFF, 0xBFFFF, 0xCFFFF,
+    0xDFFFF, 0xE0001, 0xE007F, 0xE01EF, 0x10FFFF,)
+
+
+def assigned(cp: int) -> bool:
+    i = bisect_right(STARTS, cp) - 1
+    return i >= 0 and cp <= ENDS[i]

entropy_protocol/attest.py

@@ -0,0 +1,62 @@
+"""A signed verification attestation in its minimal form: Ed25519 over canonical JSON.
+
+The pack carries the verdict, counts, divergence ranges, the model/tokenizer identity and the
+decoding configuration, the verifier nonce and a digest of the log token — never the text.
+Signed with Ed25519 over canonical JSON; checkable by anyone with the verifier's public key.
+Signed COSE statements, the transparency log, RFC 3161 time stamps and the CBOR evidence package that supersede
+it for publication: statements.py, tlog.py, ts3161.py, pack.py.
+"""
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import time
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey, Ed25519PublicKey
+
+from . import ENGINE, crypto
+
+_PACK_FIELDS = ("verdict", "reason", "score", "matched", "divergent", "indeterminate", "entries", "model_evidence",
+                "divergence_ranges", "changed_ranges", "deletion_points", "digest_match", "model", "weights_digest",
+                "tokenizer_digest", "decoding", "nonce", "doc_id", "candidate_digest")
+
+
+def canonical_json(obj) -> bytes:
+    return json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
+
+
+def new_signing_key() -> Ed25519PrivateKey:
+    return Ed25519PrivateKey.generate()
+
+
+def public_bytes(key: Ed25519PublicKey) -> bytes:
+    return key.public_bytes(serialization.Encoding.Raw, serialization.PublicFormat.Raw)
+
+
+def key_id(key: Ed25519PublicKey) -> str:
+    return hashlib.sha256(public_bytes(key)).hexdigest()[:16]
+
+
+def evidence_pack(result, verifier_id: str, token: str) -> dict:
+    pack = {f: getattr(result, f) for f in _PACK_FIELDS}
+    pack.update({"type": "ep1/evidence-pack", "engine": ENGINE, "verifier": verifier_id,
+                 "log_token_digest": crypto.sha256_hex(token), "time": int(time.time())})
+    return pack
+
+
+def sign(pack: dict, key: Ed25519PrivateKey) -> dict:
+    sig = key.sign(canonical_json(pack))
+    return {"pack": pack, "alg": "Ed25519", "kid": key_id(key.public_key()),
+            "sig": base64.urlsafe_b64encode(sig).decode().rstrip("=")}
+
+
+def verify_signed(signed: dict, key: Ed25519PublicKey) -> bool:
+    try:
+        sig = signed["sig"]
+        key.verify(base64.urlsafe_b64decode(sig + "=" * (-len(sig) % 4)), canonical_json(signed["pack"]))
+        return signed.get("kid") == key_id(key)
+    except (InvalidSignature, KeyError, ValueError):
+        return False

entropy_protocol/attested/__init__.py

@@ -0,0 +1,6 @@
+"""Attested sealing and attested detection (ARCHITECTURE §7d).
+
+The keys, the model and the sealing code run in a confidential VM with a confidential GPU; a credential authority
+appraises the hardware evidence, which carries a binding value over the statement key, the model and the code, and
+only then certifies the statement key. Attester side: `azure_cgpu` (evidence from inside the guest), `binding`.
+"""

entropy_protocol/attested/amd.py

@@ -0,0 +1,221 @@
+"""AMD SEV-SNP: the attestation report and its certificate chain, checked from the specifications.
+
+Report (SEV-SNP Firmware ABI, AMD 56860; offsets also in our library, attestation/platforms.md): 1184 octets, signed
+body [0x000:0x2A0], ECDSA P-384 with SHA-384, r and s little-endian in 72-octet slots at 0x2A0 and 0x2E8.
+Chain: VCEK (or VLEK) <- ASK (or ASVK) <- ARK, all RSASSA-PSS with SHA-384. The certificates encode the PSS trailer
+field at its default value, which DER forbids: cryptography 42.0.8 refuses to load them, 43.0.3 and later load and
+verify them (checked 27.10.2026 against AMD KDS's Genoa chain; hence the dependency floor). ARKs are pinned by SHA-256
+of their DER, taken from AMD KDS (snapshot archived 30.09.2026 in the library; ARK-Milan matches the fingerprint
+recorded there).
+VCEK extensions (AMD 57230 rev 1.05, tables 10-11): structVersion .1.1, productName .1.2, TCB_VERSION elements
+.1.3.x (blSPL 1, teeSPL 2, snpSPL 3, ucodeSPL 8, fmcSPL 9), hwID .1.4 (64 octets on Milan/Genoa, 8 from Turin).
+"""
+from __future__ import annotations
+
+import datetime as dt
+import hashlib
+from dataclasses import dataclass
+
+from cryptography import x509
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.asymmetric.utils import encode_dss_signature
+
+from .pki import UNREADABLE
+
+ARK_SHA256 = {
+    "Milan": "69d063b45344d26a2e94e1f4210de49ef555308287d4c174445c95639a540bcd",
+    "Genoa": "4c6598d19c18719c5dfd4a7d335f674e5bfe1d8f800cea2cf270c10d103db2f1",
+    "Turin": "1f084161a44bb6d93778a904877d4819cafa5d05ef4193b2ded9dd9c73dd3f6a",
+    "Venice": "46ef2eb7664175c7e9d3923ea0d275e572366d755556a30e229634592dce5903",
+}
+OID_RSASSA_PSS = "1.2.840.113549.1.1.10"
+OID_ECDSA_SHA384 = "1.2.840.10045.4.3.3"
+VCEK_OID = "1.3.6.1.4.1.3704.1."
+REPORT_SIZE = 0x4A0
+SIGNED = 0x2A0
+
+
+class SNPError(ValueError):
+    """The report or its chain does not hold."""
+
+
+def verify_chain(leaf_der: bytes, ask_der: bytes, ark_der: bytes, product: str, at: dt.datetime) -> dict:
+    """The leaf (VCEK or VLEK) to the pinned ARK of ``product``. Returns the leaf's AMD extensions; SNPError otherwise."""
+    pin = ARK_SHA256.get(product)
+    if pin is None:
+        raise SNPError(f"no pinned ARK for {product}")
+    if hashlib.sha256(ark_der).hexdigest() != pin:
+        raise SNPError(f"ARK is not AMD's pinned ARK-{product}")
+    try:
+        leaf, ask, ark = (x509.load_der_x509_certificate(x) for x in (leaf_der, ask_der, ark_der))
+    except UNREADABLE as exc:
+        raise SNPError(f"not a DER certificate: {exc}") from exc
+    for child, parent in ((ark, ark), (ask, ark), (leaf, ask)):
+        if child.signature_algorithm_oid.dotted_string != OID_RSASSA_PSS:
+            raise SNPError(f"unexpected signature algorithm {child.signature_algorithm_oid.dotted_string}")
+        try:
+            child.verify_directly_issued_by(parent)
+        except (*UNREADABLE, InvalidSignature) as exc:                     # an unreadable key included
+            raise SNPError(f"{child.subject.rfc4514_string()} is not signed by its issuer") from exc
+    for c in (leaf, ask, ark):
+        if not c.not_valid_before_utc <= at <= c.not_valid_after_utc:
+            raise SNPError(f"certificate not valid at {at.isoformat()}")
+    return vcek_extensions(leaf)
+
+
+def _der_value(raw: bytes) -> tuple[int, bytes]:
+    """(tag, contents) of one short DER element - the INTEGER, IA5String or OCTET STRING inside an AMD extension."""
+    tag, ln, off = raw[0], raw[1], 2
+    if ln & 0x80:
+        n = ln & 0x7F
+        ln, off = int.from_bytes(raw[2:2 + n], "big"), 2 + n
+    return tag, raw[off:off + ln]
+
+
+def vcek_extensions(leaf: x509.Certificate) -> dict:
+    out: dict = {}
+    names = {"1": "structVersion", "3.1": "blSPL", "3.2": "teeSPL", "3.3": "snpSPL", "3.8": "ucodeSPL",
+             "3.9": "fmcSPL"}
+    for ext in leaf.extensions:
+        oid = ext.oid.dotted_string
+        if not oid.startswith(VCEK_OID) or not isinstance(ext.value, x509.UnrecognizedExtension):
+            continue
+        tail = oid[len(VCEK_OID):]
+        tag, val = _der_value(ext.value.value)
+        if tail in names and tag == 0x02:
+            out[names[tail]] = int.from_bytes(val, "big", signed=True)
+        elif tail == "2" and tag == 0x16:
+            out["productName"] = val.decode("ascii")
+        elif tail == "4":
+            out["hwID"] = val if tag == 0x04 else ext.value.value
+    return out
+
+
+@dataclass
+class Report:
+    raw: bytes
+    version: int
+    guest_svn: int
+    policy: int
+    vmpl: int
+    signature_algo: int
+    current_tcb: int
+    platform_info: int
+    flags: int
+    report_data: bytes
+    measurement: bytes
+    host_data: bytes
+    id_key_digest: bytes
+    report_id: bytes
+    reported_tcb: int
+    chip_id: bytes
+    committed_tcb: int
+    launch_tcb: int
+    family_id: bytes           # from the ID block, when one was given at launch
+    image_id: bytes
+    author_key_digest: bytes
+    launch_mit_vector: int     # report version 5: 0x1F8
+    current_mit_vector: int    # report version 5: 0x200
+    r: int
+    s: int
+
+    @property
+    def id_block(self) -> bool:
+        """An ID block was given at launch: the firmware then refused to launch unless the block's expected launch
+        digest equalled the measurement and the block's signature verified under the ID key whose SHA-384 digest the
+        report carries (AMD 56860 rev. 1.59 §8.19.2, SNP_LAUNCH_FINISH)."""
+        return any(self.id_key_digest)
+
+    @property
+    def alias_check_complete(self) -> bool:
+        """PLATFORM_INFO bit 5: the platform checked DIMM aliasing (the BadRAM fix, AMD-SB-3015)."""
+        return bool(self.platform_info >> 5 & 1)
+
+    @property
+    def debug(self) -> bool:
+        return bool(self.policy >> 19 & 1)
+
+    @property
+    def signing_key(self) -> str:
+        return {0: "vcek", 1: "vlek", 7: "none"}.get(self.flags >> 2 & 7, "reserved")
+
+
+def _u(b: bytes, off: int, n: int) -> int:
+    return int.from_bytes(b[off:off + n], "little")
+
+
+def parse_report(raw: bytes) -> Report:
+    if len(raw) < REPORT_SIZE:
+        raise SNPError(f"report is {len(raw)} octets, expected {REPORT_SIZE}")
+    raw = raw[:REPORT_SIZE]
+    return Report(raw=raw, version=_u(raw, 0, 4), guest_svn=_u(raw, 4, 4), policy=_u(raw, 8, 8), vmpl=_u(raw, 0x30, 4),
+                  signature_algo=_u(raw, 0x34, 4), current_tcb=_u(raw, 0x38, 8), platform_info=_u(raw, 0x40, 8),
+                  flags=_u(raw, 0x48, 4), report_data=raw[0x50:0x90], measurement=raw[0x90:0xC0],
+                  host_data=raw[0xC0:0xE0], id_key_digest=raw[0xE0:0x110], report_id=raw[0x140:0x160],
+                  reported_tcb=_u(raw, 0x180, 8), chip_id=raw[0x1A0:0x1E0], committed_tcb=_u(raw, 0x1E0, 8),
+                  launch_tcb=_u(raw, 0x1F0, 8), family_id=raw[0x10:0x20], image_id=raw[0x20:0x30],
+                  author_key_digest=raw[0x110:0x140], launch_mit_vector=_u(raw, 0x1F8, 8) if _u(raw, 0, 4) >= 5 else 0,
+                  current_mit_vector=_u(raw, 0x200, 8) if _u(raw, 0, 4) >= 5 else 0,
+                  r=_u(raw, 0x2A0, 72), s=_u(raw, 0x2E8, 72))
+
+
+def verify_report(rep: Report, leaf_der: bytes) -> None:
+    """ECDSA P-384 / SHA-384 over the signed body, under the VCEK or VLEK."""
+    if rep.signature_algo != 1:
+        raise SNPError(f"signature algorithm {rep.signature_algo}, expected 1 (ECDSA P-384 with SHA-384)")
+    try:
+        key = x509.load_der_x509_certificate(leaf_der).public_key()
+    except UNREADABLE as exc:
+        raise SNPError(f"the report key cannot be read: {exc}") from exc
+    if not isinstance(key, ec.EllipticCurvePublicKey) or key.curve.name != "secp384r1":
+        raise SNPError("the report key is not ECDSA P-384")
+    try:
+        key.verify(encode_dss_signature(rep.r, rep.s), rep.raw[:SIGNED], ec.ECDSA(hashes.SHA384()))
+    except InvalidSignature as exc:
+        raise SNPError("report signature does not verify") from exc
+
+
+def tcb_parts(tcb: int, product: str) -> dict:
+    """TCB_VERSION decomposed by product layout (Milan/Genoa vs Turin and later)."""
+    if product in ("Milan", "Genoa"):
+        return {"blSPL": tcb & 0xFF, "teeSPL": tcb >> 8 & 0xFF, "snpSPL": tcb >> 48 & 0xFF, "ucodeSPL": tcb >> 56 & 0xFF}
+    return {"fmcSPL": tcb & 0xFF, "blSPL": tcb >> 8 & 0xFF, "teeSPL": tcb >> 16 & 0xFF, "snpSPL": tcb >> 24 & 0xFF,
+            "ucodeSPL": tcb >> 56 & 0xFF}
+
+
+def tcb_at_least(tcb: dict, minimum: dict) -> bool:
+    """Every component at or above the minimum: TCB components are compared one by one, never as one integer."""
+    return all(tcb.get(k, -1) >= v for k, v in minimum.items())
+
+
+KDS = "https://kdsintf.amd.com"
+
+
+def crl_url(product: str, signer: str = "vcek") -> str:
+    return f"{KDS}/{signer}/v1/{product}/crl"
+
+
+def fetch_crl(product: str, signer: str = "vcek", timeout: int = 20) -> bytes:
+    """AMD's CRL for the product's ASK (or ASVK), signed by the ARK. KDS rate-limits: fetch once per appraisal."""
+    import urllib.request
+    with urllib.request.urlopen(crl_url(product, signer), timeout=timeout) as r:  # noqa: S310 - fixed https URL
+        return r.read()
+
+
+def check_crl(crl_der: bytes, ask_der: bytes, ark_der: bytes, at: dt.datetime,
+              skew: dt.timedelta = dt.timedelta(minutes=5)) -> None:
+    """The CRL is the ARK's, current at ``at``, and does not list the ASK; SNPError otherwise."""
+    try:
+        crl = x509.load_der_x509_crl(crl_der)
+        ask, ark = x509.load_der_x509_certificate(ask_der), x509.load_der_x509_certificate(ark_der)
+        signed = crl.issuer == ark.subject and crl.is_signature_valid(ark.public_key())
+    except UNREADABLE as exc:
+        raise SNPError(f"CRL or certificates cannot be read: {exc}") from exc
+    if not signed:
+        raise SNPError("CRL not signed by the ARK")
+    if crl.last_update_utc > at + skew or (crl.next_update_utc is not None and at > crl.next_update_utc + skew):
+        raise SNPError(f"CRL not current at {at.isoformat()}")
+    if crl.get_revoked_certificate_by_serial_number(ask.serial_number) is not None:
+        raise SNPError("the ASK is revoked")