
#include <fstream>
#include <iostream>

#include "internals.h"

//
// Used to model the cryptography extension entropy source.
// See Section 4 of the Scalar Cryptography Extension specificaiton.
class entropy_source {

public:

  // Valid return codes for OPST bits [31:30] when reading seed.
  static const uint32_t OPST_BIST = 0x0 << 30;
  static const uint32_t OPST_WAIT = 0x1 << 30;
  static const uint32_t OPST_ES16 = 0x2 << 30;
  static const uint32_t OPST_DEAD = 0x3 << 30;

  //
  // Other system events
  // ------------------------------------------------------------

  void reset() {
    // Does nothing for now. In the future, can be used to model things
    // like initial BIST states.
  }

  //
  // seed register
  // ------------------------------------------------------------

  void set_seed(reg_t val) {
    // Always ignore writes to seed.
    // This CSR is strictly read only. It occupies a RW CSR address
    // to handle the side-effect of the changing seed value on a read.
  }

  //
  // The format of seed is described in Section 4.1 of
  // the scalar cryptography specification.
  reg_t get_seed() {

    uint32_t result  = 0;

    // Currently, always return ES16 (i.e. good randomness) In the future, we
    // can more realistically model things like WAIT states, BIST warm up and
    // maybe scriptable entry into the DEAD state, but until then, this is
    // the bare minimum.
    uint32_t return_status = OPST_ES16;

    if(return_status == OPST_ES16) {

        // Add some sampled entropy into the low 16 bits
        uint16_t entropy = this -> get_two_random_bytes();
        result |= entropy;

    } else if(return_status == OPST_BIST) {

        // Do nothing.

    } else if(return_status == OPST_WAIT) {

        // Do nothing.

    } else if(return_status == OPST_DEAD) {

        // Do nothing. Stay dead.

    } else {

        // Unreachable.

    }

    // Note that if we get here any return_status is anything other than
    // OPST_ES16, then the low 16-bits of the return value must be zero.

    result |= return_status;

    // Result is zero-extended on RV64.
    return (reg_t)result;
  }

  //
  // Utility / support variables and functions.
  // ------------------------------------------------------------

  // The file to read entropy from.
  std::string randomness_source = "/dev/urandom";

  // Read two random bytes from the entropy source file.
  uint16_t get_two_random_bytes() {

      std::ifstream fh(this -> randomness_source, std::ios::binary);

      if(fh.is_open()) {

          uint16_t random_bytes;

          fh.read((char*)(&random_bytes), 2);

          fh.close();

          return random_bytes;

      } else {

          fprintf(stderr, "Could not open randomness source file:\n\t");
          fprintf(stderr, "%s", randomness_source.c_str());
          abort();

      }

  }

};

