#include <stdlib.h>
#include <string.h>
#include "api.h"
#include "aes128.h"
#include "aes_cmac.h"

#include "driver.h"

static u128 buf[AES_BUFSIZE+1];

////// key table real
//  (KEY_TABLE[15] is for error indication should be always 0 )
KEY_TABLE key_table[16];

////// Error Handling
//
int ERROR_FLAG = 0;
static void error_on(int val)
{
  ERROR_FLAG |= val;
}

static void error_off(int val)
{
  ERROR_FLAG &= ~val;
}

////// utils
//
static KEY_TABLE *key_entry(KEY_ID keyid)
{
  return &key_table[keyid];
}

static KEY128 *key(KEY_ID keyid)
{
  if ((keyid == RAMKEY && 
       key_table[keyid].key_flag== RAM_PLAIN_KEY) ||
      key_table[keyid].key_flag & KEY_PRESENT) {
    return &key_table[keyid].key;
  } else {
    error_on(ERC_KEY_EMPTY);
    return &key_table[ERROR].key;
  }
}

static void xor(u128 *p, u128 *q) 
{
  for (int i = 0; i< 4; i++)
    p->ul[i] ^= q->ul[i];
}

void SB_B_SET_WORKMEM()
{
  // dummy  for future extension
}

//////// APIs
//
ODAT* SB_B_ENC_ECB(int n, KEY_ID keyid, u128 *idat)
{
  memcpy(buf, idat, n*sizeof(u128));
	for (int i =0; i< n; i++) {
    drv_AES_crypt((uint *)(&buf[i]), (uint8*)key(keyid));
	}
	return buf;
};

ODAT* SB_B_DEC_ECB(int n, KEY_ID keyid, u128 *idat)
{
  memcpy(buf, idat, n*sizeof(u128));
	for (int i =0; i< n; i++) {
    drv_AES_decrypt((uint *)(&buf[i]), (uint8*)key(keyid));
	}
	return buf;
};

ODAT* SB_B_ENC_CBC(int n, KEY_ID keyid, u128 iv, u128 *idat)
{
  memcpy(buf, idat, n*sizeof(u128));
	for (int i =0; i< n; i++) {
    if (i == 0) 
      xor(&buf[i], &iv);
    else 
      xor(&buf[i], &buf[i-1]);
    AES128_crypt((uint *)(&buf[i]), (uint8*)key(keyid));
	}
	return buf;
};

ODAT* SB_B_DEC_CBC(int n, KEY_ID keyid, u128 iv, u128 *idat)
{
  memcpy(buf, idat, n*sizeof(u128));
	for (int i =0; i< n; i++) {
    AES128_decrypt((uint *)(&buf[i]), (uint8*)key(keyid));
    if (i == 0) 
      xor(&buf[i], &iv);
    else 
      xor(&buf[i], &idat[i-1]);
	}
	return buf;
};

ODAT* SB_B_GENERATE_MAC(int n, KEY_ID keyid, u128 *idat)
{
  return (ODAT*)drv_AES_cmac(key(keyid), idat, n);
}

uint SB_B_VERIFY_MAC(int n, int nbits, KEY_ID keyid, u128 *idat3, u128 *idat4)
{
  uint8 *p =
    (uint8*)drv_AES_cmac(key(keyid), idat3, n);
  uint8 *q = (uint8*) idat4;

  for (int i = 0; i< nbits/8; i++) {
    if (*p++ != *q++) return 1;
  }

  int r = (nbits & 0x7);
  if (r) {
      int mask = ((1<<r)-1)<<(8-r);
      if ((mask & *p) != (mask & *q)) return 1;
  }
  return 0;
}
 
void SB_B_LOAD_KEY(u128 M1, u256 M2, u128 M3) 
{
   
}

// plain key to RAMKEY(15) entry
void SB_B_LOAD_PLAIN_KEY(KEY128 key) 
{
  key_table[RAMKEY].key = key;
  key_table[RAMKEY].key_flag |= RAM_PLAIN_KEY;
}

KEY128 SB_B_EXPORT_RAM_KEY()
{
  return *key(RAMKEY);
}

ODAT* SB_B_INIT_RNG() 
{
  uint8 *val;
  drv_reset(DRV_RST_PRNG|DRV_RST_MD5);
  val = drv_rtc_get_bin();
  // -> md5 
  //md5( val);
    //*/
  return NULL;

}
//SB_B_EXTEND_SEED
 //SB_B_RND()
//{
  //return 0;
//}

//SB_B_GET_STATUS
//SB_B_GET_ID
void SB_B_CANCEL()
{
  //dummy
}

void SB_B_IMPORT_KEY()
{
}
void SB_B_EXPORT_KEY()
{
}


// vi:expandtab:foldmethod=syntax sw=2 ts=2