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 <Gilles.Peskine@arm.com>

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."""
@@ -396,12 +405,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."""

tests/scripts/generate_psa_tests.py

@@ -527,7 +527,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,
@@ -646,9 +646,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,
@@ -691,7 +691,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,
@@ -770,9 +770,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,