From 8ff81f9ad2c782dc7d07d5161d16af9a9b4fec69 Mon Sep 17 00:00:00 2001 From: ai-bot Date: Sat, 24 Oct 2026 10:10:16 +0000 Subject: [PATCH] Schema 13: active key rows, check snapshots, and the security key id --- database.py | 323 +++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 256 insertions(+), 67 deletions(-) diff --git a/database.py b/database.py index 5eaa707..45b69dc 100644 --- a/database.py +++ b/database.py @@ -11,7 +11,14 @@ import sqlite3 # that holds the multisig threshold and key count (section 31 point 7) and later # the admin credentials (section 31 point 1), and it loosens the ``key_number`` # CHECK so the number of key slots is configurable, not fixed at three. -SCHEMA_VERSION = 12 +# Version 13 freezes the history: a rotation inserts a new ``keys`` row for the +# same ``key_number`` and retires the old one, so ``keys`` carries an ``active`` +# flag and a ``rotated_at``, the ``UNIQUE`` on ``key_number`` becomes a partial +# unique index over the active row, every ``key_checks`` row carries a snapshot of +# the name, the type, and the model it was recorded with, and +# ``ai_security_checks`` carries the checked key so the source of a security alert +# cannot flip on a rename (section 32.8 points 5 and 6). +SCHEMA_VERSION = 13 # The number of key slots a database without a stored multisig setting falls back # to. A new database starts at the 2-of-3 default the app was built for, and the # stored ``multisig_key_count`` decides the real number from then on @@ -38,19 +45,24 @@ _UNSET = object() # Table definitions use a {table} placeholder, so a migration can create the same # table under a temporary name while it rebuilds it. # -# ``key_number`` is only UNIQUE now, not bounded by a CHECK: the number of key -# slots is read from ``app_settings`` and bounded by ``validation.py`` instead, so -# a CHECK would have to be rebuilt for every setup shape (section 31 point 7). -# ``model`` is the optional model or service label of a key, and it is only -# documentation, never part of the key's identity (section 31 point 5). +# ``key_number`` is the multisig slot, and it is no longer UNIQUE on the table: a +# rotation inserts a new row for the same slot and retires the old one, so the +# one-active-row-per-slot rule is enforced by the partial unique index in +# ``INDEX_STATEMENTS`` instead, and any number of retired rows may share a slot +# (section 32.8 point 5). ``active`` marks the row the app reads as "the key", +# ``rotated_at`` records when a row was retired, and ``model`` is the optional +# model or service label, which is only documentation and never part of the key's +# identity (section 31 point 5). KEYS_TABLE = """ CREATE TABLE IF NOT EXISTS {table} ( id INTEGER PRIMARY KEY, - key_number INTEGER NOT NULL UNIQUE, + key_number INTEGER NOT NULL, name TEXT NOT NULL, type TEXT NOT NULL CHECK (type IN ('hardware', 'cloud')), address_path TEXT NOT NULL DEFAULT '', model TEXT, + active INTEGER NOT NULL DEFAULT 1 CHECK (active IN (0, 1)), + rotated_at TEXT, created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP ) """ @@ -72,12 +84,17 @@ HEALTH_CHECKS_TABLE = """ ) """ # The two derived cloud results are gone: a cloud key records only its -# availability (section 25.6). +# availability (section 25.6). The name, the type, and the model of the checked +# key are snapshotted per row, so neither a rotation nor a rename can change what +# an older check says (section 32.8 point 5). KEY_CHECKS_TABLE = """ CREATE TABLE IF NOT EXISTS {table} ( id INTEGER PRIMARY KEY, health_check_id INTEGER NOT NULL REFERENCES health_checks(id) ON DELETE CASCADE, key_id INTEGER NOT NULL REFERENCES keys(id) ON DELETE RESTRICT, + key_name TEXT, + key_type TEXT, + key_model TEXT, available INTEGER CHECK (available IN (0, 1)), hardware_works INTEGER CHECK (hardware_works IN (0, 1)), firmware_version TEXT, @@ -89,12 +106,16 @@ KEY_CHECKS_TABLE = """ ) """ # The provider is the key's configured name and the selected wallet software, so -# the column holds free text (section 23.3). +# the column holds free text (section 23.3). ``key_id`` is the checked key when +# the provider is that key's own configured name, and NULL otherwise, so the +# source of a security alert is decided by the row itself and cannot flip when +# the key is renamed or rotated (section 32.8 point 6). AI_SECURITY_CHECKS_TABLE = """ CREATE TABLE IF NOT EXISTS {table} ( id INTEGER PRIMARY KEY, health_check_id INTEGER NOT NULL REFERENCES health_checks(id) ON DELETE CASCADE, provider TEXT NOT NULL, + key_id INTEGER, status TEXT NOT NULL CHECK (status IN ('SECURE', 'PATCHED', 'VULNERABLE', 'COMPROMISED')), comments TEXT, UNIQUE (health_check_id, provider) @@ -144,8 +165,14 @@ TABLES = ( ) # The address path is part of the key's identity and is written by the setup # step (section 25.1). It is added to a database that predates version 10, the -# key of an acknowledgement to one that predates version 11 (section 27), and the -# key model to one that predates version 12 (section 31 point 5). +# key of an acknowledgement to one that predates version 11 (section 27), the +# key model to one that predates version 12 (section 31 point 5), and the +# snapshot of a check and the key of a security row to one that predates +# version 13 (section 32.8 points 5 and 6). +# +# ``active`` and ``rotated_at`` on ``keys`` are deliberately not listed here: the +# ``UNIQUE`` on ``key_number`` has to go at the same time, so that table is +# rebuilt by ``_migrate_keys`` instead. OPTIONAL_COLUMNS = ( ("keys", "address_path", "TEXT NOT NULL DEFAULT ''"), ("keys", "model", "TEXT"), @@ -153,6 +180,10 @@ OPTIONAL_COLUMNS = ( ("health_checks", "wallet_software", "TEXT"), ("health_checks", "software_version", "TEXT"), ("alert_acknowledgements", "key_id", "INTEGER"), + ("key_checks", "key_name", "TEXT"), + ("key_checks", "key_type", "TEXT"), + ("key_checks", "key_model", "TEXT"), + ("ai_security_checks", "key_id", "INTEGER"), ) INDEX_STATEMENTS = ( ( @@ -160,6 +191,15 @@ INDEX_STATEMENTS = ( "checked_at", "CREATE INDEX IF NOT EXISTS idx_health_checks_checked_at ON health_checks(checked_at DESC)", ), + ( + # One active row per multisig slot, while the retired rows keep their + # number (section 32.8 point 5). The index is partial, so any number of + # retired rows may share a slot. + "keys", + "active", + "CREATE UNIQUE INDEX IF NOT EXISTS idx_keys_active_key_number " + "ON keys(key_number) WHERE active = 1", + ), ) # Columns that only exist in the pre-section-19 key_checks layout. LEGACY_KEY_CHECK_COLUMNS = ("seed_backup_status", "address_verified", "derivation_height") @@ -231,6 +271,10 @@ def initialize_database(database_path="data/vardkey.sqlite3"): _migrate_ai_security_checks(connection) _migrate_status_values(connection) _drop_tool_checks(connection) + # After every rebuild, so a check that lost its snapshot to one of + # them gets it back from the key it belongs to (section 32.8 + # point 5). + _backfill_key_check_snapshots(connection) _seed_default_wallet_software(connection) for table, column, statement in INDEX_STATEMENTS: _ensure_index(connection, table, column, statement) @@ -380,32 +424,45 @@ def _seed_default_wallet_software(connection): def _migrate_keys(connection): - """Rebuild keys when it carries the removed device column or a fixed bound. + """Rebuild keys when it has the removed device column, a fixed bound, or no flag. The configured name is the product label everywhere, so the fixed device - value is gone (section 23.2). SQLite cannot drop a column from a table with - a CHECK constraint, so the table is rebuilt once. The same rebuild loosens - the ``key_number`` CHECK, because the number of key slots is configurable now - and is bounded by ``validation.py`` instead (section 31 point 7). The address + value is gone (section 23.2). SQLite can neither drop a column from a table + with a CHECK constraint nor drop the ``UNIQUE`` on ``key_number``, so the + table is rebuilt once. The same rebuild loosens the ``key_number`` CHECK, + because the number of key slots is configurable now and is bounded by + ``validation.py`` instead (section 31 point 7), and it adds the ``active`` + flag and ``rotated_at`` a rotation needs (section 32.8 point 5). The address path and the model are part of the current definition and are copied along, taking their default for a row that predates them (sections 25.1 and 31.5). + + Every row of a database without the flag is active, because it was written + before a rotation could insert a second row for the same slot. """ columns = _table_columns(connection, "keys") if not columns: return sql = _table_sql(connection, "keys") or "" - if "device" not in columns and LEGACY_KEY_NUMBER_CHECK not in sql: + if ( + "device" not in columns + and "active" in columns + and LEGACY_KEY_NUMBER_CHECK not in sql + ): return temporary = _create_replacement(connection, "keys", KEYS_TABLE) connection.execute(f""" - INSERT INTO {temporary} (id, key_number, name, type, address_path, model, created_at) + INSERT INTO {temporary} ( + id, key_number, name, type, address_path, model, active, rotated_at, created_at + ) SELECT {_column_or_null(columns, "id")}, key_number, name, type, {_column_or_null(columns, "address_path")}, {_column_or_null(columns, "model")}, + COALESCE({_column_or_null(columns, "active")}, 1), + {_column_or_null(columns, "rotated_at")}, {_column_or_null(columns, "created_at")} FROM keys """) @@ -467,7 +524,9 @@ def _migrate_ai_security_checks(connection): Two changes need the same rebuild: the Norwegian status values became English (section 21), and the fixed provider list was dropped because the - key's configured name is the provider label (section 23.3). + key's configured name is the provider label (section 23.3). The ``key_id`` + column is added by ``OPTIONAL_COLUMNS`` and is carried along when the table + is rebuilt for one of those two reasons. """ sql = _table_sql(connection, "ai_security_checks") if sql is None: @@ -475,14 +534,16 @@ def _migrate_ai_security_checks(connection): if "SECURE" in sql and LEGACY_PROVIDER_CHECK not in sql: return + columns = _table_columns(connection, "ai_security_checks") connection.execute("ALTER TABLE ai_security_checks RENAME TO ai_security_checks_legacy") _create_table(connection, "ai_security_checks", 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) + INSERT INTO ai_security_checks (id, health_check_id, provider, key_id, status, comments) SELECT id, health_check_id, provider, + {_column_or_null(columns, "key_id")}, CASE status {cases} ELSE status END, comments FROM ai_security_checks_legacy @@ -490,6 +551,31 @@ def _migrate_ai_security_checks(connection): connection.execute("DROP TABLE ai_security_checks_legacy") +def _backfill_key_check_snapshots(connection): + """Copy the name, the type, and the model of the key onto every older check. + + Before version 13 the three values were read through ``keys``, so a check + that predates the snapshot keeps the values its key has at the moment of the + migration. From then on the row carries its own copy, and a rotation or a + rename cannot change it (section 32.8 point 5). A check that already carries + a snapshot is left alone, so the migration may run more than once without + rewriting a frozen record. + """ + connection.execute(""" + UPDATE key_checks + SET key_name = COALESCE( + key_name, (SELECT k.name FROM keys AS k WHERE k.id = key_checks.key_id) + ), + key_type = COALESCE( + key_type, (SELECT k.type FROM keys AS k WHERE k.id = key_checks.key_id) + ), + key_model = COALESCE( + key_model, (SELECT k.model FROM keys AS k WHERE k.id = key_checks.key_id) + ) + WHERE key_name IS NULL OR key_type IS NULL + """) + + def _migrate_status_values(connection): """Rewrite the tables whose stored values or CHECK constraints changed. @@ -590,16 +676,24 @@ def _rebuild_key_checks(connection): The pre-section-21 ``IKKJE_VURDERT`` value is gone from the definition, and the two derived cloud results are dropped because a cloud key records only - its availability (sections 21 and 25.6). Every surviving column is copied. + its availability (sections 21 and 25.6). Every surviving column is copied; + a snapshot column that this rebuild cannot carry over is refilled by + ``_backfill_key_check_snapshots`` afterwards (section 32.8 point 5). """ + columns = _table_columns(connection, "key_checks") temporary = _create_replacement(connection, "key_checks", KEY_CHECKS_TABLE) connection.execute(f""" INSERT INTO {temporary} ( - id, health_check_id, key_id, available, hardware_works, firmware_version, - seed_backup_verified, address_path_verified, address_path, comments + id, health_check_id, key_id, key_name, key_type, key_model, + available, hardware_works, firmware_version, seed_backup_verified, + address_path_verified, address_path, comments ) - SELECT id, health_check_id, key_id, available, hardware_works, firmware_version, - seed_backup_verified, address_path_verified, address_path, comments + SELECT id, health_check_id, key_id, + {_column_or_null(columns, "key_name")}, + {_column_or_null(columns, "key_type")}, + {_column_or_null(columns, "key_model")}, + available, hardware_works, firmware_version, seed_backup_verified, + address_path_verified, address_path, comments FROM key_checks """) _replace_table(connection, "key_checks", temporary) @@ -682,16 +776,19 @@ def save_multisig_settings(threshold, key_count, database_path="data/vardkey.sql def list_keys(database_path="data/vardkey.sqlite3"): - """Return the stored key profiles in key order. + """Return the active key profiles in key order. - An empty list means a new database, which the app answers with the first-run - setup step. A database that holds only part of the setup raises an error, so - an unreadable database is never treated as a new installation - (section 23.2). The expected number of keys comes from the stored multisig - setting, so a setup with another key count is read back correctly - (section 31 point 7). The address path is part of the key's identity and is - compared with every submitted path (section 25.1), and the model is the - optional documentation label of the key (section 31 point 5). + Only the active row of each multisig slot is returned, so a retired row left + behind by a rotation is invisible to the setup, the settings, the form, and + the dashboard (section 32.8 point 5). An empty list means a new database, + which the app answers with the first-run setup step. A database that holds + only part of the setup raises an error, so an unreadable database is never + treated as a new installation (section 23.2). The expected number of keys + comes from the stored multisig setting, so a setup with another key count is + read back correctly (section 31 point 7). The address path is part of the + key's identity and is compared with every submitted path (section 25.1), and + the model is the optional documentation label of the key (section 31 + point 5). """ connection = sqlite3.connect(database_path, timeout=5) connection.row_factory = sqlite3.Row @@ -700,6 +797,7 @@ def list_keys(database_path="data/vardkey.sqlite3"): """ SELECT id, key_number, name, type, address_path, model, created_at FROM keys + WHERE active = 1 ORDER BY key_number """ ).fetchall() @@ -725,6 +823,8 @@ def save_key_setup(entries, database_path="data/vardkey.sqlite3", *, threshold=N (section 31 point 7). ``threshold`` and ``key_count`` fall back to the 2-of-3 default when they are left out, so a caller that only passes the keys keeps working. The model is the optional label of a key (section 31 point 5). + Every row is written as the active row of its slot, which is the default of + the column (section 32.8 point 5). """ if list_keys(database_path): raise RuntimeError("The key setup is already stored") @@ -786,23 +886,26 @@ def save_key_settings(key_id, name, address_path, database_path="data/vardkey.sq left out. ``model`` is written as given, including an empty value that clears it; when the argument is left out, the stored model is kept, so a caller that does not manage it never drops it. + + This writes the row in place, so it is the settings that use it. A rotation + goes through ``rotate_key`` instead, which inserts a new row and retires this + one (section 32.8 point 5). """ connection = sqlite3.connect(database_path, timeout=5) connection.execute("PRAGMA foreign_keys = ON") try: with connection: - # COALESCE keeps the stored type when no new one is passed, so the - # settings and a rotation can share this one statement. + # COALESCE keeps the stored type when no new one is passed. if model is _UNSET: statement = ( "UPDATE keys SET name = ?, address_path = ?, " - "type = COALESCE(?, type) WHERE id = ?" + "type = COALESCE(?, type) WHERE id = ? AND active = 1" ) parameters = (name, address_path, key_type, key_id) else: statement = ( "UPDATE keys SET name = ?, address_path = ?, " - "type = COALESCE(?, type), model = ? WHERE id = ?" + "type = COALESCE(?, type), model = ? WHERE id = ? AND active = 1" ) parameters = (name, address_path, key_type, model, key_id) cursor = connection.execute(statement, parameters) @@ -812,6 +915,55 @@ def save_key_settings(key_id, name, address_path, database_path="data/vardkey.sq connection.close() +def rotate_key(key_id, name, address_path, database_path="data/vardkey.sqlite3", *, key_type=None, model=_UNSET): + """Replace a key with a new active row and retire the old one. + + A rotation is a new key: the multisig slot stays, so the new row carries the + same ``key_number``, while the old row is marked inactive and stamped with + ``rotated_at``. The older checks keep pointing at the old row and carry their + own snapshot, so the history is frozen (section 32.8 point 5). + + The old row is retired before the new one is inserted, because the partial + unique index allows only one active row per slot. The address path and the + type are part of the key's identity, so both are written as given; + ``key_type`` keeps the stored type when it is left out, and ``model`` keeps + the stored model when the argument is left out and clears it when it is + empty. The id of the new row is returned, so the caller can close the alerts + of the slot against it. + """ + connection = sqlite3.connect(database_path, timeout=5) + connection.execute("PRAGMA foreign_keys = ON") + try: + with connection: + row = connection.execute( + "SELECT key_number, type, model FROM keys WHERE id = ? AND active = 1", + (key_id,), + ).fetchone() + if row is None: + raise ValueError(f"Key {key_id} does not exist") + key_number, stored_type, stored_model = row + connection.execute( + "UPDATE keys SET active = 0, rotated_at = ? WHERE id = ?", + (datetime.now().isoformat(timespec="seconds"), key_id), + ) + cursor = connection.execute( + """ + INSERT INTO keys (key_number, name, type, address_path, model, active) + VALUES (?, ?, ?, ?, ?, 1) + """, + ( + key_number, + name, + stored_type if key_type is None else key_type, + address_path, + stored_model if model is _UNSET else model, + ), + ) + return cursor.lastrowid + finally: + connection.close() + + def list_wallet_software(database_path="data/vardkey.sqlite3"): """Return the stored wallet software names in their stored order. @@ -918,7 +1070,8 @@ def delete_all_data(database_path="data/vardkey.sqlite3"): RESTRICT``, so the checks have to go before the keys. The child rows of a check (``key_checks`` and ``ai_security_checks``) go with it through ``ON DELETE CASCADE``, while ``alert_acknowledgements`` has no foreign key and is - deleted explicitly. + deleted explicitly. Every key row goes, active and retired alike + (section 32.8 point 5). The number of deleted checks is returned, so the caller can report it. """ @@ -951,11 +1104,27 @@ def delete_all_data(database_path="data/vardkey.sqlite3"): def save_health_check(data, database_path="data/vardkey.sqlite3"): - """Store one validated health check for a single key together with its rows.""" + """Store one validated health check for a single key together with its rows. + + The name, the type, and the model of the key are copied onto the check as a + snapshot, so neither a rotation nor a rename can change what an older record + says (section 32.8 point 5). A security row carries the checked key when its + provider is that key's own configured name, and NULL otherwise, so the source + of a security alert is decided by the row itself (section 32.8 point 6). + """ connection = sqlite3.connect(database_path, timeout=5) connection.execute("PRAGMA foreign_keys = ON") try: with connection: + key_check = data["key_check"] + key = connection.execute( + "SELECT name, type, model FROM keys WHERE id = ?", + (key_check["key_id"],), + ).fetchone() + if key is None: + raise ValueError(f"Key {key_check['key_id']} does not exist") + key_name, key_type, key_model = key + cursor = connection.execute( """ INSERT INTO health_checks ( @@ -976,17 +1145,20 @@ def save_health_check(data, database_path="data/vardkey.sqlite3"): ), ) health_check_id = cursor.lastrowid - key_check = data["key_check"] connection.execute( """ INSERT INTO key_checks ( - health_check_id, key_id, available, hardware_works, firmware_version, + health_check_id, key_id, key_name, key_type, key_model, + available, hardware_works, firmware_version, seed_backup_verified, address_path_verified, address_path, comments - ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) + ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) """, ( health_check_id, key_check["key_id"], + key_name, + key_type, + key_model, key_check["available"], key_check["hardware_works"], key_check["firmware_version"], @@ -998,11 +1170,17 @@ def save_health_check(data, database_path="data/vardkey.sqlite3"): ) connection.executemany( """ - INSERT INTO ai_security_checks (health_check_id, provider, status, comments) - VALUES (?, ?, ?, ?) + INSERT INTO ai_security_checks (health_check_id, provider, key_id, status, comments) + VALUES (?, ?, ?, ?, ?) """, [ - (health_check_id, entry["provider"], entry["status"], entry["comments"]) + ( + health_check_id, + entry["provider"], + key_check["key_id"] if entry["provider"] == key_name else None, + entry["status"], + entry["comments"], + ) for entry in data["ai_security_checks"] ], ) @@ -1015,7 +1193,8 @@ def list_health_checks(database_path="data/vardkey.sqlite3"): """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. + which key a submission belongs to. The number is the multisig slot, which a + rotation never changes, so it is read from ``keys`` (section 32.8 point 5). """ connection = sqlite3.connect(database_path, timeout=5) connection.row_factory = sqlite3.Row @@ -1052,13 +1231,15 @@ def list_health_checks(database_path="data/vardkey.sqlite3"): def list_key_status(database_path="data/vardkey.sqlite3"): - """Return each key with the dates of its newest saved check. + """Return each active key with the dates of its newest saved check. - A key that has never been checked has no dates. Whether a date is overdue is - left to the caller, so this function stays independent of the current date. - The address path and the model are carried as well, so the dashboard card can - show them (sections 31.4 and 31.5). An empty address path, which a migrated - key can have, is passed through as it stands and left out by the card. + A retired row left behind by a rotation is left out, so the dashboard shows + one card per multisig slot (section 32.8 point 5). A key that has never been + checked has no dates. Whether a date is overdue is left to the caller, so + this function stays independent of the current date. The address path and the + model are carried as well, so the dashboard card can show them + (sections 31.4 and 31.5). An empty address path, which a migrated key can + have, is passed through as it stands and left out by the card. """ connection = sqlite3.connect(database_path, timeout=5) connection.row_factory = sqlite3.Row @@ -1070,6 +1251,7 @@ def list_key_status(database_path="data/vardkey.sqlite3"): ({_LATEST_CHECK_QUERY.format(expression="hc.checked_at")}) AS last_checked_at, ({_LATEST_CHECK_QUERY.format(expression="hc.next_check_due")}) AS next_check_due FROM keys AS k + WHERE k.active = 1 ORDER BY k.key_number """ ).fetchall() @@ -1081,10 +1263,11 @@ def list_key_status(database_path="data/vardkey.sqlite3"): def list_previous_values(database_path="data/vardkey.sqlite3"): """Return the most recently saved values, for pre-filling the form. - ``keys`` carries the last recorded firmware version, address path, wallet - software, and software version for each key. ``security`` carries the last - recorded security status for each provider, whatever key recorded it. Both - are used to pre-fill the form. + Only the active row of each slot is read, so a retired row is invisible to + the form (section 32.8 point 5). ``keys`` carries the last recorded firmware + version, address path, wallet software, and software version for each key. + ``security`` carries the last recorded security status for each provider, + whatever key recorded it. Both are used to pre-fill the form. """ connection = sqlite3.connect(database_path, timeout=5) connection.row_factory = sqlite3.Row @@ -1099,6 +1282,7 @@ def list_previous_values(database_path="data/vardkey.sqlite3"): ({_LATEST_CHECK_QUERY.format(expression="hc.wallet_software")}) AS wallet_software, ({_LATEST_CHECK_QUERY.format(expression="hc.software_version")}) AS software_version FROM keys AS k + WHERE k.active = 1 ORDER BY k.key_number """ ).fetchall() @@ -1123,9 +1307,12 @@ def list_export_rows(database_path="data/vardkey.sqlite3"): Every row is one key check. ``check_id`` identifies the submission it belongs to, so rows saved before section 19 (up to three keys in one submission) stay - grouped. The per-provider security results are joined into a single text - cell, because they have more than one value per submission, and so are the - closures that belong to a key (section 27). + grouped. The key name and the key type come from the snapshot on the check, + so a rotation or a rename cannot rewrite an older row (section 32.8 point 5); + the key number is the multisig slot, which never changes. The per-provider + security results are joined into a single text cell, because they have more + than one value per submission, and so are the closures that belong to a key + (section 27). """ connection = sqlite3.connect(database_path, timeout=5) connection.row_factory = sqlite3.Row @@ -1136,7 +1323,8 @@ def list_export_rows(database_path="data/vardkey.sqlite3"): hc.wallet_software, hc.software_version, hc.software_compatibility_status, hc.software_comments, hc.contact_info_verified, hc.comments, - kc.key_id, k.key_number, k.name AS key_name, k.type AS key_type, + kc.key_id, k.key_number, + kc.key_name AS key_name, kc.key_type AS key_type, kc.available, kc.hardware_works, kc.firmware_version, kc.seed_backup_verified, kc.address_path_verified, kc.address_path, kc.comments AS key_comments @@ -1199,10 +1387,10 @@ def _short_date(value): def get_health_check(health_check_id, database_path="data/vardkey.sqlite3"): """Return one saved health check with its related rows, or None. - The key rows are read through ``keys``, so the history, the alerts and the - export show the name a key has now, which the settings may change - (section 25.2). The model of the key is carried as well, so the history can - name the hardware and the firmware on one line; it is an added field and the + The name, the type, and the model of the checked key are read from the + snapshot on the row, so a rotation or a rename cannot change what an older + record says (section 32.8 point 5). The key number is the multisig slot, read + through ``keys``, which never changes. The model is an added field and the existing ones keep their names (section 32.1). """ connection = sqlite3.connect(database_path, timeout=5) @@ -1225,7 +1413,8 @@ def get_health_check(health_check_id, database_path="data/vardkey.sqlite3"): dict(row) for row in connection.execute( """ - SELECT kc.id, kc.key_id, k.key_number, k.name, k.type, k.model, + SELECT kc.id, kc.key_id, k.key_number, + kc.key_name AS name, kc.key_type AS type, kc.key_model AS model, kc.available, kc.hardware_works, kc.firmware_version, kc.seed_backup_verified, kc.address_path_verified, kc.address_path, kc.comments @@ -1241,7 +1430,7 @@ def get_health_check(health_check_id, database_path="data/vardkey.sqlite3"): dict(row) for row in connection.execute( """ - SELECT id, provider, status, comments + SELECT id, provider, key_id, status, comments FROM ai_security_checks WHERE health_check_id = ? ORDER BY id """,