mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-02-07 15:03:34 +00:00
8bdaddd81d
The stdio reader thread now appears to be working recursively along cosmopolitan subprocesses. For example, it's now possible to launch vim.com from the unbourne.com bestline repl, thanks to hacks plus a bug fix to select() timeouts.
489 lines
18 KiB
C
489 lines
18 KiB
C
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
|
|
│vi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8 :vi│
|
|
╚──────────────────────────────────────────────────────────────────────────────╝
|
|
│ │
|
|
│ Argon2 reference source code package - reference C implementations │
|
|
│ │
|
|
│ Copyright 2015 │
|
|
│ Daniel Dinu, Dmitry Khovratovich, Jean-Philippe Aumasson, and Samuel Neves │
|
|
│ │
|
|
│ You may use this work under the terms of a Creative Commons CC0 1.0 │
|
|
│ License/Waiver or the Apache Public License 2.0, at your option. The │
|
|
│ terms of these licenses can be found at: │
|
|
│ │
|
|
│ - CC0 1.0 Universal : https://creativecommons.org/publicdomain/zero/1.0 │
|
|
│ - Apache 2.0 : https://www.apache.org/licenses/LICENSE-2.0 │
|
|
│ │
|
|
╚─────────────────────────────────────────────────────────────────────────────*/
|
|
#include "third_party/argon2/encoding.h"
|
|
#include "libc/fmt/fmt.h"
|
|
#include "libc/limits.h"
|
|
#include "libc/stdio/stdio.h"
|
|
#include "libc/str/str.h"
|
|
#include "third_party/argon2/core.h"
|
|
|
|
asm(".ident\t\"\\n\\n\
|
|
argon2 (CC0 or Apache2)\\n\
|
|
Copyright 2016 Daniel Dinu, Dmitry Khovratovich\\n\
|
|
Copyright 2016 Jean-Philippe Aumasson, Samuel Neves\"");
|
|
/* clang-format off */
|
|
|
|
/*
|
|
* Example code for a decoder and encoder of "hash strings", with Argon2
|
|
* parameters.
|
|
*
|
|
* This code comprises three sections:
|
|
*
|
|
* -- The first section contains generic Base64 encoding and decoding
|
|
* functions. It is conceptually applicable to any hash function
|
|
* implementation that uses Base64 to encode and decode parameters,
|
|
* salts and outputs. It could be made into a library, provided that
|
|
* the relevant functions are made public (non-static) and be given
|
|
* reasonable names to avoid collisions with other functions.
|
|
*
|
|
* -- The second section is specific to Argon2. It encodes and decodes
|
|
* the parameters, salts and outputs. It does not compute the hash
|
|
* itself.
|
|
*
|
|
* The code was originally written by Thomas Pornin <pornin@bolet.org>,
|
|
* to whom comments and remarks may be sent. It is released under what
|
|
* should amount to Public Domain or its closest equivalent; the
|
|
* following mantra is supposed to incarnate that fact with all the
|
|
* proper legal rituals:
|
|
*
|
|
* ---------------------------------------------------------------------
|
|
* This file is provided under the terms of Creative Commons CC0 1.0
|
|
* Public Domain Dedication. To the extent possible under law, the
|
|
* author (Thomas Pornin) has waived all copyright and related or
|
|
* neighboring rights to this file. This work is published from: Canada.
|
|
* ---------------------------------------------------------------------
|
|
*
|
|
* Copyright (c) 2015 Thomas Pornin
|
|
*/
|
|
|
|
/* ==================================================================== */
|
|
/*
|
|
* Common code; could be shared between different hash functions.
|
|
*
|
|
* Note: the Base64 functions below assume that uppercase letters (resp.
|
|
* lowercase letters) have consecutive numerical codes, that fit on 8
|
|
* bits. All modern systems use ASCII-compatible charsets, where these
|
|
* properties are true. If you are stuck with a dinosaur of a system
|
|
* that still defaults to EBCDIC then you already have much bigger
|
|
* interoperability issues to deal with.
|
|
*/
|
|
|
|
/*
|
|
* Some macros for constant-time comparisons. These work over values in
|
|
* the 0..255 range. Returned value is 0x00 on "false", 0xFF on "true".
|
|
*/
|
|
#define EQ(x, y) ((((0U - ((unsigned)(x) ^ (unsigned)(y))) >> 8) & 0xFF) ^ 0xFF)
|
|
#define GT(x, y) ((((unsigned)(y) - (unsigned)(x)) >> 8) & 0xFF)
|
|
#define GE(x, y) (GT(y, x) ^ 0xFF)
|
|
#define LT(x, y) GT(y, x)
|
|
#define LE(x, y) GE(y, x)
|
|
|
|
/*
|
|
* Convert value x (0..63) to corresponding Base64 character.
|
|
*/
|
|
static int b64_byte_to_char(unsigned x) {
|
|
return (LT(x, 26) & (x + 'A')) |
|
|
(GE(x, 26) & LT(x, 52) & (x + ('a' - 26))) |
|
|
(GE(x, 52) & LT(x, 62) & (x + ('0' - 52))) | (EQ(x, 62) & '+') |
|
|
(EQ(x, 63) & '/');
|
|
}
|
|
|
|
/*
|
|
* Convert character c to the corresponding 6-bit value. If character c
|
|
* is not a Base64 character, then 0xFF (255) is returned.
|
|
*/
|
|
static unsigned b64_char_to_byte(int c) {
|
|
unsigned x;
|
|
|
|
x = (GE(c, 'A') & LE(c, 'Z') & (c - 'A')) |
|
|
(GE(c, 'a') & LE(c, 'z') & (c - ('a' - 26))) |
|
|
(GE(c, '0') & LE(c, '9') & (c - ('0' - 52))) | (EQ(c, '+') & 62) |
|
|
(EQ(c, '/') & 63);
|
|
return x | (EQ(x, 0) & (EQ(c, 'A') ^ 0xFF));
|
|
}
|
|
|
|
/*
|
|
* Convert some bytes to Base64. 'dst_len' is the length (in characters)
|
|
* of the output buffer 'dst'; if that buffer is not large enough to
|
|
* receive the result (including the terminating 0), then (size_t)-1
|
|
* is returned. Otherwise, the zero-terminated Base64 string is written
|
|
* in the buffer, and the output length (counted WITHOUT the terminating
|
|
* zero) is returned.
|
|
*/
|
|
static size_t to_base64(char *dst, size_t dst_len, const void *src,
|
|
size_t src_len) {
|
|
size_t olen;
|
|
const unsigned char *buf;
|
|
unsigned acc, acc_len;
|
|
|
|
olen = (src_len / 3) << 2;
|
|
switch (src_len % 3) {
|
|
case 2:
|
|
olen++;
|
|
/* fall through */
|
|
case 1:
|
|
olen += 2;
|
|
break;
|
|
}
|
|
if (dst_len <= olen) {
|
|
return (size_t)-1;
|
|
}
|
|
acc = 0;
|
|
acc_len = 0;
|
|
buf = (const unsigned char *)src;
|
|
while (src_len-- > 0) {
|
|
acc = (acc << 8) + (*buf++);
|
|
acc_len += 8;
|
|
while (acc_len >= 6) {
|
|
acc_len -= 6;
|
|
*dst++ = (char)b64_byte_to_char((acc >> acc_len) & 0x3F);
|
|
}
|
|
}
|
|
if (acc_len > 0) {
|
|
*dst++ = (char)b64_byte_to_char((acc << (6 - acc_len)) & 0x3F);
|
|
}
|
|
*dst++ = 0;
|
|
return olen;
|
|
}
|
|
|
|
/*
|
|
* Decode Base64 chars into bytes. The '*dst_len' value must initially
|
|
* contain the length of the output buffer '*dst'; when the decoding
|
|
* ends, the actual number of decoded bytes is written back in
|
|
* '*dst_len'.
|
|
*
|
|
* Decoding stops when a non-Base64 character is encountered, or when
|
|
* the output buffer capacity is exceeded. If an error occurred (output
|
|
* buffer is too small, invalid last characters leading to unprocessed
|
|
* buffered bits), then NULL is returned; otherwise, the returned value
|
|
* points to the first non-Base64 character in the source stream, which
|
|
* may be the terminating zero.
|
|
*/
|
|
static const char *from_base64(void *dst, size_t *dst_len, const char *src) {
|
|
size_t len;
|
|
unsigned char *buf;
|
|
unsigned acc, acc_len;
|
|
|
|
buf = (unsigned char *)dst;
|
|
len = 0;
|
|
acc = 0;
|
|
acc_len = 0;
|
|
for (;;) {
|
|
unsigned d;
|
|
|
|
d = b64_char_to_byte(*src);
|
|
if (d == 0xFF) {
|
|
break;
|
|
}
|
|
src++;
|
|
acc = (acc << 6) + d;
|
|
acc_len += 6;
|
|
if (acc_len >= 8) {
|
|
acc_len -= 8;
|
|
if ((len++) >= *dst_len) {
|
|
return NULL;
|
|
}
|
|
*buf++ = (acc >> acc_len) & 0xFF;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If the input length is equal to 1 modulo 4 (which is
|
|
* invalid), then there will remain 6 unprocessed bits;
|
|
* otherwise, only 0, 2 or 4 bits are buffered. The buffered
|
|
* bits must also all be zero.
|
|
*/
|
|
if (acc_len > 4 || (acc & (((unsigned)1 << acc_len) - 1)) != 0) {
|
|
return NULL;
|
|
}
|
|
*dst_len = len;
|
|
return src;
|
|
}
|
|
|
|
/*
|
|
* Decode decimal integer from 'str'; the value is written in '*v'.
|
|
* Returned value is a pointer to the next non-decimal character in the
|
|
* string. If there is no digit at all, or the value encoding is not
|
|
* minimal (extra leading zeros), or the value does not fit in an
|
|
* 'unsigned long', then NULL is returned.
|
|
*/
|
|
static const char *decode_decimal(const char *str, unsigned long *v) {
|
|
const char *orig;
|
|
unsigned long acc;
|
|
|
|
acc = 0;
|
|
for (orig = str;; str++) {
|
|
int c;
|
|
|
|
c = *str;
|
|
if (c < '0' || c > '9') {
|
|
break;
|
|
}
|
|
c -= '0';
|
|
if (acc > (ULONG_MAX / 10)) {
|
|
return NULL;
|
|
}
|
|
acc *= 10;
|
|
if ((unsigned long)c > (ULONG_MAX - acc)) {
|
|
return NULL;
|
|
}
|
|
acc += (unsigned long)c;
|
|
}
|
|
if (str == orig || (*orig == '0' && str != (orig + 1))) {
|
|
return NULL;
|
|
}
|
|
*v = acc;
|
|
return str;
|
|
}
|
|
|
|
/* ==================================================================== */
|
|
/*
|
|
* Code specific to Argon2.
|
|
*
|
|
* The code below applies the following format:
|
|
*
|
|
* $argon2<T>[$v=<num>]$m=<num>,t=<num>,p=<num>$<bin>$<bin>
|
|
*
|
|
* where <T> is either 'd', 'id', or 'i', <num> is a decimal integer (positive,
|
|
* fits in an 'unsigned long'), and <bin> is Base64-encoded data (no '=' padding
|
|
* characters, no newline or whitespace).
|
|
*
|
|
* The last two binary chunks (encoded in Base64) are, in that order,
|
|
* the salt and the output. Both are required. The binary salt length and the
|
|
* output length must be in the allowed ranges defined in argon2.h.
|
|
*
|
|
* The ctx struct must contain buffers large enough to hold the salt and pwd
|
|
* when it is fed into decode_string.
|
|
*/
|
|
|
|
/**
|
|
* Decodes an Argon2 hash string into the provided structure 'ctx'.
|
|
* The only fields that must be set prior to this call are ctx.saltlen and
|
|
* ctx.outlen (which must be the maximal salt and out length values that are
|
|
* allowed), ctx.salt and ctx.out (which must be buffers of the specified
|
|
* length), and ctx.pwd and ctx.pwdlen which must hold a valid password.
|
|
*
|
|
* Invalid input string causes an error. On success, the ctx is valid and all
|
|
* fields have been initialized.
|
|
*
|
|
* @return value is ARGON2_OK on success, other ARGON2_ codes on error
|
|
*/
|
|
int decode_string(argon2_context *ctx, const char *str, argon2_type type) {
|
|
|
|
/* check for prefix */
|
|
#define CC(prefix) \
|
|
do { \
|
|
size_t cc_len = strlen(prefix); \
|
|
if (strncmp(str, prefix, cc_len) != 0) { \
|
|
return ARGON2_DECODING_FAIL; \
|
|
} \
|
|
str += cc_len; \
|
|
} while ((void)0, 0)
|
|
|
|
/* optional prefix checking with supplied code */
|
|
#define CC_opt(prefix, code) \
|
|
do { \
|
|
size_t cc_len = strlen(prefix); \
|
|
if (strncmp(str, prefix, cc_len) == 0) { \
|
|
str += cc_len; \
|
|
{ code; } \
|
|
} \
|
|
} while ((void)0, 0)
|
|
|
|
/* Decoding prefix into decimal */
|
|
#define DECIMAL(x) \
|
|
do { \
|
|
unsigned long dec_x; \
|
|
str = decode_decimal(str, &dec_x); \
|
|
if (str == NULL) { \
|
|
return ARGON2_DECODING_FAIL; \
|
|
} \
|
|
(x) = dec_x; \
|
|
} while ((void)0, 0)
|
|
|
|
|
|
/* Decoding prefix into uint32_t decimal */
|
|
#define DECIMAL_U32(x) \
|
|
do { \
|
|
unsigned long dec_x; \
|
|
str = decode_decimal(str, &dec_x); \
|
|
if (str == NULL || dec_x > UINT32_MAX) { \
|
|
return ARGON2_DECODING_FAIL; \
|
|
} \
|
|
(x) = (uint32_t)dec_x; \
|
|
} while ((void)0, 0)
|
|
|
|
|
|
/* Decoding base64 into a binary buffer */
|
|
#define BIN(buf, max_len, len) \
|
|
do { \
|
|
size_t bin_len = (max_len); \
|
|
str = from_base64(buf, &bin_len, str); \
|
|
if (str == NULL || bin_len > UINT32_MAX) { \
|
|
return ARGON2_DECODING_FAIL; \
|
|
} \
|
|
(len) = (uint32_t)bin_len; \
|
|
} while ((void)0, 0)
|
|
|
|
size_t maxsaltlen = ctx->saltlen;
|
|
size_t maxoutlen = ctx->outlen;
|
|
int validation_result;
|
|
const char* type_string;
|
|
|
|
/* We should start with the argon2_type we are using */
|
|
type_string = argon2_type2string(type, 0);
|
|
if (!type_string) {
|
|
return ARGON2_INCORRECT_TYPE;
|
|
}
|
|
|
|
CC("$");
|
|
CC(type_string);
|
|
|
|
/* Reading the version number if the default is suppressed */
|
|
ctx->version = ARGON2_VERSION_10;
|
|
CC_opt("$v=", DECIMAL_U32(ctx->version));
|
|
|
|
CC("$m=");
|
|
DECIMAL_U32(ctx->m_cost);
|
|
CC(",t=");
|
|
DECIMAL_U32(ctx->t_cost);
|
|
CC(",p=");
|
|
DECIMAL_U32(ctx->lanes);
|
|
ctx->threads = ctx->lanes;
|
|
|
|
CC("$");
|
|
BIN(ctx->salt, maxsaltlen, ctx->saltlen);
|
|
CC("$");
|
|
BIN(ctx->out, maxoutlen, ctx->outlen);
|
|
|
|
/* The rest of the fields get the default values */
|
|
ctx->secret = NULL;
|
|
ctx->secretlen = 0;
|
|
ctx->ad = NULL;
|
|
ctx->adlen = 0;
|
|
ctx->allocate_cbk = NULL;
|
|
ctx->free_cbk = NULL;
|
|
ctx->flags = ARGON2_DEFAULT_FLAGS;
|
|
|
|
/* On return, must have valid context */
|
|
validation_result = validate_inputs(ctx);
|
|
if (validation_result != ARGON2_OK) {
|
|
return validation_result;
|
|
}
|
|
|
|
/* Can't have any additional characters */
|
|
if (*str == 0) {
|
|
return ARGON2_OK;
|
|
} else {
|
|
return ARGON2_DECODING_FAIL;
|
|
}
|
|
#undef CC
|
|
#undef CC_opt
|
|
#undef DECIMAL
|
|
#undef BIN
|
|
}
|
|
|
|
/**
|
|
* Encodes an Argon2 hash string into the provided buffer. 'dst_len'
|
|
* contains the size, in characters, of the 'dst' buffer; if 'dst_len'
|
|
* is less than the number of required characters (including the
|
|
* terminating 0), then this function returns ARGON2_ENCODING_ERROR.
|
|
*
|
|
* @return on success, ARGON2_OK is returned
|
|
*/
|
|
int encode_string(char *dst, size_t dst_len, argon2_context *ctx,
|
|
argon2_type type) {
|
|
#define SS(str) \
|
|
do { \
|
|
size_t pp_len = strlen(str); \
|
|
if (pp_len >= dst_len) { \
|
|
return ARGON2_ENCODING_FAIL; \
|
|
} \
|
|
memcpy(dst, str, pp_len + 1); \
|
|
dst += pp_len; \
|
|
dst_len -= pp_len; \
|
|
} while ((void)0, 0)
|
|
|
|
#define SX(x) \
|
|
do { \
|
|
char tmp[30]; \
|
|
sprintf(tmp, "%lu", (unsigned long)(x)); \
|
|
SS(tmp); \
|
|
} while ((void)0, 0)
|
|
|
|
#define SB(buf, len) \
|
|
do { \
|
|
size_t sb_len = to_base64(dst, dst_len, buf, len); \
|
|
if (sb_len == (size_t)-1) { \
|
|
return ARGON2_ENCODING_FAIL; \
|
|
} \
|
|
dst += sb_len; \
|
|
dst_len -= sb_len; \
|
|
} while ((void)0, 0)
|
|
|
|
const char* type_string = argon2_type2string(type, 0);
|
|
int validation_result = validate_inputs(ctx);
|
|
|
|
if (!type_string) {
|
|
return ARGON2_ENCODING_FAIL;
|
|
}
|
|
|
|
if (validation_result != ARGON2_OK) {
|
|
return validation_result;
|
|
}
|
|
|
|
|
|
SS("$");
|
|
SS(type_string);
|
|
|
|
SS("$v=");
|
|
SX(ctx->version);
|
|
|
|
SS("$m=");
|
|
SX(ctx->m_cost);
|
|
SS(",t=");
|
|
SX(ctx->t_cost);
|
|
SS(",p=");
|
|
SX(ctx->lanes);
|
|
|
|
SS("$");
|
|
SB(ctx->salt, ctx->saltlen);
|
|
|
|
SS("$");
|
|
SB(ctx->out, ctx->outlen);
|
|
return ARGON2_OK;
|
|
|
|
#undef SS
|
|
#undef SX
|
|
#undef SB
|
|
}
|
|
|
|
/** Returns length of the encoded byte stream with length len */
|
|
size_t b64len(uint32_t len) {
|
|
size_t olen = ((size_t)len / 3) << 2;
|
|
switch (len % 3) {
|
|
case 2:
|
|
olen++;
|
|
/* fall through */
|
|
case 1:
|
|
olen += 2;
|
|
break;
|
|
}
|
|
return olen;
|
|
}
|
|
|
|
/** Returns length of the encoded number num */
|
|
size_t numlen(uint32_t num) {
|
|
size_t len = 1;
|
|
while (num >= 10) {
|
|
++len;
|
|
num = num / 10;
|
|
}
|
|
return len;
|
|
}
|
|
|