| 1 |
/*- |
| 2 |
* Copyright 2013-2018 Alexander Peslyak |
| 3 |
* All rights reserved. |
| 4 |
* |
| 5 |
* Redistribution and use in source and binary forms, with or without |
| 6 |
* modification, are permitted. |
| 7 |
* |
| 8 |
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND |
| 9 |
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| 10 |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| 11 |
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
| 12 |
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 13 |
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
| 14 |
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
| 15 |
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
| 16 |
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
| 17 |
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 18 |
* SUCH DAMAGE. |
| 19 |
*/ |
| 20 |
|
| 21 |
#include "crypt-port.h" |
| 22 |
|
| 23 |
#if INCLUDE_yescrypt || INCLUDE_scrypt || INCLUDE_gost_yescrypt || \ |
| 24 |
INCLUDE_sm3_yescrypt |
| 25 |
|
| 26 |
#pragma GCC diagnostic ignored "-Wconversion" |
| 27 |
#pragma GCC diagnostic ignored "-Wsign-conversion" |
| 28 |
#pragma GCC diagnostic ignored "-Wcast-qual" |
| 29 |
|
| 30 |
#include <stdio.h> |
| 31 |
#include <string.h> |
| 32 |
|
| 33 |
#define YESCRYPT_FLAGS YESCRYPT_DEFAULTS |
| 34 |
#if 1 |
| 35 |
#define YESCRYPT_P 11 |
| 36 |
#define YESCRYPT_PROM 8 |
| 37 |
#else |
| 38 |
#define YESCRYPT_P 1 |
| 39 |
#define YESCRYPT_PROM 1 |
| 40 |
#endif |
| 41 |
|
| 42 |
#undef TEST_PBKDF2_SHA256 |
| 43 |
#define TEST_SCRYPT |
| 44 |
#define TEST_YESCRYPT_KDF |
| 45 |
#define TEST_YESCRYPT_ENCODING |
| 46 |
#define TEST_ROM |
| 47 |
#define TEST_ROM_PREALLOC |
| 48 |
|
| 49 |
static int retval = 0; |
| 50 |
|
| 51 |
#ifdef TEST_ROM_PREALLOC |
| 52 |
#include <stdlib.h> /* for malloc() */ |
| 53 |
#endif |
| 54 |
|
| 55 |
#ifdef TEST_PBKDF2_SHA256 |
| 56 |
#include <assert.h> |
| 57 |
|
| 58 |
#include "alg-sha256.h" |
| 59 |
|
| 60 |
static void print_PBKDF2_SHA256_raw(const char *passwd, size_t passwdlen, |
| 61 |
const char *salt, size_t saltlen, uint64_t c, size_t dkLen) |
| 62 |
{ |
| 63 |
uint8_t dk[64]; |
| 64 |
size_t i; |
| 65 |
|
| 66 |
assert(dkLen <= sizeof(dk)); |
| 67 |
|
| 68 |
/* XXX This prints the strings truncated at first NUL */ |
| 69 |
printf("PBKDF2_SHA256(\"%s\", \"%s\", %llu, %llu) =", |
| 70 |
passwd, salt, (unsigned long long)c, (unsigned long long)dkLen); |
| 71 |
|
| 72 |
PBKDF2_SHA256((const uint8_t *) passwd, passwdlen, |
| 73 |
(const uint8_t *) salt, saltlen, c, dk, dkLen); |
| 74 |
|
| 75 |
for (i = 0; i < dkLen; i++) |
| 76 |
printf(" %02x", dk[i]); |
| 77 |
puts(""); |
| 78 |
} |
| 79 |
|
| 80 |
static void print_PBKDF2_SHA256(const char *passwd, |
| 81 |
const char *salt, uint64_t c, size_t dkLen) |
| 82 |
{ |
| 83 |
print_PBKDF2_SHA256_raw(passwd, strlen(passwd), salt, strlen(salt), c, |
| 84 |
dkLen); |
| 85 |
} |
| 86 |
#endif |
| 87 |
|
| 88 |
#if defined(TEST_SCRYPT) || defined(TEST_YESCRYPT_ENCODING) |
| 89 |
#include "alg-yescrypt.h" |
| 90 |
#endif |
| 91 |
|
| 92 |
#ifdef TEST_SCRYPT |
| 93 |
static void print_scrypt(const char *passwd, const char *salt, |
| 94 |
uint64_t N, uint32_t r, uint32_t p) |
| 95 |
{ |
| 96 |
uint8_t dk[64]; |
| 97 |
size_t i; |
| 98 |
|
| 99 |
printf("scrypt(\"%s\", \"%s\", %llu, %u, %u) =", |
| 100 |
passwd, salt, (unsigned long long)N, r, p); |
| 101 |
|
| 102 |
if (crypto_scrypt((const uint8_t *) passwd, strlen(passwd), |
| 103 |
(const uint8_t *) salt, strlen(salt), N, r, p, dk, sizeof(dk))) { |
| 104 |
puts(" FAILED"); |
| 105 |
retval = 1; |
| 106 |
return; |
| 107 |
} |
| 108 |
|
| 109 |
for (i = 0; i < sizeof(dk); i++) |
| 110 |
printf(" %02x", dk[i]); |
| 111 |
puts(""); |
| 112 |
} |
| 113 |
#endif |
| 114 |
|
| 115 |
#ifdef TEST_YESCRYPT_KDF |
| 116 |
static void print_yescrypt(const char *passwd, const char *salt, |
| 117 |
yescrypt_flags_t flags, |
| 118 |
uint64_t N, uint32_t r, uint32_t p, uint32_t t, uint32_t g, |
| 119 |
uint32_t dklen) |
| 120 |
{ |
| 121 |
yescrypt_local_t local; |
| 122 |
yescrypt_params_t params = {flags, N, r, p, t, g, 0}; |
| 123 |
uint8_t dk[64]; |
| 124 |
uint32_t i; |
| 125 |
|
| 126 |
#if 1 |
| 127 |
/* Don't test hash upgrades */ |
| 128 |
if (g) |
| 129 |
return; |
| 130 |
#endif |
| 131 |
|
| 132 |
if (dklen > sizeof(dk) || yescrypt_init_local(&local)) { |
| 133 |
puts("FAILED"); |
| 134 |
retval = 1; |
| 135 |
return; |
| 136 |
} |
| 137 |
|
| 138 |
printf("yescrypt(\"%s\", \"%s\", %u, %llu, %u, %u, %u, %u) =", |
| 139 |
passwd, salt, flags, (unsigned long long)N, r, p, t, g); |
| 140 |
|
| 141 |
if (yescrypt_kdf(NULL, &local, |
| 142 |
(const uint8_t *) passwd, strlen(passwd), |
| 143 |
(const uint8_t *) salt, strlen(salt), ¶ms, dk, dklen)) { |
| 144 |
yescrypt_free_local(&local); |
| 145 |
puts(" FAILED"); |
| 146 |
retval = 1; |
| 147 |
return; |
| 148 |
} |
| 149 |
|
| 150 |
yescrypt_free_local(&local); |
| 151 |
|
| 152 |
for (i = 0; i < dklen; i++) |
| 153 |
printf(" %02x", dk[i]); |
| 154 |
puts(""); |
| 155 |
} |
| 156 |
#endif |
| 157 |
|
| 158 |
int main(void) |
| 159 |
{ |
| 160 |
int i; |
| 161 |
|
| 162 |
setvbuf(stdout, NULL, _IOLBF, 0); |
| 163 |
|
| 164 |
#ifdef TEST_PBKDF2_SHA256 |
| 165 |
print_PBKDF2_SHA256("password", "salt", 1, 20); |
| 166 |
print_PBKDF2_SHA256("password", "salt", 2, 20); |
| 167 |
print_PBKDF2_SHA256("password", "salt", 4096, 20); |
| 168 |
print_PBKDF2_SHA256("password", "salt", 16777216, 20); |
| 169 |
print_PBKDF2_SHA256("passwordPASSWORDpassword", |
| 170 |
"saltSALTsaltSALTsaltSALTsaltSALTsalt", 4096, 25); |
| 171 |
print_PBKDF2_SHA256_raw("pass\0word", 9, "sa\0lt", 5, 4096, 16); |
| 172 |
#if 0 |
| 173 |
print_PBKDF2_SHA256("password", "salt", 1, 32); |
| 174 |
print_PBKDF2_SHA256("password", "salt", 2, 32); |
| 175 |
print_PBKDF2_SHA256("password", "salt", 4096, 32); |
| 176 |
print_PBKDF2_SHA256("password", "salt", 16777216, 32); |
| 177 |
print_PBKDF2_SHA256("passwordPASSWORDpassword", |
| 178 |
"saltSALTsaltSALTsaltSALTsaltSALTsalt", 4096, 40); |
| 179 |
print_PBKDF2_SHA256("password", "salt", 4096, 16); |
| 180 |
print_PBKDF2_SHA256("password", "salt", 1, 20); |
| 181 |
print_PBKDF2_SHA256("password", "salt", 2, 20); |
| 182 |
print_PBKDF2_SHA256("password", "salt", 4096, 20); |
| 183 |
print_PBKDF2_SHA256("password", "salt", 16777216, 20); |
| 184 |
print_PBKDF2_SHA256("password", "salt", 4096, 25); |
| 185 |
print_PBKDF2_SHA256("password", "salt", 4096, 16); |
| 186 |
#endif |
| 187 |
#endif |
| 188 |
|
| 189 |
#ifdef TEST_SCRYPT |
| 190 |
print_scrypt("", "", 16, 1, 1); |
| 191 |
print_scrypt("password", "NaCl", 1024, 8, 16); |
| 192 |
print_scrypt("pleaseletmein", "SodiumChloride", 16384, 8, 1); |
| 193 |
print_scrypt("pleaseletmein", "SodiumChloride", 1048576, 8, 1); |
| 194 |
#endif |
| 195 |
|
| 196 |
#ifdef TEST_YESCRYPT_KDF |
| 197 |
print_yescrypt("", "", 0, 16, 1, 1, 0, 0, 64); |
| 198 |
print_yescrypt("", "", 0, 16, 1, 1, 0, 0, 8); |
| 199 |
print_yescrypt("", "", 0, 4, 1, 1, 0, 0, 64); |
| 200 |
print_yescrypt("", "", YESCRYPT_WORM, 4, 1, 1, 0, 0, 64); |
| 201 |
print_yescrypt("", "", YESCRYPT_WORM, 4, 1, 1, 0, 0, 8); |
| 202 |
print_yescrypt("", "", YESCRYPT_WORM, 4, 1, 1, 1, 0, 64); |
| 203 |
print_yescrypt("", "", YESCRYPT_WORM, 4, 1, 1, 2, 0, 64); |
| 204 |
print_yescrypt("", "", YESCRYPT_WORM, 4, 1, 1, 3, 0, 64); |
| 205 |
print_yescrypt("", "", YESCRYPT_WORM, 4, 1, 1, 3, 0, 33); |
| 206 |
print_yescrypt("", "", YESCRYPT_WORM, 4, 1, 1, 3, 0, 32); |
| 207 |
print_yescrypt("", "", YESCRYPT_WORM, 4, 1, 1, 3, 0, 31); |
| 208 |
print_yescrypt("", "", YESCRYPT_WORM, 4, 1, 1, 3, 0, 1); |
| 209 |
print_yescrypt("", "", YESCRYPT_DEFAULTS, 4, 1, 1, 0, 0, 64); |
| 210 |
print_yescrypt("", "", YESCRYPT_DEFAULTS, 4, 1, 1, 0, 0, 4); |
| 211 |
print_yescrypt("", "", YESCRYPT_DEFAULTS, 4, 1, 1, 1, 0, 64); |
| 212 |
print_yescrypt("", "", YESCRYPT_DEFAULTS, 4, 1, 1, 1, 0, 33); |
| 213 |
print_yescrypt("", "", YESCRYPT_DEFAULTS, 4, 1, 1, 1, 0, 32); |
| 214 |
print_yescrypt("", "", YESCRYPT_DEFAULTS, 4, 1, 1, 1, 0, 31); |
| 215 |
print_yescrypt("", "", YESCRYPT_DEFAULTS, 4, 1, 1, 1, 0, 1); |
| 216 |
for (i = 0; i <= 6; i++) |
| 217 |
print_yescrypt("p", "s", YESCRYPT_DEFAULTS, 16, 8, 1, i + 10, i, 40); |
| 218 |
for (i = 0; i <= 6; i++) |
| 219 |
print_yescrypt("p", "s", YESCRYPT_WORM, 16, 8, 1, i + 10, i, 40); |
| 220 |
for (i = 0; i <= 6; i++) |
| 221 |
print_yescrypt("p", "s", YESCRYPT_DEFAULTS, 16, 8, 1, 0, i, 40); |
| 222 |
for (i = 0; i <= 6; i++) |
| 223 |
print_yescrypt("p", "s", YESCRYPT_WORM, 16, 8, 1, 0, i, 40); |
| 224 |
for (i = 0; i <= 2; i++) |
| 225 |
print_yescrypt("p", "s", YESCRYPT_DEFAULTS, 16, 8, 1, 0, i, 32); |
| 226 |
for (i = 0; i <= 2; i++) |
| 227 |
print_yescrypt("p", "s", YESCRYPT_DEFAULTS, 16, 8, 1, 0, i, 8); |
| 228 |
#endif |
| 229 |
|
| 230 |
#ifdef TEST_YESCRYPT_ENCODING |
| 231 |
{ |
| 232 |
uint8_t *setting; |
| 233 |
yescrypt_binary_t key = {.uc={ |
| 234 |
1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16, |
| 235 |
17,18,19,20,21,22,23,24,25,26,27,28,255,128,64,32}}; |
| 236 |
|
| 237 |
for (i = 0; i < 18; i++) { |
| 238 |
uint32_t N_log2 = (i < 14) ? (16 - i) : 2; |
| 239 |
uint32_t r = (i < 8) ? (8 - i) : (1 + (i & 1)); |
| 240 |
uint32_t p = (i & 1) ? 1 : YESCRYPT_P; |
| 241 |
yescrypt_flags_t flags = YESCRYPT_DEFAULTS; |
| 242 |
if ((int)p - (i / 2) > 1) |
| 243 |
p -= i / 2; |
| 244 |
if (i & 2) { |
| 245 |
flags = YESCRYPT_WORM; |
| 246 |
} else { |
| 247 |
while ((1ULL << N_log2) / p <= 3) |
| 248 |
N_log2++; |
| 249 |
} |
| 250 |
yescrypt_params_t params = |
| 251 |
{flags, (uint64_t)1 << N_log2, r, p, 0, 0, 0}; |
| 252 |
setting = yescrypt_encode_params(¶ms, |
| 253 |
(const uint8_t *)"WZaPV7LSUEKMo34.", 16 - (i & 15)); |
| 254 |
if (setting && i == 0) |
| 255 |
printf("'%s'\n", (char *)setting); |
| 256 |
if (!setting) { |
| 257 |
printf("%d yescrypt_encode_params() = NULL\n", i); |
| 258 |
retval = 1; |
| 259 |
} |
| 260 |
if (setting) { |
| 261 |
uint8_t *hash = yescrypt( |
| 262 |
(const uint8_t *)"pleaseletmein", setting); |
| 263 |
printf("Plaintext: '%s'\n", (char *)hash); |
| 264 |
hash = (uint8_t *)strdup((char *)hash); |
| 265 |
if (!hash || strcmp( |
| 266 |
(char *)hash, (char *)yescrypt( |
| 267 |
(const uint8_t *)"pleaseletmein", hash))) { |
| 268 |
puts("Validation FAILED"); |
| 269 |
retval = 1; |
| 270 |
} |
| 271 |
uint8_t *orig = (uint8_t *)strdup((char *)hash); |
| 272 |
if (!yescrypt_reencrypt(hash, NULL, &key)) { |
| 273 |
printf("%d yescrypt_reencrypt() = NULL\n", i); |
| 274 |
retval = 1; |
| 275 |
} |
| 276 |
printf("Encrypted: '%s'\n", (char *)hash); |
| 277 |
yescrypt_local_t local; |
| 278 |
if (yescrypt_init_local(&local)) { |
| 279 |
puts("yescrypt_init_local() FAILED"); |
| 280 |
retval = 1; |
| 281 |
} |
| 282 |
uint8_t buf[128]; |
| 283 |
if (strcmp((char *)hash, (char *)yescrypt_r( |
| 284 |
NULL, &local, |
| 285 |
(const uint8_t *)"pleaseletmein", 13, |
| 286 |
hash, &key, buf, sizeof(buf)))) { |
| 287 |
puts("Validation of encrypted FAILED"); |
| 288 |
retval = 1; |
| 289 |
} |
| 290 |
if (!strcmp((char *)hash, (char *)yescrypt_r( |
| 291 |
NULL, &local, |
| 292 |
(const uint8_t *)"pleaseletmein", 13, |
| 293 |
hash, NULL, buf, sizeof(buf)))) { |
| 294 |
puts("Validation of encrypted " |
| 295 |
"unexpectedly succeeded"); |
| 296 |
retval = 1; |
| 297 |
} |
| 298 |
if (!strcmp((char *)orig, (char *)yescrypt_r( |
| 299 |
NULL, &local, |
| 300 |
(const uint8_t *)"pleaseletmein", 13, |
| 301 |
orig, &key, buf, sizeof(buf)))) { |
| 302 |
puts("Validation of unencrypted " |
| 303 |
"unexpectedly succeeded"); |
| 304 |
retval = 1; |
| 305 |
} |
| 306 |
yescrypt_free_local(&local); |
| 307 |
if (!yescrypt_reencrypt(hash, &key, NULL)) { |
| 308 |
printf("%d yescrypt_reencrypt() = NULL\n", i); |
| 309 |
retval = 1; |
| 310 |
} |
| 311 |
if (strcmp((char *)hash, (char *)orig)) { |
| 312 |
puts("Decryption FAILED"); |
| 313 |
retval = 1; |
| 314 |
} |
| 315 |
free(orig); |
| 316 |
free(hash); |
| 317 |
} |
| 318 |
} |
| 319 |
|
| 320 |
printf("'%s'\n", (char *)yescrypt( |
| 321 |
(const uint8_t *)"pleaseletmein", |
| 322 |
(const uint8_t *)"$7$C6..../....SodiumChloride")); |
| 323 |
|
| 324 |
printf("'%s'\n", (char *)yescrypt( |
| 325 |
(const uint8_t *)"pleaseletmein", |
| 326 |
(const uint8_t *)"$7$06..../....SodiumChloride")); |
| 327 |
|
| 328 |
#ifdef TEST_ROM |
| 329 |
uint64_t rom_bytes = 256 * (1024ULL*1024); |
| 330 |
uint64_t ram_bytes = 2 * (1024ULL*1024); |
| 331 |
uint32_t r; |
| 332 |
uint64_t NROM_log2, N_log2; |
| 333 |
yescrypt_shared_t shared; |
| 334 |
yescrypt_local_t local; |
| 335 |
|
| 336 |
NROM_log2 = 0; |
| 337 |
while (((rom_bytes >> NROM_log2) & 0xff) == 0) |
| 338 |
NROM_log2++; |
| 339 |
r = rom_bytes >> (7 + NROM_log2); |
| 340 |
while (r < 5 && NROM_log2 > 0) { |
| 341 |
r <<= 1; |
| 342 |
NROM_log2--; |
| 343 |
} |
| 344 |
rom_bytes = (uint64_t)r << (7 + NROM_log2); |
| 345 |
|
| 346 |
N_log2 = 0; |
| 347 |
while (((uint64_t)r << (7 + N_log2)) < ram_bytes) |
| 348 |
N_log2++; |
| 349 |
ram_bytes = (uint64_t)r << (7 + N_log2); |
| 350 |
|
| 351 |
printf("r=%u N=2^%u NROM=2^%u\n", r, |
| 352 |
(unsigned int)N_log2, (unsigned int)NROM_log2); |
| 353 |
|
| 354 |
printf("Will use %.2f KiB ROM\n", rom_bytes / 1024.0); |
| 355 |
printf(" %.2f KiB RAM\n", ram_bytes / 1024.0); |
| 356 |
|
| 357 |
printf("Initializing ROM ..."); |
| 358 |
fflush(stdout); |
| 359 |
yescrypt_params_t rom_params = { YESCRYPT_DEFAULTS, |
| 360 |
0, r, YESCRYPT_PROM, 0, 0, (uint64_t)1 << NROM_log2 }; |
| 361 |
if (yescrypt_init_shared(&shared, |
| 362 |
(uint8_t *)"local param", 12, &rom_params)) { |
| 363 |
puts(" FAILED"); |
| 364 |
retval = 1; |
| 365 |
} |
| 366 |
yescrypt_binary_t *digest = yescrypt_digest_shared(&shared); |
| 367 |
printf(" DONE (%02x%02x%02x%02x)\n", |
| 368 |
digest->uc[0], digest->uc[1], digest->uc[2], digest->uc[3]); |
| 369 |
|
| 370 |
if (yescrypt_init_local(&local)) { |
| 371 |
puts("FAILED"); |
| 372 |
retval = 1; |
| 373 |
} |
| 374 |
|
| 375 |
yescrypt_params_t params = rom_params; |
| 376 |
params.flags = YESCRYPT_FLAGS; |
| 377 |
params.N = (uint64_t)1 << N_log2; |
| 378 |
params.p = YESCRYPT_P; |
| 379 |
setting = yescrypt_encode_params(¶ms, |
| 380 |
(const uint8_t *)"WZaPV7LSUEKMo34.", 16); |
| 381 |
printf("'%s'\n", (char *)setting); |
| 382 |
|
| 383 |
uint8_t hash[128]; |
| 384 |
|
| 385 |
printf("'%s'\n", (char *)yescrypt_r(&shared, &local, |
| 386 |
(const uint8_t *)"pleaseletmein", 13, setting, NULL, |
| 387 |
hash, sizeof(hash))); |
| 388 |
|
| 389 |
#ifdef TEST_ROM_PREALLOC |
| 390 |
yescrypt_free_shared(&shared); |
| 391 |
|
| 392 |
shared.aligned_size = ((uint64_t)1 << NROM_log2) * 128 * r; |
| 393 |
shared.base_size = shared.aligned_size + 63; |
| 394 |
uint8_t *where = shared.base = malloc(shared.base_size); |
| 395 |
where += 63; |
| 396 |
where = shared.aligned = where - ((uintptr_t)where & 63); |
| 397 |
|
| 398 |
printf("Initializing ROM in preallocated memory ..."); |
| 399 |
fflush(stdout); |
| 400 |
rom_params.flags |= YESCRYPT_SHARED_PREALLOCATED; |
| 401 |
if (yescrypt_init_shared(&shared, |
| 402 |
(uint8_t *)"local param", 12, &rom_params)) { |
| 403 |
puts(" FAILED"); |
| 404 |
retval = 1; |
| 405 |
} |
| 406 |
digest = yescrypt_digest_shared(&shared); |
| 407 |
printf(" DONE (%02x%02x%02x%02x)\n", |
| 408 |
digest->uc[0], digest->uc[1], digest->uc[2], digest->uc[3]); |
| 409 |
|
| 410 |
if ((void *)where != shared.aligned) { |
| 411 |
puts("YESCRYPT_SHARED_PREALLOCATED failed"); |
| 412 |
retval = 1; |
| 413 |
} |
| 414 |
|
| 415 |
#endif |
| 416 |
|
| 417 |
printf("'%s'\n", (char *)yescrypt_r(&shared, &local, |
| 418 |
(const uint8_t *)"pleaseletmein", 13, setting, NULL, |
| 419 |
hash, sizeof(hash))); |
| 420 |
|
| 421 |
printf("'%s'\n", (char *)yescrypt_r(&shared, &local, |
| 422 |
(const uint8_t *)"pleaseletmeIn", 13, setting, NULL, |
| 423 |
hash, sizeof(hash))); |
| 424 |
|
| 425 |
setting = yescrypt_encode_params(¶ms, |
| 426 |
(const uint8_t *)"WZaPV7LSUEIMo34.", 16); |
| 427 |
|
| 428 |
printf("'%s'\n", (char *)yescrypt_r(&shared, &local, |
| 429 |
(const uint8_t *)"pleaseletmein", 13, setting, NULL, |
| 430 |
hash, sizeof(hash))); |
| 431 |
|
| 432 |
printf("'%s'\n", (char *)yescrypt_r(&shared, &local, |
| 433 |
(const uint8_t *)"pleaseletmeIn", 13, setting, NULL, |
| 434 |
hash, sizeof(hash))); |
| 435 |
|
| 436 |
params.N = 4; |
| 437 |
params.NROM *= params.r; |
| 438 |
params.r = 1; |
| 439 |
params.p = 1; |
| 440 |
setting = yescrypt_encode_params(¶ms, |
| 441 |
(const uint8_t *)"WZaPV7LSUEKMo34.", 16); |
| 442 |
|
| 443 |
printf("'%s'\n", (char *)yescrypt_r(&shared, &local, |
| 444 |
(const uint8_t *)"pleaseletmein", 13, setting, NULL, |
| 445 |
hash, sizeof(hash))); |
| 446 |
|
| 447 |
free(shared.base); /* has been malloc'ed */ |
| 448 |
shared.base = NULL; |
| 449 |
yescrypt_free_shared(&shared); |
| 450 |
#endif |
| 451 |
} |
| 452 |
#endif |
| 453 |
|
| 454 |
return retval; |
| 455 |
} |
| 456 |
|
| 457 |
#else |
| 458 |
|
| 459 |
int |
| 460 |
main (void) |
| 461 |
{ |
| 462 |
return 77; /* UNSUPPORTED */ |
| 463 |
} |
| 464 |
|
| 465 |
#endif /* INCLUDE_yescrypt || INCLUDE_scrypt || INCLUDE_gost_yescrypt || |
| 466 |
INCLUDE_sm3_yescrypt */ |