mirror of
https://github.com/jart/cosmopolitan.git
synced 2025-01-31 11:37:35 +00:00
957c61cbbf
This change upgrades to GCC 12.3 and GNU binutils 2.42. The GNU linker appears to have changed things so that only a single de-duplicated str table is present in the binary, and it gets placed wherever the linker wants, regardless of what the linker script says. To cope with that we need to stop using .ident to embed licenses. As such, this change does significant work to revamp how third party licenses are defined in the codebase, using `.section .notice,"aR",@progbits`. This new GCC 12.3 toolchain has support for GNU indirect functions. It lets us support __target_clones__ for the first time. This is used for optimizing the performance of libc string functions such as strlen and friends so far on x86, by ensuring AVX systems favor a second codepath that uses VEX encoding. It shaves some latency off certain operations. It's a useful feature to have for scientific computing for the reasons explained by the test/libcxx/openmp_test.cc example which compiles for fifteen different microarchitectures. Thanks to the upgrades, it's now also possible to use newer instruction sets, such as AVX512FP16, VNNI. Cosmo now uses the %gs register on x86 by default for TLS. Doing it is helpful for any program that links `cosmo_dlopen()`. Such programs had to recompile their binaries at startup to change the TLS instructions. That's not great, since it means every page in the executable needs to be faulted. The work of rewriting TLS-related x86 opcodes, is moved to fixupobj.com instead. This is great news for MacOS x86 users, since we previously needed to morph the binary every time for that platform but now that's no longer necessary. The only platforms where we need fixup of TLS x86 opcodes at runtime are now Windows, OpenBSD, and NetBSD. On Windows we morph TLS to point deeper into the TIB, based on a TlsAlloc assignment, and on OpenBSD/NetBSD we morph %gs back into %fs since the kernels do not allow us to specify a value for the %gs register. OpenBSD users are now required to use APE Loader to run Cosmo binaries and assimilation is no longer possible. OpenBSD kernel needs to change to allow programs to specify a value for the %gs register, or it needs to stop marking executable pages loaded by the kernel as mimmutable(). This release fixes __constructor__, .ctor, .init_array, and lastly the .preinit_array so they behave the exact same way as glibc. We no longer use hex constants to define math.h symbols like M_PI.
482 lines
18 KiB
C
482 lines
18 KiB
C
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
|
|
│ vi: set et 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/limits.h"
|
|
#include "libc/stdio/stdio.h"
|
|
#include "libc/str/str.h"
|
|
#include "third_party/argon2/core.h"
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
|