579 lines
23 KiB
Python
579 lines
23 KiB
Python
"""Knowledge about cryptographic mechanisms implemented in Mbed TLS.
|
|
|
|
This module is entirely based on the PSA API.
|
|
"""
|
|
|
|
# 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 enum
|
|
import re
|
|
from typing import FrozenSet, Iterable, List, Optional, Tuple, Dict
|
|
|
|
from .asymmetric_key_data import ASYMMETRIC_KEY_DATA
|
|
|
|
|
|
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,
|
|
such as a leading ``PSA_KEY_TYPE_``.
|
|
For larger values of `level`, also abbreviate some names in an
|
|
unambiguous, but ad hoc way.
|
|
"""
|
|
short = original
|
|
short = re.sub(r'\bPSA_(?:ALG|DH_FAMILY|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
|
|
|
|
|
|
BLOCK_CIPHERS = frozenset(['AES', 'ARIA', 'CAMELLIA', 'DES'])
|
|
BLOCK_MAC_MODES = frozenset(['CBC_MAC', 'CMAC'])
|
|
BLOCK_CIPHER_MODES = frozenset([
|
|
'CTR', 'CFB', 'OFB', 'XTS', 'CCM_STAR_NO_TAG',
|
|
'ECB_NO_PADDING', 'CBC_NO_PADDING', 'CBC_PKCS7',
|
|
])
|
|
BLOCK_AEAD_MODES = frozenset(['CCM', 'GCM'])
|
|
|
|
class EllipticCurveCategory(enum.Enum):
|
|
"""Categorization of elliptic curve families.
|
|
|
|
The category of a curve determines what algorithms are defined over it.
|
|
"""
|
|
|
|
SHORT_WEIERSTRASS = 0
|
|
MONTGOMERY = 1
|
|
TWISTED_EDWARDS = 2
|
|
|
|
@staticmethod
|
|
def from_family(family: str) -> 'EllipticCurveCategory':
|
|
if family == 'PSA_ECC_FAMILY_MONTGOMERY':
|
|
return EllipticCurveCategory.MONTGOMERY
|
|
if family == 'PSA_ECC_FAMILY_TWISTED_EDWARDS':
|
|
return EllipticCurveCategory.TWISTED_EDWARDS
|
|
# Default to SW, which most curves belong to.
|
|
return EllipticCurveCategory.SHORT_WEIERSTRASS
|
|
|
|
|
|
class KeyType:
|
|
"""Knowledge about a PSA key type."""
|
|
|
|
def __init__(self, name: str, params: Optional[Iterable[str]] = None) -> None:
|
|
"""Analyze a key type.
|
|
|
|
The key type must be specified in PSA syntax. In its simplest form,
|
|
`name` is a string 'PSA_KEY_TYPE_xxx' which is the name of a PSA key
|
|
type macro. For key types that take arguments, the arguments can
|
|
be passed either through the optional argument `params` or by
|
|
passing an expression of the form 'PSA_KEY_TYPE_xxx(param1, ...)'
|
|
in `name` as a string.
|
|
"""
|
|
|
|
self.name = name.strip()
|
|
"""The key type macro name (``PSA_KEY_TYPE_xxx``).
|
|
|
|
For key types constructed from a macro with arguments, this is the
|
|
name of the macro, and the arguments are in `self.params`.
|
|
"""
|
|
if params is None:
|
|
if '(' in self.name:
|
|
m = re.match(r'(\w+)\s*\((.*)\)\Z', self.name)
|
|
assert m is not None
|
|
self.name = m.group(1)
|
|
params = m.group(2).split(',')
|
|
self.params = (None if params is None else
|
|
[param.strip() for param in params])
|
|
"""The parameters of the key type, if there are any.
|
|
|
|
None if the key type is a macro without arguments.
|
|
"""
|
|
assert re.match(r'PSA_KEY_TYPE_\w+\Z', self.name)
|
|
|
|
self.expression = self.name
|
|
"""A C expression whose value is the key type encoding."""
|
|
if self.params is not None:
|
|
self.expression += '(' + ', '.join(self.params) + ')'
|
|
|
|
m = re.match(r'PSA_KEY_TYPE_(\w+)', self.name)
|
|
assert m
|
|
self.head = re.sub(r'_(?:PUBLIC_KEY|KEY_PAIR)\Z', r'', m.group(1))
|
|
"""The key type macro name, with common prefixes and suffixes stripped."""
|
|
|
|
self.private_type = re.sub(r'_PUBLIC_KEY\Z', r'_KEY_PAIR', self.name)
|
|
"""The key type macro name for the corresponding key pair type.
|
|
|
|
For everything other than a public key type, this is the same as
|
|
`self.name`.
|
|
"""
|
|
|
|
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, level=level)
|
|
|
|
def is_public(self) -> bool:
|
|
"""Whether the key type is for public keys."""
|
|
return self.name.endswith('_PUBLIC_KEY')
|
|
|
|
DH_KEY_SIZES = {
|
|
'PSA_DH_FAMILY_RFC7919': (2048, 3072, 4096, 6144, 8192),
|
|
} # type: Dict[str, Tuple[int, ...]]
|
|
ECC_KEY_SIZES = {
|
|
'PSA_ECC_FAMILY_SECP_K1': (192, 224, 256),
|
|
'PSA_ECC_FAMILY_SECP_R1': (225, 256, 384, 521),
|
|
'PSA_ECC_FAMILY_SECP_R2': (160,),
|
|
'PSA_ECC_FAMILY_SECT_K1': (163, 233, 239, 283, 409, 571),
|
|
'PSA_ECC_FAMILY_SECT_R1': (163, 233, 283, 409, 571),
|
|
'PSA_ECC_FAMILY_SECT_R2': (163,),
|
|
'PSA_ECC_FAMILY_BRAINPOOL_P_R1': (160, 192, 224, 256, 320, 384, 512),
|
|
'PSA_ECC_FAMILY_MONTGOMERY': (255, 448),
|
|
'PSA_ECC_FAMILY_TWISTED_EDWARDS': (255, 448),
|
|
} # type: Dict[str, Tuple[int, ...]]
|
|
KEY_TYPE_SIZES = {
|
|
'PSA_KEY_TYPE_AES': (128, 192, 256), # exhaustive
|
|
'PSA_KEY_TYPE_ARIA': (128, 192, 256), # exhaustive
|
|
'PSA_KEY_TYPE_CAMELLIA': (128, 192, 256), # exhaustive
|
|
'PSA_KEY_TYPE_CHACHA20': (256,), # exhaustive
|
|
'PSA_KEY_TYPE_DERIVE': (120, 128), # sample
|
|
'PSA_KEY_TYPE_DES': (64, 128, 192), # exhaustive
|
|
'PSA_KEY_TYPE_HMAC': (128, 160, 224, 256, 384, 512), # standard size for each supported hash
|
|
'PSA_KEY_TYPE_PASSWORD': (48, 168, 336), # sample
|
|
'PSA_KEY_TYPE_PASSWORD_HASH': (128, 256), # sample
|
|
'PSA_KEY_TYPE_PEPPER': (128, 256), # sample
|
|
'PSA_KEY_TYPE_RAW_DATA': (8, 40, 128), # sample
|
|
'PSA_KEY_TYPE_RSA_KEY_PAIR': (1024, 1536), # small sample
|
|
} # type: Dict[str, Tuple[int, ...]]
|
|
def sizes_to_test(self) -> Tuple[int, ...]:
|
|
"""Return a tuple of key sizes to test.
|
|
|
|
For key types that only allow a single size, or only a small set of
|
|
sizes, these are all the possible sizes. For key types that allow a
|
|
wide range of sizes, these are a representative sample of sizes,
|
|
excluding large sizes for which a typical resource-constrained platform
|
|
may run out of memory.
|
|
"""
|
|
if self.private_type == 'PSA_KEY_TYPE_ECC_KEY_PAIR':
|
|
assert self.params is not None
|
|
return self.ECC_KEY_SIZES[self.params[0]]
|
|
if self.private_type == 'PSA_KEY_TYPE_DH_KEY_PAIR':
|
|
assert self.params is not None
|
|
return self.DH_KEY_SIZES[self.params[0]]
|
|
return self.KEY_TYPE_SIZES[self.private_type]
|
|
|
|
# "48657265006973206b6579a064617461"
|
|
DATA_BLOCK = b'Here\000is key\240data'
|
|
def key_material(self, bits: int) -> bytes:
|
|
"""Return a byte string containing suitable key material with the given bit length.
|
|
|
|
Use the PSA export representation. The resulting byte string is one that
|
|
can be obtained with the following code:
|
|
```
|
|
psa_set_key_type(&attributes, `self.expression`);
|
|
psa_set_key_bits(&attributes, `bits`);
|
|
psa_set_key_usage_flags(&attributes, PSA_KEY_USAGE_EXPORT);
|
|
psa_generate_key(&attributes, &id);
|
|
psa_export_key(id, `material`, ...);
|
|
```
|
|
"""
|
|
if self.expression in ASYMMETRIC_KEY_DATA:
|
|
if bits not in ASYMMETRIC_KEY_DATA[self.expression]:
|
|
raise ValueError('No key data for {}-bit {}'
|
|
.format(bits, self.expression))
|
|
return ASYMMETRIC_KEY_DATA[self.expression][bits]
|
|
if bits % 8 != 0:
|
|
raise ValueError('Non-integer number of bytes: {} bits for {}'
|
|
.format(bits, self.expression))
|
|
length = bits // 8
|
|
if self.name == 'PSA_KEY_TYPE_DES':
|
|
# "644573206b457901644573206b457902644573206b457904"
|
|
des3 = b'dEs kEy\001dEs kEy\002dEs kEy\004'
|
|
return des3[:length]
|
|
return b''.join([self.DATA_BLOCK] * (length // len(self.DATA_BLOCK)) +
|
|
[self.DATA_BLOCK[:length % len(self.DATA_BLOCK)]])
|
|
|
|
def can_do(self, alg: 'Algorithm') -> bool:
|
|
"""Whether this key type can be used for operations with the given algorithm.
|
|
|
|
This function does not currently handle key derivation or PAKE.
|
|
"""
|
|
#pylint: disable=too-many-branches,too-many-return-statements
|
|
if not alg.is_valid_for_operation():
|
|
return False
|
|
if self.head == 'HMAC' and alg.head == 'HMAC':
|
|
return True
|
|
if self.head == 'DES':
|
|
# 64-bit block ciphers only allow a reduced set of modes.
|
|
return alg.head in [
|
|
'CBC_NO_PADDING', 'CBC_PKCS7',
|
|
'ECB_NO_PADDING',
|
|
]
|
|
if self.head in BLOCK_CIPHERS and \
|
|
alg.head in frozenset.union(BLOCK_MAC_MODES,
|
|
BLOCK_CIPHER_MODES,
|
|
BLOCK_AEAD_MODES):
|
|
if alg.head in ['CMAC', 'OFB'] and \
|
|
self.head in ['ARIA', 'CAMELLIA']:
|
|
return False # not implemented in Mbed TLS
|
|
return True
|
|
if self.head == 'CHACHA20' and alg.head == 'CHACHA20_POLY1305':
|
|
return True
|
|
if self.head in {'ARC4', 'CHACHA20'} and \
|
|
alg.head == 'STREAM_CIPHER':
|
|
return True
|
|
if self.head == 'RSA' and alg.head.startswith('RSA_'):
|
|
return True
|
|
if alg.category == AlgorithmCategory.KEY_AGREEMENT and \
|
|
self.is_public():
|
|
# The PSA API does not use public key objects in key agreement
|
|
# operations: it imports the public key as a formatted byte string.
|
|
# So a public key object with a key agreement algorithm is not
|
|
# a valid combination.
|
|
return False
|
|
if alg.is_invalid_key_agreement_with_derivation():
|
|
return False
|
|
if self.head == 'ECC':
|
|
assert self.params is not None
|
|
eccc = EllipticCurveCategory.from_family(self.params[0])
|
|
if alg.head == 'ECDH' and \
|
|
eccc in {EllipticCurveCategory.SHORT_WEIERSTRASS,
|
|
EllipticCurveCategory.MONTGOMERY}:
|
|
return True
|
|
if alg.head == 'ECDSA' and \
|
|
eccc == EllipticCurveCategory.SHORT_WEIERSTRASS:
|
|
return True
|
|
if alg.head in {'PURE_EDDSA', 'EDDSA_PREHASH'} and \
|
|
eccc == EllipticCurveCategory.TWISTED_EDWARDS:
|
|
return True
|
|
if self.head == 'DH' and alg.head == 'FFDH':
|
|
return True
|
|
return False
|
|
|
|
|
|
class AlgorithmCategory(enum.Enum):
|
|
"""PSA algorithm categories."""
|
|
# The numbers are aligned with the category bits in numerical values of
|
|
# algorithms.
|
|
HASH = 2
|
|
MAC = 3
|
|
CIPHER = 4
|
|
AEAD = 5
|
|
SIGN = 6
|
|
ASYMMETRIC_ENCRYPTION = 7
|
|
KEY_DERIVATION = 8
|
|
KEY_AGREEMENT = 9
|
|
PAKE = 10
|
|
|
|
def requires_key(self) -> bool:
|
|
"""Whether operations in this category are set up with a key."""
|
|
return self not in {self.HASH, self.KEY_DERIVATION}
|
|
|
|
def is_asymmetric(self) -> bool:
|
|
"""Whether operations in this category involve asymmetric keys."""
|
|
return self in {
|
|
self.SIGN,
|
|
self.ASYMMETRIC_ENCRYPTION,
|
|
self.KEY_AGREEMENT
|
|
}
|
|
|
|
|
|
class AlgorithmNotRecognized(Exception):
|
|
def __init__(self, expr: str) -> None:
|
|
super().__init__('Algorithm not recognized: ' + expr)
|
|
self.expr = expr
|
|
|
|
|
|
class Algorithm:
|
|
"""Knowledge about a PSA algorithm."""
|
|
|
|
@staticmethod
|
|
def determine_base(expr: str) -> str:
|
|
"""Return an expression for the "base" of the algorithm.
|
|
|
|
This strips off variants of algorithms such as MAC truncation.
|
|
|
|
This function does not attempt to detect invalid inputs.
|
|
"""
|
|
m = re.match(r'PSA_ALG_(?:'
|
|
r'(?:TRUNCATED|AT_LEAST_THIS_LENGTH)_MAC|'
|
|
r'AEAD_WITH_(?:SHORTENED|AT_LEAST_THIS_LENGTH)_TAG'
|
|
r')\((.*),[^,]+\)\Z', expr)
|
|
if m:
|
|
expr = m.group(1)
|
|
return expr
|
|
|
|
@staticmethod
|
|
def determine_head(expr: str) -> str:
|
|
"""Return the head of an algorithm expression.
|
|
|
|
The head is the first (outermost) constructor, without its PSA_ALG_
|
|
prefix, and with some normalization of similar algorithms.
|
|
"""
|
|
m = re.match(r'PSA_ALG_(?:DETERMINISTIC_)?(\w+)', expr)
|
|
if not m:
|
|
raise AlgorithmNotRecognized(expr)
|
|
head = m.group(1)
|
|
if head == 'KEY_AGREEMENT':
|
|
m = re.match(r'PSA_ALG_KEY_AGREEMENT\s*\(\s*PSA_ALG_(\w+)', expr)
|
|
if not m:
|
|
raise AlgorithmNotRecognized(expr)
|
|
head = m.group(1)
|
|
head = re.sub(r'_ANY\Z', r'', head)
|
|
if re.match(r'ED[0-9]+PH\Z', head):
|
|
head = 'EDDSA_PREHASH'
|
|
return head
|
|
|
|
CATEGORY_FROM_HEAD = {
|
|
'SHA': AlgorithmCategory.HASH,
|
|
'SHAKE256_512': AlgorithmCategory.HASH,
|
|
'MD': AlgorithmCategory.HASH,
|
|
'RIPEMD': AlgorithmCategory.HASH,
|
|
'ANY_HASH': AlgorithmCategory.HASH,
|
|
'HMAC': AlgorithmCategory.MAC,
|
|
'STREAM_CIPHER': AlgorithmCategory.CIPHER,
|
|
'CHACHA20_POLY1305': AlgorithmCategory.AEAD,
|
|
'DSA': AlgorithmCategory.SIGN,
|
|
'ECDSA': AlgorithmCategory.SIGN,
|
|
'EDDSA': AlgorithmCategory.SIGN,
|
|
'PURE_EDDSA': AlgorithmCategory.SIGN,
|
|
'RSA_PSS': AlgorithmCategory.SIGN,
|
|
'RSA_PKCS1V15_SIGN': AlgorithmCategory.SIGN,
|
|
'RSA_PKCS1V15_CRYPT': AlgorithmCategory.ASYMMETRIC_ENCRYPTION,
|
|
'RSA_OAEP': AlgorithmCategory.ASYMMETRIC_ENCRYPTION,
|
|
'HKDF': AlgorithmCategory.KEY_DERIVATION,
|
|
'TLS12_PRF': AlgorithmCategory.KEY_DERIVATION,
|
|
'TLS12_PSK_TO_MS': AlgorithmCategory.KEY_DERIVATION,
|
|
'TLS12_ECJPAKE_TO_PMS': AlgorithmCategory.KEY_DERIVATION,
|
|
'PBKDF': AlgorithmCategory.KEY_DERIVATION,
|
|
'ECDH': AlgorithmCategory.KEY_AGREEMENT,
|
|
'FFDH': AlgorithmCategory.KEY_AGREEMENT,
|
|
# KEY_AGREEMENT(...) is a key derivation with a key agreement component
|
|
'KEY_AGREEMENT': AlgorithmCategory.KEY_DERIVATION,
|
|
'JPAKE': AlgorithmCategory.PAKE,
|
|
}
|
|
for x in BLOCK_MAC_MODES:
|
|
CATEGORY_FROM_HEAD[x] = AlgorithmCategory.MAC
|
|
for x in BLOCK_CIPHER_MODES:
|
|
CATEGORY_FROM_HEAD[x] = AlgorithmCategory.CIPHER
|
|
for x in BLOCK_AEAD_MODES:
|
|
CATEGORY_FROM_HEAD[x] = AlgorithmCategory.AEAD
|
|
|
|
def determine_category(self, expr: str, head: str) -> AlgorithmCategory:
|
|
"""Return the category of the given algorithm expression.
|
|
|
|
This function does not attempt to detect invalid inputs.
|
|
"""
|
|
prefix = head
|
|
while prefix:
|
|
if prefix in self.CATEGORY_FROM_HEAD:
|
|
return self.CATEGORY_FROM_HEAD[prefix]
|
|
if re.match(r'.*[0-9]\Z', prefix):
|
|
prefix = re.sub(r'_*[0-9]+\Z', r'', prefix)
|
|
else:
|
|
prefix = re.sub(r'_*[^_]*\Z', r'', prefix)
|
|
raise AlgorithmNotRecognized(expr)
|
|
|
|
@staticmethod
|
|
def determine_wildcard(expr) -> bool:
|
|
"""Whether the given algorithm expression is a wildcard.
|
|
|
|
This function does not attempt to detect invalid inputs.
|
|
"""
|
|
if re.search(r'\bPSA_ALG_ANY_HASH\b', expr):
|
|
return True
|
|
if re.search(r'_AT_LEAST_', expr):
|
|
return True
|
|
return False
|
|
|
|
def __init__(self, expr: str) -> None:
|
|
"""Analyze an algorithm value.
|
|
|
|
The algorithm must be expressed as a C expression containing only
|
|
calls to PSA algorithm constructor macros and numeric literals.
|
|
|
|
This class is only programmed to handle valid expressions. Invalid
|
|
expressions may result in exceptions or in nonsensical results.
|
|
"""
|
|
self.expression = re.sub(r'\s+', r'', expr)
|
|
self.base_expression = self.determine_base(self.expression)
|
|
self.head = self.determine_head(self.base_expression)
|
|
self.category = self.determine_category(self.base_expression, self.head)
|
|
self.is_wildcard = self.determine_wildcard(self.expression)
|
|
|
|
def get_key_agreement_derivation(self) -> Optional[str]:
|
|
"""For a combined key agreement and key derivation algorithm, get the derivation part.
|
|
|
|
For anything else, return None.
|
|
"""
|
|
if self.category != AlgorithmCategory.KEY_AGREEMENT:
|
|
return None
|
|
m = re.match(r'PSA_ALG_KEY_AGREEMENT\(\w+,\s*(.*)\)\Z', self.expression)
|
|
if not m:
|
|
return None
|
|
kdf_alg = m.group(1)
|
|
# Assume kdf_alg is either a valid KDF or 0.
|
|
if re.match(r'(?:0[Xx])?0+\s*\Z', kdf_alg):
|
|
return None
|
|
return kdf_alg
|
|
|
|
KEY_DERIVATIONS_INCOMPATIBLE_WITH_AGREEMENT = frozenset([
|
|
'PSA_ALG_TLS12_ECJPAKE_TO_PMS', # secret input in specific format
|
|
])
|
|
def is_valid_key_agreement_with_derivation(self) -> bool:
|
|
"""Whether this is a valid combined key agreement and key derivation algorithm."""
|
|
kdf_alg = self.get_key_agreement_derivation()
|
|
if kdf_alg is None:
|
|
return False
|
|
return kdf_alg not in self.KEY_DERIVATIONS_INCOMPATIBLE_WITH_AGREEMENT
|
|
|
|
def is_invalid_key_agreement_with_derivation(self) -> bool:
|
|
"""Whether this is an invalid combined key agreement and key derivation algorithm."""
|
|
kdf_alg = self.get_key_agreement_derivation()
|
|
if kdf_alg is None:
|
|
return False
|
|
return kdf_alg in self.KEY_DERIVATIONS_INCOMPATIBLE_WITH_AGREEMENT
|
|
|
|
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, level=level)
|
|
|
|
HASH_LENGTH = {
|
|
'PSA_ALG_MD5': 16,
|
|
'PSA_ALG_SHA_1': 20,
|
|
}
|
|
HASH_LENGTH_BITS_RE = re.compile(r'([0-9]+)\Z')
|
|
@classmethod
|
|
def hash_length(cls, alg: str) -> int:
|
|
"""The length of the given hash algorithm, in bytes."""
|
|
if alg in cls.HASH_LENGTH:
|
|
return cls.HASH_LENGTH[alg]
|
|
m = cls.HASH_LENGTH_BITS_RE.search(alg)
|
|
if m:
|
|
return int(m.group(1)) // 8
|
|
raise ValueError('Unknown hash length for ' + alg)
|
|
|
|
PERMITTED_TAG_LENGTHS = {
|
|
'PSA_ALG_CCM': frozenset([4, 6, 8, 10, 12, 14, 16]),
|
|
'PSA_ALG_CHACHA20_POLY1305': frozenset([16]),
|
|
'PSA_ALG_GCM': frozenset([4, 8, 12, 13, 14, 15, 16]),
|
|
}
|
|
MAC_LENGTH = {
|
|
'PSA_ALG_CBC_MAC': 16, # actually the block cipher length
|
|
'PSA_ALG_CMAC': 16, # actually the block cipher length
|
|
}
|
|
HMAC_RE = re.compile(r'PSA_ALG_HMAC\((.*)\)\Z')
|
|
@classmethod
|
|
def permitted_truncations(cls, base: str) -> FrozenSet[int]:
|
|
"""Permitted output lengths for the given MAC or AEAD base algorithm.
|
|
|
|
For a MAC algorithm, this is the set of truncation lengths that
|
|
Mbed TLS supports.
|
|
For an AEAD algorithm, this is the set of truncation lengths that
|
|
are permitted by the algorithm specification.
|
|
"""
|
|
if base in cls.PERMITTED_TAG_LENGTHS:
|
|
return cls.PERMITTED_TAG_LENGTHS[base]
|
|
max_length = cls.MAC_LENGTH.get(base, None)
|
|
if max_length is None:
|
|
m = cls.HMAC_RE.match(base)
|
|
if m:
|
|
max_length = cls.hash_length(m.group(1))
|
|
if max_length is None:
|
|
raise ValueError('Unknown permitted lengths for ' + base)
|
|
return frozenset(range(4, max_length + 1))
|
|
|
|
TRUNCATED_ALG_RE = re.compile(
|
|
r'(?P<face>PSA_ALG_(?:AEAD_WITH_SHORTENED_TAG|TRUNCATED_MAC))'
|
|
r'\((?P<base>.*),'
|
|
r'(?P<length>0[Xx][0-9A-Fa-f]+|[1-9][0-9]*|0[0-7]*)[LUlu]*\)\Z')
|
|
def is_invalid_truncation(self) -> bool:
|
|
"""False for a MAC or AEAD algorithm truncated to an invalid length.
|
|
|
|
True for a MAC or AEAD algorithm truncated to a valid length or to
|
|
a length that cannot be determined. True for anything other than
|
|
a truncated MAC or AEAD.
|
|
"""
|
|
m = self.TRUNCATED_ALG_RE.match(self.expression)
|
|
if m:
|
|
base = m.group('base')
|
|
to_length = int(m.group('length'), 0)
|
|
permitted_lengths = self.permitted_truncations(base)
|
|
if to_length not in permitted_lengths:
|
|
return True
|
|
return False
|
|
|
|
def is_valid_for_operation(self) -> bool:
|
|
"""Whether this algorithm construction is valid for an operation.
|
|
|
|
This function assumes that the algorithm is constructed in a
|
|
"grammatically" correct way, and only rejects semantically invalid
|
|
combinations.
|
|
"""
|
|
if self.is_wildcard:
|
|
return False
|
|
if self.is_invalid_truncation():
|
|
return False
|
|
return True
|
|
|
|
def can_do(self, category: AlgorithmCategory) -> bool:
|
|
"""Whether this algorithm can perform operations in the given category.
|
|
"""
|
|
if category == self.category:
|
|
return True
|
|
if category == AlgorithmCategory.KEY_DERIVATION and \
|
|
self.is_valid_key_agreement_with_derivation():
|
|
return True
|
|
return False
|
|
|
|
def usage_flags(self, public: bool = False) -> List[str]:
|
|
"""The list of usage flags describing operations that can perform this algorithm.
|
|
|
|
If public is true, only return public-key operations, not private-key operations.
|
|
"""
|
|
if self.category == AlgorithmCategory.HASH:
|
|
flags = []
|
|
elif self.category == AlgorithmCategory.MAC:
|
|
flags = ['SIGN_HASH', 'SIGN_MESSAGE',
|
|
'VERIFY_HASH', 'VERIFY_MESSAGE']
|
|
elif self.category == AlgorithmCategory.CIPHER or \
|
|
self.category == AlgorithmCategory.AEAD:
|
|
flags = ['DECRYPT', 'ENCRYPT']
|
|
elif self.category == AlgorithmCategory.SIGN:
|
|
flags = ['VERIFY_HASH', 'VERIFY_MESSAGE']
|
|
if not public:
|
|
flags += ['SIGN_HASH', 'SIGN_MESSAGE']
|
|
elif self.category == AlgorithmCategory.ASYMMETRIC_ENCRYPTION:
|
|
flags = ['ENCRYPT']
|
|
if not public:
|
|
flags += ['DECRYPT']
|
|
elif self.category == AlgorithmCategory.KEY_DERIVATION or \
|
|
self.category == AlgorithmCategory.KEY_AGREEMENT:
|
|
flags = ['DERIVE']
|
|
else:
|
|
raise AlgorithmNotRecognized(self.expression)
|
|
return ['PSA_KEY_USAGE_' + flag for flag in flags]
|