database.py: rebuild key_checks and ai_security_checks for per-key checks (section 19)

This commit is contained in:
ai-bot committed 2026-10-02 08:24:42 +00:00
1 parent 367cdbf286
commit 303c903228
1 file changed
+195 -64
+195 -64
View File
@@ -4,14 +4,13 @@ from pathlib import Path
import sqlite3 import sqlite3
SCHEMA_VERSION = 4 SCHEMA_VERSION = 5
FIXED_KEYS = ( FIXED_KEYS = (
(1, "SeedSigner", "hardware", "SeedSigner"), (1, "SeedSigner", "hardware", "SeedSigner"),
(2, "Blockstream Jade", "hardware", "Blockstream Jade"), (2, "Blockstream Jade", "hardware", "Blockstream Jade"),
(3, "Nunchuk", "cloud", "Nunchuk"), (3, "Nunchuk", "cloud", "Nunchuk"),
) )
SCHEMA_STATEMENTS = ( KEYS_TABLE = """
"""
CREATE TABLE IF NOT EXISTS keys ( CREATE TABLE IF NOT EXISTS keys (
id INTEGER PRIMARY KEY, id INTEGER PRIMARY KEY,
key_number INTEGER NOT NULL UNIQUE CHECK (key_number BETWEEN 1 AND 3), key_number INTEGER NOT NULL UNIQUE CHECK (key_number BETWEEN 1 AND 3),
@@ -20,12 +19,14 @@ SCHEMA_STATEMENTS = (
device TEXT NOT NULL CHECK (device IN ('SeedSigner', 'Blockstream Jade', 'Nunchuk')), device TEXT NOT NULL CHECK (device IN ('SeedSigner', 'Blockstream Jade', 'Nunchuk')),
created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
) )
""",
""" """
HEALTH_CHECKS_TABLE = """
CREATE TABLE IF NOT EXISTS health_checks ( CREATE TABLE IF NOT EXISTS health_checks (
id INTEGER PRIMARY KEY, id INTEGER PRIMARY KEY,
checked_at TEXT NOT NULL, checked_at TEXT NOT NULL,
next_check_due TEXT NOT NULL, next_check_due TEXT NOT NULL,
wallet_software TEXT CHECK (wallet_software IN ('Sparrow Wallet', 'Nunchuk')),
software_version TEXT,
software_compatibility_status TEXT NOT NULL DEFAULT 'IKKJE_VURDERT' software_compatibility_status TEXT NOT NULL DEFAULT 'IKKJE_VURDERT'
CHECK (software_compatibility_status IN ('OK', 'PROBLEM', 'IKKJE_VURDERT')), CHECK (software_compatibility_status IN ('OK', 'PROBLEM', 'IKKJE_VURDERT')),
sparrow_version TEXT, sparrow_version TEXT,
@@ -34,8 +35,8 @@ SCHEMA_STATEMENTS = (
contact_info_verified INTEGER CHECK (contact_info_verified IN (0, 1)), contact_info_verified INTEGER CHECK (contact_info_verified IN (0, 1)),
comments TEXT comments TEXT
) )
""",
""" """
KEY_CHECKS_TABLE = """
CREATE TABLE IF NOT EXISTS key_checks ( CREATE TABLE IF NOT EXISTS key_checks (
id INTEGER PRIMARY KEY, id INTEGER PRIMARY KEY,
health_check_id INTEGER NOT NULL REFERENCES health_checks(id) ON DELETE CASCADE, health_check_id INTEGER NOT NULL REFERENCES health_checks(id) ON DELETE CASCADE,
@@ -43,19 +44,16 @@ SCHEMA_STATEMENTS = (
available INTEGER CHECK (available IN (0, 1)), available INTEGER CHECK (available IN (0, 1)),
hardware_works INTEGER CHECK (hardware_works IN (0, 1)), hardware_works INTEGER CHECK (hardware_works IN (0, 1)),
firmware_version TEXT, firmware_version TEXT,
seed_backup_status TEXT CHECK (seed_backup_status IN ('OK', 'PROBLEM', 'IKKJE_VURDERT')), seed_backup_verified TEXT CHECK (seed_backup_verified IN ('OK', 'PROBLEM')),
cloud_health_status TEXT CHECK (cloud_health_status IN ('OK', 'PROBLEM', 'IKKJE_VURDERT')), cloud_health_status TEXT CHECK (cloud_health_status IN ('OK', 'PROBLEM', 'IKKJE_VURDERT')),
cloud_provider_operational INTEGER CHECK (cloud_provider_operational IN (0, 1)), cloud_provider_operational INTEGER CHECK (cloud_provider_operational IN (0, 1)),
address_verified INTEGER CHECK (address_verified IN (0, 1)), address_path_verified TEXT CHECK (address_path_verified IN ('OK', 'PROBLEM')),
seed_backup_verified INTEGER CHECK (seed_backup_verified IN (0, 1)),
address_path_verified INTEGER CHECK (address_path_verified IN (0, 1)),
derivation_height TEXT,
address_path TEXT, address_path TEXT,
comments TEXT, comments TEXT,
UNIQUE (health_check_id, key_id) UNIQUE (health_check_id, key_id)
) )
""",
""" """
TOOL_CHECKS_TABLE = """
CREATE TABLE IF NOT EXISTS tool_checks ( CREATE TABLE IF NOT EXISTS tool_checks (
id INTEGER PRIMARY KEY, id INTEGER PRIMARY KEY,
health_check_id INTEGER NOT NULL REFERENCES health_checks(id) ON DELETE CASCADE, health_check_id INTEGER NOT NULL REFERENCES health_checks(id) ON DELETE CASCADE,
@@ -69,23 +67,28 @@ SCHEMA_STATEMENTS = (
notes TEXT, notes TEXT,
UNIQUE (health_check_id, product) UNIQUE (health_check_id, product)
) )
""",
""" """
AI_SECURITY_CHECKS_TABLE = """
CREATE TABLE IF NOT EXISTS ai_security_checks ( CREATE TABLE IF NOT EXISTS ai_security_checks (
id INTEGER PRIMARY KEY, id INTEGER PRIMARY KEY,
health_check_id INTEGER NOT NULL REFERENCES health_checks(id) ON DELETE CASCADE, health_check_id INTEGER NOT NULL REFERENCES health_checks(id) ON DELETE CASCADE,
provider TEXT NOT NULL CHECK (provider IN ('SeedSigner', 'Blockstream Jade', 'Nunchuk', 'Sparrow Wallet')), provider TEXT NOT NULL CHECK (provider IN ('SeedSigner', 'Blockstream Jade', 'Nunchuk', 'Sparrow Wallet')),
status TEXT NOT NULL CHECK (status IN ('TRYGG', 'PATCHA', 'SÅRBAR', 'KOMPROMITTERT')), status TEXT NOT NULL CHECK (status IN ('SECURE', 'PATCHED', 'VULNERABLE', 'COMPROMISED')),
comments TEXT, comments TEXT,
UNIQUE (health_check_id, provider) UNIQUE (health_check_id, provider)
) )
""", """
SCHEMA_STATEMENTS = (
KEYS_TABLE,
HEALTH_CHECKS_TABLE,
KEY_CHECKS_TABLE,
TOOL_CHECKS_TABLE,
AI_SECURITY_CHECKS_TABLE,
) )
OPTIONAL_COLUMNS = ( OPTIONAL_COLUMNS = (
("key_checks", "address_verified", "INTEGER CHECK (address_verified IN (0, 1))"),
("key_checks", "derivation_height", "TEXT"),
("health_checks", "software_comments", "TEXT"), ("health_checks", "software_comments", "TEXT"),
("key_checks", "seed_backup_verified", "INTEGER CHECK (seed_backup_verified IN (0, 1))"), ("health_checks", "wallet_software", "TEXT"),
("health_checks", "software_version", "TEXT"),
) )
INDEX_STATEMENTS = ( INDEX_STATEMENTS = (
( (
@@ -94,10 +97,19 @@ INDEX_STATEMENTS = (
"CREATE INDEX IF NOT EXISTS idx_health_checks_checked_at ON health_checks(checked_at DESC)", "CREATE INDEX IF NOT EXISTS idx_health_checks_checked_at ON health_checks(checked_at DESC)",
), ),
) )
# Columns that only exist in the pre-section-19 key_checks layout.
LEGACY_KEY_CHECK_COLUMNS = ("seed_backup_status", "address_verified", "derivation_height")
# Value mapping used when the security status values became English.
SECURITY_STATUS_MIGRATION = (
("TRYGG", "SECURE"),
("PATCHA", "PATCHED"),
("SÅRBAR", "VULNERABLE"),
("KOMPROMITTERT", "COMPROMISED"),
)
def initialize_database(database_path="data/helsesjekk.sqlite3"): def initialize_database(database_path="data/helsesjekk.sqlite3"):
"""Create the schema and safely add missing columns to existing databases.""" """Create the schema and safely migrate existing databases."""
path = Path(database_path) path = Path(database_path)
path.parent.mkdir(parents=True, exist_ok=True) path.parent.mkdir(parents=True, exist_ok=True)
connection = sqlite3.connect(path, timeout=5) connection = sqlite3.connect(path, timeout=5)
@@ -115,6 +127,8 @@ def initialize_database(database_path="data/helsesjekk.sqlite3"):
connection.execute(statement) connection.execute(statement)
for table, column, definition in OPTIONAL_COLUMNS: for table, column, definition in OPTIONAL_COLUMNS:
_ensure_column(connection, table, column, definition) _ensure_column(connection, table, column, definition)
_migrate_key_checks(connection)
_migrate_ai_security_checks(connection)
for table, column, statement in INDEX_STATEMENTS: for table, column, statement in INDEX_STATEMENTS:
_ensure_index(connection, table, column, statement) _ensure_index(connection, table, column, statement)
connection.execute(f"PRAGMA user_version = {SCHEMA_VERSION}") connection.execute(f"PRAGMA user_version = {SCHEMA_VERSION}")
@@ -128,10 +142,23 @@ def initialize_database(database_path="data/helsesjekk.sqlite3"):
return path return path
def _table_columns(connection, table):
"""Return the column names of a table, or an empty set when it is missing."""
return {row[1] for row in connection.execute(f"PRAGMA table_info({table})")}
def _table_sql(connection, table):
"""Return the stored CREATE statement of a table, or None when it is missing."""
row = connection.execute(
"SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
(table,),
).fetchone()
return row[0] if row else None
def _ensure_column(connection, table, column, definition): def _ensure_column(connection, table, column, definition):
"""Add a table column only when it is missing.""" """Add a table column only when it is missing."""
columns = {row[1] for row in connection.execute(f"PRAGMA table_info({table})")} if column not in _table_columns(connection, table):
if column not in columns:
connection.execute(f"ALTER TABLE {table} ADD COLUMN {column} {definition}") connection.execute(f"ALTER TABLE {table} ADD COLUMN {column} {definition}")
@@ -142,11 +169,104 @@ def _ensure_index(connection, table, column, statement):
creating the index would then fail. Such a database cannot serve health creating the index would then fail. Such a database cannot serve health
checks until the column exists, so the index is skipped instead. checks until the column exists, so the index is skipped instead.
""" """
columns = {row[1] for row in connection.execute(f"PRAGMA table_info({table})")} if column in _table_columns(connection, table):
if column in columns:
connection.execute(statement) connection.execute(statement)
def _column_or_null(columns, name):
"""Return the column name, or a NULL literal when the column is missing."""
return name if name in columns else "NULL"
def _verification_expression(columns, mappings):
"""Build a CASE expression that maps legacy values to OK or PROBLEM.
Each mapping is a (column, SQL value, result) triple. Mappings are evaluated
in order, so the preferred source column must come first.
"""
cases = [
f"WHEN {column} = {value} THEN '{result}'"
for column, value, result in mappings
if column in columns
]
if not cases:
return "NULL"
return "CASE " + " ".join(cases) + " ELSE NULL END"
def _migrate_key_checks(connection):
"""Rebuild key_checks when it still uses the pre-section-19 layout.
The legacy table stored the verification results as 0/1 flags and kept the
removed columns seed_backup_status, address_verified, and derivation_height.
SQLite cannot change a CHECK constraint, so the table is rebuilt once and the
legacy flags are folded into the OK/PROBLEM values.
"""
columns = _table_columns(connection, "key_checks")
if not columns or not set(LEGACY_KEY_CHECK_COLUMNS) & columns:
return
connection.execute("ALTER TABLE key_checks RENAME TO key_checks_legacy")
connection.execute(KEY_CHECKS_TABLE)
if {"health_check_id", "key_id"} <= columns:
seed_backup = _verification_expression(columns, (
("seed_backup_verified", 1, "OK"),
("seed_backup_verified", 0, "PROBLEM"),
("seed_backup_status", "'OK'", "OK"),
("seed_backup_status", "'PROBLEM'", "PROBLEM"),
))
address_path = _verification_expression(columns, (
("address_path_verified", 1, "OK"),
("address_path_verified", 0, "PROBLEM"),
("address_verified", 1, "OK"),
("address_verified", 0, "PROBLEM"),
))
connection.execute(f"""
INSERT INTO key_checks (
id, health_check_id, key_id, available, hardware_works, firmware_version,
seed_backup_verified, cloud_health_status, cloud_provider_operational,
address_path_verified, address_path, comments
)
SELECT
{_column_or_null(columns, "id")},
health_check_id,
key_id,
{_column_or_null(columns, "available")},
{_column_or_null(columns, "hardware_works")},
{_column_or_null(columns, "firmware_version")},
{seed_backup},
{_column_or_null(columns, "cloud_health_status")},
{_column_or_null(columns, "cloud_provider_operational")},
{address_path},
{_column_or_null(columns, "address_path")},
{_column_or_null(columns, "comments")}
FROM key_checks_legacy
WHERE health_check_id IS NOT NULL AND key_id IS NOT NULL
""")
connection.execute("DROP TABLE key_checks_legacy")
def _migrate_ai_security_checks(connection):
"""Rebuild ai_security_checks when it still allows the Norwegian values."""
sql = _table_sql(connection, "ai_security_checks")
if sql is None or "SECURE" in sql:
return
connection.execute("ALTER TABLE ai_security_checks RENAME TO ai_security_checks_legacy")
connection.execute(AI_SECURITY_CHECKS_TABLE)
cases = " ".join(
f"WHEN '{old}' THEN '{new}'" for old, new in SECURITY_STATUS_MIGRATION
)
connection.execute(f"""
INSERT INTO ai_security_checks (id, health_check_id, provider, status, comments)
SELECT id, health_check_id, provider,
CASE status {cases} ELSE status END,
comments
FROM ai_security_checks_legacy
""")
connection.execute("DROP TABLE ai_security_checks_legacy")
def seed_fixed_keys(database_path="data/helsesjekk.sqlite3"): def seed_fixed_keys(database_path="data/helsesjekk.sqlite3"):
"""Ensure the three fixed key profiles exist without overwriting custom names.""" """Ensure the three fixed key profiles exist without overwriting custom names."""
connection = sqlite3.connect(database_path, timeout=5) connection = sqlite3.connect(database_path, timeout=5)
@@ -185,7 +305,7 @@ def list_keys(database_path="data/helsesjekk.sqlite3"):
def save_health_check(data, database_path="data/helsesjekk.sqlite3"): def save_health_check(data, database_path="data/helsesjekk.sqlite3"):
"""Store one validated health check together with its related rows.""" """Store one validated health check for a single key together with its rows."""
connection = sqlite3.connect(database_path, timeout=5) connection = sqlite3.connect(database_path, timeout=5)
connection.execute("PRAGMA foreign_keys = ON") connection.execute("PRAGMA foreign_keys = ON")
try: try:
@@ -193,58 +313,51 @@ def save_health_check(data, database_path="data/helsesjekk.sqlite3"):
cursor = connection.execute( cursor = connection.execute(
""" """
INSERT INTO health_checks ( INSERT INTO health_checks (
checked_at, next_check_due, software_compatibility_status, checked_at, next_check_due, wallet_software, software_version,
sparrow_version, nunchuk_version, software_comments, software_compatibility_status, software_comments,
contact_info_verified, comments contact_info_verified, comments
) VALUES (?, ?, ?, ?, ?, ?, ?, ?) ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
""", """,
( (
data["checked_at"], data["checked_at"],
data["next_check_due"], data["next_check_due"],
data["wallet_software"],
data["software_version"],
data["software_compatibility_status"], data["software_compatibility_status"],
data["sparrow_version"],
data["nunchuk_version"],
data["software_comments"], data["software_comments"],
data["contact_info_verified"], data["contact_info_verified"],
data["comments"], data["comments"],
), ),
) )
health_check_id = cursor.lastrowid health_check_id = cursor.lastrowid
connection.executemany( key_check = data["key_check"]
connection.execute(
""" """
INSERT INTO key_checks ( INSERT INTO key_checks (
health_check_id, key_id, available, hardware_works, firmware_version, health_check_id, key_id, available, hardware_works, firmware_version,
seed_backup_status, seed_backup_verified, cloud_health_status, seed_backup_verified, cloud_health_status, cloud_provider_operational,
cloud_provider_operational, address_verified, derivation_height,
address_path_verified, address_path, comments address_path_verified, address_path, comments
) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
""", """,
[
( (
health_check_id, health_check_id,
entry["key_id"], key_check["key_id"],
entry["available"], key_check["available"],
entry["hardware_works"], key_check["hardware_works"],
entry["firmware_version"], key_check["firmware_version"],
entry["seed_backup_status"], key_check["seed_backup_verified"],
entry["seed_backup_verified"], key_check["cloud_health_status"],
entry["cloud_health_status"], key_check["cloud_provider_operational"],
entry["cloud_provider_operational"], key_check["address_path_verified"],
entry["address_verified"], key_check["address_path"],
entry["derivation_height"], key_check["comments"],
entry["address_path_verified"], ),
entry["address_path"],
entry["comments"],
)
for entry in data["key_checks"]
],
) )
connection.executemany( connection.executemany(
""" """
INSERT INTO tool_checks ( INSERT INTO tool_checks (
health_check_id, product, bip327_status, slip39_status, health_check_id, product, bip327_status, slip39_status
version, checked_at, notes ) VALUES (?, ?, ?, ?)
) VALUES (?, ?, ?, ?, ?, ?, ?)
""", """,
[ [
( (
@@ -252,9 +365,6 @@ def save_health_check(data, database_path="data/helsesjekk.sqlite3"):
entry["product"], entry["product"],
entry["bip327_status"], entry["bip327_status"],
entry["slip39_status"], entry["slip39_status"],
entry["version"],
entry["checked_at"],
entry["notes"],
) )
for entry in data["tool_checks"] for entry in data["tool_checks"]
], ],
@@ -275,19 +385,41 @@ def save_health_check(data, database_path="data/helsesjekk.sqlite3"):
def list_health_checks(database_path="data/helsesjekk.sqlite3"): def list_health_checks(database_path="data/helsesjekk.sqlite3"):
"""Return saved health check summaries, newest first.""" """Return saved health check summaries, newest first.
Each summary carries the key numbers of the check, so the history can show
which key a submission belongs to.
"""
connection = sqlite3.connect(database_path, timeout=5) connection = sqlite3.connect(database_path, timeout=5)
connection.row_factory = sqlite3.Row connection.row_factory = sqlite3.Row
try: try:
rows = connection.execute( rows = connection.execute(
""" """
SELECT id, checked_at, next_check_due, software_compatibility_status, SELECT id, checked_at, next_check_due, software_compatibility_status,
contact_info_verified, comments wallet_software, contact_info_verified, comments
FROM health_checks FROM health_checks
ORDER BY checked_at DESC, id DESC ORDER BY checked_at DESC, id DESC
""" """
).fetchall() ).fetchall()
return [dict(row) for row in rows] summaries = [dict(row) for row in rows]
if summaries:
placeholders = ", ".join("?" for _ in summaries)
key_rows = connection.execute(
f"""
SELECT kc.health_check_id, k.key_number
FROM key_checks AS kc
JOIN keys AS k ON k.id = kc.key_id
WHERE kc.health_check_id IN ({placeholders})
ORDER BY k.key_number
""",
[entry["id"] for entry in summaries],
).fetchall()
numbers = {}
for row in key_rows:
numbers.setdefault(row["health_check_id"], []).append(row["key_number"])
for entry in summaries:
entry["key_numbers"] = numbers.get(entry["id"], [])
return summaries
finally: finally:
connection.close() connection.close()
@@ -299,9 +431,9 @@ def get_health_check(health_check_id, database_path="data/helsesjekk.sqlite3"):
try: try:
record = connection.execute( record = connection.execute(
""" """
SELECT id, checked_at, next_check_due, software_compatibility_status, SELECT id, checked_at, next_check_due, wallet_software, software_version,
sparrow_version, nunchuk_version, software_comments, software_compatibility_status, sparrow_version, nunchuk_version,
contact_info_verified, comments software_comments, contact_info_verified, comments
FROM health_checks WHERE id = ? FROM health_checks WHERE id = ?
""", """,
(health_check_id,), (health_check_id,),
@@ -316,10 +448,9 @@ def get_health_check(health_check_id, database_path="data/helsesjekk.sqlite3"):
""" """
SELECT kc.id, kc.key_id, k.key_number, k.name, k.type, k.device, SELECT kc.id, kc.key_id, k.key_number, k.name, k.type, k.device,
kc.available, kc.hardware_works, kc.firmware_version, kc.available, kc.hardware_works, kc.firmware_version,
kc.seed_backup_status, kc.seed_backup_verified, kc.seed_backup_verified, kc.cloud_health_status,
kc.cloud_health_status, kc.cloud_provider_operational, kc.cloud_provider_operational, kc.address_path_verified,
kc.address_verified, kc.derivation_height, kc.address_path, kc.comments
kc.address_path_verified, kc.address_path, kc.comments
FROM key_checks AS kc FROM key_checks AS kc
JOIN keys AS k ON k.id = kc.key_id JOIN keys AS k ON k.id = kc.key_id
WHERE kc.health_check_id = ? WHERE kc.health_check_id = ?