From 16b2506e3de25fb1972bf515408f59a0d65db056 Mon Sep 17 00:00:00 2001 From: Gilles Peskine Date: Fri, 18 Mar 2022 00:02:15 +0100 Subject: [PATCH] Abbreviate descriptions of generated PSA storage tests This currently makes all the descriptions unambiguous even when truncated at 66 characters, as the unit test framework does. Signed-off-by: Gilles Peskine --- scripts/mbedtls_dev/crypto_knowledge.py | 19 ++++++++++++++----- tests/scripts/generate_psa_tests.py | 14 +++++++------- 2 files changed, 21 insertions(+), 12 deletions(-) diff --git a/scripts/mbedtls_dev/crypto_knowledge.py b/scripts/mbedtls_dev/crypto_knowledge.py index f2775265c..434ecf33e 100644 --- a/scripts/mbedtls_dev/crypto_knowledge.py +++ b/scripts/mbedtls_dev/crypto_knowledge.py @@ -25,7 +25,7 @@ from typing import Iterable, Optional, Tuple from mbedtls_dev.asymmetric_key_data import ASYMMETRIC_KEY_DATA -def short_expression(original: str) -> str: +def short_expression(original: str, level: int = 0) -> str: """Abbreviate the expression, keeping it human-readable. If `level` is 0, just remove parts that are implicit from context, @@ -36,6 +36,15 @@ def short_expression(original: str) -> str: short = original short = re.sub(r'\bPSA_(?:ALG|ECC_FAMILY|KEY_[A-Z]+)_', r'', short) short = re.sub(r' +', r'', short) + if level >= 1: + short = re.sub(r'PUBLIC_KEY\b', r'PUB', short) + short = re.sub(r'KEY_PAIR\b', r'PAIR', short) + short = re.sub(r'\bBRAINPOOL_P', r'BP', short) + short = re.sub(r'\bMONTGOMERY\b', r'MGM', short) + short = re.sub(r'AEAD_WITH_SHORTENED_TAG\b', r'AEAD_SHORT', short) + short = re.sub(r'\bDETERMINISTIC_', r'DET_', short) + short = re.sub(r'\bKEY_AGREEMENT\b', r'KA', short) + short = re.sub(r'_PSK_TO_MS\b', r'_PSK2MS', short) return short @@ -118,12 +127,12 @@ class KeyType: `self.name`. """ - def short_expression(self) -> str: + def short_expression(self, level: int = 0) -> str: """Abbreviate the expression, keeping it human-readable. See `crypto_knowledge.short_expression`. """ - return short_expression(self.expression) + return short_expression(self.expression, level=level) def is_public(self) -> bool: """Whether the key type is for public keys.""" @@ -398,12 +407,12 @@ class Algorithm: return not re.match(r'(?:0[Xx])?0+\s*\Z', kdf_alg) - def short_expression(self) -> str: + def short_expression(self, level: int = 0) -> str: """Abbreviate the expression, keeping it human-readable. See `crypto_knowledge.short_expression`. """ - return short_expression(self.expression) + return short_expression(self.expression, level=level) def can_do(self, category: AlgorithmCategory) -> bool: """Whether this algorithm fits the specified operation category.""" diff --git a/tests/scripts/generate_psa_tests.py b/tests/scripts/generate_psa_tests.py index 68cd714f5..2a7014705 100755 --- a/tests/scripts/generate_psa_tests.py +++ b/tests/scripts/generate_psa_tests.py @@ -529,7 +529,7 @@ class StorageFormat: """ verb = 'save' if self.forward else 'read' tc = test_case.TestCase() - tc.set_description('PSA storage {}: {}'.format(verb, key.description)) + tc.set_description(verb + ' ' + key.description) dependencies = automatic_dependencies( key.lifetime.string, key.type.string, key.alg.string, key.alg2.string, @@ -648,9 +648,9 @@ class StorageFormat: alg1 = 0 if alg is None else alg.expression #type: psa_storage.Exprable alg2 = 0 key_material = kt.key_material(bits) - description = 'type: {} {}-bit'.format(kt.short_expression(), bits) + description = 'type: {} {}-bit'.format(kt.short_expression(1), bits) if alg is not None: - description += ', ' + alg.short_expression() + description += ', ' + alg.short_expression(1) key = StorageTestData(version=self.version, id=1, lifetime=0x00000001, type=kt.expression, bits=bits, @@ -693,7 +693,7 @@ class StorageFormat: # whether the key read from storage is suitable for an operation. # `keys_for_types` generate read tests with an algorithm and a # compatible key. - descr = crypto_knowledge.short_expression(alg) + descr = crypto_knowledge.short_expression(alg, 1) usage = ['PSA_KEY_USAGE_EXPORT'] key1 = StorageTestData(version=self.version, id=1, lifetime=0x00000001, @@ -772,9 +772,9 @@ class StorageFormatV0(StorageFormat): expected_usage_flags = material_usage_flags + [implicit_usage] alg2 = 0 key_material = key_type.key_material(bits) - usage_expression = crypto_knowledge.short_expression(implyer_usage) - alg_expression = crypto_knowledge.short_expression(alg) - key_type_expression = key_type.short_expression() + usage_expression = crypto_knowledge.short_expression(implyer_usage, 1) + alg_expression = crypto_knowledge.short_expression(alg, 1) + key_type_expression = key_type.short_expression(1) description = 'implied by {}: {} {} {}-bit'.format( usage_expression, alg_expression, key_type_expression, bits) key = StorageTestData(version=self.version,