sha256 added

sha256/benchmark/input.c

@@ -0,0 +1,273 @@
+/* First file is usable as standalone C program
+   without header management necessary */
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+/* ROSE has problems duoing a
+   deepy copy of something like
+   typedef struct { bla } typename;
+   It unparses no structure members.
+   The following workaround was provided. */
+struct sha256_ctx_s {
+  uint8_t data[64];
+  uint32_t datalen;
+  uint32_t bitlen[2];
+  uint32_t state[8];
+};
+typedef struct sha256_ctx_s SHA256_CTX;
+
+void sha256_transform(SHA256_CTX *, uint8_t[]);
+void sha256_init(SHA256_CTX *);
+void sha256_update(SHA256_CTX *, uint8_t[], uint32_t);
+void sha256_final(SHA256_CTX *, uint8_t[]);
+
+uint32_t k[64] = {
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1,
+    0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
+    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b,
+    0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2};
+
+// DBL_INT_ADD treats two unsigned ints a and b as one 64-bit integer and adds c
+// to it
+#define DBL_INT_ADD(a, b, c)                                                   \
+  if (a > 0xffffffff - (c))                                                    \
+    ++b;                                                                       \
+  a += c;
+
+uint32_t ROTLEFT(uint32_t a, uint32_t b) {
+  return (((a) << (b)) | ((a) >> (32 - (b))));
+}
+
+uint32_t ROTRIGHT(uint32_t a, uint32_t b) {
+  return (((a) >> (b)) | ((a) << (32 - (b))));
+}
+
+uint32_t CH(uint32_t x, uint32_t y, uint32_t z) {
+  return (((x) & (y)) ^ (~(x) & (z)));
+}
+
+uint32_t MAJ(uint32_t x, uint32_t y, uint32_t z) {
+  return (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)));
+}
+
+uint32_t EP0(uint32_t x) {
+  return (ROTRIGHT(x, 2) ^ ROTRIGHT(x, 13) ^ ROTRIGHT(x, 22));
+}
+
+uint32_t SIG0(uint32_t x) {
+  return (ROTRIGHT(x, 7) ^ ROTRIGHT(x, 18) ^ ((x) >> 3));
+}
+
+uint32_t SIG1(uint32_t x) {
+  return (ROTRIGHT(x, 17) ^ ROTRIGHT(x, 19) ^ ((x) >> 10));
+}
+
+uint32_t EP1(uint32_t x) {
+  return (ROTRIGHT(x, 6) ^ ROTRIGHT(x, 11) ^ ROTRIGHT(x, 25));
+}
+
+void sha256_transform(SHA256_CTX *ctx, uint8_t data[]) {
+  uint32_t a, b, c, d, e, f, g, h, i, j;
+  uint32_t t1, t2;
+
+  uint32_t m[64];
+
+  for (i = 0, j = 0; i < 16; ++i, j += 4) {
+    m[i] = (data[j] << 24) | (data[j + 1] << 16) | (data[j + 2] << 8) |
+           (data[j + 3]);
+  }
+
+  for (; i < 64; ++i) {
+    m[i] = SIG1(m[i - 2]) + m[i - 7] + SIG0(m[i - 15]) + m[i - 16];
+  }
+
+  a = ctx->state[0];
+  b = ctx->state[1];
+  c = ctx->state[2];
+  d = ctx->state[3];
+  e = ctx->state[4];
+  f = ctx->state[5];
+  g = ctx->state[6];
+  h = ctx->state[7];
+
+  for (i = 0; i < 64; ++i) {
+    t1 = h + EP1(e) + CH(e, f, g) + k[i] + m[i];
+    t2 = EP0(a) + MAJ(a, b, c);
+    h = g;
+    g = f;
+    f = e;
+    e = d + t1;
+    d = c;
+    c = b;
+    b = a;
+    a = t1 + t2;
+  }
+
+  ctx->state[0] += a;
+  ctx->state[1] += b;
+  ctx->state[2] += c;
+  ctx->state[3] += d;
+  ctx->state[4] += e;
+  ctx->state[5] += f;
+  ctx->state[6] += g;
+  ctx->state[7] += h;
+}
+
+void my_memset(uint8_t *data, uint8_t val, uint32_t len) {
+  for (int i = 0; i < len; i++) {
+    data[i] = val;
+  }
+}
+
+void sha256_final(SHA256_CTX *ctx, uint8_t hash[]) {
+  uint32_t i;
+
+  i = ctx->datalen;
+
+  // Pad whatever data is left in the buffer.
+  if (ctx->datalen < 56) {
+    ctx->data[i++] = 0x80;
+    while (i < 56)
+      ctx->data[i++] = 0x00;
+  } else {
+    ctx->data[i++] = 0x80;
+    while (i < 64)
+      ctx->data[i++] = 0x00;
+    sha256_transform(ctx, ctx->data);
+    my_memset(ctx->data, 0, 56);
+  }
+
+  // Append to the padding the total message's length in bits and transform.
+  DBL_INT_ADD(ctx->bitlen[0], ctx->bitlen[1], ctx->datalen * 8);
+  ctx->data[63] = ctx->bitlen[0];
+  ctx->data[62] = ctx->bitlen[0] >> 8;
+  ctx->data[61] = ctx->bitlen[0] >> 16;
+  ctx->data[60] = ctx->bitlen[0] >> 24;
+  ctx->data[59] = ctx->bitlen[1];
+  ctx->data[58] = ctx->bitlen[1] >> 8;
+  ctx->data[57] = ctx->bitlen[1] >> 16;
+  ctx->data[56] = ctx->bitlen[1] >> 24;
+
+  sha256_transform(ctx, ctx->data);
+
+  // Since this implementation uses little endian byte ordering and SHA uses big
+  // endian, reverse all the bytes when copying the final state to the output
+  // hash.
+  for (i = 0; i < 4; ++i) {
+    hash[i] = (ctx->state[0] >> (24 - i * 8)) & 0x000000ff;
+    hash[i + 4] = (ctx->state[1] >> (24 - i * 8)) & 0x000000ff;
+    hash[i + 8] = (ctx->state[2] >> (24 - i * 8)) & 0x000000ff;
+    hash[i + 12] = (ctx->state[3] >> (24 - i * 8)) & 0x000000ff;
+    hash[i + 16] = (ctx->state[4] >> (24 - i * 8)) & 0x000000ff;
+    hash[i + 20] = (ctx->state[5] >> (24 - i * 8)) & 0x000000ff;
+    hash[i + 24] = (ctx->state[6] >> (24 - i * 8)) & 0x000000ff;
+    hash[i + 28] = (ctx->state[7] >> (24 - i * 8)) & 0x000000ff;
+  }
+}
+
+void sha256_init(SHA256_CTX *ctx) {
+  ctx->datalen = 0;
+  ctx->bitlen[0] = 0;
+  ctx->bitlen[1] = 0;
+  ctx->state[0] = 0x6a09e667;
+  ctx->state[1] = 0xbb67ae85;
+  ctx->state[2] = 0x3c6ef372;
+  ctx->state[3] = 0xa54ff53a;
+  ctx->state[4] = 0x510e527f;
+  ctx->state[5] = 0x9b05688c;
+  ctx->state[6] = 0x1f83d9ab;
+  ctx->state[7] = 0x5be0cd19;
+}
+
+void sha256_update(SHA256_CTX *ctx, uint8_t data[], uint32_t len) {
+  uint32_t i;
+
+  for (i = 0; i < len; ++i) {
+    ctx->data[ctx->datalen] = data[i];
+    ctx->datalen++;
+    if (ctx->datalen == 64) {
+      sha256_transform(ctx, ctx->data);
+      DBL_INT_ADD(ctx->bitlen[0], ctx->bitlen[1], 512);
+      ctx->datalen = 0;
+    }
+  }
+}
+
+// Top Function
+void sha256(uint8_t data[64], uint8_t result[32]) {
+  SHA256_CTX ctx;
+  sha256_init(&ctx);
+  sha256_update(&ctx, data, 64);
+  sha256_final(&ctx, result);
+}
+
+void print_hash(unsigned char hash[32]) {
+  int idx;
+  for (idx = 0; idx < 32; idx++)
+    printf("%02x", hash[idx]);
+  printf("\n");
+}
+
+bool check(uint8_t *expected, uint8_t *actual, int len) {
+  bool result = !(strncmp(expected, actual, len));
+  fprintf(stderr, "Check was %s!\n", result ? "successful" : "not successful");
+  return result;
+}
+
+void hexStrToArray(const char *input, uint8_t *output, int outputLen) {
+  int len = strlen(input);
+  assert(len == 2 * outputLen);
+
+  int outputCnt = 0;
+  for (int i = 0; i < len; i += 2) {
+    sscanf(input, "%02hhx", output);
+    output++;
+    input += 2;
+  }
+}
+
+void mov256(uint8_t *in, uint8_t *target) {
+  for (int i = 0; i < 32; i++) {
+    target[i] = in[i];
+  }
+}
+
+bool toReturnCode(bool tf) { return !tf; }
+
+int main(int argc, char **argv) {
+  int times = 10000;
+  if (argc == 2) {
+    times = atoi(argv[1]);
+  }
+  uint8_t text1[64] = {
+      "abcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcdabcd"};
+  uint8_t result[32] = {0};
+
+  #pragma omp target map(to : text1) map(tofrom : result) map(to: times)
+  {
+    uint8_t buffer1[64];
+    uint8_t buffer2[32];
+    for (int i = 0; i < 64; i++) {
+      buffer1[i] = 0;
+    }
+    mov256(text1, buffer1);
+    for (int i = 0; i < times; i++) {
+      sha256(buffer1, buffer2);
+      mov256(buffer2, buffer1);
+    }
+    mov256(buffer1, result);
+  }
+  print_hash(text1);
+  printf("Hashed %d times\n", times);
+  print_hash(result);
+}