remove NRF_CRYPTOCELL->ENABLE guard, since it is manged by libcrypto already

fix begun check

Author: hathach

src/Adafruit_nRFCrypto.cpp

@@ -29,6 +29,8 @@
 #include "nrf_cc310/include/sns_silib.h"
 #include "Adafruit_nRFCrypto.h"
 
+#include <Adafruit_TinyUSB.h> // for Serial
+
 // Only nRF52840 has CC310
 #ifndef NRF_CRYPTOCELL
   #error CryptoCell CC310 is not supported on this board
@@ -53,27 +55,22 @@ Adafruit_nRFCrypto nRFCrypto;
 Adafruit_nRFCrypto::Adafruit_nRFCrypto(void)
 {
   _begun = false;
-  _en_count = 0;
 }
 
 bool Adafruit_nRFCrypto::begin(void)
 {
   // skip if already called begin before
   if (_begun) return true;
-  _begun = false;
+  _begun = true;
 
 #ifndef USE_CC310_LIB_NO_INTERRUPT
   NVIC_SetPriority(CRYPTOCELL_IRQn, 2);
   NVIC_EnableIRQ(CRYPTOCELL_IRQn);
 #endif
 
-  enable();
-
   VERIFY_ERROR(SaSi_LibInit(), false);
   VERIFY( Random.begin() );
 
-  disable();
-
   return true;
 }
 
@@ -83,32 +80,12 @@ void Adafruit_nRFCrypto::end(void)
   if (!_begun) return;
   _begun = false;
 
-  enable();
-
   SaSi_LibFini();
   Random.end();
 
 #ifndef USE_CC310_LIB_NO_INTERRUPT
   NVIC_DisableIRQ(CRYPTOCELL_IRQn);
 #endif
-
-  disable();
-}
-
-void Adafruit_nRFCrypto::enable(void)
-{
-  _en_count++;
-  NRF_CRYPTOCELL->ENABLE = 1;
-}
-
-void Adafruit_nRFCrypto::disable(void)
-{
-  _en_count--;
-
-  if ( _en_count == 0)
-  {
-    NRF_CRYPTOCELL->ENABLE = 0;
-  }
 }
 
 //--------------------------------------------------------------------+

src/Adafruit_nRFCrypto.h

@@ -40,13 +40,9 @@ class Adafruit_nRFCrypto
     bool begin(void);
     void end(void);
 
-    void enable(void);
-    void disable(void);
-
     nRFCrypto_Random Random;
 
   private:
-    uint32_t _en_count;
     bool _begun;
 };
 

src/ecc/nRFCrypto_ECC.cpp

@@ -42,14 +42,9 @@ bool nRFCrypto_ECC::genKeyPair(nRFCrypto_ECC_PrivateKey& private_key, nRFCrypto_
   CRYS_ECPKI_KG_TempData_t* tempbuf = (CRYS_ECPKI_KG_TempData_t*) rtos_malloc( sizeof(CRYS_ECPKI_KG_TempData_t) );
   VERIFY(tempbuf);
 
-  nRFCrypto.enable();
-
   uint32_t err = CRYS_ECPKI_GenKeyPair(nRFCrypto.Random.getContext(), CRYS_RND_GenerateVector, private_key.getDomain(),
                                        &private_key._key, &public_key._key,
                                        tempbuf, NULL);
-
-  nRFCrypto.disable();
-
   rtos_free(tempbuf);
 
   VERIFY_CRYS(err, false);
@@ -61,12 +56,8 @@ uint32_t nRFCrypto_ECC::SVDP_DH(nRFCrypto_ECC_PrivateKey& private_key, nRFCrypto
   CRYS_ECDH_TempData_t* tempbuf = (CRYS_ECDH_TempData_t *) rtos_malloc(sizeof(CRYS_ECDH_TempData_t));
   VERIFY(tempbuf);
 
-  nRFCrypto.enable();
-
   uint32_t err = CRYS_ECDH_SVDP_DH(&peer_pubkey._key, &private_key._key, shared_secret, &bufsize, tempbuf);
 
-  nRFCrypto.disable();
-
   rtos_free(tempbuf);
 
   VERIFY_CRYS(err, 0);

src/ecc/nRFCrypto_ECC_PrivateKey.cpp

@@ -40,11 +40,7 @@ nRFCrypto_ECC_PrivateKey::nRFCrypto_ECC_PrivateKey(void)
 
 bool nRFCrypto_ECC_PrivateKey::begin(CRYS_ECPKI_DomainID_t id)
 {
-  nRFCrypto.enable();
-
   _domain = CRYS_ECPKI_GetEcDomain(id);
-
-  nRFCrypto.disable();
   return _domain != NULL;
 }
 
@@ -57,25 +53,13 @@ void nRFCrypto_ECC_PrivateKey::end(void)
 // return raw buffer size = keysize + 1 (header)
 uint32_t nRFCrypto_ECC_PrivateKey::toRaw(uint8_t* buffer, uint32_t bufsize)
 {
-  nRFCrypto.enable();
-
-  uint32_t err = CRYS_ECPKI_ExportPrivKey(&_key, buffer, &bufsize);
-
-  nRFCrypto.disable();
-
-  VERIFY_CRYS(err, 0);
+  VERIFY_CRYS(CRYS_ECPKI_ExportPrivKey(&_key, buffer, &bufsize), 0);
   return bufsize;
 }
 
 // Build public key from raw bytes in Big Endian
 bool nRFCrypto_ECC_PrivateKey::fromRaw(uint8_t* buffer, uint32_t bufsize)
 {
-  nRFCrypto.enable();
-
-  uint32_t err = CRYS_ECPKI_BuildPrivKey(_domain, buffer, bufsize, &_key);
-
-  nRFCrypto.disable();
-
-  VERIFY_CRYS(err, false);
+  VERIFY_CRYS(CRYS_ECPKI_BuildPrivKey(_domain, buffer, bufsize, &_key), false);
   return true;
 }

src/ecc/nRFCrypto_ECC_PublicKey.cpp

@@ -40,11 +40,7 @@ nRFCrypto_ECC_PublicKey::nRFCrypto_ECC_PublicKey(void)
 
 bool nRFCrypto_ECC_PublicKey::begin(CRYS_ECPKI_DomainID_t id)
 {
-  nRFCrypto.enable();
-
   _domain = CRYS_ECPKI_GetEcDomain(id);
-
-  nRFCrypto.disable();
   return _domain != NULL;
 }
 
@@ -57,13 +53,7 @@ void nRFCrypto_ECC_PublicKey::end(void)
 // return raw buffer size = keysize + 1 (header)
 uint32_t nRFCrypto_ECC_PublicKey::toRaw(uint8_t* buffer, uint32_t bufsize)
 {
-  nRFCrypto.enable();
-
-  uint32_t err = CRYS_ECPKI_ExportPublKey(&_key, CRYS_EC_PointUncompressed, buffer, &bufsize);
-
-  nRFCrypto.disable();
-
-  VERIFY_CRYS(err, 0);
+  VERIFY_CRYS(CRYS_ECPKI_ExportPublKey(&_key, CRYS_EC_PointUncompressed, buffer, &bufsize), 0);
   return bufsize;
 }
 
@@ -73,12 +63,8 @@ bool nRFCrypto_ECC_PublicKey::fromRaw(uint8_t* buffer, uint32_t bufsize)
   CRYS_ECPKI_BUILD_TempData_t* tempbuf = (CRYS_ECPKI_BUILD_TempData_t*) rtos_malloc( sizeof(CRYS_ECPKI_BUILD_TempData_t) );
   VERIFY(tempbuf);
 
-  nRFCrypto.enable();
-
   uint32_t err = CRYS_ECPKI_BuildPublKeyPartlyCheck(_domain, buffer, bufsize, &_key, tempbuf);
 
-  nRFCrypto.disable();
-
   rtos_free(tempbuf);
 
   VERIFY_CRYS(err, false);

src/nRFCrypto_Hash.cpp

@@ -48,29 +48,21 @@ nRFCrypto_Hash::nRFCrypto_Hash(void)
 
 bool nRFCrypto_Hash::begin(CRYS_HASH_OperationMode_t mode)
 {
-  nRFCrypto.enable();
-
   VERIFY_ERROR( CRYS_HASH_Init(&_context, mode), false );
   if ( mode < CRYS_HASH_NumOfModes ) _digest_len = digest_len_arr[mode];
 
-  nRFCrypto.disable();
   return true;
 }
 
 bool nRFCrypto_Hash::update(uint8_t data[], size_t size)
 {
-  nRFCrypto.enable();
   VERIFY_ERROR( CRYS_HASH_Update(&_context, data, size), false );
-  nRFCrypto.disable();
   return true;
 }
 
 uint8_t nRFCrypto_Hash::end(uint32_t result[16])
 {
-  nRFCrypto.enable();
   VERIFY_ERROR( CRYS_HASH_Finish(&_context, result), 0);
-  nRFCrypto.disable();
-
   return _digest_len;
 }
 

src/nRFCrypto_Random.cpp

@@ -39,17 +39,12 @@ bool nRFCrypto_Random::begin(void)
 {
   // skip if already called begin before
   if (_begun) return true;
-  _begun = false;
+  _begun = true;
 
   CRYS_RND_WorkBuff_t* workbuf = (CRYS_RND_WorkBuff_t*) rtos_malloc(sizeof(CRYS_RND_WorkBuff_t));
   VERIFY(workbuf);
 
-  nRFCrypto.enable();
-
   uint32_t err = CRYS_RndInit(&_state, workbuf);
-
-  nRFCrypto.disable();
-
   rtos_free(workbuf);
 
   VERIFY_ERROR(err, false);
@@ -62,30 +57,18 @@ void nRFCrypto_Random::end(void)
   if (!_begun) return;
   _begun = false;
 
-  nRFCrypto.enable();
-
   uint32_t err = CRYS_RND_UnInstantiation(&_state);
-
-  nRFCrypto.disable();
-
   VERIFY_ERROR(err, );
 }
 
-
 CRYS_RND_State_t* nRFCrypto_Random::getContext(void)
 {
   return &_state;
 }
 
 bool nRFCrypto_Random::addAdditionalInput(uint8_t* input, uint16_t size)
 {
-  nRFCrypto.enable();
-
-  uint32_t err = CRYS_RND_AddAdditionalInput(&_state, input, size);
-
-  nRFCrypto.disable();
-
-  VERIFY_ERROR(err, false);
+  VERIFY_ERROR(CRYS_RND_AddAdditionalInput(&_state, input, size), false);
   return true;
 }
 
@@ -94,12 +77,7 @@ bool nRFCrypto_Random::reseed(void)
   CRYS_RND_WorkBuff_t* workbuf = (CRYS_RND_WorkBuff_t*) rtos_malloc(sizeof(CRYS_RND_WorkBuff_t));
   VERIFY(workbuf);
 
-  nRFCrypto.enable();
-
   uint32_t err = CRYS_RND_Reseeding(&_state, workbuf);
-
-  nRFCrypto.disable();
-
   rtos_free(workbuf);
 
   VERIFY_ERROR(err, false);
@@ -108,24 +86,12 @@ bool nRFCrypto_Random::reseed(void)
 
 bool nRFCrypto_Random::generate(uint8_t* buf, uint16_t bufsize)
 {
-  nRFCrypto.enable();
-
-  uint32_t err = CRYS_RND_GenerateVector(&_state, bufsize, buf);
-
-  nRFCrypto.disable();
-
-  VERIFY_ERROR(err, false);
+  VERIFY_ERROR(CRYS_RND_GenerateVector(&_state, bufsize, buf), false);
   return true;
 }
 
 bool nRFCrypto_Random::generateInRange(uint8_t* buf, uint32_t bitsize, uint8_t* max)
 {
-  nRFCrypto.enable();
-
-  uint32_t err = CRYS_RND_GenerateVectorInRange(&_state, CRYS_RND_GenerateVector, bitsize, max, buf);
-
-  nRFCrypto.disable();
-
-  VERIFY_ERROR(err, false);
+  VERIFY_ERROR(CRYS_RND_GenerateVectorInRange(&_state, CRYS_RND_GenerateVector, bitsize, max, buf), false);
   return true;
 }