fix(tools): SignError statt roher ValueError bei kaputtem Schluesselmaterial

nl_sign.py verify/sign gaben bei syntaktisch ungueltigem --pub/--key-Inhalt
(falsches DER/PEM-Format) bisher eine unbehandelte ValueError (pycryptodome
teils IndexError/TypeError) an den Aufrufer durch - die CLI brach dadurch
mit Python-Traceback ab statt mit der vorgesehenen "error: ..."-Meldung und
Exitcode 1. Beide Backends (cryptography und pycryptodome/pycryptodomex)
kapseln das Einlesen des privaten wie des oeffentlichen Schluessels jetzt in
try/except und werfen SignError mit einer festen, schluesselinhaltsfreien
Meldung (via "from None", damit die urspruengliche Bibliotheksausnahme nicht
implizit mitgeschleppt wird). Ein ungueltiger Schluessel kann dadurch nie zu
verify_image() == True fuehren.

Vier neue Tests in test_nl_sign.py: je ein Modul- und CLI-Test fuer kaputtes
--pub und kaputtes --key, die SignError bzw. Exitcode != 0 ohne Traceback auf
stderr festnageln.

tools/mkimage/nl_sign.py

@@ -44,7 +44,11 @@ def _backend():
         from cryptography.exceptions import InvalidSignature
 
         def sign(private_pem: bytes, data: bytes) -> bytes:
-            key = serialization.load_pem_private_key(private_pem, password=None)
+            try:
+                key = serialization.load_pem_private_key(private_pem, password=None)
+            except (ValueError, TypeError):
+                raise SignError(
+                    "privater Schluessel ist kein gueltiger PEM-Schluessel") from None
             if key.key_size != KEY_BITS:
                 raise SignError(
                     f"Schluessel hat {key.key_size} Bit, benoetigt werden {KEY_BITS}")
@@ -55,7 +59,11 @@ def _backend():
             try:
                 key = serialization.load_der_public_key(public_key_bytes)
             except ValueError:
-                key = serialization.load_pem_public_key(public_key_bytes)
+                try:
+                    key = serialization.load_pem_public_key(public_key_bytes)
+                except (ValueError, TypeError):
+                    raise SignError(
+                        "oeffentlicher Schluessel ist weder gueltiges DER noch PEM") from None
             try:
                 key.verify(signature, data, padding.PKCS1v15(), hashes.SHA256())
                 return True
@@ -90,7 +98,11 @@ def _backend():
             from Crypto.PublicKey import RSA
 
         def sign(private_pem: bytes, data: bytes) -> bytes:
-            key = RSA.import_key(private_pem)
+            try:
+                key = RSA.import_key(private_pem)
+            except (ValueError, TypeError, IndexError):
+                raise SignError(
+                    "privater Schluessel ist kein gueltiger PEM/DER-Schluessel") from None
             if key.size_in_bits() != KEY_BITS:
                 raise SignError(
                     f"Schluessel hat {key.size_in_bits()} Bit, benoetigt werden {KEY_BITS}")
@@ -98,7 +110,11 @@ def _backend():
             return pkcs1_15.new(key).sign(digest)
 
         def verify(public_der: bytes, data: bytes, signature: bytes) -> bool:
-            key = RSA.import_key(public_der)
+            try:
+                key = RSA.import_key(public_der)
+            except (ValueError, TypeError, IndexError):
+                raise SignError(
+                    "oeffentlicher Schluessel ist kein gueltiger PEM/DER-Schluessel") from None
             digest = SHA256.new(data)
             try:
                 pkcs1_15.new(key).verify(digest, signature)