cryptoAES128.cpp

Go to the documentation of this file.

#include <cstring>
#include "psaerr2str.h"
#include "AES128ESP32.h"
// #include "psaerr2str.h"
// #include "AES128ESP32.h"
// #include "cryptoAES128.h"
#include <list>
 
cryptoAES128::cryptoAES128() {
  DEBUG3("");
  psa_crypto_init();
}

bool cryptoAES128::setKeyaccess(pass2Key &keyholder) {
  DEBUG3("");
  if (!keyholder.newkeyid) {
    cryptoerrortoString(AES128_ERROR2);
    return false;
  }
  key = keyholder.newkeyid;
  return true;
}

bool cryptoAES128::getIVbytes(ivData &ivdata) {
  DEBUG3("");
  if (ivdata.size == AES128IVSIZE) {
    memcpy(ivdata.data, iv, ivdata.size);
    return true;
  }
  cryptoerrortoString(AES128_ERROR1);
  return false;
}
 

 
bool cryptoAES128::setIVbytes(ivData &ivdata) {
  DEBUG3("");
  if (ivdata.size == AES128IVSIZE) {
    memcpy(iv, ivdata.data, ivdata.size);
    givlen = ivdata.size;
    return true;
  }
    cryptoerrortoString(AES128_ERROR1);
  return false;
}
void cryptoAES128::clearIV() {
  DEBUG3("");
  memset(iv, 0, AES128IVSIZE);
  givlen = 0;
}

// probably should be private or protected??
 
bool cryptoAES128::buildKeyForAESEncryptOrDecrypt(bool shouldEncrypt) {
  if ((shouldEncrypt != PSA_KEY_USAGE_DECRYPT) || (shouldEncrypt != PSA_KEY_USAGE_ENCRYPT))
    assert(true);
 
  psa_status_t status;
  /*psa_aead_operation_t */ op = PSA_AEAD_OPERATION_INIT;
  if (shouldEncrypt == true) {
    status = psa_aead_encrypt_setup(&op, key, PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_GCM, 8));
    if (status != PSA_SUCCESS) {
      FALSEORSTOP(status, "psa_aead_encrypt_setup");
    }
    if (!givlen) {
      status = psa_aead_generate_nonce(&op, iv, sizeof(iv), &givlen);
      if (status != PSA_SUCCESS) {
        FALSEORSTOP(status, "psa_aead_generate_nonce");
      }
      DEBUG3("generated iv size = " + String(givlen));
      assert(givlen == AES128IVSIZE);
    } else {
      // 2. Set the nonce with psa_aead_generate_nonce() or psa_aead_set_nonce().
      status = psa_aead_set_nonce(&op, iv, sizeof(iv));
      if (status != PSA_SUCCESS) {
        FALSEORSTOP(status, "psa_aead_set_nonce");
      }
    }
  } else {
    status = psa_aead_decrypt_setup(&op, key, PSA_ALG_AEAD_WITH_SHORTENED_TAG(PSA_ALG_GCM, 8));
    if (status != PSA_SUCCESS) {
      FALSEORSTOP(status, "psa_aead_decrypt_setup");
    }
    // 2. Set the nonce with psa_aead_generate_nonce() or psa_aead_set_nonce().
    status = psa_aead_set_nonce(&op, iv, sizeof(iv));
    if (status != PSA_SUCCESS) {
      FALSEORSTOP(status, "psa_aead_set_nonce");
    }
  }
  return true;
}

bool cryptoAES128::Decrypt(encryptedData &encdata, String &rtn) {
  DEBUG3("");
  psa_status_t status;
  /*String*/ rtn = "";
  unsigned char outbuf[key_bits / 8];
  assert(sizeof(outbuf) == 16);
  unsigned char inpbuf[key_bits / 8];
  assert(encdata.size % 16 == 0);
 
  buildKeyForAESEncryptOrDecrypt(false);
  DEBUG3("len = " + String(encdata.size));
  int lastcharactercount = 0;
  size_t olen;
  unsigned char *bytes = encdata.data;
  while (lastcharactercount < encdata.size) {
    DEBUG3("while lastcharactercount = " + String(lastcharactercount));
    for (int i = 0; i < sizeof(inpbuf); i++)
      inpbuf[i] = *bytes++;
 
    // DUMP("inpbuf decrypt", inpbuf, sizeof(inpbuf));
    lastcharactercount = lastcharactercount + sizeof(inpbuf);
    status = psa_aead_update(&op, inpbuf, sizeof(inpbuf), outbuf, sizeof(outbuf), &olen);
    if (status != PSA_SUCCESS) {
      FALSEORSTOP(status, "psa_aead_update");
    }
 
    for (int i = 0; i < olen; i++)
      if (outbuf[i])
        rtn.concat((char)outbuf[i]);
 
    DUMP("outbuf decrypt", outbuf, sizeof(outbuf));
  }  // while
  psa_aead_abort(&op);
  // return rtn;
  return true;
}
 

bool cryptoAES128::Encrypt(String datatoEncrypt, encryptedData **returndata) {
  DEBUG3("");
  psa_status_t status;
  unsigned char outbuf[key_bits / 8];
  assert(sizeof(outbuf) == 16);
  unsigned char inpbuf[(key_bits / 8)]; 
 
  buildKeyForAESEncryptOrDecrypt();
 
  size_t olen;
  std::list<unsigned char>  outputbytes;
  int lastcharactercount = 0;
  int maxlength = datatoEncrypt.length();  
  const char* thetext = datatoEncrypt.c_str();
 
  // copy at most key_bits /8
  while (lastcharactercount < maxlength) {
    DEBUG3("start of loop");
    memset(inpbuf,0,sizeof(inpbuf));
    size_t copymax = (lastcharactercount + 16 < maxlength-lastcharactercount) ? lastcharactercount + 16 : maxlength-lastcharactercount;
    DEBUG3("copy max = " + String(copymax));
    memcpy(inpbuf, thetext+lastcharactercount, copymax);
    lastcharactercount += 16;
 
    DUMP("inpbuf", inpbuf, sizeof(inpbuf));
 
    status = psa_aead_update(&op, inpbuf, sizeof(inpbuf), outbuf, sizeof(outbuf), &olen);
    if (status != PSA_SUCCESS) {
      FALSEORSTOP(status, "psa_aead_update");
    }
    // move encrytped data to output buffer
    for (int i = 0; i < olen; i++)
      outputbytes.push_back(outbuf[i]);
    DUMP("outbuf", outbuf, olen);
  }
 
  status = psa_aead_abort(&op);
  if (status != PSA_SUCCESS) {
    FALSEORSTOP(status, "psa_aead_update");
  }
 
  int numbytes = outputbytes.size(); //
  /*encryptedData */ *returndata = new encryptedData(numbytes);
  unsigned char *rtn = (*returndata)->data;
  for (int i = 0; i < numbytes; i++) {
    rtn[i] = outputbytes.front();
    outputbytes.pop_front();
  }
  return true;
}