test/pkey_meth_kdf_test.c

   1 /*
   2  * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /* Tests of the EVP_PKEY_CTX_set_* macro family */
  11
  12 #include <stdio.h>
  13 #include <string.h>
  14
  15 #include <openssl/evp.h>
  16 #include <openssl/kdf.h>
  17 #include "testutil.h"
  18
  19 static int test_kdf_hkdf(void)
  20 {
  21     EVP_PKEY_CTX *pctx;
  22     unsigned char out[10];
  23     size_t outlen = sizeof(out);
  24     pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, NULL);
  25
  26     if (EVP_PKEY_derive_init(pctx) <= 0) {
  27         TEST_error("EVP_PKEY_derive_init");
  28         return 0;
  29     }
  30     if (EVP_PKEY_CTX_set_hkdf_md(pctx, EVP_sha256()) <= 0) {
  31         TEST_error("EVP_PKEY_CTX_set_hkdf_md");
  32         return 0;
  33     }
  34     if (EVP_PKEY_CTX_set1_hkdf_salt(pctx, "salt", 4) <= 0) {
  35         TEST_error("EVP_PKEY_CTX_set1_hkdf_salt");
  36         return 0;
  37     }
  38     if (EVP_PKEY_CTX_set1_hkdf_key(pctx, "secret", 6) <= 0) {
  39         TEST_error("EVP_PKEY_CTX_set1_hkdf_key");
  40         return 0;
  41     }
  42     if (EVP_PKEY_CTX_add1_hkdf_info(pctx, "label", 5) <= 0) {
  43         TEST_error("EVP_PKEY_CTX_set1_hkdf_info");
  44         return 0;
  45     }
  46     if (EVP_PKEY_derive(pctx, out, &outlen) <= 0) {
  47         TEST_error("EVP_PKEY_derive");
  48         return 0;
  49     }
  50
  51     {
  52         const unsigned char expected[sizeof(out)] = {
  53             0x2a, 0xc4, 0x36, 0x9f, 0x52, 0x59, 0x96, 0xf8, 0xde, 0x13
  54         };
  55         if (!TEST_mem_eq(out, sizeof(out), expected, sizeof(expected))) {
  56             return 0;
  57         }
  58     }
  59     EVP_PKEY_CTX_free(pctx);
  60     return 1;
  61 }
  62
  63 static int test_kdf_scrypt(void)
  64 {
  65     EVP_PKEY_CTX *pctx;
  66     unsigned char out[64];
  67     size_t outlen = sizeof(out);
  68     pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_SCRYPT, NULL);
  69
  70     if (EVP_PKEY_derive_init(pctx) <= 0) {
  71         TEST_error("EVP_PKEY_derive_init");
  72         return 0;
  73     }
  74     if (EVP_PKEY_CTX_set1_pbe_pass(pctx, "password", 8) <= 0) {
  75         TEST_error("EVP_PKEY_CTX_set1_pbe_pass");
  76         return 0;
  77     }
  78     if (EVP_PKEY_CTX_set1_scrypt_salt(pctx, "NaCl", 4) <= 0) {
  79         TEST_error("EVP_PKEY_CTX_set1_scrypt_salt");
  80         return 0;
  81     }
  82     if (EVP_PKEY_CTX_set_scrypt_N(pctx, 1024) <= 0) {
  83         TEST_error("EVP_PKEY_CTX_set_scrypt_N");
  84         return 0;
  85     }
  86     if (EVP_PKEY_CTX_set_scrypt_r(pctx, 8) <= 0) {
  87         TEST_error("EVP_PKEY_CTX_set_scrypt_r");
  88         return 0;
  89     }
  90     if (EVP_PKEY_CTX_set_scrypt_p(pctx, 16) <= 0) {
  91         TEST_error("EVP_PKEY_CTX_set_scrypt_p");
  92         return 0;
  93     }
  94     if (EVP_PKEY_CTX_set_scrypt_maxmem_bytes(pctx, 16) <= 0) {
  95         TEST_error("EVP_PKEY_CTX_set_maxmem_bytes");
  96         return 0;
  97     }
  98     if (EVP_PKEY_derive(pctx, out, &outlen) > 0) {
  99         TEST_error("EVP_PKEY_derive should have failed");
 100         return 0;
 101     }
 102     if (EVP_PKEY_CTX_set_scrypt_maxmem_bytes(pctx, 10 * 1024 * 1024) <= 0) {
 103         TEST_error("EVP_PKEY_CTX_set_maxmem_bytes");
 104         return 0;
 105     }
 106     if (EVP_PKEY_derive(pctx, out, &outlen) <= 0) {
 107         TEST_error("EVP_PKEY_derive");
 108         return 0;
 109     }
 110
 111     {
 112         const unsigned char expected[sizeof(out)] = {
 113             0xfd, 0xba, 0xbe, 0x1c, 0x9d, 0x34, 0x72, 0x00,
 114             0x78, 0x56, 0xe7, 0x19, 0x0d, 0x01, 0xe9, 0xfe,
 115             0x7c, 0x6a, 0xd7, 0xcb, 0xc8, 0x23, 0x78, 0x30,
 116             0xe7, 0x73, 0x76, 0x63, 0x4b, 0x37, 0x31, 0x62,
 117             0x2e, 0xaf, 0x30, 0xd9, 0x2e, 0x22, 0xa3, 0x88,
 118             0x6f, 0xf1, 0x09, 0x27, 0x9d, 0x98, 0x30, 0xda,
 119             0xc7, 0x27, 0xaf, 0xb9, 0x4a, 0x83, 0xee, 0x6d,
 120             0x83, 0x60, 0xcb, 0xdf, 0xa2, 0xcc, 0x06, 0x40
 121         };
 122         if (!TEST_mem_eq(out, sizeof(out), expected, sizeof(expected))) {
 123             return 0;
 124         }
 125     }
 126     EVP_PKEY_CTX_free(pctx);
 127     return 1;
 128 }
 129
 130 int setup_tests()
 131 {
 132     ADD_TEST(test_kdf_hkdf);
 133     ADD_TEST(test_kdf_scrypt);
 134     return 1;
 135 }