mirror of
https://github.com/yuzu-emu/mbedtls.git
synced 2024-11-23 21:25:40 +01:00
33c601cb73
Make it possible to enumerate the key types, algorithms, etc. collected by PSAMacroCollector. This commit ensures that all fields of PSAMacroEnumerator are filled by code inspection. Testing of the result may reveal more work to be done in later commits. Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
254 lines
11 KiB
Python
254 lines
11 KiB
Python
"""Collect macro definitions from header files.
|
|
"""
|
|
|
|
# Copyright The Mbed TLS Contributors
|
|
# SPDX-License-Identifier: Apache-2.0
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
import itertools
|
|
import re
|
|
from typing import Dict, Iterable, Iterator, List, Set
|
|
|
|
|
|
class PSAMacroEnumerator:
|
|
"""Information about constructors of various PSA Crypto types.
|
|
|
|
This includes macro names as well as information about their arguments
|
|
when applicable.
|
|
|
|
This class only provides ways to enumerate expressions that evaluate to
|
|
values of the covered types. Derived classes are expected to populate
|
|
the set of known constructors of each kind, as well as populate
|
|
`self.arguments_for` for arguments that are not of a kind that is
|
|
enumerated here.
|
|
"""
|
|
|
|
def __init__(self) -> None:
|
|
"""Set up an empty set of known constructor macros.
|
|
"""
|
|
self.statuses = set() #type: Set[str]
|
|
self.algorithms = set() #type: Set[str]
|
|
self.ecc_curves = set() #type: Set[str]
|
|
self.dh_groups = set() #type: Set[str]
|
|
self.key_types = set() #type: Set[str]
|
|
self.key_usage_flags = set() #type: Set[str]
|
|
self.hash_algorithms = set() #type: Set[str]
|
|
self.mac_algorithms = set() #type: Set[str]
|
|
self.ka_algorithms = set() #type: Set[str]
|
|
self.kdf_algorithms = set() #type: Set[str]
|
|
self.aead_algorithms = set() #type: Set[str]
|
|
# macro name -> list of argument names
|
|
self.argspecs = {} #type: Dict[str, List[str]]
|
|
# argument name -> list of values
|
|
self.arguments_for = {
|
|
'mac_length': [],
|
|
'min_mac_length': [],
|
|
'tag_length': [],
|
|
'min_tag_length': [],
|
|
} #type: Dict[str, List[str]]
|
|
|
|
def gather_arguments(self) -> None:
|
|
"""Populate the list of values for macro arguments.
|
|
|
|
Call this after parsing all the inputs.
|
|
"""
|
|
self.arguments_for['hash_alg'] = sorted(self.hash_algorithms)
|
|
self.arguments_for['mac_alg'] = sorted(self.mac_algorithms)
|
|
self.arguments_for['ka_alg'] = sorted(self.ka_algorithms)
|
|
self.arguments_for['kdf_alg'] = sorted(self.kdf_algorithms)
|
|
self.arguments_for['aead_alg'] = sorted(self.aead_algorithms)
|
|
self.arguments_for['curve'] = sorted(self.ecc_curves)
|
|
self.arguments_for['group'] = sorted(self.dh_groups)
|
|
|
|
@staticmethod
|
|
def _format_arguments(name: str, arguments: Iterable[str]) -> str:
|
|
"""Format a macro call with arguments.."""
|
|
return name + '(' + ', '.join(arguments) + ')'
|
|
|
|
_argument_split_re = re.compile(r' *, *')
|
|
@classmethod
|
|
def _argument_split(cls, arguments: str) -> List[str]:
|
|
return re.split(cls._argument_split_re, arguments)
|
|
|
|
def distribute_arguments(self, name: str) -> Iterator[str]:
|
|
"""Generate macro calls with each tested argument set.
|
|
|
|
If name is a macro without arguments, just yield "name".
|
|
If name is a macro with arguments, yield a series of
|
|
"name(arg1,...,argN)" where each argument takes each possible
|
|
value at least once.
|
|
"""
|
|
try:
|
|
if name not in self.argspecs:
|
|
yield name
|
|
return
|
|
argspec = self.argspecs[name]
|
|
if argspec == []:
|
|
yield name + '()'
|
|
return
|
|
argument_lists = [self.arguments_for[arg] for arg in argspec]
|
|
arguments = [values[0] for values in argument_lists]
|
|
yield self._format_arguments(name, arguments)
|
|
# Dear Pylint, enumerate won't work here since we're modifying
|
|
# the array.
|
|
# pylint: disable=consider-using-enumerate
|
|
for i in range(len(arguments)):
|
|
for value in argument_lists[i][1:]:
|
|
arguments[i] = value
|
|
yield self._format_arguments(name, arguments)
|
|
arguments[i] = argument_lists[0][0]
|
|
except BaseException as e:
|
|
raise Exception('distribute_arguments({})'.format(name)) from e
|
|
|
|
def generate_expressions(self, names: Iterable[str]) -> Iterator[str]:
|
|
"""Generate expressions covering values constructed from the given names.
|
|
|
|
`names` can be any iterable collection of macro names.
|
|
|
|
For example:
|
|
* ``generate_expressions(['PSA_ALG_CMAC', 'PSA_ALG_HMAC'])``
|
|
generates ``'PSA_ALG_CMAC'`` as well as ``'PSA_ALG_HMAC(h)'`` for
|
|
every known hash algorithm ``h``.
|
|
* ``macros.generate_expressions(macros.key_types)`` generates all
|
|
key types.
|
|
"""
|
|
return itertools.chain(*map(self.distribute_arguments, names))
|
|
|
|
|
|
class PSAMacroCollector(PSAMacroEnumerator):
|
|
"""Collect PSA crypto macro definitions from C header files.
|
|
"""
|
|
|
|
def __init__(self, include_intermediate: bool = False) -> None:
|
|
"""Set up an object to collect PSA macro definitions.
|
|
|
|
Call the read_file method of the constructed object on each header file.
|
|
|
|
* include_intermediate: if true, include intermediate macros such as
|
|
PSA_XXX_BASE that do not designate semantic values.
|
|
"""
|
|
super().__init__()
|
|
self.include_intermediate = include_intermediate
|
|
self.key_types_from_curve = {} #type: Dict[str, str]
|
|
self.key_types_from_group = {} #type: Dict[str, str]
|
|
self.algorithms_from_hash = {} #type: Dict[str, str]
|
|
|
|
def is_internal_name(self, name: str) -> bool:
|
|
"""Whether this is an internal macro. Internal macros will be skipped."""
|
|
if not self.include_intermediate:
|
|
if name.endswith('_BASE') or name.endswith('_NONE'):
|
|
return True
|
|
if '_CATEGORY_' in name:
|
|
return True
|
|
return name.endswith('_FLAG') or name.endswith('_MASK')
|
|
|
|
def record_algorithm_subtype(self, name: str, expansion: str) -> None:
|
|
"""Record the subtype of an algorithm constructor.
|
|
|
|
Given a ``PSA_ALG_xxx`` macro name and its expansion, if the algorithm
|
|
is of a subtype that is tracked in its own set, add it to the relevant
|
|
set.
|
|
"""
|
|
# This code is very ad hoc and fragile. It should be replaced by
|
|
# something more robust.
|
|
if re.match(r'MAC(?:_|\Z)', name):
|
|
self.mac_algorithms.add(name)
|
|
elif re.match(r'KDF(?:_|\Z)', name):
|
|
self.kdf_algorithms.add(name)
|
|
elif re.search(r'0x020000[0-9A-Fa-f]{2}', expansion):
|
|
self.hash_algorithms.add(name)
|
|
elif re.search(r'0x03[0-9A-Fa-f]{6}', expansion):
|
|
self.mac_algorithms.add(name)
|
|
elif re.search(r'0x05[0-9A-Fa-f]{6}', expansion):
|
|
self.aead_algorithms.add(name)
|
|
elif re.search(r'0x09[0-9A-Fa-f]{2}0000', expansion):
|
|
self.ka_algorithms.add(name)
|
|
elif re.search(r'0x08[0-9A-Fa-f]{6}', expansion):
|
|
self.kdf_algorithms.add(name)
|
|
|
|
# "#define" followed by a macro name with either no parameters
|
|
# or a single parameter and a non-empty expansion.
|
|
# Grab the macro name in group 1, the parameter name if any in group 2
|
|
# and the expansion in group 3.
|
|
_define_directive_re = re.compile(r'\s*#\s*define\s+(\w+)' +
|
|
r'(?:\s+|\((\w+)\)\s*)' +
|
|
r'(.+)')
|
|
_deprecated_definition_re = re.compile(r'\s*MBEDTLS_DEPRECATED')
|
|
|
|
def read_line(self, line):
|
|
"""Parse a C header line and record the PSA identifier it defines if any.
|
|
This function analyzes lines that start with "#define PSA_"
|
|
(up to non-significant whitespace) and skips all non-matching lines.
|
|
"""
|
|
# pylint: disable=too-many-branches
|
|
m = re.match(self._define_directive_re, line)
|
|
if not m:
|
|
return
|
|
name, parameter, expansion = m.groups()
|
|
expansion = re.sub(r'/\*.*?\*/|//.*', r' ', expansion)
|
|
if parameter:
|
|
self.argspecs[name] = [parameter]
|
|
if re.match(self._deprecated_definition_re, expansion):
|
|
# Skip deprecated values, which are assumed to be
|
|
# backward compatibility aliases that share
|
|
# numerical values with non-deprecated values.
|
|
return
|
|
if self.is_internal_name(name):
|
|
# Macro only to build actual values
|
|
return
|
|
elif (name.startswith('PSA_ERROR_') or name == 'PSA_SUCCESS') \
|
|
and not parameter:
|
|
self.statuses.add(name)
|
|
elif name.startswith('PSA_KEY_TYPE_') and not parameter:
|
|
self.key_types.add(name)
|
|
elif name.startswith('PSA_KEY_TYPE_') and parameter == 'curve':
|
|
self.key_types_from_curve[name] = name[:13] + 'IS_' + name[13:]
|
|
elif name.startswith('PSA_KEY_TYPE_') and parameter == 'group':
|
|
self.key_types_from_group[name] = name[:13] + 'IS_' + name[13:]
|
|
elif name.startswith('PSA_ECC_FAMILY_') and not parameter:
|
|
self.ecc_curves.add(name)
|
|
elif name.startswith('PSA_DH_FAMILY_') and not parameter:
|
|
self.dh_groups.add(name)
|
|
elif name.startswith('PSA_ALG_') and not parameter:
|
|
if name in ['PSA_ALG_ECDSA_BASE',
|
|
'PSA_ALG_RSA_PKCS1V15_SIGN_BASE']:
|
|
# Ad hoc skipping of duplicate names for some numerical values
|
|
return
|
|
self.algorithms.add(name)
|
|
self.record_algorithm_subtype(name, expansion)
|
|
elif name.startswith('PSA_ALG_') and parameter == 'hash_alg':
|
|
if name in ['PSA_ALG_DSA', 'PSA_ALG_ECDSA']:
|
|
# A naming irregularity
|
|
tester = name[:8] + 'IS_RANDOMIZED_' + name[8:]
|
|
else:
|
|
tester = name[:8] + 'IS_' + name[8:]
|
|
self.algorithms_from_hash[name] = tester
|
|
elif name.startswith('PSA_KEY_USAGE_') and not parameter:
|
|
self.key_usage_flags.add(name)
|
|
else:
|
|
# Other macro without parameter
|
|
return
|
|
|
|
_nonascii_re = re.compile(rb'[^\x00-\x7f]+')
|
|
_continued_line_re = re.compile(rb'\\\r?\n\Z')
|
|
def read_file(self, header_file):
|
|
for line in header_file:
|
|
m = re.search(self._continued_line_re, line)
|
|
while m:
|
|
cont = next(header_file)
|
|
line = line[:m.start(0)] + cont
|
|
m = re.search(self._continued_line_re, line)
|
|
line = re.sub(self._nonascii_re, rb'', line).decode('ascii')
|
|
self.read_line(line)
|