More crypto code, still unfinished.

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@10870 35acf78f-673a-0410-8e92-d51de3d6d3f4

1 files changed, 75 insertions, 51 deletions

diff --git a/os/hal/src/hal_crypto.c b/os/hal/src/hal_crypto.c
index 0493da872..79a5be9a2 100644
--- a/os/hal/src/hal_crypto.c
+++ b/os/hal/src/hal_crypto.c
@@ -69,10 +69,6 @@ void cryObjectInit(CRYDriver *cryp) {
 

   cryp->state    = CRY_STOP;

   cryp->config   = NULL;

-  cryp->thread   = NULL;

-#if CRY_USE_MUTUAL_EXCLUSION == TRUE

-  osalMutexObjectInit(&cryp->mutex);

-#endif

 #if defined(CRY_DRIVER_EXT_INIT_HOOK)

   CRY_DRIVER_EXT_INIT_HOOK(cryp);

 #endif

@@ -141,12 +137,28 @@ void cryStop(CRYDriver *cryp) {
 cryerror_t cryLoadTransientKey(CRYDriver *cryp,

                                cryalgorithm_t algorithm,

                                size_t size,

-                               const uint8_t *keyp);

+                               const uint8_t *keyp) {

+  cryerror_t err;

+

+  /* Storing the transient key metadata.*/

+  cryp->key0_type = algorithm;

+  cryp->key0_size = size;

+

+  /* Key setup in the low level driver.*/

+  err = cry_lld_loadkey(cryp, algorithm, size, keyp);

+  if (err != CRY_NOERROR) {

+    cryp->key0_type = cry_algo_none;

+    cryp->key0_size = (size_t)0;

+  }

+

+  return err;

+}

 

 #if (CRY_LLD_SUPPORTS_AES_ECB == TRUE) || defined(__DOXYGEN__)

 /**

  * @brief   Encryption operation using AES-ECB.

  *

+ * @param[in] cryp      pointer to the @p CRYDriver object

  * @param[in] key_id    the key to be used for the operation, zero is the

  *                      transient key, other values are keys stored in an

  *                      unspecified way

@@ -164,16 +176,21 @@ cryerror_t cryLoadTransientKey(CRYDriver *cryp,
  *

  * @api

  */

-cryerror_t cryEncryptAES_ECB(crykey_t key_id,

+cryerror_t cryEncryptAES_ECB(CRYDriver *cryp,

+                             crykey_t key_id,

                              size_t size,

                              const uint8_t *in,

                              uint8_t *out) {

 

+  osalDbgCheck((in != NULL) && (out != NULL));

+

+  return cry_lld_encrypt_AES_ECB(cryp, key_id, size, in, out);

 }

 

 /**

  * @brief   Decryption operation using AES-ECB.

  *

+ * @param[in] cryp      pointer to the @p CRYDriver object

  * @param[in] key_id    the key to be used for the operation, zero is the

  *                      transient key, other values are keys stored in an

  *                      unspecified way

@@ -191,11 +208,16 @@ cryerror_t cryEncryptAES_ECB(crykey_t key_id,
  *

  * @api

  */

-cryerror_t cryDecryptAES_ECB(crykey_t key_id,

-                             size_t blocks,

+cryerror_t cryDecryptAES_ECB(CRYDriver *cryp,

+                             crykey_t key_id,

+                             size_t size,

                              const uint8_t *in,

                              uint8_t *out) {

 

+  osalDbgCheck((in != NULL) && (out != NULL));

+  osalDbgAssert(cryp->state == CRY_READY, "not ready");

+

+  return cry_lld_decrypt_AES_ECB(cryp, key_id, size, in, out);

 }

 #endif /* CRY_LLD_SUPPORTS_AES_ECB == TRUE */

 

@@ -203,6 +225,7 @@ cryerror_t cryDecryptAES_ECB(crykey_t key_id,
 /**

  * @brief   Encryption operation using AES-CBC.

  *

+ * @param[in] cryp      pointer to the @p CRYDriver object

  * @param[in] key_id    the key to be used for the operation, zero is the

  *                      transient key, other values are keys stored in an

  *                      unspecified way

@@ -221,17 +244,23 @@ cryerror_t cryDecryptAES_ECB(crykey_t key_id,
  *

  * @api

  */

-cryerror_t cryEncryptAES_CBC(crykey_t key_id,

+cryerror_t cryEncryptAES_CBC(CRYDriver *cryp,

+                             crykey_t key_id,

                              size_t size,

                              const uint8_t *in,

                              uint8_t *out,

-                             const uint8_t *iv){

+                             const uint8_t *iv) {

 

+  osalDbgCheck((in != NULL) && (out != NULL) && (iv != NULL));

+  osalDbgAssert(cryp->state == CRY_READY, "not ready");

+

+  return cry_lld_encrypt_AES_CBC(cryp, key_id, size, in, out, iv);

 }

 

 /**

  * @brief   Decryption operation using AES-CBC.

  *

+ * @param[in] cryp      pointer to the @p CRYDriver object

  * @param[in] key_id    the key to be used for the operation, zero is the

  *                      transient key, other values are keys stored in an

  *                      unspecified way

@@ -250,12 +279,17 @@ cryerror_t cryEncryptAES_CBC(crykey_t key_id,
  *

  * @api

  */

-cryerror_t cryDecryptAES_CBC(crykey_t key_id,

+cryerror_t cryDecryptAES_CBC(CRYDriver *cryp,

+                             crykey_t key_id,

                              size_t size,

                              const uint8_t *in,

                              uint8_t *out,

                              const uint8_t *iv) {

 

+  osalDbgCheck((in != NULL) && (out != NULL) && (iv != NULL));

+  osalDbgAssert(cryp->state == CRY_READY, "not ready");

+

+  return cry_lld_decrypt_AES_CBC(cryp, key_id, size, in, out, iv);

 }

 #endif /* CRY_LLD_SUPPORTS_AES_CBC == TRUE */

 

@@ -263,6 +297,7 @@ cryerror_t cryDecryptAES_CBC(crykey_t key_id,
 /**

  * @brief   Encryption operation using AES-CFB.

  *

+ * @param[in] cryp      pointer to the @p CRYDriver object

  * @param[in] key_id    the key to be used for the operation, zero is the

  *                      transient key, other values are keys stored in an

  *                      unspecified way

@@ -281,17 +316,23 @@ cryerror_t cryDecryptAES_CBC(crykey_t key_id,
  *

  * @api

  */

-cryerror_t cryEncryptAES_CFB(crykey_t key_id,

+cryerror_t cryEncryptAES_CFB(CRYDriver *cryp,

+                             crykey_t key_id,

                              size_t size,

                              const uint8_t *in,

                              uint8_t *out,

                              const uint8_t *iv) {

 

+  osalDbgCheck((in != NULL) && (out != NULL) && (iv != NULL));

+  osalDbgAssert(cryp->state == CRY_READY, "not ready");

+

+  return cry_lld_encrypt_AES_CBC(cryp, key_id, size, in, out, iv);

 }

 

 /**

  * @brief   Decryption operation using AES-CFB.

  *

+ * @param[in] cryp      pointer to the @p CRYDriver object

  * @param[in] key_id    the key to be used for the operation, zero is the

  *                      transient key, other values are keys stored in an

  *                      unspecified way

@@ -310,12 +351,17 @@ cryerror_t cryEncryptAES_CFB(crykey_t key_id,
  *

  * @api

  */

-cryerror_t cryDecryptAES_CFB(crykey_t key_id,

+cryerror_t cryDecryptAES_CFB(CRYDriver *cryp,

+                             crykey_t key_id,

                              size_t size,

                              const uint8_t *in,

                              uint8_t *out,

                              const uint8_t *iv) {

 

+  osalDbgCheck((in != NULL) && (out != NULL) && (iv != NULL));

+  osalDbgAssert(cryp->state == CRY_READY, "not ready");

+

+  return cry_lld_decrypt_AES_CBC(cryp, key_id, size, in, out, iv);

 }

 #endif /* CRY_LLD_SUPPORTS_AES_CFB == TRUE */

 

@@ -323,6 +369,7 @@ cryerror_t cryDecryptAES_CFB(crykey_t key_id,
 /**

  * @brief   Encryption operation using AES-CTR.

  *

+ * @param[in] cryp      pointer to the @p CRYDriver object

  * @param[in] key_id    the key to be used for the operation, zero is the

  *                      transient key, other values are keys stored in an

  *                      unspecified way

@@ -342,18 +389,25 @@ cryerror_t cryDecryptAES_CFB(crykey_t key_id,
  *

  * @api

  */

-cryerror_t cryEncryptAES_CTR(crykey_t key_id,

+cryerror_t cryEncryptAES_CTR(CRYDriver *cryp,

+                             crykey_t key_id,

                              size_t size,

                              const uint8_t *in,

                              uint8_t *out,

                              const uint8_t *nonce,

                              uint8_t *cnt) {

 

+  osalDbgCheck((in != NULL) && (out != NULL) &&

+               (nonce != NULL) && (cnt != NULL));

+  osalDbgAssert(cryp->state == CRY_READY, "not ready");

+

+  return cry_lld_encrypt_AES_CTR(cryp, key_id, size, in, out, nonce, cnt);

 }

 

 /**

  * @brief   Decryption operation using AES-CTR.

  *

+ * @param[in] cryp      pointer to the @p CRYDriver object

  * @param[in] key_id    the key to be used for the operation, zero is the

  *                      transient key, other values are keys stored in an

  *                      unspecified way

@@ -373,51 +427,21 @@ cryerror_t cryEncryptAES_CTR(crykey_t key_id,
  *

  * @api

  */

-cryerror_t cryDecryptAES_CTR(crykey_t key_id,

+cryerror_t cryDecryptAES_CTR(CRYDriver *cryp,

+                             crykey_t key_id,

                              size_t size,

                              const uint8_t *in,

                              uint8_t *out,

                              const uint8_t *nonce,

                              uint8_t *cnt) {

 

-}

-#endif /* CRY_LLD_SUPPORTS_AES_CTR == TRUE */

-

-#if (CRY_USE_MUTUAL_EXCLUSION == TRUE) || defined(__DOXYGEN__)

-/**

- * @brief   Gains exclusive access to the CRY peripheral.

- * @details This function tries to gain ownership to CRY bus, if the bus

- *          is already being used then the invoking thread is queued.

- * @pre     In order to use this function the option

- *          @p CRY_USE_MUTUAL_EXCLUSION must be enabled.

- *

- * @param[in] cryp      pointer to the @p CRYDriver object

- *

- * @api

- */

-void cryAcquireBus(CRYDriver *cryp) {

-

-  osalDbgCheck(cryp != NULL);

-

-  osalMutexLock(&cryp->mutex);

-}

+  osalDbgCheck((in != NULL) && (out != NULL) &&

+               (nonce != NULL) && (cnt != NULL));

+  osalDbgAssert(cryp->state == CRY_READY, "not ready");

 

-/**

- * @brief   Releases exclusive access to the CRY peripheral.

- * @pre     In order to use this function the option

- *          @p CRY_USE_MUTUAL_EXCLUSION must be enabled.

- *

- * @param[in] cryp      pointer to the @p CRYDriver object

- *

- * @api

- */

-void cryReleaseBus(CRYDriver *cryp) {

-

-  osalDbgCheck(cryp != NULL);

-

-  osalMutexUnlock(&cryp->mutex);

+  return cry_lld_decrypt_AES_CTR(cryp, key_id, size, in, out, nonce, cnt);

 }

-#endif /* CRY_USE_MUTUAL_EXCLUSION == TRUE */

+#endif /* CRY_LLD_SUPPORTS_AES_CTR == TRUE */

 

 #endif /* HAL_USE_CRY == TRUE */