mirror of
https://github.com/Mbed-TLS/mbedtls.git
synced 2025-01-30 06:33:06 +00:00
Merge remote-tracking branch 'origin/development' into msft-aarch64
This commit is contained in:
Dave Rodgman
commit
b351d60e99
3
ChangeLog.d/8372.txt
Normal file
3
ChangeLog.d/8372.txt
Normal file
@ -0,0 +1,3 @@
|
||||
Features
|
||||
* AES-NI is now supported in Windows builds with clang and clang-cl.
|
||||
Resolves #8372.
|
||||
2
ChangeLog.d/fix-linux-builds-in-conda-forge.txt
Normal file
2
ChangeLog.d/fix-linux-builds-in-conda-forge.txt
Normal file
@ -0,0 +1,2 @@
|
||||
Bugfix
|
||||
* Fix build failure in conda-forge. Fixes #8422.
|
||||
@ -1,9 +1,16 @@
|
||||
Thread safety of the PSA subsystem
|
||||
==================================
|
||||
# Thread safety of the PSA subsystem
|
||||
|
||||
## Requirements
|
||||
Currently PSA Crypto API calls in Mbed TLS releases are not thread-safe. In Mbed TLS 3.6 we are planning to add a minimal support for thread-safety of the PSA Crypto API (see section [Strategy for 3.6](#strategy-for-36)).
|
||||
|
||||
### Backward compatibility requirement
|
||||
In the [Design analysis](#design-analysis) section we analyse design choices. This discussion is not constrained to what is planned for 3.6 and considers future developments. It also leaves some questions open and discusses options that have been (or probably will be) rejected.
|
||||
|
||||
## Design analysis
|
||||
|
||||
This section explores possible designs and does not reflect what is currently implemented.
|
||||
|
||||
### Requirements
|
||||
|
||||
#### Backward compatibility requirement
|
||||
|
||||
Code that is currently working must keep working. There can be an exception for code that uses features that are advertised as experimental; for example, it would be annoying but ok to add extra requirements for drivers.
|
||||
|
||||
@ -18,7 +25,7 @@ Tempting platform requirements that we cannot add to the default `MBEDTLS_THREAD
|
||||
* Releasing a mutex from a different thread than the one that acquired it. This isn't even guaranteed to work with pthreads.
|
||||
* New primitives such as semaphores or condition variables.
|
||||
|
||||
### Correctness out of the box
|
||||
#### Correctness out of the box
|
||||
|
||||
If you build with `MBEDTLS_PSA_CRYPTO_C` and `MBEDTLS_THREADING_C`, the code must be functionally correct: no race conditions, deadlocks or livelocks.
|
||||
|
||||
@ -31,7 +38,7 @@ The [PSA Crypto API specification](https://armmbed.github.io/mbed-crypto/html/ov
|
||||
|
||||
Note that while the specification does not define the behavior in such cases, Mbed TLS can be used as a crypto service. It's acceptable if an application can mess itself up, but it is not acceptable if an application can mess up the crypto service. As a consequence, destroying a key while it's in use may violate the security property that all key material is erased as soon as `psa_destroy_key` returns, but it may not cause data corruption or read-after-free inside the key store.
|
||||
|
||||
### No spinning
|
||||
#### No spinning
|
||||
|
||||
The code must not spin on a potentially non-blocking task. For example, this is proscribed:
|
||||
```
|
||||
@ -44,22 +51,22 @@ while (!its_my_turn) {
|
||||
|
||||
Rationale: this can cause battery drain, and can even be a livelock (spinning forever), e.g. if the thread that might unblock this one has a lower priority.
|
||||
|
||||
### Driver requirements
|
||||
#### Driver requirements
|
||||
|
||||
At the time of writing, the driver interface specification does not consider multithreaded environments.
|
||||
|
||||
We need to define clear policies so that driver implementers know what to expect. Here are two possible policies at two ends of the spectrum; what is desirable is probably somewhere in between.
|
||||
|
||||
* Driver entry points may be called concurrently from multiple threads, even if they're using the same key, and even including destroying a key while an operation is in progress on it.
|
||||
* At most one driver entry point is active at any given time.
|
||||
* **Policy 1:** Driver entry points may be called concurrently from multiple threads, even if they're using the same key, and even including destroying a key while an operation is in progress on it.
|
||||
* **Policy 2:** At most one driver entry point is active at any given time.
|
||||
|
||||
A more reasonable policy could be:
|
||||
Combining the two we arrive at **Policy 3**:
|
||||
|
||||
* By default, each driver only has at most one entry point active at any given time. In other words, each driver has its own exclusive lock.
|
||||
* Drivers have an optional `"thread_safe"` boolean property. If true, it allows concurrent calls to this driver.
|
||||
* Even with a thread-safe driver, the core never starts the destruction of a key while there are operations in progress on it, and never performs concurrent calls on the same multipart operation.
|
||||
|
||||
### Long-term performance requirements
|
||||
#### Long-term performance requirements
|
||||
|
||||
In the short term, correctness is the important thing. We can start with a global lock.
|
||||
|
||||
@ -67,9 +74,9 @@ In the medium to long term, performing a slow or blocking operation (for example
|
||||
|
||||
We may want to go directly to a more sophisticated approach because when a system works with a global lock, it's typically hard to get rid of it to get more fine-grained concurrency.
|
||||
|
||||
### Key destruction short-term requirements
|
||||
#### Key destruction short-term requirements
|
||||
|
||||
#### Summary of guarantees in the short term
|
||||
##### Summary of guarantees in the short term
|
||||
|
||||
When `psa_destroy_key` returns:
|
||||
|
||||
@ -79,11 +86,11 @@ When `psa_destroy_key` returns:
|
||||
|
||||
When `psa_destroy_key` is called on a key that is in use, guarantee 2. might be violated. (This is consistent with the requirement [“Correctness out of the box”](#correctness-out-of-the-box), as destroying a key while it's in use is undefined behavior.)
|
||||
|
||||
### Key destruction long-term requirements
|
||||
#### Key destruction long-term requirements
|
||||
|
||||
The [PSA Crypto API specification](https://armmbed.github.io/mbed-crypto/html/api/keys/management.html#key-destruction) mandates that implementations make a best effort to ensure that the key material cannot be recovered. In the long term, it would be good to guarantee that `psa_destroy_key` wipes all copies of the key material.
|
||||
|
||||
#### Summary of guarantees in the long term
|
||||
##### Summary of guarantees in the long term
|
||||
|
||||
When `psa_destroy_key` returns:
|
||||
|
||||
@ -94,11 +101,11 @@ When `psa_destroy_key` returns:
|
||||
|
||||
As opposed to the short term requirements, all the above guarantees hold even if `psa_destroy_key` is called on a key that is in use.
|
||||
|
||||
## Resources to protect
|
||||
### Resources to protect
|
||||
|
||||
Analysis of the behavior of the PSA key store as of Mbed TLS 9202ba37b19d3ea25c8451fd8597fce69eaa6867.
|
||||
|
||||
### Global variables
|
||||
#### Global variables
|
||||
|
||||
* `psa_crypto_slot_management::global_data.key_slots[i]`: see [“Key slots”](#key-slots).
|
||||
|
||||
@ -120,9 +127,9 @@ Analysis of the behavior of the PSA key store as of Mbed TLS 9202ba37b19d3ea25c8
|
||||
* `psa_crypto_init`: modification.
|
||||
* Many functions via `GUARD_MODULE_INITIALIZED`: read.
|
||||
|
||||
### Key slots
|
||||
#### Key slots
|
||||
|
||||
#### Key slot array traversal
|
||||
##### Key slot array traversal
|
||||
|
||||
“Occupied key slot” is determined by `psa_is_key_slot_occupied` based on `slot->attr.type`.
|
||||
|
||||
@ -136,7 +143,7 @@ The following functions traverse the key slot array:
|
||||
* `psa_wipe_all_key_slots`: writes to all slots.
|
||||
* `mbedtls_psa_get_stats`: reads from all slots.
|
||||
|
||||
#### Key slot state
|
||||
##### Key slot state
|
||||
|
||||
The following functions modify a slot's usage state:
|
||||
|
||||
@ -194,13 +201,15 @@ The following functions modify a slot's usage state:
|
||||
* `psa_key_derivation_input_key` - reads attr.type
|
||||
* `psa_key_agreement_raw_internal` - reads attr.type and attr.bits
|
||||
|
||||
#### Determining whether a key slot is occupied
|
||||
##### Determining whether a key slot is occupied
|
||||
|
||||
`psa_is_key_slot_occupied` currently uses the `attr.type` field to determine whether a key slot is occupied. This works because we maintain the invariant that an occupied slot contains key material. With concurrency, it is desirable to allow a key slot to be reserved, but not yet contain key material or even metadata. When creating a key, determining the key type can be costly, for example when loading a persistent key from storage or (not yet implemented) when importing or unwrapping a key using an interface that determines the key type from the data that it parses. So we should not need to hold the global key store lock while the key type is undetermined.
|
||||
|
||||
Instead, `psa_is_key_slot_occupied` should use the key identifier to decide whether a slot is occupied. The key identifier is always readily available: when allocating a slot for a persistent key, it's an input of the function that allocates the key slot; when allocating a slot for a volatile key, the identifier is calculated from the choice of slot.
|
||||
|
||||
#### Key slot content
|
||||
Alternatively, we could use a dedicated indicator that the slot is occupied. The advantage of this is that no field of the `attr` structure would be needed to determine the slot state. This would be a clean separation between key attributes and slot state and `attr` could be treated exactly like key slot content. This would save code size and maintenance effort. The cost of it would be that each slot would need an extra field to indicate whether it is occupied.
|
||||
|
||||
##### Key slot content
|
||||
|
||||
Other than what is used to determine the [“key slot state”](#key-slot-state), the contents of a key slot are only accessed as follows:
|
||||
|
||||
@ -236,7 +245,7 @@ Other than what is used to determine the [“key slot state”](#key-slot-state)
|
||||
* `psa_key_agreement_raw_internal` - passes key data to mbedtls_psa_ecp_load_representation
|
||||
* `psa_generate_key` - passes key data to psa_driver_wrapper_generate_key
|
||||
|
||||
### Random generator
|
||||
#### Random generator
|
||||
|
||||
The PSA RNG can be accessed both from various PSA functions, and from application code via `mbedtls_psa_get_random`.
|
||||
|
||||
@ -244,11 +253,11 @@ With the built-in RNG implementations using `mbedtls_ctr_drbg_context` or `mbedt
|
||||
|
||||
When `MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG` is enabled, thread safety depends on the implementation.
|
||||
|
||||
### Driver resources
|
||||
#### Driver resources
|
||||
|
||||
Depends on the driver. The PSA driver interface specification does not discuss whether drivers must support concurrent calls.
|
||||
|
||||
## Simple global lock strategy
|
||||
### Simple global lock strategy
|
||||
|
||||
Have a single mutex protecting all accesses to the key store and other global variables. In practice, this means every PSA API function needs to take the lock on entry and release on exit, except for:
|
||||
|
||||
@ -261,7 +270,7 @@ Note that this does not protect access to the RNG via `mbedtls_psa_get_random`,
|
||||
|
||||
This approach is conceptually simple, but requires extra instrumentation to every function and has bad performance in a multithreaded environment since a slow operation in one thread blocks unrelated operations on other threads.
|
||||
|
||||
## Global lock excluding slot content
|
||||
### Global lock excluding slot content
|
||||
|
||||
Have a single mutex protecting all accesses to the key store and other global variables, except that it's ok to access the content of a key slot without taking the lock if one of the following conditions holds:
|
||||
|
||||
@ -270,7 +279,7 @@ Have a single mutex protecting all accesses to the key store and other global va
|
||||
|
||||
Note that a thread must hold the global mutex when it reads or changes a slot's state.
|
||||
|
||||
### Slot states
|
||||
#### Slot states
|
||||
|
||||
For concurrency purposes, a slot can be in one of three states:
|
||||
|
||||
@ -285,16 +294,129 @@ A high-level view of state transitions:
|
||||
* `psa_unlock_key_slot`: READING → UNUSED or READING.
|
||||
* `psa_finish_key_creation`: WRITING → READING.
|
||||
* `psa_fail_key_creation`: WRITING → UNUSED.
|
||||
* `psa_wipe_key_slot`: any → UNUSED. If the slot is READING or WRITING on entry, this function must wait until the writer or all readers have finished. (By the way, the WRITING state is possible if `mbedtls_psa_crypto_free` is called while a key creation is in progress.) See [“Destruction of a key in use”](#destruction of a key in use).
|
||||
* `psa_wipe_key_slot`: any → UNUSED. If the slot is READING or WRITING on entry, this function must wait until the writer or all readers have finished. (By the way, the WRITING state is possible if `mbedtls_psa_crypto_free` is called while a key creation is in progress.) See [“Destruction of a key in use”](#destruction-of-a-key-in-use).
|
||||
|
||||
The current `state->lock_count` corresponds to the difference between UNUSED and READING: a slot is in use iff its lock count is nonzero, so `lock_count == 0` corresponds to UNUSED and `lock_count != 0` corresponds to READING.
|
||||
|
||||
There is currently no indication of when a slot is in the WRITING state. This only happens between a call to `psa_start_key_creation` and a call to one of `psa_finish_key_creation` or `psa_fail_key_creation`. This new state can be conveyed by a new boolean flag, or by setting `lock_count` to `~0`.
|
||||
|
||||
### Destruction of a key in use
|
||||
#### Destruction of a key in use
|
||||
|
||||
Problem: a key slot is destroyed (by `psa_wipe_key_slot`) while it's in use (READING or WRITING).
|
||||
Problem: In [Key destruction long-term requirements](#key-destruction-long-term-requirements) we require that the key slot is destroyed (by `psa_wipe_key_slot`) even while it's in use (READING or WRITING).
|
||||
|
||||
TODO: how do we ensure that? This needs something more sophisticated than mutexes (concurrency number >2)! Even a per-slot mutex isn't enough (we'd need a reader-writer lock).
|
||||
How do we ensure that? This needs something more sophisticated than mutexes (concurrency number >2)! Even a per-slot mutex isn't enough (we'd need a reader-writer lock).
|
||||
|
||||
Solution: after some team discussion, we've decided to rely on a new threading abstraction which mimics C11 (i.e. `mbedtls_fff` where `fff` is the C11 function name, having the same parameters and return type, with default implementations for C11, pthreads and Windows). We'll likely use condition variables in addition to mutexes.
|
||||
|
||||
##### Mutex only
|
||||
|
||||
When calling `psa_wipe_key_slot` it is the callers responsibility to set the slot state to WRITING first. For most functions this is a clean UNUSED -> WRITING transition: psa_get_empty_key_slot, psa_get_and_lock_key_slot, psa_close_key, psa_purge_key.
|
||||
|
||||
`psa_wipe_all_key_slots` is only called from `mbedtls_psa_crypto_free`, here we will need to return an error as we won't be able to free the key store if a key is in use without compromising the state of the secure side. This is acceptable as an untrusted application cannot call `mbedtls_psa_crypto_free` in a crypto service. In a service integration, `mbedtls_psa_crypto_free` on the client cuts the communication with the crypto service. Also, this is the current behaviour.
|
||||
|
||||
`psa_destroy_key` marks the slot as deleted, deletes persistent keys and opaque keys and returns. This only works if drivers are protected by a mutex (and the persistent storage as well if needed). When the last reading operation finishes, it wipes the key slot. This will free the key ID, but the slot might be still in use. In case of volatile keys freeing up the ID while the slot is still in use does not provide any benefit and we don't need to do it.
|
||||
|
||||
These are serious limitations, but this can be implemented with mutexes only and arguably satisfies the [Key destruction short-term requirements](#key-destruction-short-term-requirements).
|
||||
|
||||
Variations:
|
||||
|
||||
1. As a first step the multipart operations would lock the keys for reading on setup and release on free
|
||||
2. In a later stage this would be improved by locking the keys on entry into multi-part API calls and released before exiting.
|
||||
|
||||
The second variant can't be implemented as a backward compatible improvement on the first as multipart operations that were successfully completed in the first case, would fail in the second. If we want to implement these incrementally, multipart operations in a multithreaded environment must be left unsupported in the first variant. This makes the first variant impractical (multipart operations returning an error in builds with multithreading enabled is not a behaviour that would be very useful to release).
|
||||
|
||||
We can't reuse the `lock_count` field to mark key slots deleted, as we still need to keep track the lock count while the slot is marked for deletion. This means that we will need to add a new field to key slots. This new field can be reused to indicate whether the slot is occupied (see section [Determining whether a key slot is occupied](#determining-whether-a-key-slot-is-occupied)). (There would be three states: deleted, occupied, empty.)
|
||||
|
||||
#### Condition variables
|
||||
|
||||
Clean UNUSED -> WRITING transition works as before.
|
||||
|
||||
`psa_wipe_all_key_slots` and `psa_destroy_key` mark the slot as deleted and go to sleep until the slot state becomes UNUSED. When waking up, they wipe the slot, and return.
|
||||
|
||||
If the slot is already marked as deleted the threads calling `psa_wipe_all_key_slots` and `psa_destroy_key` go to sleep until the deletion completes. To satisfy [Key destruction long-term requirements](#key-destruction-long-term-requirements) none of the threads may return from the call until the slot is deleted completely. This can be achieved by signalling them when the slot has already been wiped and ready for use, that is not marked for deletion anymore. To handle spurious wake-ups, these threads need to be able to tell whether the slot was already deleted. This is not trivial, because by the time the thread wakes up, theoretically the slot might be in any state. It might have been reused and maybe even marked for deletion again.
|
||||
|
||||
To resolve this, we can either:
|
||||
|
||||
1. Depend on the deletion marker. If the slot has been reused and is marked for deletion again, the threads keep waiting until the second deletion completes.
|
||||
2. Introduce a uuid (eg a global counter plus a slot ID), which is recorded by the thread waiting for deletion and checks whether it matches. If it doesn't, the function can return as the slot was already reallocated. If it does match, it can check whether it is still marked for deletion, if it is, the thread goes back to sleep, if it isn't, the function can return.
|
||||
|
||||
##### Platform abstraction
|
||||
|
||||
Introducing condition variables to the platform abstraction layer would be best done in a major version. If we can't wait until that, we will need to introduce a new compile time flag. Considering that this only will be needed on the PSA Crypto side and the upcoming split, it makes sense to make this flag responsible for the entire PSA Crypto threading support. Therefore if we want to keep the option open for implementing this in a backward compatible manner, we need to introduce and use this new flag already when implementing [Mutex only](#mutex-only). (If we keep the abstraction layer for mutexes the same, this shouldn't mean increase in code size and would mean only minimal effort on the porting side.)
|
||||
|
||||
#### Operation contexts
|
||||
|
||||
Concurrent access to the same operation context can compromise the crypto service for example if the operation context has a pointer (depending on the compiler and the platform, the pointer assignment may or may not be atomic). This violates the functional correctness requirement of the crypto service. (Concurrent calls to operations is undefined behaviour, but still should not compromise the CIA of the crypto service.)
|
||||
|
||||
If we want to protect against this in the library, operations will need a status field protected by a global mutex similarly to key slots. On entry, API calls would check the state and return an error if it is already ACTIVE. Otherwise they set it to ACTIVE and restore it to INACTIVE before returning.
|
||||
|
||||
Alternatively, protecting operation contexts can be left as the responsibility of the crypto service. The [PSA Crypto API Specification](https://arm-software.github.io/psa-api/crypto/1.1/overview/conventions.html#concurrent-calls) does not require the library to provide any protection in this case. A crypto service can easily add its own mutex in its operation structure wrapper (the same structure where it keeps track of which client connection owns that operation object).
|
||||
|
||||
#### Drivers
|
||||
|
||||
Each driver that hasn’t got the "thread_safe” property set has a dedicated mutex.
|
||||
|
||||
Implementing "thread_safe” drivers depends on the condition variable protection in the key store, as we must guarantee that the core never starts the destruction of a key while there are operations in progress on it.
|
||||
|
||||
Start with implementing threading for drivers without the "thread_safe” property (all drivers behave like the property wasn't set). Add "thread_safe" drivers at some point after the [Condition variables](#condition-variables) approach is implemented in the core.
|
||||
|
||||
##### Reentrancy
|
||||
|
||||
It is natural sometimes to want to perform cryptographic operations from a driver, for example calculating a hash as part of various other crypto primitives, or using a block cipher in a driver for a mode, etc. Also encrypting/authenticating communication with a secure element.
|
||||
|
||||
**Non-thread-safe drivers:**
|
||||
|
||||
A driver is non-thread-safe if the `thread-safe` property (see [Driver requirements](#driver-requirements)) is set to false.
|
||||
|
||||
In the non-thread-safe case we have these natural assumptions/requirements:
|
||||
1. Drivers don't call the core for any operation for which they provide an entry point
|
||||
2. The core doesn't hold the driver mutex between calls to entry points
|
||||
|
||||
With these, the only way of a deadlock is when we have several drivers and they have circular dependencies. That is, Driver A makes a call that is despatched to Driver B and upon executing that Driver B makes a call that is despatched to Driver A. For example Driver A does CCM calls Driver B to do CBC-MAC, which in turn calls Driver A to do AES. This example is pretty contrived and it is hard to find a more practical example.
|
||||
|
||||
Potential ways for resolving this:
|
||||
1. Non-thread-safe drivers must not call the core
|
||||
2. Provide a new public API that drivers can safely call
|
||||
3. Make the dispatch layer public for drivers to call
|
||||
4. There is a whitelist of core APIs that drivers can call. Drivers providing entry points to these must not make a call to the core when handling these calls. (Drivers are still allowed to call any core API that can't have a driver entry point.)
|
||||
|
||||
The first is too restrictive, the second and the third would require making it a stable API, and would likely increase the code size for a relatively rare feature. We are choosing the fourth as that is the most viable option.
|
||||
|
||||
**Thread-safe drivers:**
|
||||
|
||||
A driver is non-thread-safe if the `thread-safe` property (see [Driver requirements](#driver-requirements)) is set to true.
|
||||
|
||||
To make reentrancy in non-thread-safe drivers work, thread-safe drivers must not make a call to the core when handling a call that is on the non-thread-safe driver core API whitelist.
|
||||
|
||||
Thread-safe drivers have less guarantees from the core and need to implement more complex logic and we can reasonably expect them to be more flexible in terms of reentrancy as well. At this point it is hard to see what further guarantees would be useful and feasible. Therefore, we don't provide any further guarantees for now.
|
||||
|
||||
Thread-safe drivers must not make any assumption about the operation of the core beyond what is discussed in the [Reentrancy](#reentrancy) and [Driver requirements](#driver-requirements) sections.
|
||||
|
||||
#### Global data
|
||||
|
||||
PSA Crypto makes use of a `global_data` variable that will be accessible from multiple threads and needs to be protected. Any function accessing this variable (or its members) must take the corresponding lock first. Since `global_data` holds the RNG state, these will involve relatively expensive operations and therefore ideally `global_data` should be protected by its own, dedicated lock (different from the one protecting the key store).
|
||||
|
||||
Note that this does not protect access to the RNG via `mbedtls_psa_get_random`, which is guaranteed to be thread-safe when `MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG` is disabled. Still, doing so is conceptually simpler and we probably will want to remove the lower level mutex in the long run, since the corresponding interface will be removed from the public API. The two mutexes are different and are always taken in the same order, there is no risk of deadlock.
|
||||
|
||||
The purpose of `MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG` is very similar to the driver interface (and might even be added to it in the long run), therefore it makes sense to handle it the same way. In particular, we can use the `global_data` mutex to protect it as a default and when we implement the "thread_safe” property for drivers, we implement it for `MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG` as well.
|
||||
|
||||
#### Implementation notes
|
||||
|
||||
Since we only have simple mutexes, locking the same mutex from the same thread is a deadlock. Therefore functions taking the global mutex must not be called while holding the same mutex. Functions taking the mutex will document this fact and the implications.
|
||||
|
||||
Releasing the mutex before a function call might introduce race conditions. Therefore might not be practical to take the mutex in low level access functions. If functions like that don't take the mutex, they need to rely on the caller to take it for them. These functions will document that the caller is required to hold the mutex.
|
||||
|
||||
To avoid performance degradation, functions must hold mutexes for as short time as possible. In particular, they must not start expensive operations (eg. doing cryptography) while holding the mutex.
|
||||
|
||||
## Strategy for 3.6
|
||||
|
||||
The goal is to provide viable threading support without extending the platform abstraction. (Condition variables should be added in 4.0.) This means that we will be relying on mutexes only.
|
||||
|
||||
- Key Store
|
||||
- Slot states are described in the [Slot states](#slot-states) section. They guarantee safe concurrent access to slot contents.
|
||||
- Slot states will be protected by a global mutex as described in the introduction of the [Global lock excluding slot content](#global-lock-excluding-slot-content) section.
|
||||
- Simple key destruction strategy as described in the [Mutex only](#mutex-only) section (variant 2).
|
||||
- The slot state and key attributes will be separated as described in the last paragraph of the [Determining whether a key slot is occupied](#determining-whether-a-key-slot-is-occupied) section.
|
||||
- The main `global_data` (the one in `psa_crypto.c`) shall be protected by its own mutex as described in the [Global data](#global-data) section.
|
||||
- The solution shall use the pre-existing `MBEDTLS_THREADING_C` threading abstraction. That is, the flag proposed in the [Platform abstraction](#platform-abstraction) section won't be implemented.
|
||||
- The core makes no additional guarantees for drivers. That is, Policy 1 in section [Driver requirements](#driver-requirements) applies.
|
||||
|
||||
@ -4,7 +4,7 @@ Migrating to an auto generated psa_crypto_driver_wrappers.h file
|
||||
This document describes how to migrate to the auto generated psa_crypto_driver_wrappers.h file.
|
||||
It is meant to give the library user migration guidelines while the Mbed TLS project tides over multiple minor revs of version 1.0, after which this will be merged into psa-driver-interface.md.
|
||||
|
||||
For a practical guide with a description of the current state of drivers Mbed TLS, see our [PSA Cryptoprocessor driver development examples](../psa-driver-example-and-guide.html).
|
||||
For a practical guide with a description of the current state of drivers Mbed TLS, see our [PSA Cryptoprocessor driver development examples](../psa-driver-example-and-guide.md).
|
||||
|
||||
## Introduction
|
||||
|
||||
|
||||
@ -766,7 +766,9 @@
|
||||
#error "MBEDTLS_PSA_CRYPTO_C defined, but not all prerequisites (missing RNG)"
|
||||
#endif
|
||||
|
||||
#if defined(MBEDTLS_PSA_CRYPTO_C) && !defined(MBEDTLS_CIPHER_C )
|
||||
#if defined(MBEDTLS_PSA_CRYPTO_C) && \
|
||||
(defined(PSA_HAVE_SOFT_BLOCK_CIPHER) || defined(PSA_HAVE_SOFT_BLOCK_AEAD)) && \
|
||||
!defined(MBEDTLS_CIPHER_C)
|
||||
#error "MBEDTLS_PSA_CRYPTO_C defined, but not all prerequisites"
|
||||
#endif
|
||||
|
||||
|
||||
@ -238,9 +238,12 @@
|
||||
|
||||
#if defined(MBEDTLS_CHACHA20_C)
|
||||
#define PSA_WANT_KEY_TYPE_CHACHA20 1
|
||||
#define PSA_WANT_ALG_STREAM_CIPHER 1
|
||||
#define MBEDTLS_PSA_BUILTIN_KEY_TYPE_CHACHA20 1
|
||||
/* ALG_STREAM_CIPHER requires CIPHER_C in order to be supported in PSA */
|
||||
#if defined(MBEDTLS_CIPHER_C)
|
||||
#define PSA_WANT_ALG_STREAM_CIPHER 1
|
||||
#define MBEDTLS_PSA_BUILTIN_ALG_STREAM_CIPHER 1
|
||||
#endif
|
||||
#if defined(MBEDTLS_CHACHAPOLY_C)
|
||||
#define PSA_WANT_ALG_CHACHA20_POLY1305 1
|
||||
#define MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305 1
|
||||
|
||||
@ -1840,7 +1840,7 @@ struct mbedtls_ssl_context {
|
||||
* and #MBEDTLS_SSL_CID_DISABLED. */
|
||||
#endif /* MBEDTLS_SSL_DTLS_CONNECTION_ID */
|
||||
|
||||
#if defined(MBEDTLS_SSL_EARLY_DATA) && defined(MBEDTLS_SSL_CLI_C)
|
||||
#if defined(MBEDTLS_SSL_EARLY_DATA)
|
||||
int MBEDTLS_PRIVATE(early_data_status);
|
||||
#endif /* MBEDTLS_SSL_EARLY_DATA && MBEDTLS_SSL_CLI_C */
|
||||
|
||||
@ -5013,6 +5013,10 @@ int mbedtls_ssl_close_notify(mbedtls_ssl_context *ssl);
|
||||
|
||||
#if defined(MBEDTLS_SSL_EARLY_DATA)
|
||||
|
||||
#define MBEDTLS_SSL_EARLY_DATA_STATUS_NOT_SENT 0
|
||||
#define MBEDTLS_SSL_EARLY_DATA_STATUS_ACCEPTED 1
|
||||
#define MBEDTLS_SSL_EARLY_DATA_STATUS_REJECTED 2
|
||||
|
||||
#if defined(MBEDTLS_SSL_SRV_C)
|
||||
/**
|
||||
* \brief Read at most 'len' application data bytes while performing
|
||||
@ -5122,9 +5126,6 @@ int mbedtls_ssl_read_early_data(mbedtls_ssl_context *ssl,
|
||||
int mbedtls_ssl_write_early_data(mbedtls_ssl_context *ssl,
|
||||
const unsigned char *buf, size_t len);
|
||||
|
||||
#define MBEDTLS_SSL_EARLY_DATA_STATUS_NOT_SENT 0
|
||||
#define MBEDTLS_SSL_EARLY_DATA_STATUS_ACCEPTED 1
|
||||
#define MBEDTLS_SSL_EARLY_DATA_STATUS_REJECTED 2
|
||||
/**
|
||||
* \brief Get the status of the negotiation of the use of early data.
|
||||
*
|
||||
|
||||
@ -43,6 +43,17 @@
|
||||
#include <immintrin.h>
|
||||
#endif
|
||||
|
||||
#if defined(MBEDTLS_ARCH_IS_X86)
|
||||
#if defined(MBEDTLS_COMPILER_IS_GCC)
|
||||
#pragma GCC push_options
|
||||
#pragma GCC target ("pclmul,sse2,aes")
|
||||
#define MBEDTLS_POP_TARGET_PRAGMA
|
||||
#elif defined(__clang__)
|
||||
#pragma clang attribute push (__attribute__((target("pclmul,sse2,aes"))), apply_to=function)
|
||||
#define MBEDTLS_POP_TARGET_PRAGMA
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if !defined(MBEDTLS_AES_USE_HARDWARE_ONLY)
|
||||
/*
|
||||
* AES-NI support detection routine
|
||||
@ -189,7 +200,7 @@ void mbedtls_aesni_gcm_mult(unsigned char c[16],
|
||||
const unsigned char a[16],
|
||||
const unsigned char b[16])
|
||||
{
|
||||
__m128i aa, bb, cc, dd;
|
||||
__m128i aa = { 0 }, bb = { 0 }, cc, dd;
|
||||
|
||||
/* The inputs are in big-endian order, so byte-reverse them */
|
||||
for (size_t i = 0; i < 16; i++) {
|
||||
@ -398,6 +409,15 @@ static void aesni_setkey_enc_256(unsigned char *rk_bytes,
|
||||
}
|
||||
#endif /* !MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH */
|
||||
|
||||
#if defined(MBEDTLS_POP_TARGET_PRAGMA)
|
||||
#if defined(__clang__)
|
||||
#pragma clang attribute pop
|
||||
#elif defined(__GNUC__)
|
||||
#pragma GCC pop_options
|
||||
#endif
|
||||
#undef MBEDTLS_POP_TARGET_PRAGMA
|
||||
#endif
|
||||
|
||||
#else /* MBEDTLS_AESNI_HAVE_CODE == 1 */
|
||||
|
||||
#if defined(__has_feature)
|
||||
|
||||
@ -39,7 +39,7 @@
|
||||
* (Only implemented with certain compilers, only for certain targets.)
|
||||
*/
|
||||
#undef MBEDTLS_AESNI_HAVE_INTRINSICS
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(_MSC_VER) && !defined(__clang__)
|
||||
/* Visual Studio supports AESNI intrinsics since VS 2008 SP1. We only support
|
||||
* VS 2013 and up for other reasons anyway, so no need to check the version. */
|
||||
#define MBEDTLS_AESNI_HAVE_INTRINSICS
|
||||
@ -47,7 +47,11 @@
|
||||
/* GCC-like compilers: currently, we only support intrinsics if the requisite
|
||||
* target flag is enabled when building the library (e.g. `gcc -mpclmul -msse2`
|
||||
* or `clang -maes -mpclmul`). */
|
||||
#if defined(__GNUC__) && defined(__AES__) && defined(__PCLMUL__)
|
||||
#if (defined(__GNUC__) || defined(__clang__)) && defined(__AES__) && defined(__PCLMUL__)
|
||||
#define MBEDTLS_AESNI_HAVE_INTRINSICS
|
||||
#endif
|
||||
/* For 32-bit, we only support intrinsics */
|
||||
#if defined(MBEDTLS_ARCH_IS_X86) && (defined(__GNUC__) || defined(__clang__))
|
||||
#define MBEDTLS_AESNI_HAVE_INTRINSICS
|
||||
#endif
|
||||
|
||||
@ -60,13 +64,11 @@
|
||||
#if defined(MBEDTLS_AESNI_HAVE_INTRINSICS)
|
||||
#define MBEDTLS_AESNI_HAVE_CODE 2 // via intrinsics
|
||||
#elif defined(MBEDTLS_HAVE_ASM) && \
|
||||
defined(__GNUC__) && defined(MBEDTLS_ARCH_IS_X64)
|
||||
(defined(__GNUC__) || defined(__clang__)) && defined(MBEDTLS_ARCH_IS_X64)
|
||||
/* Can we do AESNI with inline assembly?
|
||||
* (Only implemented with gas syntax, only for 64-bit.)
|
||||
*/
|
||||
#define MBEDTLS_AESNI_HAVE_CODE 1 // via assembly
|
||||
#elif defined(__GNUC__)
|
||||
# error "Must use `-mpclmul -msse2 -maes` for MBEDTLS_AESNI_C"
|
||||
#else
|
||||
#error "MBEDTLS_AESNI_C defined, but neither intrinsics nor assembly available"
|
||||
#endif
|
||||
|
||||
@ -263,8 +263,11 @@ int mbedtls_cipher_setup(mbedtls_cipher_context_t *ctx,
|
||||
|
||||
memset(ctx, 0, sizeof(mbedtls_cipher_context_t));
|
||||
|
||||
if (NULL == (ctx->cipher_ctx = mbedtls_cipher_get_base(cipher_info)->ctx_alloc_func())) {
|
||||
return MBEDTLS_ERR_CIPHER_ALLOC_FAILED;
|
||||
if (mbedtls_cipher_get_base(cipher_info)->ctx_alloc_func != NULL) {
|
||||
ctx->cipher_ctx = mbedtls_cipher_get_base(cipher_info)->ctx_alloc_func();
|
||||
if (ctx->cipher_ctx == NULL) {
|
||||
return MBEDTLS_ERR_CIPHER_ALLOC_FAILED;
|
||||
}
|
||||
}
|
||||
|
||||
ctx->cipher_info = cipher_info;
|
||||
|
||||
@ -568,17 +568,18 @@ static const mbedtls_cipher_info_t aes_256_xts_info = {
|
||||
};
|
||||
#endif
|
||||
#endif /* MBEDTLS_CIPHER_MODE_XTS */
|
||||
#endif /* MBEDTLS_AES_C */
|
||||
|
||||
#if defined(MBEDTLS_GCM_C)
|
||||
#if defined(MBEDTLS_GCM_C) && defined(MBEDTLS_AES_C)
|
||||
static int gcm_aes_setkey_wrap(void *ctx, const unsigned char *key,
|
||||
unsigned int key_bitlen)
|
||||
{
|
||||
return mbedtls_gcm_setkey((mbedtls_gcm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
|
||||
key, key_bitlen);
|
||||
}
|
||||
#endif /* MBEDTLS_GCM_C */
|
||||
#endif /* MBEDTLS_GCM_C && MBEDTLS_AES_C */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_GCM_VIA_LEGACY_OR_USE_PSA)
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
|
||||
static const mbedtls_cipher_base_t gcm_aes_info = {
|
||||
MBEDTLS_CIPHER_ID_AES,
|
||||
NULL,
|
||||
@ -612,9 +613,9 @@ static const mbedtls_cipher_base_t gcm_aes_info = {
|
||||
NULL,
|
||||
#endif /* MBEDTLS_GCM_C */
|
||||
};
|
||||
#endif /* MBEDTLS_CIPHER_HAVE_GCM_VIA_LEGACY_OR_USE_PSA */
|
||||
#endif /* MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_GCM_VIA_LEGACY_OR_USE_PSA)
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
|
||||
static const mbedtls_cipher_info_t aes_128_gcm_info = {
|
||||
"AES-128-GCM",
|
||||
16,
|
||||
@ -649,18 +650,18 @@ static const mbedtls_cipher_info_t aes_256_gcm_info = {
|
||||
MBEDTLS_CIPHER_BASE_INDEX_GCM_AES
|
||||
};
|
||||
#endif
|
||||
#endif /* MBEDTLS_CIPHER_HAVE_GCM_VIA_LEGACY_OR_USE_PSA */
|
||||
#endif /* MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA */
|
||||
|
||||
#if defined(MBEDTLS_CCM_C)
|
||||
#if defined(MBEDTLS_CCM_C) && defined(MBEDTLS_AES_C)
|
||||
static int ccm_aes_setkey_wrap(void *ctx, const unsigned char *key,
|
||||
unsigned int key_bitlen)
|
||||
{
|
||||
return mbedtls_ccm_setkey((mbedtls_ccm_context *) ctx, MBEDTLS_CIPHER_ID_AES,
|
||||
key, key_bitlen);
|
||||
}
|
||||
#endif /* MBEDTLS_CCM_C */
|
||||
#endif /* MBEDTLS_CCM_C && MBEDTLS_AES_C */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_CCM_VIA_LEGACY_OR_USE_PSA)
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
|
||||
static const mbedtls_cipher_base_t ccm_aes_info = {
|
||||
MBEDTLS_CIPHER_ID_AES,
|
||||
NULL,
|
||||
@ -694,9 +695,9 @@ static const mbedtls_cipher_base_t ccm_aes_info = {
|
||||
NULL,
|
||||
#endif
|
||||
};
|
||||
#endif /* MBEDTLS_CIPHER_HAVE_CCM_VIA_LEGACY_OR_USE_PSA */
|
||||
#endif /* MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_CCM_VIA_LEGACY_OR_USE_PSA)
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
|
||||
static const mbedtls_cipher_info_t aes_128_ccm_info = {
|
||||
"AES-128-CCM",
|
||||
16,
|
||||
@ -731,9 +732,9 @@ static const mbedtls_cipher_info_t aes_256_ccm_info = {
|
||||
MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
|
||||
};
|
||||
#endif
|
||||
#endif /* MBEDTLS_CIPHER_HAVE_CCM_VIA_LEGACY_OR_USE_PSA */
|
||||
#endif /* MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA */
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_VIA_LEGACY_OR_USE_PSA)
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_AES_VIA_LEGACY_OR_USE_PSA)
|
||||
static const mbedtls_cipher_info_t aes_128_ccm_star_no_tag_info = {
|
||||
"AES-128-CCM*-NO-TAG",
|
||||
16,
|
||||
@ -768,9 +769,8 @@ static const mbedtls_cipher_info_t aes_256_ccm_star_no_tag_info = {
|
||||
MBEDTLS_CIPHER_BASE_INDEX_CCM_AES
|
||||
};
|
||||
#endif
|
||||
#endif /* MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_VIA_LEGACY_OR_USE_PSA */
|
||||
#endif /* MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_AES_VIA_LEGACY_OR_USE_PSA */
|
||||
|
||||
#endif /* MBEDTLS_AES_C */
|
||||
|
||||
#if defined(MBEDTLS_CAMELLIA_C)
|
||||
|
||||
@ -2269,28 +2269,28 @@ const mbedtls_cipher_definition_t mbedtls_cipher_definitions[] =
|
||||
{ MBEDTLS_CIPHER_AES_256_XTS, &aes_256_xts_info },
|
||||
#endif
|
||||
#endif
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_GCM_VIA_LEGACY_OR_USE_PSA)
|
||||
#endif /* MBEDTLS_AES_C */
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_GCM_AES_VIA_LEGACY_OR_USE_PSA)
|
||||
{ MBEDTLS_CIPHER_AES_128_GCM, &aes_128_gcm_info },
|
||||
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
|
||||
{ MBEDTLS_CIPHER_AES_192_GCM, &aes_192_gcm_info },
|
||||
{ MBEDTLS_CIPHER_AES_256_GCM, &aes_256_gcm_info },
|
||||
#endif
|
||||
#endif
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_CCM_VIA_LEGACY_OR_USE_PSA)
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_CCM_AES_VIA_LEGACY_OR_USE_PSA)
|
||||
{ MBEDTLS_CIPHER_AES_128_CCM, &aes_128_ccm_info },
|
||||
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
|
||||
{ MBEDTLS_CIPHER_AES_192_CCM, &aes_192_ccm_info },
|
||||
{ MBEDTLS_CIPHER_AES_256_CCM, &aes_256_ccm_info },
|
||||
#endif
|
||||
#endif
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_VIA_LEGACY_OR_USE_PSA)
|
||||
#if defined(MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_AES_VIA_LEGACY_OR_USE_PSA)
|
||||
{ MBEDTLS_CIPHER_AES_128_CCM_STAR_NO_TAG, &aes_128_ccm_star_no_tag_info },
|
||||
#if !defined(MBEDTLS_AES_ONLY_128_BIT_KEY_LENGTH)
|
||||
{ MBEDTLS_CIPHER_AES_192_CCM_STAR_NO_TAG, &aes_192_ccm_star_no_tag_info },
|
||||
{ MBEDTLS_CIPHER_AES_256_CCM_STAR_NO_TAG, &aes_256_ccm_star_no_tag_info },
|
||||
#endif
|
||||
#endif
|
||||
#endif /* MBEDTLS_AES_C */
|
||||
|
||||
#if defined(MBEDTLS_CAMELLIA_C)
|
||||
{ MBEDTLS_CIPHER_CAMELLIA_128_ECB, &camellia_128_ecb_info },
|
||||
|
||||
@ -62,6 +62,12 @@ extern "C" {
|
||||
#define MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_VIA_LEGACY_OR_USE_PSA
|
||||
#endif
|
||||
|
||||
#if (defined(MBEDTLS_CCM_C) && defined(MBEDTLS_AES_C)) || \
|
||||
(defined(MBEDTLS_USE_PSA_CRYPTO) && defined(PSA_WANT_ALG_CCM_STAR_NO_TAG) && \
|
||||
defined(PSA_WANT_KEY_TYPE_AES))
|
||||
#define MBEDTLS_CIPHER_HAVE_CCM_STAR_NO_TAG_AES_VIA_LEGACY_OR_USE_PSA
|
||||
#endif
|
||||
|
||||
#if defined(MBEDTLS_CHACHAPOLY_C) || \
|
||||
(defined(MBEDTLS_USE_PSA_CRYPTO) && defined(PSA_WANT_ALG_CHACHA20_POLY1305))
|
||||
#define MBEDTLS_CIPHER_HAVE_CHACHAPOLY_VIA_LEGACY_OR_USE_PSA
|
||||
|
||||
@ -348,8 +348,14 @@ static inline void mbedtls_xor_no_simd(unsigned char *r,
|
||||
# define MBEDTLS_MAYBE_UNUSED __attribute__((unused))
|
||||
#endif
|
||||
#if !defined(MBEDTLS_MAYBE_UNUSED) && defined(__IAR_SYSTEMS_ICC__) && defined(__VER__)
|
||||
# if (__VER__ >= 8010000) // IAR 8.1 or later
|
||||
# define MBEDTLS_MAYBE_UNUSED __attribute__((unused))
|
||||
/* IAR does support __attribute__((unused)), but only if the -e flag (extended language support)
|
||||
* is given; the pragma always works.
|
||||
* Unfortunately the pragma affects the rest of the file where it is used, but this is harmless.
|
||||
* Check for version 5.2 or later - this pragma may be supported by earlier versions, but I wasn't
|
||||
* able to find documentation).
|
||||
*/
|
||||
# if (__VER__ >= 5020000)
|
||||
# define MBEDTLS_MAYBE_UNUSED _Pragma("diag_suppress=Pe177")
|
||||
# endif
|
||||
#endif
|
||||
#if !defined(MBEDTLS_MAYBE_UNUSED) && defined(_MSC_VER)
|
||||
|
||||
@ -1424,7 +1424,7 @@ MBEDTLS_STATIC_TESTABLE int mbedtls_pk_parse_key_pkcs8_encrypted_der(
|
||||
unsigned char *buf;
|
||||
unsigned char *p, *end;
|
||||
mbedtls_asn1_buf pbe_alg_oid, pbe_params;
|
||||
#if defined(MBEDTLS_PKCS12_C)
|
||||
#if defined(MBEDTLS_PKCS12_C) && defined(MBEDTLS_CIPHER_PADDING_PKCS7)
|
||||
mbedtls_cipher_type_t cipher_alg;
|
||||
mbedtls_md_type_t md_alg;
|
||||
#endif
|
||||
@ -1472,7 +1472,7 @@ MBEDTLS_STATIC_TESTABLE int mbedtls_pk_parse_key_pkcs8_encrypted_der(
|
||||
/*
|
||||
* Decrypt EncryptedData with appropriate PBE
|
||||
*/
|
||||
#if defined(MBEDTLS_PKCS12_C)
|
||||
#if defined(MBEDTLS_PKCS12_C) && defined(MBEDTLS_CIPHER_PADDING_PKCS7)
|
||||
if (mbedtls_oid_get_pkcs12_pbe_alg(&pbe_alg_oid, &md_alg, &cipher_alg) == 0) {
|
||||
if ((ret = mbedtls_pkcs12_pbe_ext(&pbe_params, MBEDTLS_PKCS12_PBE_DECRYPT,
|
||||
cipher_alg, md_alg,
|
||||
@ -1487,7 +1487,7 @@ MBEDTLS_STATIC_TESTABLE int mbedtls_pk_parse_key_pkcs8_encrypted_der(
|
||||
decrypted = 1;
|
||||
} else
|
||||
#endif /* MBEDTLS_PKCS12_C */
|
||||
#if defined(MBEDTLS_PKCS5_C)
|
||||
#if defined(MBEDTLS_PKCS5_C) && defined(MBEDTLS_CIPHER_PADDING_PKCS7)
|
||||
if (MBEDTLS_OID_CMP(MBEDTLS_OID_PKCS5_PBES2, &pbe_alg_oid) == 0) {
|
||||
if ((ret = mbedtls_pkcs5_pbes2_ext(&pbe_params, MBEDTLS_PKCS5_DECRYPT, pwd, pwdlen,
|
||||
p, len, buf, len, &outlen)) != 0) {
|
||||
|
||||
@ -265,7 +265,7 @@ mbedtls_ms_time_t mbedtls_ms_time(void)
|
||||
struct timespec tv;
|
||||
mbedtls_ms_time_t current_ms;
|
||||
|
||||
#if defined(__linux__)
|
||||
#if defined(__linux__) && defined(CLOCK_BOOTTIME)
|
||||
ret = clock_gettime(CLOCK_BOOTTIME, &tv);
|
||||
#else
|
||||
ret = clock_gettime(CLOCK_MONOTONIC, &tv);
|
||||
|
||||
@ -43,19 +43,15 @@ static psa_status_t psa_aead_setup(
|
||||
psa_algorithm_t alg)
|
||||
{
|
||||
psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
|
||||
size_t key_bits;
|
||||
const mbedtls_cipher_info_t *cipher_info;
|
||||
mbedtls_cipher_id_t cipher_id;
|
||||
|
||||
mbedtls_cipher_mode_t mode;
|
||||
size_t key_bits = attributes->core.bits;
|
||||
(void) key_buffer_size;
|
||||
|
||||
key_bits = attributes->core.bits;
|
||||
|
||||
cipher_info = mbedtls_cipher_info_from_psa(alg,
|
||||
attributes->core.type, key_bits,
|
||||
&cipher_id);
|
||||
if (cipher_info == NULL) {
|
||||
return PSA_ERROR_NOT_SUPPORTED;
|
||||
status = mbedtls_cipher_values_from_psa(alg, attributes->core.type,
|
||||
&key_bits, &mode, &cipher_id);
|
||||
if (status != PSA_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
switch (PSA_ALG_AEAD_WITH_SHORTENED_TAG(alg, 0)) {
|
||||
|
||||
@ -31,14 +31,70 @@
|
||||
|
||||
#include <string.h>
|
||||
|
||||
const mbedtls_cipher_info_t *mbedtls_cipher_info_from_psa(
|
||||
/* mbedtls_cipher_values_from_psa() below only checks if the proper build symbols
|
||||
* are enabled, but it does not provide any compatibility check between them
|
||||
* (i.e. if the specified key works with the specified algorithm). This helper
|
||||
* function is meant to provide this support.
|
||||
* mbedtls_cipher_info_from_psa() might be used for the same purpose, but it
|
||||
* requires CIPHER_C to be enabled.
|
||||
*/
|
||||
static psa_status_t mbedtls_cipher_validate_values(
|
||||
psa_algorithm_t alg,
|
||||
psa_key_type_t key_type)
|
||||
{
|
||||
switch (alg) {
|
||||
case PSA_ALG_STREAM_CIPHER:
|
||||
case PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_CHACHA20_POLY1305, 0):
|
||||
if (key_type != PSA_KEY_TYPE_CHACHA20) {
|
||||
return PSA_ERROR_NOT_SUPPORTED;
|
||||
}
|
||||
break;
|
||||
|
||||
case PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_CCM, 0):
|
||||
case PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_GCM, 0):
|
||||
case PSA_ALG_CCM_STAR_NO_TAG:
|
||||
if ((key_type != PSA_KEY_TYPE_AES) &&
|
||||
(key_type != PSA_KEY_TYPE_ARIA) &&
|
||||
(key_type != PSA_KEY_TYPE_CAMELLIA)) {
|
||||
return PSA_ERROR_NOT_SUPPORTED;
|
||||
}
|
||||
break;
|
||||
|
||||
case PSA_ALG_CTR:
|
||||
case PSA_ALG_CFB:
|
||||
case PSA_ALG_OFB:
|
||||
case PSA_ALG_XTS:
|
||||
case PSA_ALG_ECB_NO_PADDING:
|
||||
case PSA_ALG_CBC_NO_PADDING:
|
||||
case PSA_ALG_CBC_PKCS7:
|
||||
case PSA_ALG_CMAC:
|
||||
if ((key_type != PSA_KEY_TYPE_AES) &&
|
||||
(key_type != PSA_KEY_TYPE_ARIA) &&
|
||||
(key_type != PSA_KEY_TYPE_DES) &&
|
||||
(key_type != PSA_KEY_TYPE_CAMELLIA)) {
|
||||
return PSA_ERROR_NOT_SUPPORTED;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
return PSA_ERROR_NOT_SUPPORTED;
|
||||
}
|
||||
|
||||
return PSA_SUCCESS;
|
||||
}
|
||||
|
||||
psa_status_t mbedtls_cipher_values_from_psa(
|
||||
psa_algorithm_t alg,
|
||||
psa_key_type_t key_type,
|
||||
size_t key_bits,
|
||||
size_t *key_bits,
|
||||
mbedtls_cipher_mode_t *mode,
|
||||
mbedtls_cipher_id_t *cipher_id)
|
||||
{
|
||||
mbedtls_cipher_mode_t mode;
|
||||
mbedtls_cipher_id_t cipher_id_tmp;
|
||||
/* Only DES modifies key_bits */
|
||||
#if !defined(MBEDTLS_PSA_BUILTIN_KEY_TYPE_DES)
|
||||
(void) key_bits;
|
||||
#endif
|
||||
|
||||
if (PSA_ALG_IS_AEAD(alg)) {
|
||||
alg = PSA_ALG_AEAD_WITH_SHORTENED_TAG(alg, 0);
|
||||
@ -48,66 +104,66 @@ const mbedtls_cipher_info_t *mbedtls_cipher_info_from_psa(
|
||||
switch (alg) {
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_ALG_STREAM_CIPHER)
|
||||
case PSA_ALG_STREAM_CIPHER:
|
||||
mode = MBEDTLS_MODE_STREAM;
|
||||
*mode = MBEDTLS_MODE_STREAM;
|
||||
break;
|
||||
#endif
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_ALG_CTR)
|
||||
case PSA_ALG_CTR:
|
||||
mode = MBEDTLS_MODE_CTR;
|
||||
*mode = MBEDTLS_MODE_CTR;
|
||||
break;
|
||||
#endif
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_ALG_CFB)
|
||||
case PSA_ALG_CFB:
|
||||
mode = MBEDTLS_MODE_CFB;
|
||||
*mode = MBEDTLS_MODE_CFB;
|
||||
break;
|
||||
#endif
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_ALG_OFB)
|
||||
case PSA_ALG_OFB:
|
||||
mode = MBEDTLS_MODE_OFB;
|
||||
*mode = MBEDTLS_MODE_OFB;
|
||||
break;
|
||||
#endif
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_ALG_ECB_NO_PADDING)
|
||||
case PSA_ALG_ECB_NO_PADDING:
|
||||
mode = MBEDTLS_MODE_ECB;
|
||||
*mode = MBEDTLS_MODE_ECB;
|
||||
break;
|
||||
#endif
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_ALG_CBC_NO_PADDING)
|
||||
case PSA_ALG_CBC_NO_PADDING:
|
||||
mode = MBEDTLS_MODE_CBC;
|
||||
*mode = MBEDTLS_MODE_CBC;
|
||||
break;
|
||||
#endif
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_ALG_CBC_PKCS7)
|
||||
case PSA_ALG_CBC_PKCS7:
|
||||
mode = MBEDTLS_MODE_CBC;
|
||||
*mode = MBEDTLS_MODE_CBC;
|
||||
break;
|
||||
#endif
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_ALG_CCM_STAR_NO_TAG)
|
||||
case PSA_ALG_CCM_STAR_NO_TAG:
|
||||
mode = MBEDTLS_MODE_CCM_STAR_NO_TAG;
|
||||
*mode = MBEDTLS_MODE_CCM_STAR_NO_TAG;
|
||||
break;
|
||||
#endif
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_ALG_CCM)
|
||||
case PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_CCM, 0):
|
||||
mode = MBEDTLS_MODE_CCM;
|
||||
*mode = MBEDTLS_MODE_CCM;
|
||||
break;
|
||||
#endif
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_ALG_GCM)
|
||||
case PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_GCM, 0):
|
||||
mode = MBEDTLS_MODE_GCM;
|
||||
*mode = MBEDTLS_MODE_GCM;
|
||||
break;
|
||||
#endif
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_ALG_CHACHA20_POLY1305)
|
||||
case PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_CHACHA20_POLY1305, 0):
|
||||
mode = MBEDTLS_MODE_CHACHAPOLY;
|
||||
*mode = MBEDTLS_MODE_CHACHAPOLY;
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
return NULL;
|
||||
return PSA_ERROR_NOT_SUPPORTED;
|
||||
}
|
||||
} else if (alg == PSA_ALG_CMAC) {
|
||||
mode = MBEDTLS_MODE_ECB;
|
||||
*mode = MBEDTLS_MODE_ECB;
|
||||
} else {
|
||||
return NULL;
|
||||
return PSA_ERROR_NOT_SUPPORTED;
|
||||
}
|
||||
|
||||
switch (key_type) {
|
||||
@ -125,7 +181,7 @@ const mbedtls_cipher_info_t *mbedtls_cipher_info_from_psa(
|
||||
case PSA_KEY_TYPE_DES:
|
||||
/* key_bits is 64 for Single-DES, 128 for two-key Triple-DES,
|
||||
* and 192 for three-key Triple-DES. */
|
||||
if (key_bits == 64) {
|
||||
if (*key_bits == 64) {
|
||||
cipher_id_tmp = MBEDTLS_CIPHER_ID_DES;
|
||||
} else {
|
||||
cipher_id_tmp = MBEDTLS_CIPHER_ID_3DES;
|
||||
@ -133,8 +189,8 @@ const mbedtls_cipher_info_t *mbedtls_cipher_info_from_psa(
|
||||
/* mbedtls doesn't recognize two-key Triple-DES as an algorithm,
|
||||
* but two-key Triple-DES is functionally three-key Triple-DES
|
||||
* with K1=K3, so that's how we present it to mbedtls. */
|
||||
if (key_bits == 128) {
|
||||
key_bits = 192;
|
||||
if (*key_bits == 128) {
|
||||
*key_bits = 192;
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
@ -149,16 +205,38 @@ const mbedtls_cipher_info_t *mbedtls_cipher_info_from_psa(
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
return NULL;
|
||||
return PSA_ERROR_NOT_SUPPORTED;
|
||||
}
|
||||
if (cipher_id != NULL) {
|
||||
*cipher_id = cipher_id_tmp;
|
||||
}
|
||||
|
||||
return mbedtls_cipher_info_from_values(cipher_id_tmp,
|
||||
(int) key_bits, mode);
|
||||
return mbedtls_cipher_validate_values(alg, key_type);
|
||||
}
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_C)
|
||||
const mbedtls_cipher_info_t *mbedtls_cipher_info_from_psa(
|
||||
psa_algorithm_t alg,
|
||||
psa_key_type_t key_type,
|
||||
size_t key_bits,
|
||||
mbedtls_cipher_id_t *cipher_id)
|
||||
{
|
||||
mbedtls_cipher_mode_t mode;
|
||||
psa_status_t status;
|
||||
mbedtls_cipher_id_t cipher_id_tmp;
|
||||
|
||||
status = mbedtls_cipher_values_from_psa(alg, key_type, &key_bits, &mode, &cipher_id_tmp);
|
||||
if (status != PSA_SUCCESS) {
|
||||
return NULL;
|
||||
}
|
||||
if (cipher_id != NULL) {
|
||||
*cipher_id = cipher_id_tmp;
|
||||
}
|
||||
|
||||
return mbedtls_cipher_info_from_values(cipher_id_tmp, (int) key_bits, mode);
|
||||
}
|
||||
#endif /* MBEDTLS_CIPHER_C */
|
||||
|
||||
#if defined(MBEDTLS_PSA_BUILTIN_CIPHER)
|
||||
|
||||
static psa_status_t psa_cipher_setup(
|
||||
|
||||
@ -24,6 +24,28 @@
|
||||
#include <mbedtls/cipher.h>
|
||||
#include <psa/crypto.h>
|
||||
|
||||
/** Get Mbed TLS cipher information given the cipher algorithm PSA identifier
|
||||
* as well as the PSA type and size of the key to be used with the cipher
|
||||
* algorithm.
|
||||
*
|
||||
* \param[in] alg PSA cipher algorithm identifier
|
||||
* \param[in] key_type PSA key type
|
||||
* \param[in,out] key_bits Size of the key in bits. The value provided in input
|
||||
* might be updated if necessary.
|
||||
* \param[out] mode Mbed TLS cipher mode
|
||||
* \param[out] cipher_id Mbed TLS cipher algorithm identifier
|
||||
*
|
||||
* \return On success \c PSA_SUCCESS is returned and key_bits, mode and cipher_id
|
||||
* are properly updated.
|
||||
* \c PSA_ERROR_NOT_SUPPORTED is returned if the cipher algorithm is not
|
||||
* supported.
|
||||
*/
|
||||
|
||||
psa_status_t mbedtls_cipher_values_from_psa(psa_algorithm_t alg, psa_key_type_t key_type,
|
||||
size_t *key_bits, mbedtls_cipher_mode_t *mode,
|
||||
mbedtls_cipher_id_t *cipher_id);
|
||||
|
||||
#if defined(MBEDTLS_CIPHER_C)
|
||||
/** Get Mbed TLS cipher information given the cipher algorithm PSA identifier
|
||||
* as well as the PSA type and size of the key to be used with the cipher
|
||||
* algorithm.
|
||||
@ -39,6 +61,7 @@
|
||||
const mbedtls_cipher_info_t *mbedtls_cipher_info_from_psa(
|
||||
psa_algorithm_t alg, psa_key_type_t key_type, size_t key_bits,
|
||||
mbedtls_cipher_id_t *cipher_id);
|
||||
#endif /* MBEDTLS_CIPHER_C */
|
||||
|
||||
/**
|
||||
* \brief Set the key for a multipart symmetric encryption operation.
|
||||
|
||||
@ -2129,6 +2129,12 @@ int mbedtls_ssl_tls13_write_early_data_ext(mbedtls_ssl_context *ssl,
|
||||
unsigned char *buf,
|
||||
const unsigned char *end,
|
||||
size_t *out_len);
|
||||
|
||||
#if defined(MBEDTLS_SSL_SRV_C)
|
||||
#define MBEDTLS_SSL_EARLY_DATA_STATUS_NOT_RECEIVED \
|
||||
MBEDTLS_SSL_EARLY_DATA_STATUS_NOT_SENT
|
||||
#endif /* MBEDTLS_SSL_SRV_C */
|
||||
|
||||
#endif /* MBEDTLS_SSL_EARLY_DATA */
|
||||
|
||||
#endif /* MBEDTLS_SSL_PROTO_TLS1_3 */
|
||||
|
||||
@ -1749,6 +1749,25 @@ static int ssl_tls13_parse_client_hello(mbedtls_ssl_context *ssl,
|
||||
return hrr_required ? SSL_CLIENT_HELLO_HRR_REQUIRED : SSL_CLIENT_HELLO_OK;
|
||||
}
|
||||
|
||||
#if defined(MBEDTLS_SSL_EARLY_DATA)
|
||||
static void ssl_tls13_update_early_data_status(mbedtls_ssl_context *ssl)
|
||||
{
|
||||
mbedtls_ssl_handshake_params *handshake = ssl->handshake;
|
||||
|
||||
if ((handshake->received_extensions &
|
||||
MBEDTLS_SSL_EXT_MASK(EARLY_DATA)) == 0) {
|
||||
MBEDTLS_SSL_DEBUG_MSG(
|
||||
1, ("EarlyData: no early data extension received."));
|
||||
ssl->early_data_status = MBEDTLS_SSL_EARLY_DATA_STATUS_NOT_RECEIVED;
|
||||
return;
|
||||
}
|
||||
|
||||
/* We do not accept early data for the time being */
|
||||
ssl->early_data_status = MBEDTLS_SSL_EARLY_DATA_STATUS_REJECTED;
|
||||
|
||||
}
|
||||
#endif /* MBEDTLS_SSL_EARLY_DATA */
|
||||
|
||||
/* Update the handshake state machine */
|
||||
|
||||
MBEDTLS_CHECK_RETURN_CRITICAL
|
||||
@ -1775,6 +1794,11 @@ static int ssl_tls13_postprocess_client_hello(mbedtls_ssl_context *ssl)
|
||||
return ret;
|
||||
}
|
||||
|
||||
#if defined(MBEDTLS_SSL_EARLY_DATA)
|
||||
/* There is enough information, update early data state. */
|
||||
ssl_tls13_update_early_data_status(ssl);
|
||||
#endif /* MBEDTLS_SSL_EARLY_DATA */
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
@ -469,7 +469,7 @@ int main(void)
|
||||
" otherwise. The expansion of the macro\n" \
|
||||
" is printed if it is defined\n" \
|
||||
USAGE_SERIALIZATION \
|
||||
" acceptable ciphersuite names:\n"
|
||||
"\n"
|
||||
|
||||
/*
|
||||
* global options
|
||||
@ -705,7 +705,7 @@ static int ssl_save_session_serialize(mbedtls_ssl_context *ssl,
|
||||
}
|
||||
|
||||
/* get size of the buffer needed */
|
||||
mbedtls_ssl_session_save(&exported_session, NULL, 0, session_data_len);
|
||||
(void) mbedtls_ssl_session_save(&exported_session, NULL, 0, session_data_len);
|
||||
*session_data = mbedtls_calloc(1, *session_data_len);
|
||||
if (*session_data == NULL) {
|
||||
mbedtls_printf(" failed\n ! alloc %u bytes for session data\n",
|
||||
@ -864,31 +864,6 @@ int main(int argc, char *argv[])
|
||||
mbedtls_test_enable_insecure_external_rng();
|
||||
#endif /* MBEDTLS_PSA_CRYPTO_EXTERNAL_RNG */
|
||||
|
||||
if (argc < 2) {
|
||||
usage:
|
||||
if (ret == 0) {
|
||||
ret = 1;
|
||||
}
|
||||
|
||||
mbedtls_printf(USAGE1);
|
||||
mbedtls_printf(USAGE2);
|
||||
mbedtls_printf(USAGE3);
|
||||
mbedtls_printf(USAGE4);
|
||||
|
||||
list = mbedtls_ssl_list_ciphersuites();
|
||||
while (*list) {
|
||||
mbedtls_printf(" %-42s", mbedtls_ssl_get_ciphersuite_name(*list));
|
||||
list++;
|
||||
if (!*list) {
|
||||
break;
|
||||
}
|
||||
mbedtls_printf(" %s\n", mbedtls_ssl_get_ciphersuite_name(*list));
|
||||
list++;
|
||||
}
|
||||
mbedtls_printf("\n");
|
||||
goto exit;
|
||||
}
|
||||
|
||||
opt.server_name = DFL_SERVER_NAME;
|
||||
opt.server_addr = DFL_SERVER_ADDR;
|
||||
opt.server_port = DFL_SERVER_PORT;
|
||||
@ -973,9 +948,54 @@ usage:
|
||||
opt.key_opaque_alg1 = DFL_KEY_OPAQUE_ALG;
|
||||
opt.key_opaque_alg2 = DFL_KEY_OPAQUE_ALG;
|
||||
|
||||
p = q = NULL;
|
||||
if (argc < 1) {
|
||||
usage:
|
||||
if (p != NULL && q != NULL) {
|
||||
printf("unrecognized value for '%s': '%s'\n", p, q);
|
||||
} else if (p != NULL && q == NULL) {
|
||||
printf("unrecognized param: '%s'\n", p);
|
||||
}
|
||||
|
||||
mbedtls_printf("usage: ssl_client2 [param=value] [...]\n");
|
||||
mbedtls_printf(" ssl_client2 help[_theme]\n");
|
||||
mbedtls_printf("'help' lists acceptable 'param' and 'value'\n");
|
||||
mbedtls_printf("'help_ciphersuites' lists available ciphersuites\n");
|
||||
mbedtls_printf("\n");
|
||||
|
||||
if (ret == 0) {
|
||||
ret = 1;
|
||||
}
|
||||
goto exit;
|
||||
}
|
||||
|
||||
for (i = 1; i < argc; i++) {
|
||||
p = argv[i];
|
||||
|
||||
if (strcmp(p, "help") == 0) {
|
||||
mbedtls_printf(USAGE1);
|
||||
mbedtls_printf(USAGE2);
|
||||
mbedtls_printf(USAGE3);
|
||||
mbedtls_printf(USAGE4);
|
||||
|
||||
ret = 0;
|
||||
goto exit;
|
||||
}
|
||||
if (strcmp(p, "help_ciphersuites") == 0) {
|
||||
mbedtls_printf(" acceptable ciphersuite names:\n");
|
||||
for (list = mbedtls_ssl_list_ciphersuites();
|
||||
*list != 0;
|
||||
list++) {
|
||||
mbedtls_printf(" %s\n", mbedtls_ssl_get_ciphersuite_name(*list));
|
||||
}
|
||||
|
||||
ret = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if ((q = strchr(p, '=')) == NULL) {
|
||||
mbedtls_printf("param requires a value: '%s'\n", p);
|
||||
p = NULL; // avoid "unrecnognized param" message
|
||||
goto usage;
|
||||
}
|
||||
*q++ = '\0';
|
||||
@ -1372,9 +1392,13 @@ usage:
|
||||
goto usage;
|
||||
}
|
||||
} else {
|
||||
/* This signals that the problem is with p not q */
|
||||
q = NULL;
|
||||
goto usage;
|
||||
}
|
||||
}
|
||||
/* This signals that any further errors are not with a single option */
|
||||
p = q = NULL;
|
||||
|
||||
if (opt.nss_keylog != 0 && opt.eap_tls != 0) {
|
||||
mbedtls_printf("Error: eap_tls and nss_keylog options cannot be used together.\n");
|
||||
|
||||
@ -590,7 +590,7 @@ int main(void)
|
||||
" otherwise. The expansion of the macro\n" \
|
||||
" is printed if it is defined\n" \
|
||||
USAGE_SERIALIZATION \
|
||||
" acceptable ciphersuite names:\n"
|
||||
"\n"
|
||||
|
||||
#define PUT_UINT64_BE(out_be, in_le, i) \
|
||||
{ \
|
||||
@ -1642,31 +1642,6 @@ int main(int argc, char *argv[])
|
||||
signal(SIGINT, term_handler);
|
||||
#endif
|
||||
|
||||
if (argc < 2) {
|
||||
usage:
|
||||
if (ret == 0) {
|
||||
ret = 1;
|
||||
}
|
||||
|
||||
mbedtls_printf(USAGE1);
|
||||
mbedtls_printf(USAGE2);
|
||||
mbedtls_printf(USAGE3);
|
||||
mbedtls_printf(USAGE4);
|
||||
|
||||
list = mbedtls_ssl_list_ciphersuites();
|
||||
while (*list) {
|
||||
mbedtls_printf(" %-42s", mbedtls_ssl_get_ciphersuite_name(*list));
|
||||
list++;
|
||||
if (!*list) {
|
||||
break;
|
||||
}
|
||||
mbedtls_printf(" %s\n", mbedtls_ssl_get_ciphersuite_name(*list));
|
||||
list++;
|
||||
}
|
||||
mbedtls_printf("\n");
|
||||
goto exit;
|
||||
}
|
||||
|
||||
opt.buffer_size = DFL_IO_BUF_LEN;
|
||||
opt.server_addr = DFL_SERVER_ADDR;
|
||||
opt.server_port = DFL_SERVER_PORT;
|
||||
@ -1765,9 +1740,54 @@ usage:
|
||||
opt.key2_opaque_alg1 = DFL_KEY_OPAQUE_ALG;
|
||||
opt.key2_opaque_alg2 = DFL_KEY_OPAQUE_ALG;
|
||||
|
||||
p = q = NULL;
|
||||
if (argc < 1) {
|
||||
usage:
|
||||
if (p != NULL && q != NULL) {
|
||||
printf("unrecognized value for '%s': '%s'\n", p, q);
|
||||
} else if (p != NULL && q == NULL) {
|
||||
printf("unrecognized param: '%s'\n", p);
|
||||
}
|
||||
|
||||
mbedtls_printf("usage: ssl_client2 [param=value] [...]\n");
|
||||
mbedtls_printf(" ssl_client2 help[_theme]\n");
|
||||
mbedtls_printf("'help' lists acceptable 'param' and 'value'\n");
|
||||
mbedtls_printf("'help_ciphersuites' lists available ciphersuites\n");
|
||||
mbedtls_printf("\n");
|
||||
|
||||
if (ret == 0) {
|
||||
ret = 1;
|
||||
}
|
||||
goto exit;
|
||||
}
|
||||
|
||||
for (i = 1; i < argc; i++) {
|
||||
p = argv[i];
|
||||
|
||||
if (strcmp(p, "help") == 0) {
|
||||
mbedtls_printf(USAGE1);
|
||||
mbedtls_printf(USAGE2);
|
||||
mbedtls_printf(USAGE3);
|
||||
mbedtls_printf(USAGE4);
|
||||
|
||||
ret = 0;
|
||||
goto exit;
|
||||
}
|
||||
if (strcmp(p, "help_ciphersuites") == 0) {
|
||||
mbedtls_printf(" acceptable ciphersuite names:\n");
|
||||
for (list = mbedtls_ssl_list_ciphersuites();
|
||||
*list != 0;
|
||||
list++) {
|
||||
mbedtls_printf(" %s\n", mbedtls_ssl_get_ciphersuite_name(*list));
|
||||
}
|
||||
|
||||
ret = 0;
|
||||
goto exit;
|
||||
}
|
||||
|
||||
if ((q = strchr(p, '=')) == NULL) {
|
||||
mbedtls_printf("param requires a value: '%s'\n", p);
|
||||
p = NULL; // avoid "unrecnognized param" message
|
||||
goto usage;
|
||||
}
|
||||
*q++ = '\0';
|
||||
@ -2232,9 +2252,13 @@ usage:
|
||||
goto usage;
|
||||
}
|
||||
} else {
|
||||
/* This signals that the problem is with p not q */
|
||||
q = NULL;
|
||||
goto usage;
|
||||
}
|
||||
}
|
||||
/* This signals that any further erorrs are not with a single option */
|
||||
p = q = NULL;
|
||||
|
||||
if (opt.nss_keylog != 0 && opt.eap_tls != 0) {
|
||||
mbedtls_printf("Error: eap_tls and nss_keylog options cannot be used together.\n");
|
||||
|
||||
3
tests/data_files/tls13_early_data.txt
Normal file
3
tests/data_files/tls13_early_data.txt
Normal file
@ -0,0 +1,3 @@
|
||||
EarlyData context: line 0 lf
|
||||
EarlyData context: line 1 lf
|
||||
EarlyData context: If it appears, that means early_data received.
|
||||
@ -493,3 +493,18 @@ run_test "TLS 1.3 m->m: Resumption with ticket flags, psk_all/psk_all." \
|
||||
-S "No suitable key exchange mode" \
|
||||
-s "found matched identity"
|
||||
|
||||
requires_gnutls_next
|
||||
requires_all_configs_enabled MBEDTLS_SSL_EARLY_DATA MBEDTLS_SSL_SESSION_TICKETS \
|
||||
MBEDTLS_SSL_SRV_C MBEDTLS_DEBUG_C MBEDTLS_HAVE_TIME \
|
||||
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_EPHEMERAL_ENABLED \
|
||||
MBEDTLS_SSL_TLS1_3_COMPATIBILITY_MODE
|
||||
requires_any_configs_enabled MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_ENABLED \
|
||||
MBEDTLS_SSL_TLS1_3_KEY_EXCHANGE_MODE_PSK_EPHEMERAL_ENABLED
|
||||
run_test "TLS 1.3 G->m: EarlyData: feature is disabled, fail." \
|
||||
"$P_SRV force_version=tls13 debug_level=4 max_early_data_size=-1" \
|
||||
"$G_NEXT_CLI localhost --priority=NORMAL:-VERS-ALL:+VERS-TLS1.3:+GROUP-ALL -d 10 -r --earlydata $EARLY_DATA_INPUT" \
|
||||
1 \
|
||||
-s "ClientHello: early_data(42) extension exists." \
|
||||
-s "EncryptedExtensions: early_data(42) extension does not exist." \
|
||||
-s "NewSessionTicket: early_data(42) extension does not exist." \
|
||||
-s "Last error was: -29056 - SSL - Verification of the message MAC failed"
|
||||
|
||||
@ -1488,13 +1488,13 @@ component_test_crypto_full_md_light_only () {
|
||||
}
|
||||
|
||||
component_test_full_no_cipher () {
|
||||
msg "build: full minus CIPHER"
|
||||
msg "build: full no CIPHER no PSA_CRYPTO_C"
|
||||
scripts/config.py full
|
||||
scripts/config.py unset MBEDTLS_CIPHER_C
|
||||
# Don't pull in cipher via PSA mechanisms
|
||||
# (currently ignored anyway because we completely disable PSA)
|
||||
scripts/config.py unset MBEDTLS_PSA_CRYPTO_CONFIG
|
||||
# Direct dependencies
|
||||
# Disable features that depend on CIPHER_C
|
||||
scripts/config.py unset MBEDTLS_CCM_C
|
||||
scripts/config.py unset MBEDTLS_CMAC_C
|
||||
scripts/config.py unset MBEDTLS_GCM_C
|
||||
@ -1504,24 +1504,93 @@ component_test_full_no_cipher () {
|
||||
scripts/config.py unset MBEDTLS_PSA_CRYPTO_C
|
||||
scripts/config.py unset MBEDTLS_SSL_TLS_C
|
||||
scripts/config.py unset MBEDTLS_SSL_TICKET_C
|
||||
# Indirect dependencies
|
||||
scripts/config.py unset MBEDTLS_SSL_CLI_C
|
||||
# Disable features that depend on PSA_CRYPTO_C
|
||||
scripts/config.py unset MBEDTLS_PSA_CRYPTO_SE_C
|
||||
scripts/config.py unset MBEDTLS_PSA_CRYPTO_STORAGE_C
|
||||
scripts/config.py unset MBEDTLS_SSL_DTLS_ANTI_REPLAY
|
||||
scripts/config.py unset MBEDTLS_SSL_DTLS_CONNECTION_ID
|
||||
scripts/config.py unset MBEDTLS_SSL_DTLS_CONNECTION_ID_COMPAT
|
||||
scripts/config.py unset MBEDTLS_SSL_PROTO_TLS1_3
|
||||
scripts/config.py unset MBEDTLS_SSL_SRV_C
|
||||
scripts/config.py unset MBEDTLS_USE_PSA_CRYPTO
|
||||
scripts/config.py unset MBEDTLS_LMS_C
|
||||
scripts/config.py unset MBEDTLS_LMS_PRIVATE
|
||||
make
|
||||
|
||||
msg "test: full minus CIPHER"
|
||||
msg "test: full no CIPHER no PSA_CRYPTO_C"
|
||||
make test
|
||||
}
|
||||
|
||||
# This is a common configurator and test function that is used in:
|
||||
# - component_test_full_no_cipher_with_crypto
|
||||
# - component_test_full_no_cipher_with_crypto_config
|
||||
# It accepts 2 input parameters:
|
||||
# - $1: boolean value which basically reflects status of MBEDTLS_PSA_CRYPTO_CONFIG
|
||||
# - $2: a text string which describes the test component
|
||||
common_test_full_no_cipher_with_psa_crypto () {
|
||||
USE_CRYPTO_CONFIG="$1"
|
||||
COMPONENT_DESCRIPTION="$2"
|
||||
|
||||
msg "build: $COMPONENT_DESCRIPTION"
|
||||
|
||||
scripts/config.py full
|
||||
scripts/config.py unset MBEDTLS_CIPHER_C
|
||||
|
||||
if [ "$USE_CRYPTO_CONFIG" -eq 1 ]; then
|
||||
# The built-in implementation of the following algs/key-types depends
|
||||
# on CIPHER_C so we disable them.
|
||||
# This does not hold for KEY_TYPE_CHACHA20 and ALG_CHACHA20_POLY1305
|
||||
# so we keep them enabled.
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_ALG_CCM
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_ALG_CCM_STAR_NO_TAG
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_ALG_GCM
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_ALG_CMAC
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_ALG_CBC_NO_PADDING
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_ALG_CBC_PKCS7
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_ALG_CFB
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_ALG_CTR
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_ALG_ECB_NO_PADDING
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_ALG_OFB
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_ALG_STREAM_CIPHER
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_KEY_TYPE_AES
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_KEY_TYPE_DES
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_KEY_TYPE_CAMELLIA
|
||||
scripts/config.py -f $CRYPTO_CONFIG_H unset PSA_WANT_KEY_TYPE_ARIA
|
||||
else
|
||||
# Don't pull in cipher via PSA mechanisms
|
||||
scripts/config.py unset MBEDTLS_PSA_CRYPTO_CONFIG
|
||||
# Disable cipher modes/keys that make PSA depend on CIPHER_C.
|
||||
# Keep CHACHA20 and CHACHAPOLY enabled since they do not depend on CIPHER_C.
|
||||
scripts/config.py unset-all MBEDTLS_CIPHER_MODE
|
||||
scripts/config.py unset MBEDTLS_AES_C
|
||||
scripts/config.py unset MBEDTLS_DES_C
|
||||
scripts/config.py unset MBEDTLS_ARIA_C
|
||||
scripts/config.py unset MBEDTLS_CAMELLIA_C
|
||||
# Dependencies on AES_C
|
||||
scripts/config.py unset MBEDTLS_CTR_DRBG_C
|
||||
fi
|
||||
# The following modules directly depends on CIPHER_C
|
||||
scripts/config.py unset MBEDTLS_CCM_C
|
||||
scripts/config.py unset MBEDTLS_CMAC_C
|
||||
scripts/config.py unset MBEDTLS_GCM_C
|
||||
scripts/config.py unset MBEDTLS_NIST_KW_C
|
||||
scripts/config.py unset MBEDTLS_PKCS12_C
|
||||
scripts/config.py unset MBEDTLS_PKCS5_C
|
||||
scripts/config.py unset MBEDTLS_SSL_TLS_C
|
||||
scripts/config.py unset MBEDTLS_SSL_TICKET_C
|
||||
|
||||
make
|
||||
|
||||
# Ensure that CIPHER_C was not re-enabled
|
||||
not grep mbedtls_cipher_init library/cipher.o
|
||||
|
||||
msg "test: $COMPONENT_DESCRIPTION"
|
||||
make test
|
||||
}
|
||||
|
||||
component_test_full_no_cipher_with_crypto() {
|
||||
common_test_full_no_cipher_with_psa_crypto 0 "full no CIPHER no CRYPTO_CONFIG"
|
||||
}
|
||||
|
||||
component_test_full_no_cipher_with_crypto_config() {
|
||||
common_test_full_no_cipher_with_psa_crypto 1 "full no CIPHER"
|
||||
}
|
||||
|
||||
component_test_full_no_bignum () {
|
||||
msg "build: full minus bignum"
|
||||
scripts/config.py full
|
||||
@ -3596,6 +3665,85 @@ component_test_psa_crypto_config_accel_aead () {
|
||||
make test
|
||||
}
|
||||
|
||||
# This is a common configuration function used in:
|
||||
# - component_test_psa_crypto_config_accel_cipher_aead
|
||||
# - component_test_psa_crypto_config_reference_cipher_aead
|
||||
common_psa_crypto_config_accel_cipher_aead() {
|
||||
scripts/config.py unset MBEDTLS_CTR_DRBG_C
|
||||
scripts/config.py unset MBEDTLS_NIST_KW_C
|
||||
}
|
||||
|
||||
# The 2 following test components, i.e.
|
||||
# - component_test_psa_crypto_config_accel_cipher_aead
|
||||
# - component_test_psa_crypto_config_reference_cipher_aead
|
||||
# are meant to be used together in analyze_outcomes.py script in order to test
|
||||
# driver's coverage for ciphers and AEADs.
|
||||
component_test_psa_crypto_config_accel_cipher_aead () {
|
||||
msg "test: crypto config with accelerated cipher and AEAD"
|
||||
|
||||
loc_accel_list="ALG_ECB_NO_PADDING ALG_CBC_NO_PADDING ALG_CBC_PKCS7 ALG_CTR ALG_CFB \
|
||||
ALG_OFB ALG_XTS ALG_STREAM_CIPHER \
|
||||
ALG_GCM ALG_CCM ALG_CHACHA20_POLY1305 ALG_CMAC \
|
||||
KEY_TYPE_DES KEY_TYPE_AES KEY_TYPE_ARIA KEY_TYPE_CHACHA20 KEY_TYPE_CAMELLIA"
|
||||
|
||||
# Configure
|
||||
# ---------
|
||||
|
||||
# Start from the crypto config (no X509 and TLS)
|
||||
helper_libtestdriver1_adjust_config "crypto_full"
|
||||
|
||||
common_psa_crypto_config_accel_cipher_aead
|
||||
|
||||
# Disable the things that are being accelerated
|
||||
scripts/config.py unset MBEDTLS_CIPHER_MODE_CBC
|
||||
scripts/config.py unset MBEDTLS_CIPHER_PADDING_PKCS7
|
||||
scripts/config.py unset MBEDTLS_CIPHER_MODE_CTR
|
||||
scripts/config.py unset MBEDTLS_CIPHER_MODE_CFB
|
||||
scripts/config.py unset MBEDTLS_CIPHER_MODE_OFB
|
||||
scripts/config.py unset MBEDTLS_CIPHER_MODE_XTS
|
||||
scripts/config.py unset MBEDTLS_GCM_C
|
||||
scripts/config.py unset MBEDTLS_CCM_C
|
||||
scripts/config.py unset MBEDTLS_CHACHAPOLY_C
|
||||
scripts/config.py unset MBEDTLS_CMAC_C
|
||||
scripts/config.py unset MBEDTLS_DES_C
|
||||
scripts/config.py unset MBEDTLS_AES_C
|
||||
scripts/config.py unset MBEDTLS_ARIA_C
|
||||
scripts/config.py unset MBEDTLS_CHACHA20_C
|
||||
scripts/config.py unset MBEDTLS_CAMELLIA_C
|
||||
|
||||
# Build
|
||||
# -----
|
||||
|
||||
helper_libtestdriver1_make_drivers "$loc_accel_list"
|
||||
|
||||
helper_libtestdriver1_make_main "$loc_accel_list"
|
||||
|
||||
# Make sure this was not re-enabled by accident (additive config)
|
||||
not grep mbedtls_des library/des.o
|
||||
not grep mbedtls_aes library/aes.o
|
||||
not grep mbedtls_aria library/aria.o
|
||||
not grep mbedtls_camellia library/camellia.o
|
||||
not grep mbedtls_ccm library/ccm.o
|
||||
not grep mbedtls_gcm library/gcm.o
|
||||
not grep mbedtls_chachapoly library/chachapoly.o
|
||||
not grep mbedtls_cmac library/cmac.o
|
||||
|
||||
# Run the tests
|
||||
# -------------
|
||||
|
||||
msg "test: crypto config with accelerated cipher and AEAD"
|
||||
make test
|
||||
}
|
||||
|
||||
component_test_psa_crypto_config_reference_cipher_aead () {
|
||||
helper_libtestdriver1_adjust_config "crypto_full"
|
||||
|
||||
common_psa_crypto_config_accel_cipher_aead
|
||||
|
||||
msg "test: crypto config with non-accelerated cipher and AEAD"
|
||||
make test
|
||||
}
|
||||
|
||||
component_test_aead_chachapoly_disabled() {
|
||||
msg "build: full minus CHACHAPOLY"
|
||||
scripts/config.py full
|
||||
@ -4321,8 +4469,6 @@ component_test_aesni () { # ~ 60s
|
||||
not grep -q "AES note: built-in implementation." ./programs/test/selftest
|
||||
}
|
||||
|
||||
|
||||
|
||||
support_test_aesni_m32() {
|
||||
support_test_m32_o0 && (lscpu | grep -qw aes)
|
||||
}
|
||||
@ -4338,10 +4484,10 @@ component_test_aesni_m32 () { # ~ 60s
|
||||
scripts/config.py unset MBEDTLS_AES_USE_HARDWARE_ONLY
|
||||
scripts/config.py set MBEDTLS_HAVE_ASM
|
||||
|
||||
# test the intrinsics implementation
|
||||
msg "AES tests, test intrinsics"
|
||||
# test the intrinsics implementation with gcc
|
||||
msg "AES tests, test intrinsics (gcc)"
|
||||
make clean
|
||||
make CC=gcc CFLAGS='-m32 -Werror -Wall -Wextra -mpclmul -msse2 -maes' LDFLAGS='-m32'
|
||||
make CC=gcc CFLAGS='-m32 -Werror -Wall -Wextra' LDFLAGS='-m32'
|
||||
# check that we built intrinsics - this should be used by default when supported by the compiler
|
||||
./programs/test/selftest aes | grep "AESNI code" | grep -q "intrinsics"
|
||||
grep -q "AES note: using AESNI" ./programs/test/selftest
|
||||
@ -4363,6 +4509,36 @@ component_test_aesni_m32 () { # ~ 60s
|
||||
not grep -q mbedtls_aesni_has_support ./programs/test/selftest
|
||||
}
|
||||
|
||||
support_test_aesni_m32_clang() {
|
||||
support_test_aesni_m32 && if command -v clang > /dev/null ; then
|
||||
# clang >= 4 is required to build with target attributes
|
||||
clang_ver="$(clang --version|grep version|sed -E 's#.*version ([0-9]+).*#\1#')"
|
||||
[[ "${clang_ver}" -ge 4 ]]
|
||||
else
|
||||
# clang not available
|
||||
false
|
||||
fi
|
||||
}
|
||||
|
||||
component_test_aesni_m32_clang() {
|
||||
|
||||
scripts/config.py set MBEDTLS_AESNI_C
|
||||
scripts/config.py set MBEDTLS_PADLOCK_C
|
||||
scripts/config.py unset MBEDTLS_AES_USE_HARDWARE_ONLY
|
||||
scripts/config.py set MBEDTLS_HAVE_ASM
|
||||
|
||||
# test the intrinsics implementation with clang
|
||||
msg "AES tests, test intrinsics (clang)"
|
||||
make clean
|
||||
make CC=clang CFLAGS='-m32 -Werror -Wall -Wextra' LDFLAGS='-m32'
|
||||
# check that we built intrinsics - this should be used by default when supported by the compiler
|
||||
./programs/test/selftest aes | grep "AESNI code" | grep -q "intrinsics"
|
||||
grep -q "AES note: using AESNI" ./programs/test/selftest
|
||||
grep -q "AES note: built-in implementation." ./programs/test/selftest
|
||||
grep -q "AES note: using VIA Padlock" ./programs/test/selftest
|
||||
grep -q mbedtls_aesni_has_support ./programs/test/selftest
|
||||
}
|
||||
|
||||
# For timebeing, no aarch64 gcc available in CI and no arm64 CI node.
|
||||
component_build_aes_aesce_armcc () {
|
||||
msg "Build: AESCE test on arm64 platform without plain C."
|
||||
|
||||
@ -95,9 +95,21 @@ def analyze_coverage(results, outcomes, allow_list, full_coverage):
|
||||
else:
|
||||
results.warning('Allow listed test case was executed: {}', key)
|
||||
|
||||
def name_matches_pattern(name, str_or_re):
|
||||
"""Check if name matches a pattern, that may be a string or regex.
|
||||
- If the pattern is a string, name must be equal to match.
|
||||
- If the pattern is a regex, name must fully match.
|
||||
"""
|
||||
# The CI's python is too old for re.Pattern
|
||||
#if isinstance(str_or_re, re.Pattern):
|
||||
if not isinstance(str_or_re, str):
|
||||
return str_or_re.fullmatch(name)
|
||||
else:
|
||||
return str_or_re == name
|
||||
|
||||
def analyze_driver_vs_reference(results: Results, outcomes,
|
||||
component_ref, component_driver,
|
||||
ignored_suites, ignored_test=None):
|
||||
ignored_suites, ignored_tests=None):
|
||||
"""Check that all tests executed in the reference component are also
|
||||
executed in the corresponding driver component.
|
||||
Skip:
|
||||
@ -105,22 +117,25 @@ def analyze_driver_vs_reference(results: Results, outcomes,
|
||||
- only some specific test inside a test suite, for which the corresponding
|
||||
output string is provided
|
||||
"""
|
||||
available = check_test_cases.collect_available_test_cases()
|
||||
|
||||
for key in available:
|
||||
# Continue if test was not executed by any component
|
||||
hits = outcomes[key].hits() if key in outcomes else 0
|
||||
if hits == 0:
|
||||
continue
|
||||
# Skip ignored test suites
|
||||
full_test_suite = key.split(';')[0] # retrieve full test suite name
|
||||
test_string = key.split(';')[1] # retrieve the text string of this test
|
||||
seen_reference_passing = False
|
||||
for key in outcomes:
|
||||
# key is like "test_suite_foo.bar;Description of test case"
|
||||
(full_test_suite, test_string) = key.split(';')
|
||||
test_suite = full_test_suite.split('.')[0] # retrieve main part of test suite name
|
||||
|
||||
# Immediately skip fully-ignored test suites
|
||||
if test_suite in ignored_suites or full_test_suite in ignored_suites:
|
||||
continue
|
||||
if ((full_test_suite in ignored_test) and
|
||||
(test_string in ignored_test[full_test_suite])):
|
||||
continue
|
||||
|
||||
# For ignored test cases inside test suites, just remember and:
|
||||
# don't issue an error if they're skipped with drivers,
|
||||
# but issue an error if they're not (means we have a bad entry).
|
||||
ignored = False
|
||||
if full_test_suite in ignored_tests:
|
||||
for str_or_re in ignored_tests[test_suite]:
|
||||
if name_matches_pattern(test_string, str_or_re):
|
||||
ignored = True
|
||||
|
||||
# Search for tests that run in reference component and not in driver component
|
||||
driver_test_passed = False
|
||||
reference_test_passed = False
|
||||
@ -129,8 +144,14 @@ def analyze_driver_vs_reference(results: Results, outcomes,
|
||||
driver_test_passed = True
|
||||
if component_ref in entry:
|
||||
reference_test_passed = True
|
||||
if(reference_test_passed and not driver_test_passed):
|
||||
results.error("Did not pass with driver: {}", key)
|
||||
seen_reference_passing = True
|
||||
if reference_test_passed and not driver_test_passed and not ignored:
|
||||
results.error("PASS -> SKIP/FAIL: {}", key)
|
||||
if ignored and driver_test_passed:
|
||||
results.error("uselessly ignored: {}", key)
|
||||
|
||||
if not seen_reference_passing:
|
||||
results.error("no passing test in reference component: bad outcome file?")
|
||||
|
||||
def analyze_outcomes(results: Results, outcomes, args):
|
||||
"""Run all analyses on the given outcome collection."""
|
||||
@ -214,17 +235,71 @@ KNOWN_TASKS = {
|
||||
}
|
||||
}
|
||||
},
|
||||
'analyze_driver_vs_reference_cipher_aead': {
|
||||
'test_function': do_analyze_driver_vs_reference,
|
||||
'args': {
|
||||
'component_ref': 'test_psa_crypto_config_reference_cipher_aead',
|
||||
'component_driver': 'test_psa_crypto_config_accel_cipher_aead',
|
||||
# Modules replaced by drivers.
|
||||
'ignored_suites': [
|
||||
# low-level (block/stream) cipher modules
|
||||
'aes', 'aria', 'camellia', 'des', 'chacha20',
|
||||
# AEAD modes
|
||||
'ccm', 'chachapoly', 'cmac', 'gcm',
|
||||
# The Cipher abstraction layer
|
||||
'cipher',
|
||||
],
|
||||
'ignored_tests': {
|
||||
# PEM decryption is not supported so far.
|
||||
# The rest of PEM (write, unencrypted read) works though.
|
||||
'test_suite_pem': [
|
||||
re.compile(r'PEM read .*(AES|DES|\bencrypt).*'),
|
||||
],
|
||||
# Following tests depend on AES_C/DES_C but are not about
|
||||
# them really, just need to know some error code is there.
|
||||
'test_suite_error': [
|
||||
'Low and high error',
|
||||
'Single low error'
|
||||
],
|
||||
# Similar to test_suite_error above.
|
||||
'test_suite_version': [
|
||||
'Check for MBEDTLS_AES_C when already present',
|
||||
],
|
||||
# The en/decryption part of PKCS#12 is not supported so far.
|
||||
# The rest of PKCS#12 (key derivation) works though.
|
||||
'test_suite_pkcs12': [
|
||||
re.compile(r'PBE Encrypt, .*'),
|
||||
re.compile(r'PBE Decrypt, .*'),
|
||||
],
|
||||
# The en/decryption part of PKCS#5 is not supported so far.
|
||||
# The rest of PKCS#5 (PBKDF2) works though.
|
||||
'test_suite_pkcs5': [
|
||||
re.compile(r'PBES2 Encrypt, .*'),
|
||||
re.compile(r'PBES2 Decrypt .*'),
|
||||
],
|
||||
# Encrypted keys are not supported so far.
|
||||
# pylint: disable=line-too-long
|
||||
'test_suite_pkparse': [
|
||||
'Key ASN1 (Encrypted key PKCS12, trailing garbage data)',
|
||||
'Key ASN1 (Encrypted key PKCS5, trailing garbage data)',
|
||||
re.compile(r'Parse RSA Key .*\(PKCS#8 encrypted .*\)'),
|
||||
],
|
||||
}
|
||||
}
|
||||
},
|
||||
'analyze_driver_vs_reference_ecp_light_only': {
|
||||
'test_function': do_analyze_driver_vs_reference,
|
||||
'args': {
|
||||
'component_ref': 'test_psa_crypto_config_reference_ecc_ecp_light_only',
|
||||
'component_driver': 'test_psa_crypto_config_accel_ecc_ecp_light_only',
|
||||
'ignored_suites': [
|
||||
'ecdsa',
|
||||
'ecdh',
|
||||
'ecjpake',
|
||||
# Modules replaced by drivers
|
||||
'ecdsa', 'ecdh', 'ecjpake',
|
||||
],
|
||||
'ignored_tests': {
|
||||
# This test wants a legacy function that takes f_rng, p_rng
|
||||
# arguments, and uses legacy ECDSA for that. The test is
|
||||
# really about the wrapper around the PSA RNG, not ECDSA.
|
||||
'test_suite_random': [
|
||||
'PSA classic wrapper: ECDSA signature (SECP256R1)',
|
||||
],
|
||||
@ -232,49 +307,14 @@ KNOWN_TASKS = {
|
||||
# so we must ignore disparities in the tests for which ECP_C
|
||||
# is required.
|
||||
'test_suite_ecp': [
|
||||
'ECP check public-private #1 (OK)',
|
||||
'ECP check public-private #2 (group none)',
|
||||
'ECP check public-private #3 (group mismatch)',
|
||||
'ECP check public-private #4 (Qx mismatch)',
|
||||
'ECP check public-private #5 (Qy mismatch)',
|
||||
'ECP check public-private #6 (wrong Qx)',
|
||||
'ECP check public-private #7 (wrong Qy)',
|
||||
'ECP gen keypair [#1]',
|
||||
'ECP gen keypair [#2]',
|
||||
'ECP gen keypair [#3]',
|
||||
'ECP gen keypair wrapper',
|
||||
'ECP point muladd secp256r1 #1',
|
||||
'ECP point muladd secp256r1 #2',
|
||||
'ECP point multiplication Curve25519 (element of order 2: origin) #3',
|
||||
'ECP point multiplication Curve25519 (element of order 4: 1) #4',
|
||||
'ECP point multiplication Curve25519 (element of order 8) #5',
|
||||
'ECP point multiplication Curve25519 (normalized) #1',
|
||||
'ECP point multiplication Curve25519 (not normalized) #2',
|
||||
'ECP point multiplication rng fail Curve25519',
|
||||
'ECP point multiplication rng fail secp256r1',
|
||||
'ECP test vectors Curve25519',
|
||||
'ECP test vectors Curve448 (RFC 7748 6.2, after decodeUCoordinate)',
|
||||
'ECP test vectors brainpoolP256r1 rfc 7027',
|
||||
'ECP test vectors brainpoolP384r1 rfc 7027',
|
||||
'ECP test vectors brainpoolP512r1 rfc 7027',
|
||||
'ECP test vectors secp192k1',
|
||||
'ECP test vectors secp192r1 rfc 5114',
|
||||
'ECP test vectors secp224k1',
|
||||
'ECP test vectors secp224r1 rfc 5114',
|
||||
'ECP test vectors secp256k1',
|
||||
'ECP test vectors secp256r1 rfc 5114',
|
||||
'ECP test vectors secp384r1 rfc 5114',
|
||||
'ECP test vectors secp521r1 rfc 5114',
|
||||
],
|
||||
'test_suite_psa_crypto': [
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1 (1 redraw)',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1, exercise ECDSA',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp384r1',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp521r1 #0',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp521r1 #1',
|
||||
re.compile(r'ECP check public-private .*'),
|
||||
re.compile(r'ECP gen keypair .*'),
|
||||
re.compile(r'ECP point muladd .*'),
|
||||
re.compile(r'ECP point multiplication .*'),
|
||||
re.compile(r'ECP test vectors .*'),
|
||||
],
|
||||
'test_suite_ssl': [
|
||||
# This deprecated function is only present when ECP_C is On.
|
||||
'Test configuration of groups for DHE through mbedtls_ssl_conf_curves()',
|
||||
],
|
||||
}
|
||||
@ -286,32 +326,14 @@ KNOWN_TASKS = {
|
||||
'component_ref': 'test_psa_crypto_config_reference_ecc_no_ecp_at_all',
|
||||
'component_driver': 'test_psa_crypto_config_accel_ecc_no_ecp_at_all',
|
||||
'ignored_suites': [
|
||||
# Ignore test suites for the modules that are disabled in the
|
||||
# accelerated test case.
|
||||
'ecp',
|
||||
'ecdsa',
|
||||
'ecdh',
|
||||
'ecjpake',
|
||||
# Modules replaced by drivers
|
||||
'ecp', 'ecdsa', 'ecdh', 'ecjpake',
|
||||
],
|
||||
'ignored_tests': {
|
||||
# See ecp_light_only
|
||||
'test_suite_random': [
|
||||
'PSA classic wrapper: ECDSA signature (SECP256R1)',
|
||||
],
|
||||
'test_suite_psa_crypto': [
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1 (1 redraw)',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1, exercise ECDSA',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp384r1',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp521r1 #0',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp521r1 #1',
|
||||
'PSA key derivation: bits=7 invalid for ECC BRAINPOOL_P_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_K1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_R2 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_K1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_R2 (ECC enabled)',
|
||||
],
|
||||
'test_suite_pkparse': [
|
||||
# When PK_PARSE_C and ECP_C are defined then PK_PARSE_EC_COMPRESSED
|
||||
# is automatically enabled in build_info.h (backward compatibility)
|
||||
@ -319,23 +341,10 @@ KNOWN_TASKS = {
|
||||
# consequence compressed points are supported in the reference
|
||||
# component but not in the accelerated one, so they should be skipped
|
||||
# while checking driver's coverage.
|
||||
'Parse EC Key #10a (SEC1 PEM, secp384r1, compressed)',
|
||||
'Parse EC Key #11a (SEC1 PEM, secp521r1, compressed)',
|
||||
'Parse EC Key #12a (SEC1 PEM, bp256r1, compressed)',
|
||||
'Parse EC Key #13a (SEC1 PEM, bp384r1, compressed)',
|
||||
'Parse EC Key #14a (SEC1 PEM, bp512r1, compressed)',
|
||||
'Parse EC Key #2a (SEC1 PEM, secp192r1, compressed)',
|
||||
'Parse EC Key #8a (SEC1 PEM, secp224r1, compressed)',
|
||||
'Parse EC Key #9a (SEC1 PEM, secp256r1, compressed)',
|
||||
'Parse Public EC Key #2a (RFC 5480, PEM, secp192r1, compressed)',
|
||||
'Parse Public EC Key #3a (RFC 5480, secp224r1, compressed)',
|
||||
'Parse Public EC Key #4a (RFC 5480, secp256r1, compressed)',
|
||||
'Parse Public EC Key #5a (RFC 5480, secp384r1, compressed)',
|
||||
'Parse Public EC Key #6a (RFC 5480, secp521r1, compressed)',
|
||||
'Parse Public EC Key #7a (RFC 5480, brainpoolP256r1, compressed)',
|
||||
'Parse Public EC Key #8a (RFC 5480, brainpoolP384r1, compressed)',
|
||||
'Parse Public EC Key #9a (RFC 5480, brainpoolP512r1, compressed)',
|
||||
re.compile(r'Parse EC Key .*compressed\)'),
|
||||
re.compile(r'Parse Public EC Key .*compressed\)'),
|
||||
],
|
||||
# See ecp_light_only
|
||||
'test_suite_ssl': [
|
||||
'Test configuration of groups for DHE through mbedtls_ssl_conf_curves()',
|
||||
],
|
||||
@ -348,90 +357,31 @@ KNOWN_TASKS = {
|
||||
'component_ref': 'test_psa_crypto_config_reference_ecc_no_bignum',
|
||||
'component_driver': 'test_psa_crypto_config_accel_ecc_no_bignum',
|
||||
'ignored_suites': [
|
||||
# Ignore test suites for the modules that are disabled in the
|
||||
# accelerated test case.
|
||||
'ecp',
|
||||
'ecdsa',
|
||||
'ecdh',
|
||||
'ecjpake',
|
||||
'bignum_core',
|
||||
'bignum_random',
|
||||
'bignum_mod',
|
||||
'bignum_mod_raw',
|
||||
'bignum.generated',
|
||||
'bignum.misc',
|
||||
# Modules replaced by drivers
|
||||
'ecp', 'ecdsa', 'ecdh', 'ecjpake',
|
||||
'bignum_core', 'bignum_random', 'bignum_mod', 'bignum_mod_raw',
|
||||
'bignum.generated', 'bignum.misc',
|
||||
],
|
||||
'ignored_tests': {
|
||||
# See ecp_light_only
|
||||
'test_suite_random': [
|
||||
'PSA classic wrapper: ECDSA signature (SECP256R1)',
|
||||
],
|
||||
'test_suite_psa_crypto': [
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1 (1 redraw)',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1, exercise ECDSA',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp384r1',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp521r1 #0',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp521r1 #1',
|
||||
'PSA key derivation: bits=7 invalid for ECC BRAINPOOL_P_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_K1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_R2 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_K1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_R2 (ECC enabled)',
|
||||
],
|
||||
# See no_ecp_at_all
|
||||
'test_suite_pkparse': [
|
||||
# See the description provided above in the
|
||||
# analyze_driver_vs_reference_no_ecp_at_all component.
|
||||
'Parse EC Key #10a (SEC1 PEM, secp384r1, compressed)',
|
||||
'Parse EC Key #11a (SEC1 PEM, secp521r1, compressed)',
|
||||
'Parse EC Key #12a (SEC1 PEM, bp256r1, compressed)',
|
||||
'Parse EC Key #13a (SEC1 PEM, bp384r1, compressed)',
|
||||
'Parse EC Key #14a (SEC1 PEM, bp512r1, compressed)',
|
||||
'Parse EC Key #2a (SEC1 PEM, secp192r1, compressed)',
|
||||
'Parse EC Key #8a (SEC1 PEM, secp224r1, compressed)',
|
||||
'Parse EC Key #9a (SEC1 PEM, secp256r1, compressed)',
|
||||
'Parse Public EC Key #2a (RFC 5480, PEM, secp192r1, compressed)',
|
||||
'Parse Public EC Key #3a (RFC 5480, secp224r1, compressed)',
|
||||
'Parse Public EC Key #4a (RFC 5480, secp256r1, compressed)',
|
||||
'Parse Public EC Key #5a (RFC 5480, secp384r1, compressed)',
|
||||
'Parse Public EC Key #6a (RFC 5480, secp521r1, compressed)',
|
||||
'Parse Public EC Key #7a (RFC 5480, brainpoolP256r1, compressed)',
|
||||
'Parse Public EC Key #8a (RFC 5480, brainpoolP384r1, compressed)',
|
||||
'Parse Public EC Key #9a (RFC 5480, brainpoolP512r1, compressed)',
|
||||
re.compile(r'Parse EC Key .*compressed\)'),
|
||||
re.compile(r'Parse Public EC Key .*compressed\)'),
|
||||
],
|
||||
'test_suite_asn1parse': [
|
||||
# This test depends on BIGNUM_C
|
||||
'INTEGER too large for mpi',
|
||||
],
|
||||
'test_suite_asn1write': [
|
||||
# Following tests depends on BIGNUM_C
|
||||
'ASN.1 Write mpi 0 (1 limb)',
|
||||
'ASN.1 Write mpi 0 (null)',
|
||||
'ASN.1 Write mpi 0x100',
|
||||
'ASN.1 Write mpi 0x7f',
|
||||
'ASN.1 Write mpi 0x7f with leading 0 limb',
|
||||
'ASN.1 Write mpi 0x80',
|
||||
'ASN.1 Write mpi 0x80 with leading 0 limb',
|
||||
'ASN.1 Write mpi 0xff',
|
||||
'ASN.1 Write mpi 1',
|
||||
'ASN.1 Write mpi, 127*8 bits',
|
||||
'ASN.1 Write mpi, 127*8+1 bits',
|
||||
'ASN.1 Write mpi, 127*8-1 bits',
|
||||
'ASN.1 Write mpi, 255*8 bits',
|
||||
'ASN.1 Write mpi, 255*8-1 bits',
|
||||
'ASN.1 Write mpi, 256*8-1 bits',
|
||||
re.compile(r'ASN.1 Write mpi.*'),
|
||||
],
|
||||
'test_suite_debug': [
|
||||
# Following tests depends on BIGNUM_C
|
||||
'Debug print mbedtls_mpi #2: 3 bits',
|
||||
'Debug print mbedtls_mpi: 0 (empty representation)',
|
||||
'Debug print mbedtls_mpi: 0 (non-empty representation)',
|
||||
'Debug print mbedtls_mpi: 49 bits',
|
||||
'Debug print mbedtls_mpi: 759 bits',
|
||||
'Debug print mbedtls_mpi: 764 bits #1',
|
||||
'Debug print mbedtls_mpi: 764 bits #2',
|
||||
re.compile(r'Debug print mbedtls_mpi.*'),
|
||||
],
|
||||
# See ecp_light_only
|
||||
'test_suite_ssl': [
|
||||
'Test configuration of groups for DHE through mbedtls_ssl_conf_curves()',
|
||||
],
|
||||
@ -444,91 +394,31 @@ KNOWN_TASKS = {
|
||||
'component_ref': 'test_psa_crypto_config_reference_ecc_ffdh_no_bignum',
|
||||
'component_driver': 'test_psa_crypto_config_accel_ecc_ffdh_no_bignum',
|
||||
'ignored_suites': [
|
||||
# Ignore test suites for the modules that are disabled in the
|
||||
# accelerated test case.
|
||||
'ecp',
|
||||
'ecdsa',
|
||||
'ecdh',
|
||||
'ecjpake',
|
||||
'bignum_core',
|
||||
'bignum_random',
|
||||
'bignum_mod',
|
||||
'bignum_mod_raw',
|
||||
'bignum.generated',
|
||||
'bignum.misc',
|
||||
'dhm',
|
||||
# Modules replaced by drivers
|
||||
'ecp', 'ecdsa', 'ecdh', 'ecjpake', 'dhm',
|
||||
'bignum_core', 'bignum_random', 'bignum_mod', 'bignum_mod_raw',
|
||||
'bignum.generated', 'bignum.misc',
|
||||
],
|
||||
'ignored_tests': {
|
||||
# See ecp_light_only
|
||||
'test_suite_random': [
|
||||
'PSA classic wrapper: ECDSA signature (SECP256R1)',
|
||||
],
|
||||
'test_suite_psa_crypto': [
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1 (1 redraw)',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1, exercise ECDSA',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp384r1',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp521r1 #0',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp521r1 #1',
|
||||
'PSA key derivation: bits=7 invalid for ECC BRAINPOOL_P_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_K1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_R2 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_K1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_R2 (ECC enabled)',
|
||||
],
|
||||
# See no_ecp_at_all
|
||||
'test_suite_pkparse': [
|
||||
# See the description provided above in the
|
||||
# analyze_driver_vs_reference_no_ecp_at_all component.
|
||||
'Parse EC Key #10a (SEC1 PEM, secp384r1, compressed)',
|
||||
'Parse EC Key #11a (SEC1 PEM, secp521r1, compressed)',
|
||||
'Parse EC Key #12a (SEC1 PEM, bp256r1, compressed)',
|
||||
'Parse EC Key #13a (SEC1 PEM, bp384r1, compressed)',
|
||||
'Parse EC Key #14a (SEC1 PEM, bp512r1, compressed)',
|
||||
'Parse EC Key #2a (SEC1 PEM, secp192r1, compressed)',
|
||||
'Parse EC Key #8a (SEC1 PEM, secp224r1, compressed)',
|
||||
'Parse EC Key #9a (SEC1 PEM, secp256r1, compressed)',
|
||||
'Parse Public EC Key #2a (RFC 5480, PEM, secp192r1, compressed)',
|
||||
'Parse Public EC Key #3a (RFC 5480, secp224r1, compressed)',
|
||||
'Parse Public EC Key #4a (RFC 5480, secp256r1, compressed)',
|
||||
'Parse Public EC Key #5a (RFC 5480, secp384r1, compressed)',
|
||||
'Parse Public EC Key #6a (RFC 5480, secp521r1, compressed)',
|
||||
'Parse Public EC Key #7a (RFC 5480, brainpoolP256r1, compressed)',
|
||||
'Parse Public EC Key #8a (RFC 5480, brainpoolP384r1, compressed)',
|
||||
'Parse Public EC Key #9a (RFC 5480, brainpoolP512r1, compressed)',
|
||||
re.compile(r'Parse EC Key .*compressed\)'),
|
||||
re.compile(r'Parse Public EC Key .*compressed\)'),
|
||||
],
|
||||
'test_suite_asn1parse': [
|
||||
# This test depends on BIGNUM_C
|
||||
'INTEGER too large for mpi',
|
||||
],
|
||||
'test_suite_asn1write': [
|
||||
# Following tests depends on BIGNUM_C
|
||||
'ASN.1 Write mpi 0 (1 limb)',
|
||||
'ASN.1 Write mpi 0 (null)',
|
||||
'ASN.1 Write mpi 0x100',
|
||||
'ASN.1 Write mpi 0x7f',
|
||||
'ASN.1 Write mpi 0x7f with leading 0 limb',
|
||||
'ASN.1 Write mpi 0x80',
|
||||
'ASN.1 Write mpi 0x80 with leading 0 limb',
|
||||
'ASN.1 Write mpi 0xff',
|
||||
'ASN.1 Write mpi 1',
|
||||
'ASN.1 Write mpi, 127*8 bits',
|
||||
'ASN.1 Write mpi, 127*8+1 bits',
|
||||
'ASN.1 Write mpi, 127*8-1 bits',
|
||||
'ASN.1 Write mpi, 255*8 bits',
|
||||
'ASN.1 Write mpi, 255*8-1 bits',
|
||||
'ASN.1 Write mpi, 256*8-1 bits',
|
||||
re.compile(r'ASN.1 Write mpi.*'),
|
||||
],
|
||||
'test_suite_debug': [
|
||||
# Following tests depends on BIGNUM_C
|
||||
'Debug print mbedtls_mpi #2: 3 bits',
|
||||
'Debug print mbedtls_mpi: 0 (empty representation)',
|
||||
'Debug print mbedtls_mpi: 0 (non-empty representation)',
|
||||
'Debug print mbedtls_mpi: 49 bits',
|
||||
'Debug print mbedtls_mpi: 759 bits',
|
||||
'Debug print mbedtls_mpi: 764 bits #1',
|
||||
'Debug print mbedtls_mpi: 764 bits #2',
|
||||
re.compile(r'Debug print mbedtls_mpi.*'),
|
||||
],
|
||||
# See ecp_light_only
|
||||
'test_suite_ssl': [
|
||||
'Test configuration of groups for DHE through mbedtls_ssl_conf_curves()',
|
||||
],
|
||||
@ -550,92 +440,21 @@ KNOWN_TASKS = {
|
||||
'component_ref': 'test_tfm_config',
|
||||
'component_driver': 'test_tfm_config_p256m_driver_accel_ec',
|
||||
'ignored_suites': [
|
||||
# Ignore test suites for the modules that are disabled in the
|
||||
# accelerated test case.
|
||||
'ecp',
|
||||
'ecdsa',
|
||||
'ecdh',
|
||||
'ecjpake',
|
||||
'bignum_core',
|
||||
'bignum_random',
|
||||
'bignum_mod',
|
||||
'bignum_mod_raw',
|
||||
'bignum.generated',
|
||||
'bignum.misc',
|
||||
# Modules replaced by drivers
|
||||
'ecp', 'ecdsa', 'ecdh', 'ecjpake',
|
||||
'bignum_core', 'bignum_random', 'bignum_mod', 'bignum_mod_raw',
|
||||
'bignum.generated', 'bignum.misc',
|
||||
],
|
||||
'ignored_tests': {
|
||||
# Ignore all tests that require DERIVE support which is disabled
|
||||
# in the driver version
|
||||
'test_suite_psa_crypto': [
|
||||
'PSA key agreement setup: ECDH + HKDF-SHA-256: good',
|
||||
('PSA key agreement setup: ECDH + HKDF-SHA-256: good, key algorithm broader '
|
||||
'than required'),
|
||||
'PSA key agreement setup: ECDH + HKDF-SHA-256: public key not on curve',
|
||||
'PSA key agreement setup: KDF instead of a key agreement algorithm',
|
||||
'PSA key agreement setup: bad key agreement algorithm',
|
||||
'PSA key agreement: ECDH SECP256R1 (RFC 5903) + HKDF-SHA-256: capacity=8160',
|
||||
'PSA key agreement: ECDH SECP256R1 (RFC 5903) + HKDF-SHA-256: read 0+32',
|
||||
'PSA key agreement: ECDH SECP256R1 (RFC 5903) + HKDF-SHA-256: read 1+31',
|
||||
'PSA key agreement: ECDH SECP256R1 (RFC 5903) + HKDF-SHA-256: read 31+1',
|
||||
'PSA key agreement: ECDH SECP256R1 (RFC 5903) + HKDF-SHA-256: read 32+0',
|
||||
'PSA key agreement: ECDH SECP256R1 (RFC 5903) + HKDF-SHA-256: read 32+32',
|
||||
'PSA key agreement: ECDH SECP256R1 (RFC 5903) + HKDF-SHA-256: read 64+0',
|
||||
'PSA key derivation: ECDH on P256 with HKDF-SHA256, info first',
|
||||
'PSA key derivation: ECDH on P256 with HKDF-SHA256, key output',
|
||||
'PSA key derivation: ECDH on P256 with HKDF-SHA256, missing info',
|
||||
'PSA key derivation: ECDH on P256 with HKDF-SHA256, omitted salt',
|
||||
'PSA key derivation: ECDH on P256 with HKDF-SHA256, raw output',
|
||||
'PSA key derivation: ECDH on P256 with HKDF-SHA256, salt after secret',
|
||||
'PSA key derivation: ECDH with TLS 1.2 PRF SHA-256, good case',
|
||||
'PSA key derivation: ECDH with TLS 1.2 PRF SHA-256, missing label',
|
||||
'PSA key derivation: ECDH with TLS 1.2 PRF SHA-256, missing label and secret',
|
||||
'PSA key derivation: ECDH with TLS 1.2 PRF SHA-256, no inputs',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1 (1 redraw)',
|
||||
'PSA key derivation: HKDF-SHA-256 -> ECC secp256r1, exercise ECDSA',
|
||||
'PSA key derivation: TLS 1.2 Mix-PSK-to-MS, SHA-256, 0+48, ka',
|
||||
'PSA key derivation: TLS 1.2 Mix-PSK-to-MS, SHA-256, 24+24, ka',
|
||||
'PSA key derivation: TLS 1.2 Mix-PSK-to-MS, SHA-256, 48+0, ka',
|
||||
'PSA key derivation: TLS 1.2 Mix-PSK-to-MS, bad state #1, ka',
|
||||
'PSA key derivation: TLS 1.2 Mix-PSK-to-MS, bad state #3, ka',
|
||||
'PSA key derivation: TLS 1.2 Mix-PSK-to-MS, bad state #4, ka',
|
||||
'PSA key derivation: bits=7 invalid for ECC BRAINPOOL_P_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC MONTGOMERY (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_K1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECP_R2 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_K1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_R1 (ECC enabled)',
|
||||
'PSA key derivation: bits=7 invalid for ECC SECT_R2 (ECC enabled)',
|
||||
'PSA raw key agreement: ECDH SECP256R1 (RFC 5903)',
|
||||
],
|
||||
# See ecp_light_only
|
||||
'test_suite_random': [
|
||||
'PSA classic wrapper: ECDSA signature (SECP256R1)',
|
||||
],
|
||||
'test_suite_psa_crypto_pake': [
|
||||
'PSA PAKE: ecjpake size macros',
|
||||
],
|
||||
'test_suite_asn1parse': [
|
||||
# This test depends on BIGNUM_C
|
||||
'INTEGER too large for mpi',
|
||||
],
|
||||
'test_suite_asn1write': [
|
||||
# Following tests depends on BIGNUM_C
|
||||
'ASN.1 Write mpi 0 (1 limb)',
|
||||
'ASN.1 Write mpi 0 (null)',
|
||||
'ASN.1 Write mpi 0x100',
|
||||
'ASN.1 Write mpi 0x7f',
|
||||
'ASN.1 Write mpi 0x7f with leading 0 limb',
|
||||
'ASN.1 Write mpi 0x80',
|
||||
'ASN.1 Write mpi 0x80 with leading 0 limb',
|
||||
'ASN.1 Write mpi 0xff',
|
||||
'ASN.1 Write mpi 1',
|
||||
'ASN.1 Write mpi, 127*8 bits',
|
||||
'ASN.1 Write mpi, 127*8+1 bits',
|
||||
'ASN.1 Write mpi, 127*8-1 bits',
|
||||
'ASN.1 Write mpi, 255*8 bits',
|
||||
'ASN.1 Write mpi, 255*8-1 bits',
|
||||
'ASN.1 Write mpi, 256*8-1 bits',
|
||||
re.compile(r'ASN.1 Write mpi.*'),
|
||||
],
|
||||
}
|
||||
}
|
||||
@ -674,7 +493,7 @@ def main():
|
||||
tasks_list = re.split(r'[, ]+', options.specified_tasks)
|
||||
for task in tasks_list:
|
||||
if task not in KNOWN_TASKS:
|
||||
sys.stderr.write('invalid task: {}'.format(task))
|
||||
sys.stderr.write('invalid task: {}\n'.format(task))
|
||||
sys.exit(2)
|
||||
|
||||
KNOWN_TASKS['analyze_coverage']['args']['full_coverage'] = options.full_coverage
|
||||
|
||||
@ -72,6 +72,7 @@ guess_config_name() {
|
||||
: ${MBEDTLS_TEST_OUTCOME_FILE=}
|
||||
: ${MBEDTLS_TEST_CONFIGURATION:="$(guess_config_name)"}
|
||||
: ${MBEDTLS_TEST_PLATFORM:="$(uname -s | tr -c \\n0-9A-Za-z _)-$(uname -m | tr -c \\n0-9A-Za-z _)"}
|
||||
: ${EARLY_DATA_INPUT:=data_files/tls13_early_data.txt}
|
||||
|
||||
O_SRV="$OPENSSL s_server -www -cert data_files/server5.crt -key data_files/server5.key"
|
||||
O_CLI="echo 'GET / HTTP/1.0' | $OPENSSL s_client"
|
||||
|
||||
@ -432,6 +432,50 @@ static void write_outcome_result(FILE *outcome_file,
|
||||
fflush(outcome_file);
|
||||
}
|
||||
|
||||
#if defined(__unix__) || \
|
||||
(defined(__APPLE__) && defined(__MACH__))
|
||||
#define MBEDTLS_HAVE_CHDIR
|
||||
#endif
|
||||
|
||||
#if defined(MBEDTLS_HAVE_CHDIR)
|
||||
/** Try chdir to the directory containing argv0.
|
||||
*
|
||||
* Failures are silent.
|
||||
*/
|
||||
static void try_chdir_if_supported(const char *argv0)
|
||||
{
|
||||
/* We might want to allow backslash as well, for Windows. But then we also
|
||||
* need to consider chdir() vs _chdir(), and different conventions
|
||||
* regarding paths in argv[0] (naively enabling this code with
|
||||
* backslash support on Windows leads to chdir into the wrong directory
|
||||
* on the CI). */
|
||||
const char *slash = strrchr(argv0, '/');
|
||||
if (slash == NULL) {
|
||||
return;
|
||||
}
|
||||
size_t path_size = slash - argv0 + 1;
|
||||
char *path = mbedtls_calloc(1, path_size);
|
||||
if (path == NULL) {
|
||||
return;
|
||||
}
|
||||
memcpy(path, argv0, path_size - 1);
|
||||
path[path_size - 1] = 0;
|
||||
int ret = chdir(path);
|
||||
if (ret != 0) {
|
||||
mbedtls_fprintf(stderr, "%s: note: chdir(\"%s\") failed.\n",
|
||||
__func__, path);
|
||||
}
|
||||
mbedtls_free(path);
|
||||
}
|
||||
#else /* MBEDTLS_HAVE_CHDIR */
|
||||
/* No chdir() or no support for parsing argv[0] on this platform. */
|
||||
static void try_chdir_if_supported(const char *argv0)
|
||||
{
|
||||
(void) argv0;
|
||||
return;
|
||||
}
|
||||
#endif /* MBEDTLS_HAVE_CHDIR */
|
||||
|
||||
/**
|
||||
* \brief Desktop implementation of execute_tests().
|
||||
* Parses command line and executes tests from
|
||||
|
||||
@ -237,6 +237,21 @@ int main(int argc, const char *argv[])
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/* Try changing to the directory containing the executable, if
|
||||
* using the default data file. This allows running the executable
|
||||
* from another directory (e.g. the project root) and still access
|
||||
* the .datax file as well as data files used by test cases
|
||||
* (typically from tests/data_files).
|
||||
*
|
||||
* Note that we do this before the platform setup (which may access
|
||||
* files such as a random seed). We also do this before accessing
|
||||
* test-specific files such as the outcome file, which is arguably
|
||||
* not desirable and should be fixed later.
|
||||
*/
|
||||
if (argc == 1) {
|
||||
try_chdir_if_supported(argv[0]);
|
||||
}
|
||||
|
||||
int ret = mbedtls_test_platform_setup();
|
||||
if (ret != 0) {
|
||||
mbedtls_fprintf(stderr,
|
||||
|
||||
@ -173,8 +173,8 @@ void cipher_invalid_param_unconditional()
|
||||
unsigned char valid_buffer[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 };
|
||||
int valid_size = sizeof(valid_buffer);
|
||||
int valid_bitlen = valid_size * 8;
|
||||
const mbedtls_cipher_info_t *valid_info = mbedtls_cipher_info_from_type(
|
||||
*(mbedtls_cipher_list()));
|
||||
const int *cipher_list = mbedtls_cipher_list();
|
||||
const mbedtls_cipher_info_t *valid_info;
|
||||
size_t size_t_var;
|
||||
|
||||
(void) valid_mode; /* In some configurations this is unused */
|
||||
@ -182,6 +182,10 @@ void cipher_invalid_param_unconditional()
|
||||
mbedtls_cipher_init(&valid_ctx);
|
||||
mbedtls_cipher_init(&invalid_ctx);
|
||||
|
||||
/* Ensure that there is at least 1 supported cipher, otherwise exit gracefully */
|
||||
TEST_ASSUME(*cipher_list != 0);
|
||||
valid_info = mbedtls_cipher_info_from_type(*cipher_list);
|
||||
|
||||
TEST_ASSERT(mbedtls_cipher_setup(&valid_ctx, valid_info) == 0);
|
||||
|
||||
/* mbedtls_cipher_setup() */
|
||||
|
||||
@ -31,15 +31,13 @@ static void ctr_drbg_validate_internal(int reseed_mode, data_t *nonce,
|
||||
data_t *result)
|
||||
{
|
||||
mbedtls_ctr_drbg_context ctx;
|
||||
mbedtls_ctr_drbg_init(&ctx);
|
||||
unsigned char buf[64];
|
||||
|
||||
size_t entropy_chunk_len = (size_t) entropy_len_arg;
|
||||
|
||||
TEST_ASSERT(entropy_chunk_len <= sizeof(buf));
|
||||
|
||||
test_offset_idx = 0;
|
||||
mbedtls_ctr_drbg_init(&ctx);
|
||||
|
||||
test_max_idx = entropy->len;
|
||||
|
||||
/* CTR_DRBG_Instantiate(entropy[:entropy->len], nonce, perso, <ignored>)
|
||||
|
||||
@ -102,6 +102,7 @@ static int write_nv_seed(unsigned char *buf, size_t buf_len)
|
||||
|
||||
if (fwrite(buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f) !=
|
||||
MBEDTLS_ENTROPY_BLOCK_SIZE) {
|
||||
fclose(f);
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -124,6 +125,7 @@ int read_nv_seed(unsigned char *buf, size_t buf_len)
|
||||
|
||||
if (fread(buf, 1, MBEDTLS_ENTROPY_BLOCK_SIZE, f) !=
|
||||
MBEDTLS_ENTROPY_BLOCK_SIZE) {
|
||||
fclose(f);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
@ -65,6 +65,8 @@ void mbedtls_mps_reader_no_pausing_single_step_single_round(int with_acc)
|
||||
/* Wrapup (lower layer) */
|
||||
TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, &paused) == 0);
|
||||
TEST_ASSERT(paused == 0);
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -119,6 +121,8 @@ void mbedtls_mps_reader_no_pausing_single_step_multiple_rounds(int with_acc)
|
||||
TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
|
||||
/* Wrapup (lower layer) */
|
||||
TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -170,6 +174,8 @@ void mbedtls_mps_reader_no_pausing_multiple_steps_single_round(int with_acc)
|
||||
TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
|
||||
/* Wrapup (lower layer) */
|
||||
TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -217,6 +223,8 @@ void mbedtls_mps_reader_no_pausing_multiple_steps_multiple_rounds(int with_acc)
|
||||
TEST_ASSERT(mbedtls_mps_reader_commit(&rd) == 0);
|
||||
/* Wrapup */
|
||||
TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -250,6 +258,8 @@ void mbedtls_mps_reader_pausing_needed_disabled()
|
||||
/* Wrapup (lower layer) */
|
||||
TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) ==
|
||||
MBEDTLS_ERR_MPS_READER_NEED_ACCUMULATOR);
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -297,6 +307,7 @@ void mbedtls_mps_reader_pausing_needed_buffer_too_small()
|
||||
TEST_ASSERT(mbedtls_mps_reader_get(&rd, 50, &tmp, &tmp_len) == 0);
|
||||
TEST_MEMORY_COMPARE(tmp, tmp_len, buf + 50, 50);
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -333,6 +344,7 @@ void mbedtls_mps_reader_reclaim_overflow()
|
||||
TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) ==
|
||||
MBEDTLS_ERR_MPS_READER_ACCUMULATOR_TOO_SMALL);
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -458,6 +470,8 @@ void mbedtls_mps_reader_pausing(int option)
|
||||
|
||||
/* Wrapup */
|
||||
TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -562,6 +576,8 @@ void mbedtls_mps_reader_pausing_multiple_feeds(int option)
|
||||
|
||||
/* Wrapup */
|
||||
TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -623,6 +639,8 @@ void mbedtls_mps_reader_reclaim_data_left(int option)
|
||||
/* Wrapup */
|
||||
TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) ==
|
||||
MBEDTLS_ERR_MPS_READER_DATA_LEFT);
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -795,6 +813,7 @@ void mbedtls_mps_reader_multiple_pausing(int option)
|
||||
break;
|
||||
}
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
@ -951,6 +970,7 @@ void mbedtls_mps_reader_random_usage(int num_out_chunks,
|
||||
}
|
||||
}
|
||||
|
||||
exit:
|
||||
/* Cleanup */
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
mbedtls_free(incoming);
|
||||
@ -1103,6 +1123,7 @@ void mbedtls_reader_inconsistent_usage(int option)
|
||||
TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
|
||||
}
|
||||
|
||||
exit:
|
||||
/* Wrapup */
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
@ -1136,6 +1157,8 @@ void mbedtls_mps_reader_feed_empty()
|
||||
|
||||
/* Wrapup */
|
||||
TEST_ASSERT(mbedtls_mps_reader_reclaim(&rd, NULL) == 0);
|
||||
|
||||
exit:
|
||||
mbedtls_mps_reader_free(&rd);
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
@ -68,6 +68,7 @@ static int pk_write_any_key(mbedtls_pk_context *pk, unsigned char **p,
|
||||
static void pk_write_check_common(char *key_file, int is_public_key, int is_der)
|
||||
{
|
||||
mbedtls_pk_context key;
|
||||
mbedtls_pk_init(&key);
|
||||
unsigned char *buf = NULL;
|
||||
unsigned char *check_buf = NULL;
|
||||
unsigned char *start_buf;
|
||||
@ -78,9 +79,6 @@ static void pk_write_check_common(char *key_file, int is_public_key, int is_der)
|
||||
|
||||
USE_PSA_INIT();
|
||||
|
||||
mbedtls_pk_init(&key);
|
||||
USE_PSA_INIT();
|
||||
|
||||
/* Note: if mbedtls_pk_load_file() successfully reads the file, then
|
||||
it also allocates check_buf, which should be freed on exit */
|
||||
TEST_EQUAL(mbedtls_pk_load_file(key_file, &check_buf, &check_buf_len), 0);
|
||||
|
||||
@ -2205,7 +2205,7 @@ depends_on:PSA_WANT_ALG_CTR:PSA_WANT_KEY_TYPE_AES
|
||||
cipher_setup:PSA_KEY_TYPE_AES:"000102030405060708090a0b0c0d0e0f":PSA_ALG_CTR:PSA_SUCCESS
|
||||
|
||||
PSA cipher setup: bad algorithm (unknown cipher algorithm)
|
||||
depends_on:MBEDTLS_AES_C
|
||||
depends_on:PSA_WANT_KEY_TYPE_AES
|
||||
cipher_setup:PSA_KEY_TYPE_AES:"000102030405060708090a0b0c0d0e0f":PSA_ALG_CATEGORY_CIPHER:PSA_ERROR_NOT_SUPPORTED
|
||||
|
||||
PSA cipher setup: bad algorithm (not a cipher algorithm)
|
||||
@ -2213,12 +2213,12 @@ depends_on:PSA_WANT_ALG_CMAC:PSA_WANT_KEY_TYPE_AES
|
||||
cipher_setup:PSA_KEY_TYPE_AES:"000102030405060708090a0b0c0d0e0f":PSA_ALG_CMAC:PSA_ERROR_INVALID_ARGUMENT
|
||||
|
||||
PSA cipher setup: invalid key type, CTR
|
||||
depends_on:MBEDTLS_CIPHER_MODE_CTR
|
||||
depends_on:PSA_WANT_ALG_CTR
|
||||
# Either INVALID_ARGUMENT or NOT_SUPPORTED would be reasonable here
|
||||
cipher_setup:PSA_KEY_TYPE_RAW_DATA:"000102030405060708090a0b0c0d0e0f":PSA_ALG_CTR:PSA_ERROR_NOT_SUPPORTED
|
||||
|
||||
PSA cipher setup: incompatible key ChaCha20 for CTR
|
||||
depends_on:PSA_WANT_KEY_TYPE_CHACHA20:MBEDTLS_CIPHER_MODE_CTR
|
||||
depends_on:PSA_WANT_KEY_TYPE_CHACHA20:PSA_WANT_ALG_CTR
|
||||
# Either INVALID_ARGUMENT or NOT_SUPPORTED would be reasonable here
|
||||
cipher_setup:PSA_KEY_TYPE_CHACHA20:"000102030405060708090a0b0c0d0e0f10111213141516171819202122232425":PSA_ALG_CTR:PSA_ERROR_NOT_SUPPORTED
|
||||
|
||||
@ -2419,7 +2419,7 @@ depends_on:PSA_WANT_ALG_CBC_NO_PADDING:PSA_WANT_KEY_TYPE_AES
|
||||
cipher_decrypt_fail:PSA_ALG_CBC_NO_PADDING:PSA_KEY_TYPE_AES:"2b7e151628aed2a6abf7158809cf4f3c":"2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a":"6bc1bee223":PSA_ERROR_INVALID_ARGUMENT
|
||||
|
||||
PSA symmetric decrypt: CCM*-no-tag, input too short (15 bytes)
|
||||
depends_on:PSA_WANT_ALG_CCM_STAR_NO_TAG:MBEDTLS_AES_C
|
||||
depends_on:PSA_WANT_ALG_CCM_STAR_NO_TAG:PSA_WANT_KEY_TYPE_AES
|
||||
cipher_decrypt_fail:PSA_ALG_CCM_STAR_NO_TAG:PSA_KEY_TYPE_AES:"19ebfde2d5468ba0a3031bde629b11fd":"5a8aa485c316e9":"2a2a2a2a2a2a2a2a":PSA_ERROR_INVALID_ARGUMENT
|
||||
|
||||
PSA symmetric decrypt: AES-ECB, 0 bytes, good
|
||||
@ -2805,7 +2805,7 @@ depends_on:PSA_WANT_ALG_CCM:PSA_WANT_KEY_TYPE_AES
|
||||
aead_encrypt_decrypt:PSA_KEY_TYPE_AES:"D7828D13B2B0BDC325A76236DF93CC6B":PSA_ALG_CCM:"000102030405060708090A0B":"EC46BB63B02520C33C49FD70":"B96B49E21D621741632875DB7F6C9243D2D7C2":PSA_SUCCESS
|
||||
|
||||
PSA AEAD encrypt/decrypt: DES-CCM not supported
|
||||
depends_on:MBEDTLS_DES_C:MBEDTLS_CCM_C
|
||||
depends_on:PSA_WANT_KEY_TYPE_DES:PSA_WANT_ALG_CCM
|
||||
aead_encrypt_decrypt:PSA_KEY_TYPE_DES:"D7828D13B2B0BDC325A76236DF93CC6B":PSA_ALG_CCM:"000102030405060708090A0B":"EC46BB63B02520C33C49FD70":"B96B49E21D621741632875DB7F6C9243D2D7C2":PSA_ERROR_NOT_SUPPORTED
|
||||
|
||||
PSA AEAD encrypt: AES-CCM, 23 bytes
|
||||
@ -3201,7 +3201,7 @@ depends_on:PSA_WANT_ALG_CHACHA20_POLY1305:PSA_WANT_KEY_TYPE_CHACHA20
|
||||
aead_decrypt:PSA_KEY_TYPE_CHACHA20:"808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9f":PSA_ALG_CHACHA20_POLY1305:"07000000404142434445464700":"":"a0784d7a4716f3feb4f64e7f4b39bf04":"":PSA_ERROR_INVALID_ARGUMENT
|
||||
|
||||
PSA AEAD encrypt/decrypt: invalid algorithm (CTR)
|
||||
depends_on:MBEDTLS_AES_C:MBEDTLS_GCM_C
|
||||
depends_on:PSA_WANT_KEY_TYPE_AES:PSA_WANT_ALG_GCM
|
||||
aead_encrypt_decrypt:PSA_KEY_TYPE_AES:"D7828D13B2B0BDC325A76236DF93CC6B":PSA_ALG_CTR:"000102030405060708090A0B0C0D0E0F":"":"":PSA_ERROR_INVALID_ARGUMENT
|
||||
|
||||
PSA AEAD encrypt/decrypt: invalid algorithm (ChaCha20)
|
||||
|
||||
@ -7639,8 +7639,7 @@ void interruptible_signverify_hash_edgecase_tests(int key_type_arg,
|
||||
* no reliance on external buffers. */
|
||||
psa_interruptible_set_max_ops(PSA_INTERRUPTIBLE_MAX_OPS_UNLIMITED);
|
||||
|
||||
input_buffer = mbedtls_calloc(1, input_data->len);
|
||||
TEST_ASSERT(input_buffer != NULL);
|
||||
TEST_CALLOC(input_buffer, input_data->len);
|
||||
|
||||
memcpy(input_buffer, input_data->x, input_data->len);
|
||||
|
||||
@ -7657,8 +7656,7 @@ void interruptible_signverify_hash_edgecase_tests(int key_type_arg,
|
||||
|
||||
PSA_ASSERT(psa_sign_hash_abort(&sign_operation));
|
||||
|
||||
input_buffer = mbedtls_calloc(1, input_data->len);
|
||||
TEST_ASSERT(input_buffer != NULL);
|
||||
TEST_CALLOC(input_buffer, input_data->len);
|
||||
|
||||
memcpy(input_buffer, input_data->x, input_data->len);
|
||||
|
||||
@ -7683,6 +7681,7 @@ exit:
|
||||
|
||||
psa_destroy_key(key);
|
||||
mbedtls_free(signature);
|
||||
mbedtls_free(input_buffer);
|
||||
PSA_DONE();
|
||||
}
|
||||
/* END_CASE */
|
||||
|
||||
@ -1297,7 +1297,7 @@ void sign_verify(int flow,
|
||||
mbedtls_svc_key_id_t returned_id;
|
||||
mbedtls_svc_key_id_t sw_key = MBEDTLS_SVC_KEY_ID_INIT;
|
||||
psa_key_attributes_t sw_attributes = PSA_KEY_ATTRIBUTES_INIT;
|
||||
psa_key_attributes_t drv_attributes;
|
||||
psa_key_attributes_t drv_attributes = PSA_KEY_ATTRIBUTES_INIT;
|
||||
uint8_t signature[PSA_SIGNATURE_MAX_SIZE];
|
||||
size_t signature_length;
|
||||
|
||||
|
||||
@ -24,6 +24,7 @@ void test_callback_buffer_sanity()
|
||||
{
|
||||
enum { MSGLEN = 10 };
|
||||
mbedtls_test_ssl_buffer buf;
|
||||
mbedtls_test_ssl_buffer_init(&buf);
|
||||
unsigned char input[MSGLEN];
|
||||
unsigned char output[MSGLEN];
|
||||
|
||||
@ -43,8 +44,6 @@ void test_callback_buffer_sanity()
|
||||
|
||||
/* Make sure calling put and get on a buffer that hasn't been set up results
|
||||
* in error. */
|
||||
mbedtls_test_ssl_buffer_init(&buf);
|
||||
|
||||
TEST_ASSERT(mbedtls_test_ssl_buffer_put(&buf, input, sizeof(input))
|
||||
== -1);
|
||||
TEST_ASSERT(mbedtls_test_ssl_buffer_get(&buf, output, sizeof(output))
|
||||
@ -1200,7 +1199,7 @@ void ssl_crypt_record(int cipher_type, int hash_id,
|
||||
|
||||
TEST_ASSERT(ret == 0);
|
||||
|
||||
TEST_ASSERT((buf = mbedtls_calloc(1, buflen)) != NULL);
|
||||
TEST_CALLOC(buf, buflen);
|
||||
|
||||
while (num_records-- > 0) {
|
||||
mbedtls_ssl_transform *t_dec, *t_enc;
|
||||
@ -1354,7 +1353,7 @@ void ssl_crypt_record_small(int cipher_type, int hash_id,
|
||||
|
||||
TEST_ASSERT(ret == 0);
|
||||
|
||||
TEST_ASSERT((buf = mbedtls_calloc(1, buflen)) != NULL);
|
||||
TEST_CALLOC(buf, buflen);
|
||||
|
||||
for (mode = 1; mode <= 3; mode++) {
|
||||
seen_success = 0;
|
||||
@ -1787,7 +1786,9 @@ void ssl_tls13_record_protection(int ciphersuite,
|
||||
{
|
||||
mbedtls_ssl_key_set keys;
|
||||
mbedtls_ssl_transform transform_send;
|
||||
mbedtls_ssl_transform_init(&transform_send);
|
||||
mbedtls_ssl_transform transform_recv;
|
||||
mbedtls_ssl_transform_init(&transform_recv);
|
||||
mbedtls_record rec;
|
||||
unsigned char *buf = NULL;
|
||||
size_t buf_len;
|
||||
@ -1818,8 +1819,6 @@ void ssl_tls13_record_protection(int ciphersuite,
|
||||
keys.key_len = server_write_key->len;
|
||||
keys.iv_len = server_write_iv->len;
|
||||
|
||||
mbedtls_ssl_transform_init(&transform_recv);
|
||||
mbedtls_ssl_transform_init(&transform_send);
|
||||
MD_OR_USE_PSA_INIT();
|
||||
|
||||
TEST_ASSERT(mbedtls_ssl_tls13_populate_transform(
|
||||
@ -1958,7 +1957,7 @@ void ssl_serialize_session_save_load(int ticket_len, char *crt_file,
|
||||
/* Serialize it */
|
||||
TEST_ASSERT(mbedtls_ssl_session_save(&original, NULL, 0, &len)
|
||||
== MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
|
||||
TEST_ASSERT((buf = mbedtls_calloc(1, len)) != NULL);
|
||||
TEST_CALLOC(buf, len);
|
||||
TEST_ASSERT(mbedtls_ssl_session_save(&original, buf, len, &len)
|
||||
== 0);
|
||||
|
||||
@ -2172,7 +2171,8 @@ void ssl_serialize_session_save_buf_size(int ticket_len, char *crt_file,
|
||||
for (bad_len = 1; bad_len < good_len; bad_len++) {
|
||||
/* Allocate exact size so that asan/valgrind can detect any overwrite */
|
||||
mbedtls_free(buf);
|
||||
TEST_ASSERT((buf = mbedtls_calloc(1, bad_len)) != NULL);
|
||||
buf = NULL;
|
||||
TEST_CALLOC(buf, bad_len);
|
||||
TEST_ASSERT(mbedtls_ssl_session_save(&session, buf, bad_len,
|
||||
&test_len)
|
||||
== MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
|
||||
@ -2215,7 +2215,7 @@ void ssl_serialize_session_load_buf_size(int ticket_len, char *crt_file,
|
||||
}
|
||||
TEST_ASSERT(mbedtls_ssl_session_save(&session, NULL, 0, &good_len)
|
||||
== MBEDTLS_ERR_SSL_BUFFER_TOO_SMALL);
|
||||
TEST_ASSERT((good_buf = mbedtls_calloc(1, good_len)) != NULL);
|
||||
TEST_CALLOC(good_buf, good_len);
|
||||
TEST_ASSERT(mbedtls_ssl_session_save(&session, good_buf, good_len,
|
||||
&good_len) == 0);
|
||||
mbedtls_ssl_session_free(&session);
|
||||
@ -2224,8 +2224,8 @@ void ssl_serialize_session_load_buf_size(int ticket_len, char *crt_file,
|
||||
for (bad_len = 0; bad_len < good_len; bad_len++) {
|
||||
/* Allocate exact size so that asan/valgrind can detect any overread */
|
||||
mbedtls_free(bad_buf);
|
||||
bad_buf = mbedtls_calloc(1, bad_len ? bad_len : 1);
|
||||
TEST_ASSERT(bad_buf != NULL);
|
||||
bad_buf = NULL;
|
||||
TEST_CALLOC_NONNULL(bad_buf, bad_len);
|
||||
memcpy(bad_buf, good_buf, bad_len);
|
||||
|
||||
TEST_ASSERT(mbedtls_ssl_session_load(&session, bad_buf, bad_len)
|
||||
@ -3122,6 +3122,7 @@ void raw_key_agreement_fail(int bad_server_ecdhe_key)
|
||||
mbedtls_psa_stats_t stats;
|
||||
size_t free_slots_before = -1;
|
||||
mbedtls_test_handshake_test_options options;
|
||||
mbedtls_test_init_handshake_options(&options);
|
||||
|
||||
uint16_t iana_tls_group_list[] = { MBEDTLS_SSL_IANA_TLS_GROUP_SECP256R1,
|
||||
MBEDTLS_SSL_IANA_TLS_GROUP_NONE };
|
||||
@ -3129,7 +3130,6 @@ void raw_key_agreement_fail(int bad_server_ecdhe_key)
|
||||
mbedtls_platform_zeroize(&client, sizeof(client));
|
||||
mbedtls_platform_zeroize(&server, sizeof(server));
|
||||
|
||||
mbedtls_test_init_handshake_options(&options);
|
||||
options.pk_alg = MBEDTLS_PK_ECDSA;
|
||||
options.server_min_version = MBEDTLS_SSL_VERSION_TLS1_2;
|
||||
options.server_max_version = MBEDTLS_SSL_VERSION_TLS1_2;
|
||||
|
||||
@ -729,7 +729,7 @@ void x509_verify(char *crt_file, char *ca_file, char *crl_file,
|
||||
#if defined(MBEDTLS_X509_TRUSTED_CERTIFICATE_CALLBACK)
|
||||
/* CRLs aren't supported with CA callbacks, so skip the CA callback
|
||||
* version of the test if CRLs are in use. */
|
||||
if (crl_file == NULL || strcmp(crl_file, "") == 0) {
|
||||
if (strcmp(crl_file, "") == 0) {
|
||||
flags = 0;
|
||||
|
||||
res = mbedtls_x509_crt_verify_with_ca_cb(&crt,
|
||||
@ -928,15 +928,17 @@ void mbedtls_x509_dn_get_next(char *name_str,
|
||||
int ret = 0, i;
|
||||
size_t len = 0, out_size;
|
||||
mbedtls_asn1_named_data *names = NULL;
|
||||
mbedtls_x509_name parsed, *parsed_cur;
|
||||
mbedtls_x509_name parsed;
|
||||
memset(&parsed, 0, sizeof(parsed));
|
||||
mbedtls_x509_name *parsed_cur;
|
||||
// Size of buf is maximum required for test cases
|
||||
unsigned char buf[80], *out = NULL, *c;
|
||||
unsigned char buf[80] = { 0 };
|
||||
unsigned char *out = NULL;
|
||||
unsigned char *c = buf + sizeof(buf);
|
||||
const char *short_name;
|
||||
|
||||
USE_PSA_INIT();
|
||||
memset(&parsed, 0, sizeof(parsed));
|
||||
memset(buf, 0, sizeof(buf));
|
||||
c = buf + sizeof(buf);
|
||||
|
||||
// Additional size required for trailing space
|
||||
out_size = strlen(expected_oids) + 2;
|
||||
TEST_CALLOC(out, out_size);
|
||||
|
||||
@ -699,16 +699,16 @@ void mbedtls_x509_string_to_names(char *name, char *parsed_name,
|
||||
int ret;
|
||||
size_t len = 0;
|
||||
mbedtls_asn1_named_data *names = NULL;
|
||||
mbedtls_x509_name parsed, *parsed_cur, *parsed_prv;
|
||||
unsigned char buf[1024], out[1024], *c;
|
||||
mbedtls_x509_name parsed;
|
||||
memset(&parsed, 0, sizeof(parsed));
|
||||
mbedtls_x509_name *parsed_cur = NULL;
|
||||
mbedtls_x509_name *parsed_prv = NULL;
|
||||
unsigned char buf[1024] = { 0 };
|
||||
unsigned char out[1024] = { 0 };
|
||||
unsigned char *c = buf + sizeof(buf);
|
||||
|
||||
USE_PSA_INIT();
|
||||
|
||||
memset(&parsed, 0, sizeof(parsed));
|
||||
memset(out, 0, sizeof(out));
|
||||
memset(buf, 0, sizeof(buf));
|
||||
c = buf + sizeof(buf);
|
||||
|
||||
ret = mbedtls_x509_string_to_names(&names, name);
|
||||
TEST_EQUAL(ret, result);
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user