|
|
EdDSA driver implementation for the CC26X2 family.
===========================================================================
This file should only be included in the board file to fill the EDDSA_config struct.
The CC26X2 family has a dedicated public key accelerator. It is capable of multiple mathematical operations including dedicated ECC point addition, doubling, and scalar multiplication. Only one operation can be carried out on the accelerator at a time. Mutual exclusion is implemented at the driver level and coordinated between all drivers relying on the accelerator. It is transparent to the application and only noted ensure sensible access timeouts are set.
The large number maths engine (LNME) uses a dedicated 2kB block of RAM (PKA RAM) for its operations. The operands of the maths operations must be copied into and results out of the PKA RAM. This necessitates a significant number of reads and writes for each operation. The bus interface to the RAM only allows for word-aligned reads and writes. The CPU splits the reads and writes from and to general SRAM from unaligned addresses into multiple bus operations while accumulating the data in a register until it is full. The result of this hardware process is that providing buffers such as plaintext CryptoKey keying material to ECC APIs that are word-aligned will significantly speed up the operation and reduce power consumption.
The driver implementation does not perform runtime checks for most input parameters. Only values that are likely to have a stochastic element to them are checked (such as whether a driver is already open). Higher input parameter validation coverage is achieved by turning on assertions when compiling the driver.
The driver implementation supports the following curves for EdDSA:
| Curve | Supported |
|---|---|
| Ed25519 | Yes |
| Ed448 | No |
When performing signature verification, the foreign public key will always be validated by performing a public key decompression followed by verifying that the point is on the Edwards curve.
Go to the source code of this file.
Data Structures | |
| struct | EDDSACC26X2_HWAttrs |
| EDDSACC26X2 Hardware Attributes. More... | |
| struct | EDDSACC26X2_Workspace |
| EDDSACC26X2 Workspace. More... | |
| struct | EDDSACC26X2_Object |
| EDDSACC26X2 Object. More... | |
Macros | |
| #define | EDDSACC26X2_STATUS_FSM_RUN_PKA_OP EDDSA_STATUS_RESERVED - 0 |
| #define | EDDSACC26X2_STATUS_FSM_RUN_FSM EDDSA_STATUS_RESERVED - 1 |
| #define | EDDSACC26X2_PKA_OPERATION_STARTED (0xFFFFFFFFUL) |
| #define | ED25519_LENGTH 32 |
Typedefs | |
| typedef int_fast16_t(* | EDDSACC26X2_stateMachineFxn) (EDDSA_Handle handle) |
| EDDSACC26X2 state machine function prototype. More... | |
| #define EDDSACC26X2_STATUS_FSM_RUN_PKA_OP EDDSA_STATUS_RESERVED - 0 |
| #define EDDSACC26X2_STATUS_FSM_RUN_FSM EDDSA_STATUS_RESERVED - 1 |
| #define EDDSACC26X2_PKA_OPERATION_STARTED (0xFFFFFFFFUL) |
| #define ED25519_LENGTH 32 |
| typedef int_fast16_t(* EDDSACC26X2_stateMachineFxn) (EDDSA_Handle handle) |
EDDSACC26X2 state machine function prototype.
The FSM controller in the EDDSACC26X2 SWI executes a state machine function containing a switch statement that governs state execution. This function pointer is stored in the object at the beginning of the transaction. This way, unused state machines are removed at link time.
| enum EDDSACC26X2_FsmState |
EDDSACC26X2 KeyGen, Sign, and Verify states.
The public key generation, sign, and verify operations are implemented using multiple individual PKA operations. Since state transitions for these operations are almost always predictable, the state transitions are encoded linearly in this enum. The FSM controller will increment the state counter and iterate through states until it is told to stop or restart.
EDDSACC26X2 Weierstrass to Edwards states.
The public key generation, sign, and verify operations all use a common subroutine that converts an input point on the short Weierstrass curve Wei25519 to an output point on the twisted Edwards curve Ed25519. Since state transitions for these operations are almost always predictable, the state transitions are encoded linearly in this enum. The FSM controller will increment the substate counter and iterate through states until it is told to stop or restart.