uint8_t* yescrypt_r(const yescrypt_shared_t* shared, yescrypt_local_t* local,
const uint8_t* passwd, size_t passwdlen, const uint8_t* setting, uint8_t* buf, size_t buflen)
{
uint8_t hash[HASH_SIZE];
const uint8_t * src, * salt;
uint8_t * dst;
size_t prefixlen, saltlen, need;
uint8_t version;
uint64_t N;
uint32_t r, p;
yescrypt_flags_t flags = YESCRYPT_WORM;
printf("pass1 ...");
fflush(stdout);
if (setting[0] != '$' || setting[1] != '7') {
printf("died$7 ...");
fflush(stdout);
return NULL;
}
printf("died80 ...");
fflush(stdout);
src = setting + 2;
printf("hello '%p'\n", (char *)src);
fflush(stdout);
switch ((version = *src)) {
case '$':
printf("died2 ...");
fflush(stdout);
break;
case 'X':
src++;
flags = YESCRYPT_RW;
printf("died3 ...");
fflush(stdout);
break;
default:
printf("died4 ...");
fflush(stdout);
return NULL;
}
printf("pass2 ...");
fflush(stdout);
if (*src != '$') {
uint32_t decoded_flags;
if (decode64_one(&decoded_flags, *src)) {
printf("died5 ...");
fflush(stdout);
return NULL;
}
flags = decoded_flags;
if (*++src != '$') {
printf("died6 ...");
fflush(stdout);
return NULL;
}
}
src++;
{
uint32_t N_log2;
if (decode64_one(&N_log2, *src)) {
printf("died7 ...");
return NULL;
}
src++;
N = (uint64_t)1 << N_log2;
}
src = decode64_uint32(&r, 30, src);
if (!src) {
printf("died6 ...");
return NULL;
}
src = decode64_uint32(&p, 30, src);
if (!src) {
printf("died7 ...");
return NULL;
}
prefixlen = src - setting;
salt = src;
src = (uint8_t *)strrchr((char *)salt, '$');
if (src)
saltlen = src - salt;
else
saltlen = strlen((char *)salt);
need = prefixlen + saltlen + 1 + HASH_LEN + 1;
if (need > buflen || need < saltlen) {
printf("'%d %d %d'", (int) need, (int) buflen, (int) saltlen);
printf("died8killbuf ...");
fflush(stdout);
return NULL;
}
if (yescrypt_kdf(shared, local, passwd, passwdlen, salt, saltlen, N, r, p, 0, flags, hash, sizeof(hash))) {
printf("died10 ...");
fflush(stdout);
return NULL;
}
dst = buf;
memcpy(dst, setting, prefixlen + saltlen);
dst += prefixlen + saltlen;
*dst++ = '$';
dst = encode64(dst, buflen - (dst - buf), hash, sizeof(hash));
/* Could zeroize hash[] here, but yescrypt_kdf() doesn't zeroize its
* memory allocations yet anyway. */
if (!dst || dst >= buf + buflen) { /* Can't happen */
printf("died11 ...");
return NULL;
}
*dst = 0; /* NUL termination */
printf("died12 ...");
fflush(stdout);
return buf;
}
void conversor(char opt1, char opt2, char *a_entrada, char *a_saida){
switch (opt1) {
// Ajuda.
case 'h':
printf("%s", help);
break;
// Codificar.
case '1': case 'e':
switch (opt2) {
// Base 62.
case '2':
encode62(a_entrada, a_saida);
printf("\nCodificado com Sucesso!\n\n");
break;
// Base 64.
case '4':
encode64(a_entrada, a_saida);
printf("\nCodificado com Sucesso!\n\n");
break;
// Base 85.
case '5':
encode85(a_entrada, a_saida);
printf("\nCodificado com Sucesso!\n\n");
break;
// Base 91.
case '1':
encode91(a_entrada, a_saida);
printf("\nCodificado com Sucesso!\n\n");
break;
default:
printf("%s", err[1]);
break;
}
break;
// Decodificar.
case '2': case 'd':
switch (opt2) {
// Base 62.
case '2':
decode62(a_entrada, a_saida);
printf("\nDecodificado com sucesso!\n\n");
break;
// Base 64.
case '4':
decode64(a_entrada, a_saida);
printf("\nDecodificado com sucesso!\n\n");
break;
// Base 85.
case '5':
decode85(a_entrada, a_saida);
printf("\nDecodificado com sucesso!\n\n");
break;
// Base 91.
case '1':
decode91(a_entrada, a_saida);
printf("\nDecodificado com sucesso!\n\n");
break;
default:
printf("%s", err[1]);
break;
}
break;
default:
printf("%s", err[0]);
break;
}
}
uint8_t *
yescrypt_r(const yescrypt_shared_t * shared, yescrypt_local_t * local,
const uint8_t * passwd, size_t passwdlen,
const uint8_t * setting,
uint8_t * buf, size_t buflen)
{
uint8_t hash[HASH_SIZE];
const uint8_t * src, * salt;
uint8_t * dst;
size_t prefixlen, saltlen, need;
uint8_t version;
uint64_t N;
uint32_t r, p;
yescrypt_flags_t flags = 0;
if (setting[0] != '$' || setting[1] != '7')
return NULL;
src = setting + 2;
switch ((version = *src)) {
case '$':
break;
case 'X':
src++;
flags = YESCRYPT_RW;
break;
default:
return NULL;
}
if (*src != '$') {
uint32_t decoded_flags;
if (decode64_one(&decoded_flags, *src))
return NULL;
flags = decoded_flags;
if (*++src != '$')
return NULL;
}
src++;
{
uint32_t N_log2;
if (decode64_one(&N_log2, *src))
return NULL;
src++;
N = (uint64_t)1 << N_log2;
}
src = decode64_uint32(&r, 30, src);
if (!src)
return NULL;
src = decode64_uint32(&p, 30, src);
if (!src)
return NULL;
prefixlen = src - setting;
salt = src;
src = (uint8_t *)strrchr((char *)salt, '$');
if (src)
saltlen = src - salt;
else
saltlen = strlen((char *)salt);
need = prefixlen + saltlen + 1 + HASH_LEN + 1;
if (need > buflen || need < saltlen)
return NULL;
if (yescrypt_kdf(shared, local, passwd, passwdlen, salt, saltlen,
N, r, p, 0, 0, flags, hash, sizeof(hash)))
return NULL;
dst = buf;
memcpy(dst, setting, prefixlen + saltlen);
dst += prefixlen + saltlen;
*dst++ = '$';
dst = encode64(dst, buflen - (dst - buf), hash, sizeof(hash));
/* Could zeroize hash[] here, but yescrypt_kdf() doesn't zeroize its
* memory allocations yet anyway. */
if (!dst || dst >= buf + buflen) /* Can't happen */
return NULL;
*dst = 0; /* NUL termination */
return buf;
}
void
crypt_gost_yescrypt_rn (const char *phrase, size_t phr_size,
const char *setting, size_t set_size,
uint8_t *output, size_t o_size,
void *scratch, size_t s_size)
{
if (o_size < set_size + 1 + 43 + 1 ||
CRYPT_OUTPUT_SIZE < set_size + 1 + 43 + 1 ||
s_size < sizeof (crypt_gost_yescrypt_internal_t))
{
errno = ERANGE;
return;
}
/* Fail when called with wrong prefix. */
if (strncmp (setting, "$gy$", 4))
{
errno = EINVAL;
return;
}
crypt_gost_yescrypt_internal_t *intbuf = scratch;
if (yescrypt_init_local (&intbuf->local))
return;
/* convert gost setting to yescrypt setting */
intbuf->gsetting[0] = '$';
intbuf->gsetting[1] = 'y';
intbuf->gsetting[2] = '$';
XCRYPT_STRCPY_OR_ABORT (&intbuf->gsetting[3], set_size - 3, setting + 4);
intbuf->retval = yescrypt_r (NULL, &intbuf->local,
(const uint8_t *) phrase, phr_size,
intbuf->gsetting, NULL,
intbuf->outbuf + 1, o_size - 1);
if (!intbuf->retval)
errno = EINVAL;
if (yescrypt_free_local (&intbuf->local) || !intbuf->retval)
return;
intbuf->outbuf[0] = '$';
intbuf->outbuf[1] = 'g';
/* extract yescrypt output from "$y$param$salt$output" */
char *hptr = strchr ((const char *) intbuf->retval + 3, '$');
if (!hptr)
{
errno = EINVAL;
return;
}
hptr = strchr (hptr + 1, '$');
if (!hptr)
{
errno = EINVAL;
return;
}
hptr++; /* start of output */
/* decode yescrypt output into its raw 256-bit form */
size_t ylen = sizeof (intbuf->y);
if (!decode64 (intbuf->y, &ylen, (uint8_t *) hptr, strlen (hptr)) ||
ylen != sizeof (intbuf->y))
{
errno = EINVAL;
return;
}
/*
* HMAC_GOSTR3411_2012_256(
* HMAC_GOSTR3411_2012_256(GOST2012_256(K), S),
* yescrypt(K, S)
* )
* yescrypt output is used in place of message,
* thus, its crypto properties are superseded by GOST.
* Password is always hashed for inner hmac to avoid
* collisions between hashed and unhashed passwords.
*/
gost_hash256 ((const uint8_t *) phrase, phr_size, intbuf->hk, &intbuf->gostbuf.ctx);
gost_hmac256 (intbuf->hk, sizeof (intbuf->hk),
(const uint8_t *) setting,
(size_t) ((uint8_t *) hptr - intbuf->retval),
intbuf->interm, &intbuf->gostbuf);
outer_gost_hmac256 (intbuf->interm, sizeof (intbuf->interm),
intbuf->y, sizeof (intbuf->y), intbuf->y, &intbuf->gostbuf);
encode64 ((uint8_t *) hptr, o_size - (size_t) ((uint8_t *) hptr - intbuf->retval),
intbuf->y, sizeof (intbuf->y));
XCRYPT_STRCPY_OR_ABORT (output, o_size, intbuf->outbuf);
return;
}
