crypto.h

Go to the documentation of this file.

#pragma once
#ifndef _Cr2X_
#define _Cr2X_
#include <cstring>
#include <list>
#include "psa/crypto_values.h"
 
// #define DEBUGLEVEL 2
#include "delays.h"
#include "psaerr2str.h"
#include "pbkdf2.h"
 
#define PRINTERRORxxxx(function) \
  DEBUG2(String(function) + " failed " + errortoString(status)); \
  STOP;
 
#include "psa/crypto.h"
// AES128

class crypto {
#define NUMBYTES 16
#define IVSIZE 12
  // pass2Key *keyset;
  // psa_status_t status;
  /* Dummy data for encryption: IV/nonce - */
 
  /*const */ unsigned char iv[IVSIZE] = { 0x00 };
  size_t givlen = 0;  // generated IV
  psa_key_id_t key;   // this is the PSA key
  size_t key_bits = NUMBYTES * 8;
  psa_aead_operation_t op;
public:
  crypto() {}
  bool begin() {
    DEBUG3("");
 
    psa_status_t status = psa_crypto_init();
    if (status != PSA_SUCCESS) {
      //DEBUG2("psa_crypto_init failed " + errortoString(status));
      PRINTERROR2(status, "psa_crytpo_init");
      return false;
    }
    DEBUG3("begin success");
    return true;
  }

  void setkeyaccess(pass2Key *keyholder) {
    key = keyholder->newkeyid;
  }

  void setkeyaccess(pass2Key &keyholder) {
    key = keyholder.newkeyid;
  }

  unsigned char *getIVbytes(size_t &IVsize) {
    IVsize = givlen;
    return iv;
  }

  void setIVbytes(unsigned char *bytes, size_t byteslength) {
    assert(byteslength == IVSIZE);
    memcpy(iv, bytes, byteslength);
    givlen = byteslength;
  }

  void clearIV() {
    memset(iv, 0, IVSIZE);
    givlen = 0;
  }

  // probably should be private or protected??
private:
  void buildKeyForAESEncryptOrDecrypt(bool shouldEncrypt = true) {
    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) {
        PRINTERROR2(status, "psa_aead_encrypt_setup");
      }
      if (!givlen) {
        status = psa_aead_generate_nonce(&op, iv, sizeof(iv), &givlen);
        if (status != PSA_SUCCESS) {
          PRINTERROR2(status, "psa_aead_generate_nonce");
        }
        DEBUG3("generated iv size = " + String(givlen));
        assert(givlen == IVSIZE);
      } 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) {
          PRINTERROR2(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) {
        PRINTERROR2(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) {
        PRINTERROR2(status, "psa_aead_set_nonce");
      }
    }
  }
 

public:
  String Decrypt(unsigned char *bytes, size_t len) {
    DEBUG3("");
    psa_status_t status;
    String rtn = "";
    unsigned char outbuf[key_bits / 8];
    assert(sizeof(outbuf) == 16);
    unsigned char inpbuf[key_bits / 8];
    assert(len % 16 == 0);
 
    buildKeyForAESEncryptOrDecrypt(false);
    DEBUG3("len = " + String(len));
    int lastcharactercount = 0;
    size_t olen;
    while (lastcharactercount < len) {
      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) {
        PRINTERROR2(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;
  }
 
  unsigned char *
  Encrypt(String datatoEncrypt, size_t &outputsize) {
    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();
 
    // copy at most key_bits /8
    while (lastcharactercount < maxlength) {
      // DEBUG2("********* LOOP ******* ");
      String dataforthisround = datatoEncrypt.substring(lastcharactercount, lastcharactercount + 16);
      // DEBUG2("Data for this round = " + dataforthisround + " , length = " + dataforthisround.length());
      dataforthisround.getBytes(inpbuf, dataforthisround.length() + 1);
      lastcharactercount += dataforthisround.length();
 
      // i think i need to erase the end-- note i'm using zero bytes because its a string
      int stilltodo = sizeof(inpbuf) - dataforthisround.length();
      unsigned char *p = inpbuf + dataforthisround.length();
      for (int i = 0; i < stilltodo; i++)
        *p++ = 0;  //'*';
      // = '*';  // only for validation
      DUMP("inpbuf", inpbuf, sizeof(inpbuf));
      // *************
      // 123456789012345678
      /*    * If this function returns an error status, the operation enters an error
 * state and must be aborted by calling psa_aead_abort(). */
      status = psa_aead_update(&op, inpbuf, sizeof(inpbuf), outbuf, sizeof(outbuf), &olen);
      if (status != PSA_SUCCESS) {
        PRINTERROR2(status, "psa_aead_update");
      }
      // DEBUG2("olen for update = " + String(olen));
      // 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) {
      PRINTERROR2(status, "psa_aead_update");
    }
    int numbytes = outputbytes.size();
    outputsize = numbytes;
    unsigned char *rtn = (unsigned char *)malloc((size_t)numbytes);
    // DEBUG2("****************END size=" + String(numbytes));
    // char work[10];
    for (int i = 0; i < numbytes; i++) {
      // sprintf(work, "%02X ", outputbytes.front());
      rtn[i] = outputbytes.front();
      // sprintf(work, "%d-%02X ",i, outputbytes.front());
      outputbytes.pop_front();
      // Serial.println(work);
    }
    // Serial.println();
 
    /*
// I don't need this, before this required using psa_read_update_ad which I'm not using. but I might it in the futura
      status = psa_aead_finish(&op, outbuf, sizeof(outbuf), &olen, authenticationtag, sizeof(authenticationtag), &olen_tag);
      if (status != PSA_SUCCESS) {
      PRINTERROR("psa_aead_finish");
    }
    */
    return rtn;
  }
};
 
#endif