all repos — TinyCrypT @ 39728dd7e0d3c64d6c747076bdd4472b9d7f9ff8

Short and sweet classical cryptographic primitives

tests/src/x25519/all.cpp (view raw)

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 
extern "C"
{
#include "tinycrypt/x25519.h"
}
#include "gtest/gtest.h"
#include <cstdint>
#include <cstring>

TEST (X25519, x25519_scalarmult_0)
{
  const uint8_t SCALAR[]
      = { 0xa5, 0x46, 0xe3, 0x6b, 0xf0, 0x52, 0x7c, 0x9d, 0x3b, 0x16, 0x15,
          0x4b, 0x82, 0x46, 0x5e, 0xdd, 0x62, 0x14, 0x4c, 0x0a, 0xc1, 0xfc,
          0x5a, 0x18, 0x50, 0x6a, 0x22, 0x44, 0xba, 0x44, 0x9a, 0xc4 };
  const uint8_t U[]
      = { 0xe6, 0xdb, 0x68, 0x67, 0x58, 0x30, 0x30, 0xdb, 0x35, 0x94, 0xc1,
          0xa4, 0x24, 0xb1, 0x5f, 0x7c, 0x72, 0x66, 0x24, 0xec, 0x26, 0xb3,
          0x35, 0x3b, 0x10, 0xa9, 0x03, 0xa6, 0xd0, 0xab, 0x1c, 0x4c };
  const uint8_t EXPECTED[]
      = { 0xc3, 0xda, 0x55, 0x37, 0x9d, 0xe9, 0xc6, 0x90, 0x8e, 0x94, 0xea,
          0x4d, 0xf2, 0x8d, 0x08, 0x4f, 0x32, 0xec, 0xcf, 0x03, 0x49, 0x1c,
          0x71, 0xf7, 0x54, 0xb4, 0x07, 0x55, 0x77, 0xa2, 0x85, 0x52 };
  uint8_t actual[sizeof (EXPECTED)];
  tct_x25519 (SCALAR, U, actual);
  EXPECT_EQ (memcmp (actual, EXPECTED, sizeof (EXPECTED)), 0);
}

TEST (X25519, x25519_scalarmult_1)
{
  const uint8_t SCALAR[]
      = { 0x4b, 0x66, 0xe9, 0xd4, 0xd1, 0xb4, 0x67, 0x3c, 0x5a, 0xd2, 0x26,
          0x91, 0x95, 0x7d, 0x6a, 0xf5, 0xc1, 0x1b, 0x64, 0x21, 0xe0, 0xea,
          0x01, 0xd4, 0x2c, 0xa4, 0x16, 0x9e, 0x79, 0x18, 0xba, 0x0d };
  const uint8_t U[]
      = { 0xe5, 0x21, 0x0f, 0x12, 0x78, 0x68, 0x11, 0xd3, 0xf4, 0xb7, 0x95,
          0x9d, 0x05, 0x38, 0xae, 0x2c, 0x31, 0xdb, 0xe7, 0x10, 0x6f, 0xc0,
          0x3c, 0x3e, 0xfc, 0x4c, 0xd5, 0x49, 0xc7, 0x15, 0xa4, 0x93 };
  const uint8_t EXPECTED[]
      = { 0x95, 0xcb, 0xde, 0x94, 0x76, 0xe8, 0x90, 0x7d, 0x7a, 0xad, 0xe4,
          0x5c, 0xb4, 0xb8, 0x73, 0xf8, 0x8b, 0x59, 0x5a, 0x68, 0x79, 0x9f,
          0xa1, 0x52, 0xe6, 0xf8, 0xf7, 0x64, 0x7a, 0xac, 0x79, 0x57 };
  uint8_t actual[sizeof (EXPECTED)];
  tct_x25519 (SCALAR, U, actual);
  EXPECT_EQ (memcmp (actual, EXPECTED, sizeof (EXPECTED)), 0);
}

TEST (X25519, x25519_repetition_1)
{
  uint8_t buf[96];
  uint8_t *k = buf;
  uint8_t *u = buf + 32;
  uint8_t *out = buf + 64;
  for (unsigned int i = 0; i < 32; ++i)
    {
      k[i] = u[i] = 0x0;
    }
  k[0] = 0x9;
  u[0] = 0x9;
  tct_x25519 (k, u, out);
  const uint8_t EXPECTED[]
      = { 0x42, 0x2c, 0x8e, 0x7a, 0x62, 0x27, 0xd7, 0xbc, 0xa1, 0x35, 0x0b,
          0x3e, 0x2b, 0xb7, 0x27, 0x9f, 0x78, 0x97, 0xb8, 0x7b, 0xb6, 0x85,
          0x4b, 0x78, 0x3c, 0x60, 0xe8, 0x03, 0x11, 0xae, 0x30, 0x79 };
  EXPECT_EQ (memcmp (out, EXPECTED, sizeof (EXPECTED)), 0);
}

TEST (X25519, x25519_repetition_1000)
{
  uint8_t buf[96];
  uint8_t *k = buf;
  uint8_t *u = buf + 32;
  uint8_t *out = buf + 64;
  for (unsigned int i = 0; i < 32; ++i)
    {
      k[i] = u[i] = 0x0;
    }
  k[0] = 0x9;
  u[0] = 0x9;
  for (unsigned int i = 0; i < 1000; ++i)
    {
      tct_x25519 (k, u, out);
      uint8_t *tmp = k;
      k = out;
      out = u;
      u = tmp;
    }
  const uint8_t EXPECTED[]
      = { 0x68, 0x4c, 0xf5, 0x9b, 0xa8, 0x33, 0x09, 0x55, 0x28, 0x00, 0xef,
          0x56, 0x6f, 0x2f, 0x4d, 0x3c, 0x1c, 0x38, 0x87, 0xc4, 0x93, 0x60,
          0xe3, 0x87, 0x5f, 0x2e, 0xb9, 0x4d, 0x99, 0x53, 0x2c, 0x51 };
  EXPECT_EQ (memcmp (k, EXPECTED, sizeof (EXPECTED)), 0);
}

TEST (X25519, x25519_repetition_1000000)
{
  uint8_t buf[96];
  uint8_t *k = buf;
  uint8_t *u = buf + 32;
  uint8_t *out = buf + 64;
  for (unsigned int i = 0; i < 32; ++i)
    {
      k[i] = u[i] = 0x0;
    }
  k[0] = 0x9;
  u[0] = 0x9;
  for (unsigned int i = 0; i < 1000000; ++i)
    {
      tct_x25519 (k, u, out);
      uint8_t *tmp = k;
      k = out;
      out = u;
      u = tmp;
    }
  const uint8_t EXPECTED[]
      = { 0x7c, 0x39, 0x11, 0xe0, 0xab, 0x25, 0x86, 0xfd, 0x86, 0x44, 0x97,
          0x29, 0x7e, 0x57, 0x5e, 0x6f, 0x3b, 0xc6, 0x01, 0xc0, 0x88, 0x3c,
          0x30, 0xdf, 0x5f, 0x4d, 0xd2, 0xd2, 0x4f, 0x66, 0x54, 0x24 };
  EXPECT_EQ (memcmp (k, EXPECTED, sizeof (EXPECTED)), 0);
}