mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
std/sha256: add new package
This commit is contained in:
1 parent
71dca5adce
commit
50abf5eb6a
7 files changed
+1898
No files matched your search
@@ -18,6 +18,7 @@ The LICENSE has changed from a single license (Apache 2) to a dual license
|
||||
- Added `slice_var as nptr array[etc] etc` conversion.
|
||||
- Added `std/jpeg`.
|
||||
- Added `std/netpbm`.
|
||||
- Added `std/sha256`.
|
||||
- Added `std/xxhash32`.
|
||||
- Added `std/xxhash64`.
|
||||
- Added `wuffs_base__status__is_truncated_input_error`.
|
||||
|
||||
@@ -11808,6 +11808,237 @@ struct wuffs_png__decoder__struct {
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__PNG) || defined(WUFFS_NONMONOLITHIC)
|
||||
|
||||
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__SHA256) || defined(WUFFS_NONMONOLITHIC)
|
||||
|
||||
// ---------------- Status Codes
|
||||
|
||||
// ---------------- Public Consts
|
||||
|
||||
// ---------------- Struct Declarations
|
||||
|
||||
typedef struct wuffs_sha256__hasher__struct wuffs_sha256__hasher;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
// ---------------- Public Initializer Prototypes
|
||||
|
||||
// For any given "wuffs_foo__bar* self", "wuffs_foo__bar__initialize(self,
|
||||
// etc)" should be called before any other "wuffs_foo__bar__xxx(self, etc)".
|
||||
//
|
||||
// Pass sizeof(*self) and WUFFS_VERSION for sizeof_star_self and wuffs_version.
|
||||
// Pass 0 (or some combination of WUFFS_INITIALIZE__XXX) for options.
|
||||
|
||||
wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
|
||||
wuffs_sha256__hasher__initialize(
|
||||
wuffs_sha256__hasher* self,
|
||||
size_t sizeof_star_self,
|
||||
uint64_t wuffs_version,
|
||||
uint32_t options);
|
||||
|
||||
size_t
|
||||
sizeof__wuffs_sha256__hasher(void);
|
||||
|
||||
// ---------------- Allocs
|
||||
|
||||
// These functions allocate and initialize Wuffs structs. They return NULL if
|
||||
// memory allocation fails. If they return non-NULL, there is no need to call
|
||||
// wuffs_foo__bar__initialize, but the caller is responsible for eventually
|
||||
// calling free on the returned pointer. That pointer is effectively a C++
|
||||
// std::unique_ptr<T, wuffs_unique_ptr_deleter>.
|
||||
|
||||
wuffs_sha256__hasher*
|
||||
wuffs_sha256__hasher__alloc(void);
|
||||
|
||||
static inline wuffs_base__hasher_bitvec256*
|
||||
wuffs_sha256__hasher__alloc_as__wuffs_base__hasher_bitvec256(void) {
|
||||
return (wuffs_base__hasher_bitvec256*)(wuffs_sha256__hasher__alloc());
|
||||
}
|
||||
|
||||
// ---------------- Upcasts
|
||||
|
||||
static inline wuffs_base__hasher_bitvec256*
|
||||
wuffs_sha256__hasher__upcast_as__wuffs_base__hasher_bitvec256(
|
||||
wuffs_sha256__hasher* p) {
|
||||
return (wuffs_base__hasher_bitvec256*)p;
|
||||
}
|
||||
|
||||
// ---------------- Public Function Prototypes
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC uint64_t
|
||||
wuffs_sha256__hasher__get_quirk(
|
||||
const wuffs_sha256__hasher* self,
|
||||
uint32_t a_key);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
wuffs_sha256__hasher__set_quirk(
|
||||
wuffs_sha256__hasher* self,
|
||||
uint32_t a_key,
|
||||
uint64_t a_value);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
|
||||
wuffs_sha256__hasher__update(
|
||||
wuffs_sha256__hasher* self,
|
||||
wuffs_base__slice_u8 a_x);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__bitvec256
|
||||
wuffs_sha256__hasher__update_bitvec256(
|
||||
wuffs_sha256__hasher* self,
|
||||
wuffs_base__slice_u8 a_x);
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__bitvec256
|
||||
wuffs_sha256__hasher__checksum_bitvec256(
|
||||
const wuffs_sha256__hasher* self);
|
||||
|
||||
#ifdef __cplusplus
|
||||
} // extern "C"
|
||||
#endif
|
||||
|
||||
// ---------------- Struct Definitions
|
||||
|
||||
// These structs' fields, and the sizeof them, are private implementation
|
||||
// details that aren't guaranteed to be stable across Wuffs versions.
|
||||
//
|
||||
// See https://en.wikipedia.org/wiki/Opaque_pointer#C
|
||||
|
||||
#if defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
|
||||
|
||||
struct wuffs_sha256__hasher__struct {
|
||||
// Do not access the private_impl's or private_data's fields directly. There
|
||||
// is no API/ABI compatibility or safety guarantee if you do so. Instead, use
|
||||
// the wuffs_foo__bar__baz functions.
|
||||
//
|
||||
// It is a struct, not a struct*, so that the outermost wuffs_foo__bar struct
|
||||
// can be stack allocated when WUFFS_IMPLEMENTATION is defined.
|
||||
|
||||
struct {
|
||||
uint32_t magic;
|
||||
uint32_t active_coroutine;
|
||||
wuffs_base__vtable vtable_for__wuffs_base__hasher_bitvec256;
|
||||
wuffs_base__vtable null_vtable;
|
||||
|
||||
uint64_t f_length_modulo_u64;
|
||||
bool f_length_overflows_u64;
|
||||
uint8_t f_padding0;
|
||||
uint8_t f_padding1;
|
||||
uint8_t f_padding2;
|
||||
uint32_t f_buf_len;
|
||||
uint8_t f_buf_data[64];
|
||||
uint32_t f_h0;
|
||||
uint32_t f_h1;
|
||||
uint32_t f_h2;
|
||||
uint32_t f_h3;
|
||||
uint32_t f_h4;
|
||||
uint32_t f_h5;
|
||||
uint32_t f_h6;
|
||||
uint32_t f_h7;
|
||||
} private_impl;
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
using unique_ptr = std::unique_ptr<wuffs_sha256__hasher, wuffs_unique_ptr_deleter>;
|
||||
|
||||
// On failure, the alloc_etc functions return nullptr. They don't throw.
|
||||
|
||||
static inline unique_ptr
|
||||
alloc() {
|
||||
return unique_ptr(wuffs_sha256__hasher__alloc());
|
||||
}
|
||||
|
||||
static inline wuffs_base__hasher_bitvec256::unique_ptr
|
||||
alloc_as__wuffs_base__hasher_bitvec256() {
|
||||
return wuffs_base__hasher_bitvec256::unique_ptr(
|
||||
wuffs_sha256__hasher__alloc_as__wuffs_base__hasher_bitvec256());
|
||||
}
|
||||
#endif // defined(WUFFS_BASE__HAVE_UNIQUE_PTR)
|
||||
|
||||
#if defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
|
||||
// Disallow constructing or copying an object via standard C++ mechanisms,
|
||||
// e.g. the "new" operator, as this struct is intentionally opaque. Its total
|
||||
// size and field layout is not part of the public, stable, memory-safe API.
|
||||
// Use malloc or memcpy and the sizeof__wuffs_foo__bar function instead, and
|
||||
// call wuffs_foo__bar__baz methods (which all take a "this"-like pointer as
|
||||
// their first argument) rather than tweaking bar.private_impl.qux fields.
|
||||
//
|
||||
// In C, we can just leave wuffs_foo__bar as an incomplete type (unless
|
||||
// WUFFS_IMPLEMENTATION is #define'd). In C++, we define a complete type in
|
||||
// order to provide convenience methods. These forward on "this", so that you
|
||||
// can write "bar->baz(etc)" instead of "wuffs_foo__bar__baz(bar, etc)".
|
||||
wuffs_sha256__hasher__struct() = delete;
|
||||
wuffs_sha256__hasher__struct(const wuffs_sha256__hasher__struct&) = delete;
|
||||
wuffs_sha256__hasher__struct& operator=(
|
||||
const wuffs_sha256__hasher__struct&) = delete;
|
||||
#endif // defined(WUFFS_BASE__HAVE_EQ_DELETE) && !defined(WUFFS_IMPLEMENTATION)
|
||||
|
||||
#if !defined(WUFFS_IMPLEMENTATION)
|
||||
// As above, the size of the struct is not part of the public API, and unless
|
||||
// WUFFS_IMPLEMENTATION is #define'd, this struct type T should be heap
|
||||
// allocated, not stack allocated. Its size is not intended to be known at
|
||||
// compile time, but it is unfortunately divulged as a side effect of
|
||||
// defining C++ convenience methods. Use "sizeof__T()", calling the function,
|
||||
// instead of "sizeof T", invoking the operator. To make the two values
|
||||
// different, so that passing the latter will be rejected by the initialize
|
||||
// function, we add an arbitrary amount of dead weight.
|
||||
uint8_t dead_weight[123000000]; // 123 MB.
|
||||
#endif // !defined(WUFFS_IMPLEMENTATION)
|
||||
|
||||
inline wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
|
||||
initialize(
|
||||
size_t sizeof_star_self,
|
||||
uint64_t wuffs_version,
|
||||
uint32_t options) {
|
||||
return wuffs_sha256__hasher__initialize(
|
||||
this, sizeof_star_self, wuffs_version, options);
|
||||
}
|
||||
|
||||
inline wuffs_base__hasher_bitvec256*
|
||||
upcast_as__wuffs_base__hasher_bitvec256() {
|
||||
return (wuffs_base__hasher_bitvec256*)this;
|
||||
}
|
||||
|
||||
inline uint64_t
|
||||
get_quirk(
|
||||
uint32_t a_key) const {
|
||||
return wuffs_sha256__hasher__get_quirk(this, a_key);
|
||||
}
|
||||
|
||||
inline wuffs_base__status
|
||||
set_quirk(
|
||||
uint32_t a_key,
|
||||
uint64_t a_value) {
|
||||
return wuffs_sha256__hasher__set_quirk(this, a_key, a_value);
|
||||
}
|
||||
|
||||
inline wuffs_base__empty_struct
|
||||
update(
|
||||
wuffs_base__slice_u8 a_x) {
|
||||
return wuffs_sha256__hasher__update(this, a_x);
|
||||
}
|
||||
|
||||
inline wuffs_base__bitvec256
|
||||
update_bitvec256(
|
||||
wuffs_base__slice_u8 a_x) {
|
||||
return wuffs_sha256__hasher__update_bitvec256(this, a_x);
|
||||
}
|
||||
|
||||
inline wuffs_base__bitvec256
|
||||
checksum_bitvec256() const {
|
||||
return wuffs_sha256__hasher__checksum_bitvec256(this);
|
||||
}
|
||||
|
||||
#endif // __cplusplus
|
||||
}; // struct wuffs_sha256__hasher__struct
|
||||
|
||||
#endif // defined(__cplusplus) || defined(WUFFS_IMPLEMENTATION)
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__SHA256) || defined(WUFFS_NONMONOLITHIC)
|
||||
|
||||
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TGA) || defined(WUFFS_NONMONOLITHIC)
|
||||
|
||||
// ---------------- Status Codes
|
||||
@@ -59273,6 +59504,611 @@ wuffs_png__decoder__filter_and_swizzle_tricky(
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__PNG)
|
||||
|
||||
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__SHA256)
|
||||
|
||||
// ---------------- Status Codes Implementations
|
||||
|
||||
// ---------------- Private Consts
|
||||
|
||||
static const uint32_t
|
||||
WUFFS_SHA256__INITIAL_SHA256_H[8] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225,
|
||||
};
|
||||
|
||||
static const uint32_t
|
||||
WUFFS_SHA256__K[64] WUFFS_BASE__POTENTIALLY_UNUSED = {
|
||||
1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, 2453635748, 2870763221,
|
||||
3624381080, 310598401, 607225278, 1426881987, 1925078388, 2162078206, 2614888103, 3248222580,
|
||||
3835390401, 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986,
|
||||
2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, 113926993, 338241895,
|
||||
666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, 2456956037,
|
||||
2730485921, 2820302411, 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344,
|
||||
430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779,
|
||||
1955562222, 2024104815, 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, 3329325298,
|
||||
};
|
||||
|
||||
// ---------------- Private Initializer Prototypes
|
||||
|
||||
// ---------------- Private Function Prototypes
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_sha256__hasher__up(
|
||||
wuffs_sha256__hasher* self,
|
||||
wuffs_base__slice_u8 a_x);
|
||||
|
||||
// ---------------- VTables
|
||||
|
||||
const wuffs_base__hasher_bitvec256__func_ptrs
|
||||
wuffs_sha256__hasher__func_ptrs_for__wuffs_base__hasher_bitvec256 = {
|
||||
(wuffs_base__bitvec256(*)(const void*))(&wuffs_sha256__hasher__checksum_bitvec256),
|
||||
(uint64_t(*)(const void*,
|
||||
uint32_t))(&wuffs_sha256__hasher__get_quirk),
|
||||
(wuffs_base__status(*)(void*,
|
||||
uint32_t,
|
||||
uint64_t))(&wuffs_sha256__hasher__set_quirk),
|
||||
(wuffs_base__empty_struct(*)(void*,
|
||||
wuffs_base__slice_u8))(&wuffs_sha256__hasher__update),
|
||||
(wuffs_base__bitvec256(*)(void*,
|
||||
wuffs_base__slice_u8))(&wuffs_sha256__hasher__update_bitvec256),
|
||||
};
|
||||
|
||||
// ---------------- Initializer Implementations
|
||||
|
||||
wuffs_base__status WUFFS_BASE__WARN_UNUSED_RESULT
|
||||
wuffs_sha256__hasher__initialize(
|
||||
wuffs_sha256__hasher* self,
|
||||
size_t sizeof_star_self,
|
||||
uint64_t wuffs_version,
|
||||
uint32_t options){
|
||||
if (!self) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if (sizeof(*self) != sizeof_star_self) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_sizeof_receiver);
|
||||
}
|
||||
if (((wuffs_version >> 32) != WUFFS_VERSION_MAJOR) ||
|
||||
(((wuffs_version >> 16) & 0xFFFF) > WUFFS_VERSION_MINOR)) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_wuffs_version);
|
||||
}
|
||||
|
||||
if ((options & WUFFS_INITIALIZE__ALREADY_ZEROED) != 0) {
|
||||
// The whole point of this if-check is to detect an uninitialized *self.
|
||||
// We disable the warning on GCC. Clang-5.0 does not have this warning.
|
||||
#if !defined(__clang__) && defined(__GNUC__)
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
|
||||
#endif
|
||||
if (self->private_impl.magic != 0) {
|
||||
return wuffs_base__make_status(wuffs_base__error__initialize_falsely_claimed_already_zeroed);
|
||||
}
|
||||
#if !defined(__clang__) && defined(__GNUC__)
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
} else {
|
||||
if ((options & WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED) == 0) {
|
||||
memset(self, 0, sizeof(*self));
|
||||
options |= WUFFS_INITIALIZE__ALREADY_ZEROED;
|
||||
} else {
|
||||
memset(&(self->private_impl), 0, sizeof(self->private_impl));
|
||||
}
|
||||
}
|
||||
|
||||
self->private_impl.magic = WUFFS_BASE__MAGIC;
|
||||
self->private_impl.vtable_for__wuffs_base__hasher_bitvec256.vtable_name =
|
||||
wuffs_base__hasher_bitvec256__vtable_name;
|
||||
self->private_impl.vtable_for__wuffs_base__hasher_bitvec256.function_pointers =
|
||||
(const void*)(&wuffs_sha256__hasher__func_ptrs_for__wuffs_base__hasher_bitvec256);
|
||||
return wuffs_base__make_status(NULL);
|
||||
}
|
||||
|
||||
wuffs_sha256__hasher*
|
||||
wuffs_sha256__hasher__alloc(void) {
|
||||
wuffs_sha256__hasher* x =
|
||||
(wuffs_sha256__hasher*)(calloc(sizeof(wuffs_sha256__hasher), 1));
|
||||
if (!x) {
|
||||
return NULL;
|
||||
}
|
||||
if (wuffs_sha256__hasher__initialize(
|
||||
x, sizeof(wuffs_sha256__hasher), WUFFS_VERSION, WUFFS_INITIALIZE__ALREADY_ZEROED).repr) {
|
||||
free(x);
|
||||
return NULL;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
size_t
|
||||
sizeof__wuffs_sha256__hasher(void) {
|
||||
return sizeof(wuffs_sha256__hasher);
|
||||
}
|
||||
|
||||
// ---------------- Function Implementations
|
||||
|
||||
// -------- func sha256.hasher.get_quirk
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC uint64_t
|
||||
wuffs_sha256__hasher__get_quirk(
|
||||
const wuffs_sha256__hasher* self,
|
||||
uint32_t a_key) {
|
||||
if (!self) {
|
||||
return 0;
|
||||
}
|
||||
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
|
||||
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 0u;
|
||||
}
|
||||
|
||||
// -------- func sha256.hasher.set_quirk
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__status
|
||||
wuffs_sha256__hasher__set_quirk(
|
||||
wuffs_sha256__hasher* self,
|
||||
uint32_t a_key,
|
||||
uint64_t a_value) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_status(wuffs_base__error__bad_receiver);
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_status(
|
||||
(self->private_impl.magic == WUFFS_BASE__DISABLED)
|
||||
? wuffs_base__error__disabled_by_previous_error
|
||||
: wuffs_base__error__initialize_not_called);
|
||||
}
|
||||
|
||||
return wuffs_base__make_status(wuffs_base__error__unsupported_option);
|
||||
}
|
||||
|
||||
// -------- func sha256.hasher.update
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__empty_struct
|
||||
wuffs_sha256__hasher__update(
|
||||
wuffs_sha256__hasher* self,
|
||||
wuffs_base__slice_u8 a_x) {
|
||||
if (!self) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
uint64_t v_new_lmu = 0;
|
||||
|
||||
if ((self->private_impl.f_length_modulo_u64 == 0u) && ! self->private_impl.f_length_overflows_u64) {
|
||||
self->private_impl.f_h0 = WUFFS_SHA256__INITIAL_SHA256_H[0u];
|
||||
self->private_impl.f_h1 = WUFFS_SHA256__INITIAL_SHA256_H[1u];
|
||||
self->private_impl.f_h2 = WUFFS_SHA256__INITIAL_SHA256_H[2u];
|
||||
self->private_impl.f_h3 = WUFFS_SHA256__INITIAL_SHA256_H[3u];
|
||||
self->private_impl.f_h4 = WUFFS_SHA256__INITIAL_SHA256_H[4u];
|
||||
self->private_impl.f_h5 = WUFFS_SHA256__INITIAL_SHA256_H[5u];
|
||||
self->private_impl.f_h6 = WUFFS_SHA256__INITIAL_SHA256_H[6u];
|
||||
self->private_impl.f_h7 = WUFFS_SHA256__INITIAL_SHA256_H[7u];
|
||||
}
|
||||
v_new_lmu = ((uint64_t)(self->private_impl.f_length_modulo_u64 + ((uint64_t)(a_x.len))));
|
||||
self->private_impl.f_length_overflows_u64 = ((v_new_lmu < self->private_impl.f_length_modulo_u64) || self->private_impl.f_length_overflows_u64);
|
||||
self->private_impl.f_length_modulo_u64 = v_new_lmu;
|
||||
if (self->private_impl.f_buf_len != 0u) {
|
||||
while (self->private_impl.f_buf_len < 64u) {
|
||||
if (((uint64_t)(a_x.len)) <= 0u) {
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
self->private_impl.f_buf_data[self->private_impl.f_buf_len] = a_x.ptr[0u];
|
||||
self->private_impl.f_buf_len += 1u;
|
||||
a_x = wuffs_base__slice_u8__subslice_i(a_x, 1u);
|
||||
}
|
||||
self->private_impl.f_buf_len = 0u;
|
||||
wuffs_sha256__hasher__up(self, wuffs_base__make_slice_u8(self->private_impl.f_buf_data, 64));
|
||||
}
|
||||
wuffs_sha256__hasher__up(self, a_x);
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func sha256.hasher.update_bitvec256
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__bitvec256
|
||||
wuffs_sha256__hasher__update_bitvec256(
|
||||
wuffs_sha256__hasher* self,
|
||||
wuffs_base__slice_u8 a_x) {
|
||||
if (!self) {
|
||||
return wuffs_base__utility__make_bitvec256(0u, 0u, 0u, 0u);
|
||||
}
|
||||
if (self->private_impl.magic != WUFFS_BASE__MAGIC) {
|
||||
return wuffs_base__utility__make_bitvec256(0u, 0u, 0u, 0u);
|
||||
}
|
||||
|
||||
wuffs_sha256__hasher__update(self, a_x);
|
||||
return wuffs_sha256__hasher__checksum_bitvec256(self);
|
||||
}
|
||||
|
||||
// -------- func sha256.hasher.up
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
static wuffs_base__empty_struct
|
||||
wuffs_sha256__hasher__up(
|
||||
wuffs_sha256__hasher* self,
|
||||
wuffs_base__slice_u8 a_x) {
|
||||
wuffs_base__slice_u8 v_p = {0};
|
||||
uint32_t v_w[64] = {0};
|
||||
uint32_t v_w2 = 0;
|
||||
uint32_t v_w15 = 0;
|
||||
uint32_t v_s0 = 0;
|
||||
uint32_t v_s1 = 0;
|
||||
uint32_t v_t1 = 0;
|
||||
uint32_t v_t2 = 0;
|
||||
uint32_t v_a = 0;
|
||||
uint32_t v_b = 0;
|
||||
uint32_t v_c = 0;
|
||||
uint32_t v_d = 0;
|
||||
uint32_t v_e = 0;
|
||||
uint32_t v_f = 0;
|
||||
uint32_t v_g = 0;
|
||||
uint32_t v_h = 0;
|
||||
uint32_t v_i = 0;
|
||||
uint32_t v_buf_len = 0;
|
||||
|
||||
v_a = self->private_impl.f_h0;
|
||||
v_b = self->private_impl.f_h1;
|
||||
v_c = self->private_impl.f_h2;
|
||||
v_d = self->private_impl.f_h3;
|
||||
v_e = self->private_impl.f_h4;
|
||||
v_f = self->private_impl.f_h5;
|
||||
v_g = self->private_impl.f_h6;
|
||||
v_h = self->private_impl.f_h7;
|
||||
{
|
||||
wuffs_base__slice_u8 i_slice_p = a_x;
|
||||
v_p.ptr = i_slice_p.ptr;
|
||||
v_p.len = 64;
|
||||
uint8_t* i_end0_p = v_p.ptr + (((i_slice_p.len - (size_t)(v_p.ptr - i_slice_p.ptr)) / 64) * 64);
|
||||
while (v_p.ptr < i_end0_p) {
|
||||
v_w[0u] = ((((uint32_t)(v_p.ptr[0u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[1u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[2u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[3u])));
|
||||
v_w[1u] = ((((uint32_t)(v_p.ptr[4u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[5u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[6u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[7u])));
|
||||
v_w[2u] = ((((uint32_t)(v_p.ptr[8u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[9u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[10u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[11u])));
|
||||
v_w[3u] = ((((uint32_t)(v_p.ptr[12u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[13u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[14u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[15u])));
|
||||
v_w[4u] = ((((uint32_t)(v_p.ptr[16u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[17u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[18u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[19u])));
|
||||
v_w[5u] = ((((uint32_t)(v_p.ptr[20u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[21u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[22u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[23u])));
|
||||
v_w[6u] = ((((uint32_t)(v_p.ptr[24u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[25u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[26u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[27u])));
|
||||
v_w[7u] = ((((uint32_t)(v_p.ptr[28u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[29u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[30u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[31u])));
|
||||
v_w[8u] = ((((uint32_t)(v_p.ptr[32u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[33u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[34u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[35u])));
|
||||
v_w[9u] = ((((uint32_t)(v_p.ptr[36u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[37u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[38u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[39u])));
|
||||
v_w[10u] = ((((uint32_t)(v_p.ptr[40u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[41u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[42u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[43u])));
|
||||
v_w[11u] = ((((uint32_t)(v_p.ptr[44u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[45u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[46u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[47u])));
|
||||
v_w[12u] = ((((uint32_t)(v_p.ptr[48u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[49u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[50u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[51u])));
|
||||
v_w[13u] = ((((uint32_t)(v_p.ptr[52u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[53u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[54u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[55u])));
|
||||
v_w[14u] = ((((uint32_t)(v_p.ptr[56u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[57u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[58u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[59u])));
|
||||
v_w[15u] = ((((uint32_t)(v_p.ptr[60u])) << 24u) |
|
||||
(((uint32_t)(v_p.ptr[61u])) << 16u) |
|
||||
(((uint32_t)(v_p.ptr[62u])) << 8u) |
|
||||
((uint32_t)(v_p.ptr[63u])));
|
||||
v_i = 16u;
|
||||
while (v_i < 64u) {
|
||||
v_w2 = v_w[(v_i - 2u)];
|
||||
v_s1 = ((v_w2 >> 10u) ^ (((uint32_t)(v_w2 << 15u)) | (v_w2 >> 17u)) ^ (((uint32_t)(v_w2 << 13u)) | (v_w2 >> 19u)));
|
||||
v_w15 = v_w[(v_i - 15u)];
|
||||
v_s0 = ((v_w15 >> 3u) ^ (((uint32_t)(v_w15 << 25u)) | (v_w15 >> 7u)) ^ (((uint32_t)(v_w15 << 14u)) | (v_w15 >> 18u)));
|
||||
v_w[v_i] = ((uint32_t)(((uint32_t)(((uint32_t)(v_s1 + v_w[(v_i - 7u)])) + v_s0)) + v_w[(v_i - 16u)]));
|
||||
v_i += 1u;
|
||||
}
|
||||
v_i = 0u;
|
||||
while (v_i < 64u) {
|
||||
v_t1 = v_h;
|
||||
v_t1 += ((((uint32_t)(v_e << 26u)) | (v_e >> 6u)) ^ (((uint32_t)(v_e << 21u)) | (v_e >> 11u)) ^ (((uint32_t)(v_e << 7u)) | (v_e >> 25u)));
|
||||
v_t1 += ((v_e & v_f) ^ ((4294967295u ^ v_e) & v_g));
|
||||
v_t1 += WUFFS_SHA256__K[v_i];
|
||||
v_t1 += v_w[v_i];
|
||||
v_t2 = ((((uint32_t)(v_a << 30u)) | (v_a >> 2u)) ^ (((uint32_t)(v_a << 19u)) | (v_a >> 13u)) ^ (((uint32_t)(v_a << 10u)) | (v_a >> 22u)));
|
||||
v_t2 += ((v_a & v_b) ^ (v_a & v_c) ^ (v_b & v_c));
|
||||
v_h = v_g;
|
||||
v_g = v_f;
|
||||
v_f = v_e;
|
||||
v_e = ((uint32_t)(v_d + v_t1));
|
||||
v_d = v_c;
|
||||
v_c = v_b;
|
||||
v_b = v_a;
|
||||
v_a = ((uint32_t)(v_t1 + v_t2));
|
||||
v_i += 1u;
|
||||
}
|
||||
v_a += self->private_impl.f_h0;
|
||||
self->private_impl.f_h0 = v_a;
|
||||
v_b += self->private_impl.f_h1;
|
||||
self->private_impl.f_h1 = v_b;
|
||||
v_c += self->private_impl.f_h2;
|
||||
self->private_impl.f_h2 = v_c;
|
||||
v_d += self->private_impl.f_h3;
|
||||
self->private_impl.f_h3 = v_d;
|
||||
v_e += self->private_impl.f_h4;
|
||||
self->private_impl.f_h4 = v_e;
|
||||
v_f += self->private_impl.f_h5;
|
||||
self->private_impl.f_h5 = v_f;
|
||||
v_g += self->private_impl.f_h6;
|
||||
self->private_impl.f_h6 = v_g;
|
||||
v_h += self->private_impl.f_h7;
|
||||
self->private_impl.f_h7 = v_h;
|
||||
v_p.ptr += 64;
|
||||
}
|
||||
v_p.len = 1;
|
||||
uint8_t* i_end1_p = i_slice_p.ptr + i_slice_p.len;
|
||||
while (v_p.ptr < i_end1_p) {
|
||||
self->private_impl.f_buf_data[v_buf_len] = v_p.ptr[0u];
|
||||
v_buf_len = ((v_buf_len + 1u) & 63u);
|
||||
v_p.ptr += 1;
|
||||
}
|
||||
v_p.len = 0;
|
||||
}
|
||||
self->private_impl.f_buf_len = ((uint32_t)((((uint64_t)(a_x.len)) & 63u)));
|
||||
return wuffs_base__make_empty_struct();
|
||||
}
|
||||
|
||||
// -------- func sha256.hasher.checksum_bitvec256
|
||||
|
||||
WUFFS_BASE__GENERATED_C_CODE
|
||||
WUFFS_BASE__MAYBE_STATIC wuffs_base__bitvec256
|
||||
wuffs_sha256__hasher__checksum_bitvec256(
|
||||
const wuffs_sha256__hasher* self) {
|
||||
if (!self) {
|
||||
return wuffs_base__utility__make_bitvec256(0u, 0u, 0u, 0u);
|
||||
}
|
||||
if ((self->private_impl.magic != WUFFS_BASE__MAGIC) &&
|
||||
(self->private_impl.magic != WUFFS_BASE__DISABLED)) {
|
||||
return wuffs_base__utility__make_bitvec256(0u, 0u, 0u, 0u);
|
||||
}
|
||||
|
||||
uint32_t v_buf_len = 0;
|
||||
uint8_t v_buf_data[64] = {0};
|
||||
uint64_t v_length_in_bits = 0;
|
||||
uint32_t v_w[64] = {0};
|
||||
uint32_t v_w2 = 0;
|
||||
uint32_t v_w15 = 0;
|
||||
uint32_t v_s0 = 0;
|
||||
uint32_t v_s1 = 0;
|
||||
uint32_t v_t1 = 0;
|
||||
uint32_t v_t2 = 0;
|
||||
uint32_t v_h0 = 0;
|
||||
uint32_t v_h1 = 0;
|
||||
uint32_t v_h2 = 0;
|
||||
uint32_t v_h3 = 0;
|
||||
uint32_t v_h4 = 0;
|
||||
uint32_t v_h5 = 0;
|
||||
uint32_t v_h6 = 0;
|
||||
uint32_t v_h7 = 0;
|
||||
uint32_t v_a = 0;
|
||||
uint32_t v_b = 0;
|
||||
uint32_t v_c = 0;
|
||||
uint32_t v_d = 0;
|
||||
uint32_t v_e = 0;
|
||||
uint32_t v_f = 0;
|
||||
uint32_t v_g = 0;
|
||||
uint32_t v_h = 0;
|
||||
uint32_t v_i = 0;
|
||||
bool v_final_block = false;
|
||||
|
||||
v_i = 0u;
|
||||
while (v_i < 64u) {
|
||||
v_buf_data[v_i] = self->private_impl.f_buf_data[v_i];
|
||||
v_i += 1u;
|
||||
}
|
||||
v_buf_len = (self->private_impl.f_buf_len & 63u);
|
||||
if (v_buf_len < 56u) {
|
||||
v_buf_data[v_buf_len] = 128u;
|
||||
v_buf_len += 1u;
|
||||
while (v_buf_len < 56u) {
|
||||
v_buf_data[v_buf_len] = 0u;
|
||||
v_buf_len += 1u;
|
||||
}
|
||||
v_final_block = true;
|
||||
} else {
|
||||
v_buf_data[v_buf_len] = 128u;
|
||||
v_buf_len += 1u;
|
||||
while (v_buf_len < 64u) {
|
||||
v_buf_data[v_buf_len] = 0u;
|
||||
v_buf_len += 1u;
|
||||
}
|
||||
}
|
||||
v_h0 = self->private_impl.f_h0;
|
||||
v_a = v_h0;
|
||||
v_h1 = self->private_impl.f_h1;
|
||||
v_b = v_h1;
|
||||
v_h2 = self->private_impl.f_h2;
|
||||
v_c = v_h2;
|
||||
v_h3 = self->private_impl.f_h3;
|
||||
v_d = v_h3;
|
||||
v_h4 = self->private_impl.f_h4;
|
||||
v_e = v_h4;
|
||||
v_h5 = self->private_impl.f_h5;
|
||||
v_f = v_h5;
|
||||
v_h6 = self->private_impl.f_h6;
|
||||
v_g = v_h6;
|
||||
v_h7 = self->private_impl.f_h7;
|
||||
v_h = v_h7;
|
||||
while (true) {
|
||||
if (v_final_block) {
|
||||
v_length_in_bits = ((uint64_t)(self->private_impl.f_length_modulo_u64 * 8u));
|
||||
v_buf_data[56u] = ((uint8_t)((v_length_in_bits >> 56u)));
|
||||
v_buf_data[57u] = ((uint8_t)((v_length_in_bits >> 48u)));
|
||||
v_buf_data[58u] = ((uint8_t)((v_length_in_bits >> 40u)));
|
||||
v_buf_data[59u] = ((uint8_t)((v_length_in_bits >> 32u)));
|
||||
v_buf_data[60u] = ((uint8_t)((v_length_in_bits >> 24u)));
|
||||
v_buf_data[61u] = ((uint8_t)((v_length_in_bits >> 16u)));
|
||||
v_buf_data[62u] = ((uint8_t)((v_length_in_bits >> 8u)));
|
||||
v_buf_data[63u] = ((uint8_t)(v_length_in_bits));
|
||||
}
|
||||
v_w[0u] = ((((uint32_t)(v_buf_data[0u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[1u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[2u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[3u])));
|
||||
v_w[1u] = ((((uint32_t)(v_buf_data[4u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[5u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[6u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[7u])));
|
||||
v_w[2u] = ((((uint32_t)(v_buf_data[8u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[9u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[10u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[11u])));
|
||||
v_w[3u] = ((((uint32_t)(v_buf_data[12u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[13u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[14u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[15u])));
|
||||
v_w[4u] = ((((uint32_t)(v_buf_data[16u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[17u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[18u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[19u])));
|
||||
v_w[5u] = ((((uint32_t)(v_buf_data[20u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[21u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[22u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[23u])));
|
||||
v_w[6u] = ((((uint32_t)(v_buf_data[24u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[25u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[26u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[27u])));
|
||||
v_w[7u] = ((((uint32_t)(v_buf_data[28u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[29u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[30u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[31u])));
|
||||
v_w[8u] = ((((uint32_t)(v_buf_data[32u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[33u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[34u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[35u])));
|
||||
v_w[9u] = ((((uint32_t)(v_buf_data[36u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[37u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[38u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[39u])));
|
||||
v_w[10u] = ((((uint32_t)(v_buf_data[40u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[41u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[42u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[43u])));
|
||||
v_w[11u] = ((((uint32_t)(v_buf_data[44u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[45u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[46u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[47u])));
|
||||
v_w[12u] = ((((uint32_t)(v_buf_data[48u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[49u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[50u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[51u])));
|
||||
v_w[13u] = ((((uint32_t)(v_buf_data[52u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[53u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[54u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[55u])));
|
||||
v_w[14u] = ((((uint32_t)(v_buf_data[56u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[57u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[58u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[59u])));
|
||||
v_w[15u] = ((((uint32_t)(v_buf_data[60u])) << 24u) |
|
||||
(((uint32_t)(v_buf_data[61u])) << 16u) |
|
||||
(((uint32_t)(v_buf_data[62u])) << 8u) |
|
||||
((uint32_t)(v_buf_data[63u])));
|
||||
v_i = 16u;
|
||||
while (v_i < 64u) {
|
||||
v_w2 = v_w[(v_i - 2u)];
|
||||
v_s1 = ((v_w2 >> 10u) ^ (((uint32_t)(v_w2 << 15u)) | (v_w2 >> 17u)) ^ (((uint32_t)(v_w2 << 13u)) | (v_w2 >> 19u)));
|
||||
v_w15 = v_w[(v_i - 15u)];
|
||||
v_s0 = ((v_w15 >> 3u) ^ (((uint32_t)(v_w15 << 25u)) | (v_w15 >> 7u)) ^ (((uint32_t)(v_w15 << 14u)) | (v_w15 >> 18u)));
|
||||
v_w[v_i] = ((uint32_t)(((uint32_t)(((uint32_t)(v_s1 + v_w[(v_i - 7u)])) + v_s0)) + v_w[(v_i - 16u)]));
|
||||
v_i += 1u;
|
||||
}
|
||||
v_i = 0u;
|
||||
while (v_i < 64u) {
|
||||
v_t1 = v_h;
|
||||
v_t1 += ((((uint32_t)(v_e << 26u)) | (v_e >> 6u)) ^ (((uint32_t)(v_e << 21u)) | (v_e >> 11u)) ^ (((uint32_t)(v_e << 7u)) | (v_e >> 25u)));
|
||||
v_t1 += ((v_e & v_f) ^ ((4294967295u ^ v_e) & v_g));
|
||||
v_t1 += WUFFS_SHA256__K[v_i];
|
||||
v_t1 += v_w[v_i];
|
||||
v_t2 = ((((uint32_t)(v_a << 30u)) | (v_a >> 2u)) ^ (((uint32_t)(v_a << 19u)) | (v_a >> 13u)) ^ (((uint32_t)(v_a << 10u)) | (v_a >> 22u)));
|
||||
v_t2 += ((v_a & v_b) ^ (v_a & v_c) ^ (v_b & v_c));
|
||||
v_h = v_g;
|
||||
v_g = v_f;
|
||||
v_f = v_e;
|
||||
v_e = ((uint32_t)(v_d + v_t1));
|
||||
v_d = v_c;
|
||||
v_c = v_b;
|
||||
v_b = v_a;
|
||||
v_a = ((uint32_t)(v_t1 + v_t2));
|
||||
v_i += 1u;
|
||||
}
|
||||
v_a += v_h0;
|
||||
v_b += v_h1;
|
||||
v_c += v_h2;
|
||||
v_d += v_h3;
|
||||
v_e += v_h4;
|
||||
v_f += v_h5;
|
||||
v_g += v_h6;
|
||||
v_h += v_h7;
|
||||
if (v_final_block) {
|
||||
break;
|
||||
}
|
||||
v_final_block = true;
|
||||
v_h0 = v_a;
|
||||
v_h1 = v_b;
|
||||
v_h2 = v_c;
|
||||
v_h3 = v_d;
|
||||
v_h4 = v_e;
|
||||
v_h5 = v_f;
|
||||
v_h6 = v_g;
|
||||
v_h7 = v_h;
|
||||
v_buf_len = 0u;
|
||||
while (v_buf_len < 56u) {
|
||||
v_buf_data[v_buf_len] = 0u;
|
||||
v_buf_len += 1u;
|
||||
}
|
||||
}
|
||||
return wuffs_base__utility__make_bitvec256(
|
||||
(((uint64_t)(v_h)) | (((uint64_t)(v_g)) << 32u)),
|
||||
(((uint64_t)(v_f)) | (((uint64_t)(v_e)) << 32u)),
|
||||
(((uint64_t)(v_d)) | (((uint64_t)(v_c)) << 32u)),
|
||||
(((uint64_t)(v_b)) | (((uint64_t)(v_a)) << 32u)));
|
||||
}
|
||||
|
||||
#endif // !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__SHA256)
|
||||
|
||||
#if !defined(WUFFS_CONFIG__MODULES) || defined(WUFFS_CONFIG__MODULE__TGA)
|
||||
|
||||
// ---------------- Status Codes Implementations
|
||||
|
||||
@@ -19,6 +19,7 @@ package main
|
||||
// Usage: go run checksum.go -algorithm=crc32/ieee < foo.bar
|
||||
|
||||
import (
|
||||
"crypto/sha256"
|
||||
"flag"
|
||||
"fmt"
|
||||
"hash"
|
||||
@@ -77,6 +78,8 @@ func do(r io.Reader) error {
|
||||
h = adler32.New()
|
||||
case "crc32/ieee":
|
||||
h = crc32.NewIEEE()
|
||||
case "sha256":
|
||||
h = sha256.New()
|
||||
case "xxhash32":
|
||||
h = xxHash32.New(0)
|
||||
case "xxhash64":
|
||||
@@ -94,6 +97,16 @@ func do(r io.Reader) error {
|
||||
fmt.Printf("0x%08X", h.Sum32())
|
||||
case hash.Hash64:
|
||||
fmt.Printf("0x%016X", h.Sum64())
|
||||
case hash.Hash:
|
||||
b := h.Sum(nil)
|
||||
for i, x := range b {
|
||||
if i == 0 {
|
||||
fmt.Printf("0x")
|
||||
} else if (i & 7) == 0 {
|
||||
fmt.Printf("_")
|
||||
}
|
||||
fmt.Printf("%02X", x)
|
||||
}
|
||||
default:
|
||||
return fmt.Errorf("algorithm %q is not a Hash32 or Hash64", *algorithm)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,452 @@
|
||||
// Copyright 2023 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
|
||||
// INITIAL_SHA256_H comes from section "5.3.3 SHA-256" of
|
||||
// https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf
|
||||
pri const INITIAL_SHA256_H : roarray[8] base.u32 = [
|
||||
0x6A09_E667, 0xBB67_AE85, 0x3C6E_F372, 0xA54F_F53A,
|
||||
0x510E_527F, 0x9B05_688C, 0x1F83_D9AB, 0x5BE0_CD19,
|
||||
]
|
||||
|
||||
// K comes from section "4.2.2 SHA-224 and SHA-256 Constants" of
|
||||
// https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf
|
||||
pri const K : roarray[64] base.u32 = [
|
||||
0x428A_2F98, 0x7137_4491, 0xB5C0_FBCF, 0xE9B5_DBA5,
|
||||
0x3956_C25B, 0x59F1_11F1, 0x923F_82A4, 0xAB1C_5ED5,
|
||||
0xD807_AA98, 0x1283_5B01, 0x2431_85BE, 0x550C_7DC3,
|
||||
0x72BE_5D74, 0x80DE_B1FE, 0x9BDC_06A7, 0xC19B_F174,
|
||||
0xE49B_69C1, 0xEFBE_4786, 0x0FC1_9DC6, 0x240C_A1CC,
|
||||
0x2DE9_2C6F, 0x4A74_84AA, 0x5CB0_A9DC, 0x76F9_88DA,
|
||||
0x983E_5152, 0xA831_C66D, 0xB003_27C8, 0xBF59_7FC7,
|
||||
0xC6E0_0BF3, 0xD5A7_9147, 0x06CA_6351, 0x1429_2967,
|
||||
0x27B7_0A85, 0x2E1B_2138, 0x4D2C_6DFC, 0x5338_0D13,
|
||||
0x650A_7354, 0x766A_0ABB, 0x81C2_C92E, 0x9272_2C85,
|
||||
0xA2BF_E8A1, 0xA81A_664B, 0xC24B_8B70, 0xC76C_51A3,
|
||||
0xD192_E819, 0xD699_0624, 0xF40E_3585, 0x106A_A070,
|
||||
0x19A4_C116, 0x1E37_6C08, 0x2748_774C, 0x34B0_BCB5,
|
||||
0x391C_0CB3, 0x4ED8_AA4A, 0x5B9C_CA4F, 0x682E_6FF3,
|
||||
0x748F_82EE, 0x78A5_636F, 0x84C8_7814, 0x8CC7_0208,
|
||||
0x90BE_FFFA, 0xA450_6CEB, 0xBEF9_A3F7, 0xC671_78F2,
|
||||
]
|
||||
|
||||
pub struct hasher? implements base.hasher_bitvec256(
|
||||
length_modulo_u64 : base.u64,
|
||||
length_overflows_u64 : base.bool,
|
||||
|
||||
padding0 : base.u8,
|
||||
padding1 : base.u8,
|
||||
padding2 : base.u8,
|
||||
|
||||
buf_len : base.u32[..= 64],
|
||||
buf_data : array[64] base.u8,
|
||||
|
||||
h0 : base.u32,
|
||||
h1 : base.u32,
|
||||
h2 : base.u32,
|
||||
h3 : base.u32,
|
||||
h4 : base.u32,
|
||||
h5 : base.u32,
|
||||
h6 : base.u32,
|
||||
h7 : base.u32,
|
||||
|
||||
util : base.utility,
|
||||
)
|
||||
|
||||
pub func hasher.get_quirk(key: base.u32) base.u64 {
|
||||
return 0
|
||||
}
|
||||
|
||||
pub func hasher.set_quirk!(key: base.u32, value: base.u64) base.status {
|
||||
return base."#unsupported option"
|
||||
}
|
||||
|
||||
pub func hasher.update!(x: roslice base.u8) {
|
||||
var new_lmu : base.u64
|
||||
|
||||
if (this.length_modulo_u64 == 0) and not this.length_overflows_u64 {
|
||||
this.h0 = INITIAL_SHA256_H[0]
|
||||
this.h1 = INITIAL_SHA256_H[1]
|
||||
this.h2 = INITIAL_SHA256_H[2]
|
||||
this.h3 = INITIAL_SHA256_H[3]
|
||||
this.h4 = INITIAL_SHA256_H[4]
|
||||
this.h5 = INITIAL_SHA256_H[5]
|
||||
this.h6 = INITIAL_SHA256_H[6]
|
||||
this.h7 = INITIAL_SHA256_H[7]
|
||||
}
|
||||
|
||||
new_lmu = this.length_modulo_u64 ~mod+ args.x.length()
|
||||
this.length_overflows_u64 = (new_lmu < this.length_modulo_u64) or this.length_overflows_u64
|
||||
this.length_modulo_u64 = new_lmu
|
||||
|
||||
// Align to a block boundary before calling this.up.
|
||||
if this.buf_len <> 0 {
|
||||
while this.buf_len < 64 {
|
||||
if args.x.length() <= 0 {
|
||||
return nothing
|
||||
}
|
||||
this.buf_data[this.buf_len] = args.x[0]
|
||||
this.buf_len += 1
|
||||
args.x = args.x[1 ..]
|
||||
} endwhile
|
||||
this.buf_len = 0
|
||||
this.up!(x: this.buf_data[..])
|
||||
}
|
||||
|
||||
this.up!(x: args.x)
|
||||
}
|
||||
|
||||
pub func hasher.update_bitvec256!(x: roslice base.u8) base.bitvec256 {
|
||||
this.update!(x: args.x)
|
||||
return this.checksum_bitvec256()
|
||||
}
|
||||
|
||||
pri func hasher.up!(x: roslice base.u8) {
|
||||
var p : roslice base.u8
|
||||
|
||||
var w : array[64] base.u32
|
||||
|
||||
var w2 : base.u32
|
||||
var w15 : base.u32
|
||||
var s0 : base.u32
|
||||
var s1 : base.u32
|
||||
var t1 : base.u32
|
||||
var t2 : base.u32
|
||||
|
||||
var a : base.u32
|
||||
var b : base.u32
|
||||
var c : base.u32
|
||||
var d : base.u32
|
||||
var e : base.u32
|
||||
var f : base.u32
|
||||
var g : base.u32
|
||||
var h : base.u32
|
||||
|
||||
var i : base.u32
|
||||
|
||||
var buf_len : base.u32[..= 63]
|
||||
|
||||
a = this.h0
|
||||
b = this.h1
|
||||
c = this.h2
|
||||
d = this.h3
|
||||
e = this.h4
|
||||
f = this.h5
|
||||
g = this.h6
|
||||
h = this.h7
|
||||
|
||||
iterate (p = args.x)(length: 64, advance: 64, unroll: 1) {
|
||||
w[0x00] = ((p[0x00] as base.u32) << 24) | ((p[0x01] as base.u32) << 16) |
|
||||
((p[0x02] as base.u32) << 8) | ((p[0x03] as base.u32))
|
||||
w[0x01] = ((p[0x04] as base.u32) << 24) | ((p[0x05] as base.u32) << 16) |
|
||||
((p[0x06] as base.u32) << 8) | ((p[0x07] as base.u32))
|
||||
w[0x02] = ((p[0x08] as base.u32) << 24) | ((p[0x09] as base.u32) << 16) |
|
||||
((p[0x0A] as base.u32) << 8) | ((p[0x0B] as base.u32))
|
||||
w[0x03] = ((p[0x0C] as base.u32) << 24) | ((p[0x0D] as base.u32) << 16) |
|
||||
((p[0x0E] as base.u32) << 8) | ((p[0x0F] as base.u32))
|
||||
w[0x04] = ((p[0x10] as base.u32) << 24) | ((p[0x11] as base.u32) << 16) |
|
||||
((p[0x12] as base.u32) << 8) | ((p[0x13] as base.u32))
|
||||
w[0x05] = ((p[0x14] as base.u32) << 24) | ((p[0x15] as base.u32) << 16) |
|
||||
((p[0x16] as base.u32) << 8) | ((p[0x17] as base.u32))
|
||||
w[0x06] = ((p[0x18] as base.u32) << 24) | ((p[0x19] as base.u32) << 16) |
|
||||
((p[0x1A] as base.u32) << 8) | ((p[0x1B] as base.u32))
|
||||
w[0x07] = ((p[0x1C] as base.u32) << 24) | ((p[0x1D] as base.u32) << 16) |
|
||||
((p[0x1E] as base.u32) << 8) | ((p[0x1F] as base.u32))
|
||||
w[0x08] = ((p[0x20] as base.u32) << 24) | ((p[0x21] as base.u32) << 16) |
|
||||
((p[0x22] as base.u32) << 8) | ((p[0x23] as base.u32))
|
||||
w[0x09] = ((p[0x24] as base.u32) << 24) | ((p[0x25] as base.u32) << 16) |
|
||||
((p[0x26] as base.u32) << 8) | ((p[0x27] as base.u32))
|
||||
w[0x0A] = ((p[0x28] as base.u32) << 24) | ((p[0x29] as base.u32) << 16) |
|
||||
((p[0x2A] as base.u32) << 8) | ((p[0x2B] as base.u32))
|
||||
w[0x0B] = ((p[0x2C] as base.u32) << 24) | ((p[0x2D] as base.u32) << 16) |
|
||||
((p[0x2E] as base.u32) << 8) | ((p[0x2F] as base.u32))
|
||||
w[0x0C] = ((p[0x30] as base.u32) << 24) | ((p[0x31] as base.u32) << 16) |
|
||||
((p[0x32] as base.u32) << 8) | ((p[0x33] as base.u32))
|
||||
w[0x0D] = ((p[0x34] as base.u32) << 24) | ((p[0x35] as base.u32) << 16) |
|
||||
((p[0x36] as base.u32) << 8) | ((p[0x37] as base.u32))
|
||||
w[0x0E] = ((p[0x38] as base.u32) << 24) | ((p[0x39] as base.u32) << 16) |
|
||||
((p[0x3A] as base.u32) << 8) | ((p[0x3B] as base.u32))
|
||||
w[0x0F] = ((p[0x3C] as base.u32) << 24) | ((p[0x3D] as base.u32) << 16) |
|
||||
((p[0x3E] as base.u32) << 8) | ((p[0x3F] as base.u32))
|
||||
|
||||
i = 16
|
||||
while i < 64,
|
||||
inv i >= 16,
|
||||
{
|
||||
w2 = w[i - 2]
|
||||
s1 = (w2 >> 10) ^
|
||||
((w2 ~mod<< 15) | (w2 >> 17)) ^
|
||||
((w2 ~mod<< 13) | (w2 >> 19))
|
||||
w15 = w[i - 15]
|
||||
s0 = (w15 >> 3) ^
|
||||
((w15 ~mod<< 25) | (w15 >> 7)) ^
|
||||
((w15 ~mod<< 14) | (w15 >> 18))
|
||||
w[i] = ((s1 ~mod+ w[i - 7]) ~mod+ s0) ~mod+ w[i - 16]
|
||||
i += 1
|
||||
} endwhile
|
||||
|
||||
i = 0
|
||||
while i < 64 {
|
||||
t1 = h
|
||||
t1 ~mod+= ((e ~mod<< 26) | (e >> 6)) ^
|
||||
((e ~mod<< 21) | (e >> 11)) ^
|
||||
((e ~mod<< 7) | (e >> 25))
|
||||
t1 ~mod+= (e & f) ^ ((0xFFFF_FFFF ^ e) & g)
|
||||
t1 ~mod+= K[i]
|
||||
t1 ~mod+= w[i]
|
||||
|
||||
t2 = ((a ~mod<< 30) | (a >> 2)) ^
|
||||
((a ~mod<< 19) | (a >> 13)) ^
|
||||
((a ~mod<< 10) | (a >> 22))
|
||||
t2 ~mod+= (a & b) ^ (a & c) ^ (b & c)
|
||||
|
||||
h = g
|
||||
g = f
|
||||
f = e
|
||||
e = d ~mod+ t1
|
||||
d = c
|
||||
c = b
|
||||
b = a
|
||||
a = t1 ~mod+ t2
|
||||
|
||||
i += 1
|
||||
} endwhile
|
||||
|
||||
a ~mod+= this.h0
|
||||
this.h0 = a
|
||||
b ~mod+= this.h1
|
||||
this.h1 = b
|
||||
c ~mod+= this.h2
|
||||
this.h2 = c
|
||||
d ~mod+= this.h3
|
||||
this.h3 = d
|
||||
e ~mod+= this.h4
|
||||
this.h4 = e
|
||||
f ~mod+= this.h5
|
||||
this.h5 = f
|
||||
g ~mod+= this.h6
|
||||
this.h6 = g
|
||||
h ~mod+= this.h7
|
||||
this.h7 = h
|
||||
|
||||
} else (length: 1, advance: 1, unroll: 1) {
|
||||
this.buf_data[buf_len] = p[0]
|
||||
buf_len = (buf_len + 1) & 63
|
||||
}
|
||||
this.buf_len = (args.x.length() & 63) as base.u32
|
||||
}
|
||||
|
||||
pub func hasher.checksum_bitvec256() base.bitvec256 {
|
||||
var buf_len : base.u32[..= 64]
|
||||
var buf_data : array[64] base.u8
|
||||
|
||||
var length_in_bits : base.u64
|
||||
|
||||
var w : array[64] base.u32
|
||||
|
||||
var w2 : base.u32
|
||||
var w15 : base.u32
|
||||
var s0 : base.u32
|
||||
var s1 : base.u32
|
||||
var t1 : base.u32
|
||||
var t2 : base.u32
|
||||
|
||||
var h0 : base.u32
|
||||
var h1 : base.u32
|
||||
var h2 : base.u32
|
||||
var h3 : base.u32
|
||||
var h4 : base.u32
|
||||
var h5 : base.u32
|
||||
var h6 : base.u32
|
||||
var h7 : base.u32
|
||||
|
||||
var a : base.u32
|
||||
var b : base.u32
|
||||
var c : base.u32
|
||||
var d : base.u32
|
||||
var e : base.u32
|
||||
var f : base.u32
|
||||
var g : base.u32
|
||||
var h : base.u32
|
||||
|
||||
var i : base.u32
|
||||
|
||||
var final_block : base.bool
|
||||
|
||||
i = 0
|
||||
while i < 64 {
|
||||
buf_data[i] = this.buf_data[i]
|
||||
i += 1
|
||||
} endwhile
|
||||
|
||||
// Pad with a 1 bit and then zero or more 0 bits, until we're at 56 bytes
|
||||
// (448 bits), modulo 64 bytes (512 bits).
|
||||
buf_len = this.buf_len & 63
|
||||
if buf_len < 56 {
|
||||
buf_data[buf_len] = 0x80
|
||||
buf_len += 1
|
||||
while buf_len < 56 {
|
||||
buf_data[buf_len] = 0x00
|
||||
buf_len += 1
|
||||
} endwhile
|
||||
final_block = true
|
||||
|
||||
} else {
|
||||
assert buf_len <= 63
|
||||
buf_data[buf_len] = 0x80
|
||||
buf_len += 1
|
||||
while buf_len < 64 {
|
||||
buf_data[buf_len] = 0x00
|
||||
buf_len += 1
|
||||
} endwhile
|
||||
}
|
||||
|
||||
h0 = this.h0
|
||||
a = h0
|
||||
h1 = this.h1
|
||||
b = h1
|
||||
h2 = this.h2
|
||||
c = h2
|
||||
h3 = this.h3
|
||||
d = h3
|
||||
h4 = this.h4
|
||||
e = h4
|
||||
h5 = this.h5
|
||||
f = h5
|
||||
h6 = this.h6
|
||||
g = h6
|
||||
h7 = this.h7
|
||||
h = h7
|
||||
|
||||
while true {
|
||||
if final_block {
|
||||
// The final block ends with the total length (in bits).
|
||||
length_in_bits = this.length_modulo_u64 ~mod* 8
|
||||
buf_data[56] = ((length_in_bits >> 56) & 0xFF) as base.u8
|
||||
buf_data[57] = ((length_in_bits >> 48) & 0xFF) as base.u8
|
||||
buf_data[58] = ((length_in_bits >> 40) & 0xFF) as base.u8
|
||||
buf_data[59] = ((length_in_bits >> 32) & 0xFF) as base.u8
|
||||
buf_data[60] = ((length_in_bits >> 24) & 0xFF) as base.u8
|
||||
buf_data[61] = ((length_in_bits >> 16) & 0xFF) as base.u8
|
||||
buf_data[62] = ((length_in_bits >> 8) & 0xFF) as base.u8
|
||||
buf_data[63] = ((length_in_bits) & 0xFF) as base.u8
|
||||
}
|
||||
|
||||
w[0x00] = ((buf_data[0x00] as base.u32) << 24) | ((buf_data[0x01] as base.u32) << 16) |
|
||||
((buf_data[0x02] as base.u32) << 8) | ((buf_data[0x03] as base.u32))
|
||||
w[0x01] = ((buf_data[0x04] as base.u32) << 24) | ((buf_data[0x05] as base.u32) << 16) |
|
||||
((buf_data[0x06] as base.u32) << 8) | ((buf_data[0x07] as base.u32))
|
||||
w[0x02] = ((buf_data[0x08] as base.u32) << 24) | ((buf_data[0x09] as base.u32) << 16) |
|
||||
((buf_data[0x0A] as base.u32) << 8) | ((buf_data[0x0B] as base.u32))
|
||||
w[0x03] = ((buf_data[0x0C] as base.u32) << 24) | ((buf_data[0x0D] as base.u32) << 16) |
|
||||
((buf_data[0x0E] as base.u32) << 8) | ((buf_data[0x0F] as base.u32))
|
||||
w[0x04] = ((buf_data[0x10] as base.u32) << 24) | ((buf_data[0x11] as base.u32) << 16) |
|
||||
((buf_data[0x12] as base.u32) << 8) | ((buf_data[0x13] as base.u32))
|
||||
w[0x05] = ((buf_data[0x14] as base.u32) << 24) | ((buf_data[0x15] as base.u32) << 16) |
|
||||
((buf_data[0x16] as base.u32) << 8) | ((buf_data[0x17] as base.u32))
|
||||
w[0x06] = ((buf_data[0x18] as base.u32) << 24) | ((buf_data[0x19] as base.u32) << 16) |
|
||||
((buf_data[0x1A] as base.u32) << 8) | ((buf_data[0x1B] as base.u32))
|
||||
w[0x07] = ((buf_data[0x1C] as base.u32) << 24) | ((buf_data[0x1D] as base.u32) << 16) |
|
||||
((buf_data[0x1E] as base.u32) << 8) | ((buf_data[0x1F] as base.u32))
|
||||
w[0x08] = ((buf_data[0x20] as base.u32) << 24) | ((buf_data[0x21] as base.u32) << 16) |
|
||||
((buf_data[0x22] as base.u32) << 8) | ((buf_data[0x23] as base.u32))
|
||||
w[0x09] = ((buf_data[0x24] as base.u32) << 24) | ((buf_data[0x25] as base.u32) << 16) |
|
||||
((buf_data[0x26] as base.u32) << 8) | ((buf_data[0x27] as base.u32))
|
||||
w[0x0A] = ((buf_data[0x28] as base.u32) << 24) | ((buf_data[0x29] as base.u32) << 16) |
|
||||
((buf_data[0x2A] as base.u32) << 8) | ((buf_data[0x2B] as base.u32))
|
||||
w[0x0B] = ((buf_data[0x2C] as base.u32) << 24) | ((buf_data[0x2D] as base.u32) << 16) |
|
||||
((buf_data[0x2E] as base.u32) << 8) | ((buf_data[0x2F] as base.u32))
|
||||
w[0x0C] = ((buf_data[0x30] as base.u32) << 24) | ((buf_data[0x31] as base.u32) << 16) |
|
||||
((buf_data[0x32] as base.u32) << 8) | ((buf_data[0x33] as base.u32))
|
||||
w[0x0D] = ((buf_data[0x34] as base.u32) << 24) | ((buf_data[0x35] as base.u32) << 16) |
|
||||
((buf_data[0x36] as base.u32) << 8) | ((buf_data[0x37] as base.u32))
|
||||
w[0x0E] = ((buf_data[0x38] as base.u32) << 24) | ((buf_data[0x39] as base.u32) << 16) |
|
||||
((buf_data[0x3A] as base.u32) << 8) | ((buf_data[0x3B] as base.u32))
|
||||
w[0x0F] = ((buf_data[0x3C] as base.u32) << 24) | ((buf_data[0x3D] as base.u32) << 16) |
|
||||
((buf_data[0x3E] as base.u32) << 8) | ((buf_data[0x3F] as base.u32))
|
||||
|
||||
i = 16
|
||||
while i < 64,
|
||||
inv i >= 16,
|
||||
{
|
||||
w2 = w[i - 2]
|
||||
s1 = (w2 >> 10) ^
|
||||
((w2 ~mod<< 15) | (w2 >> 17)) ^
|
||||
((w2 ~mod<< 13) | (w2 >> 19))
|
||||
w15 = w[i - 15]
|
||||
s0 = (w15 >> 3) ^
|
||||
((w15 ~mod<< 25) | (w15 >> 7)) ^
|
||||
((w15 ~mod<< 14) | (w15 >> 18))
|
||||
w[i] = ((s1 ~mod+ w[i - 7]) ~mod+ s0) ~mod+ w[i - 16]
|
||||
i += 1
|
||||
} endwhile
|
||||
|
||||
i = 0
|
||||
while i < 64 {
|
||||
t1 = h
|
||||
t1 ~mod+= ((e ~mod<< 26) | (e >> 6)) ^
|
||||
((e ~mod<< 21) | (e >> 11)) ^
|
||||
((e ~mod<< 7) | (e >> 25))
|
||||
t1 ~mod+= (e & f) ^ ((0xFFFF_FFFF ^ e) & g)
|
||||
t1 ~mod+= K[i]
|
||||
t1 ~mod+= w[i]
|
||||
|
||||
t2 = ((a ~mod<< 30) | (a >> 2)) ^
|
||||
((a ~mod<< 19) | (a >> 13)) ^
|
||||
((a ~mod<< 10) | (a >> 22))
|
||||
t2 ~mod+= (a & b) ^ (a & c) ^ (b & c)
|
||||
|
||||
h = g
|
||||
g = f
|
||||
f = e
|
||||
e = d ~mod+ t1
|
||||
d = c
|
||||
c = b
|
||||
b = a
|
||||
a = t1 ~mod+ t2
|
||||
|
||||
i += 1
|
||||
} endwhile
|
||||
|
||||
a ~mod+= h0
|
||||
b ~mod+= h1
|
||||
c ~mod+= h2
|
||||
d ~mod+= h3
|
||||
e ~mod+= h4
|
||||
f ~mod+= h5
|
||||
g ~mod+= h6
|
||||
h ~mod+= h7
|
||||
|
||||
if final_block {
|
||||
break
|
||||
}
|
||||
final_block = true
|
||||
|
||||
h0 = a
|
||||
h1 = b
|
||||
h2 = c
|
||||
h3 = d
|
||||
h4 = e
|
||||
h5 = f
|
||||
h6 = g
|
||||
h7 = h
|
||||
|
||||
buf_len = 0
|
||||
while buf_len < 56 {
|
||||
buf_data[buf_len] = 0x00
|
||||
buf_len += 1
|
||||
} endwhile
|
||||
} endwhile
|
||||
|
||||
return this.util.make_bitvec256(
|
||||
e00: (h as base.u64) | ((g as base.u64) << 32),
|
||||
e01: (f as base.u64) | ((e as base.u64) << 32),
|
||||
e02: (d as base.u64) | ((c as base.u64) << 32),
|
||||
e03: (b as base.u64) | ((a as base.u64) << 32))
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
// Copyright 2023 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
|
||||
#include "openssl/sha.h"
|
||||
|
||||
uint8_t global_mimiclib_sha256_unused_bitvec256[SHA256_DIGEST_LENGTH];
|
||||
|
||||
const char* //
|
||||
mimic_bench_sha256(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
SHA256_CTX ctx;
|
||||
SHA256_Init(&ctx);
|
||||
|
||||
while (src->meta.ri < src->meta.wi) {
|
||||
uint8_t* ptr = src->data.ptr + src->meta.ri;
|
||||
size_t len = src->meta.wi - src->meta.ri;
|
||||
if (len > 0x7FFFFFFF) {
|
||||
return "src length is too large";
|
||||
} else if (len > rlimit) {
|
||||
len = rlimit;
|
||||
}
|
||||
SHA256_Update(&ctx, ptr, len);
|
||||
src->meta.ri += len;
|
||||
}
|
||||
|
||||
SHA256_Final(global_mimiclib_sha256_unused_bitvec256, &ctx);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
wuffs_base__bitvec256 //
|
||||
mimic_sha256_one_shot_checksum_bitvec256(wuffs_base__slice_u8 data) {
|
||||
SHA256_CTX ctx;
|
||||
uint8_t results[SHA256_DIGEST_LENGTH];
|
||||
SHA256_Init(&ctx);
|
||||
SHA256_Update(&ctx, data.ptr, data.len);
|
||||
SHA256_Final(results, &ctx);
|
||||
|
||||
return wuffs_base__make_bitvec256(
|
||||
wuffs_base__peek_u64be__no_bounds_check(results + 0x18),
|
||||
wuffs_base__peek_u64be__no_bounds_check(results + 0x10),
|
||||
wuffs_base__peek_u64be__no_bounds_check(results + 0x08),
|
||||
wuffs_base__peek_u64be__no_bounds_check(results + 0x00));
|
||||
}
|
||||
@@ -0,0 +1,512 @@
|
||||
// Copyright 2023 The Wuffs Authors.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
//
|
||||
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
|
||||
// ----------------
|
||||
|
||||
/*
|
||||
This test program is typically run indirectly, by the "wuffs test" or "wuffs
|
||||
bench" commands. These commands take an optional "-mimic" flag to check that
|
||||
Wuffs' output mimics (i.e. exactly matches) other libraries' output, such as
|
||||
giflib for GIF, libpng for PNG, etc.
|
||||
|
||||
To manually run this test:
|
||||
|
||||
for CC in clang gcc; do
|
||||
$CC -std=c99 -Wall -Werror sha256.c && ./a.out
|
||||
rm -f a.out
|
||||
done
|
||||
|
||||
Each edition should print "PASS", amongst other information, and exit(0).
|
||||
|
||||
Add the "wuffs mimic cflags" (everything after the colon below) to the C
|
||||
compiler flags (after the .c file) to run the mimic tests.
|
||||
|
||||
To manually run the benchmarks, replace "-Wall -Werror" with "-O3" and replace
|
||||
the first "./a.out" with "./a.out -bench". Combine these changes with the
|
||||
"wuffs mimic cflags" to run the mimic benchmarks.
|
||||
*/
|
||||
|
||||
// ¿ wuffs mimic cflags: -DWUFFS_MIMIC -lcrypto -lssl
|
||||
|
||||
// Wuffs ships as a "single file C library" or "header file library" as per
|
||||
// https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
|
||||
//
|
||||
// To use that single file as a "foo.c"-like implementation, instead of a
|
||||
// "foo.h"-like header, #define WUFFS_IMPLEMENTATION before #include'ing or
|
||||
// compiling it.
|
||||
#define WUFFS_IMPLEMENTATION
|
||||
|
||||
// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of
|
||||
// release/c/etc.c choose which parts of Wuffs to build. That file contains the
|
||||
// entire Wuffs standard library, implementing a variety of codecs and file
|
||||
// formats. Without this macro definition, an optimizing compiler or linker may
|
||||
// very well discard Wuffs code for unused codecs, but listing the Wuffs
|
||||
// modules we use makes that process explicit. Preprocessing means that such
|
||||
// code simply isn't compiled.
|
||||
#define WUFFS_CONFIG__MODULES
|
||||
#define WUFFS_CONFIG__MODULE__BASE
|
||||
#define WUFFS_CONFIG__MODULE__SHA256
|
||||
|
||||
// If building this program in an environment that doesn't easily accommodate
|
||||
// relative includes, you can use the script/inline-c-relative-includes.go
|
||||
// program to generate a stand-alone C file.
|
||||
#include "../../../release/c/wuffs-unsupported-snapshot.c"
|
||||
#include "../testlib/testlib.c"
|
||||
#ifdef WUFFS_MIMIC
|
||||
#include "../mimiclib/openssl.c"
|
||||
#endif
|
||||
|
||||
// ---------------- Golden Tests
|
||||
|
||||
golden_test g_sha256_midsummer_gt = {
|
||||
.src_filename = "test/data/midsummer.txt",
|
||||
};
|
||||
|
||||
golden_test g_sha256_pi_gt = {
|
||||
.src_filename = "test/data/pi.txt",
|
||||
};
|
||||
|
||||
// ---------------- SHA256 Tests
|
||||
|
||||
const char* //
|
||||
test_wuffs_sha256_interface() {
|
||||
CHECK_FOCUS(__func__);
|
||||
wuffs_sha256__hasher h;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_sha256__hasher__initialize(
|
||||
&h, sizeof h, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
return do_test__wuffs_base__hasher_bitvec256(
|
||||
wuffs_sha256__hasher__upcast_as__wuffs_base__hasher_bitvec256(&h),
|
||||
"test/data/hat.lossy.webp", 0, SIZE_MAX,
|
||||
wuffs_base__make_bitvec256(0x5CC50E1942D6F258, 0x6AB8300CEABA7095,
|
||||
0x204081787511F1A3, 0xC3E4E8E405B501CB));
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_sha256_golden() {
|
||||
CHECK_FOCUS(__func__);
|
||||
|
||||
struct {
|
||||
const char* filename;
|
||||
// The want values are determined by script/checksum.go.
|
||||
wuffs_base__bitvec256 want;
|
||||
} test_cases[] = {
|
||||
{
|
||||
.filename = "test/data/hat.bmp",
|
||||
.want = wuffs_base__make_bitvec256(
|
||||
0x2FC725BA7661C777, 0x5D80DB0568DB9741, 0x14CE2B683B211925,
|
||||
0x0EE3A9C0B94EBD3E),
|
||||
},
|
||||
{
|
||||
.filename = "test/data/hat.gif",
|
||||
.want = wuffs_base__make_bitvec256(
|
||||
0x64E368566B47BA08, 0xF37522D2D09BF24A, 0x483A2E527CC031B0,
|
||||
0xDA46A35274A6B3DB),
|
||||
},
|
||||
{
|
||||
.filename = "test/data/hat.jpeg",
|
||||
.want = wuffs_base__make_bitvec256(
|
||||
0x2C6B9551F7574AB3, 0x7486DECA160CA57C, 0x50F1B82175229C03,
|
||||
0x6085C5A688495233),
|
||||
},
|
||||
{
|
||||
.filename = "test/data/hat.lossless.webp",
|
||||
.want = wuffs_base__make_bitvec256(
|
||||
0x7AC2F1DC78F9AC80, 0xCC1142375132C3C2, 0x311B3C16A251A65E,
|
||||
0xD91429191B532107),
|
||||
},
|
||||
{
|
||||
.filename = "test/data/hat.lossy.webp",
|
||||
.want = wuffs_base__make_bitvec256(
|
||||
0x5CC50E1942D6F258, 0x6AB8300CEABA7095, 0x204081787511F1A3,
|
||||
0xC3E4E8E405B501CB),
|
||||
},
|
||||
{
|
||||
.filename = "test/data/hat.png",
|
||||
.want = wuffs_base__make_bitvec256(
|
||||
0x23958198999B6D59, 0x2DF493278110663A, 0x7A1BDBCAE77A1D75,
|
||||
0xD3F360AF629B5780),
|
||||
},
|
||||
{
|
||||
.filename = "test/data/hat.tiff",
|
||||
.want = wuffs_base__make_bitvec256(
|
||||
0xFAC8637F04EC2392, 0x373D5F707D803B99, 0x852E5F5F54D5BBD0,
|
||||
0xF44307C419C5F9BB),
|
||||
},
|
||||
};
|
||||
|
||||
for (size_t tc = 0; tc < WUFFS_TESTLIB_ARRAY_SIZE(test_cases); tc++) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file(&src, test_cases[tc].filename));
|
||||
|
||||
for (int j = 0; j < 2; j++) {
|
||||
wuffs_sha256__hasher checksum;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_sha256__hasher__initialize(
|
||||
&checksum, sizeof checksum, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
|
||||
wuffs_base__bitvec256 have = wuffs_base__make_bitvec256(0u, 0u, 0u, 0u);
|
||||
size_t num_fragments = 0;
|
||||
size_t num_bytes = 0;
|
||||
do {
|
||||
wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){
|
||||
.ptr = src.data.ptr + num_bytes,
|
||||
.len = src.meta.wi - num_bytes,
|
||||
});
|
||||
size_t limit = 101 + 103 * num_fragments;
|
||||
if ((j > 0) && (data.len > limit)) {
|
||||
data.len = limit;
|
||||
}
|
||||
have = wuffs_sha256__hasher__update_bitvec256(&checksum, data);
|
||||
num_fragments++;
|
||||
num_bytes += data.len;
|
||||
} while (num_bytes < src.meta.wi);
|
||||
|
||||
if ((have.elements_u64[0] != test_cases[tc].want.elements_u64[0]) ||
|
||||
(have.elements_u64[1] != test_cases[tc].want.elements_u64[1]) ||
|
||||
(have.elements_u64[2] != test_cases[tc].want.elements_u64[2]) ||
|
||||
(have.elements_u64[3] != test_cases[tc].want.elements_u64[3])) {
|
||||
RETURN_FAIL(
|
||||
"tc=%zu, j=%d, filename=\"%s\": " //
|
||||
"have 0x%016" PRIX64 "_%016" PRIX64 //
|
||||
"_%016" PRIX64 "_%016" PRIX64 //
|
||||
", want 0x%016" PRIX64 "_%016" PRIX64 //
|
||||
"_%016" PRIX64 "_%016" PRIX64, //
|
||||
tc, j, test_cases[tc].filename, //
|
||||
have.elements_u64[3], have.elements_u64[2], //
|
||||
have.elements_u64[1], have.elements_u64[0], //
|
||||
test_cases[tc].want.elements_u64[3], //
|
||||
test_cases[tc].want.elements_u64[2], //
|
||||
test_cases[tc].want.elements_u64[1], //
|
||||
test_cases[tc].want.elements_u64[0]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
do_test_xxxxx_sha256_pi(bool mimic) {
|
||||
const char* digits =
|
||||
"3."
|
||||
"141592653589793238462643383279502884197169399375105820974944592307816406"
|
||||
"2862089986280348253421170";
|
||||
if (strlen(digits) != 99) {
|
||||
RETURN_FAIL("strlen(digits): have %d, want 99", (int)(strlen(digits)));
|
||||
}
|
||||
|
||||
// The want values are determined by script/checksum.go.
|
||||
//
|
||||
// wants[(4*i) .. ((4*i)+4)] is the checksum of the first i bytes of the
|
||||
// digits string.
|
||||
uint64_t wants[400] = {
|
||||
0xA495991B7852B855, 0x27AE41E4649B934C, 0x9AFBF4C8996FB924,
|
||||
0xE3B0C44298FC1C14, 0x640B7E4729B49FCE, 0x16B72230967DE01F,
|
||||
0x60CE05C1DECFE3AD, 0x4E07408562BEDB8B, 0x614E6AB3B84FA55C,
|
||||
0xD208FA9C2FAFD974, 0x9BD88B9F5D1962D3, 0x267C23695B6E8FC2,
|
||||
0xF9E34E60E3AE4F44, 0xF59FCAAF3A56B538, 0xA8D86E4F33294BE0,
|
||||
0x35EFC6DED4E13F29, 0x7EE6614143500215, 0x7107CA98B0A6C242,
|
||||
0xD6698EA1047F5C0A, 0x2EFFF1261C25D94D, 0x00EC68941F27440C,
|
||||
0x038F6515DC7AD2A2, 0x02A4C5061F8AD16C, 0xA4F7BA76DB1A09F4,
|
||||
0x3A3A1DD8934D1958, 0xCE872F8C370A08DC, 0xF91001FCB6DAB28B,
|
||||
0x4E25F49BC91285E1, 0x527E79D0A3035852, 0xCC0BF86F2A60ED7E,
|
||||
0x9C8D5AB452E8B69B, 0xC0740DD25C9DE39B, 0x5D827521BB8D54DF,
|
||||
0x0C44B4C673812078, 0x0A05F1DE66EE555F, 0x8C954CD9B6C8F818,
|
||||
0x2FC3A26B33A91CD8, 0x2AF07CC393025875, 0xFF121FED87539C49,
|
||||
0x8721D1333B764926, 0xA4CD30C8355943FD, 0x4481071EAFEDEB1E,
|
||||
0x19B8C4ECE54CA63D, 0xCAAC67952F8CD5C1, 0xD21560096807F0CB,
|
||||
0xD2D991AF41C5EF75, 0x7FB2FADEB54168EC, 0x3DEC3E77C7B4AE98,
|
||||
0xFEEF53EFE3CBEE09, 0x7C1533C0CB71A163, 0x612F6D5C2BA2B291,
|
||||
0x330548C742A7C77A, 0xAA3566FE98696357, 0x5C595BAB01FDBDFB,
|
||||
0xB3150FCE2878C94A, 0x32FA47541DA9C49E, 0x8A2BAD94F28B1D20,
|
||||
0x423A5FB1BBFF501E, 0xE9F3784E332A1CCA, 0x1F0960C3EF5338A9,
|
||||
0x0CCCEEC918ED7221, 0xF989C8334DAABE36, 0xA6983AEDD3CAD63F,
|
||||
0x1564E00B0413DB17, 0xFAE59D87E444EA39, 0x76DDEB33198A342C,
|
||||
0x07E4D2A1F7B2225A, 0xB9A283FF2DBC461A, 0x71263158DFFB4E87,
|
||||
0x1DA33E2623A69F0A, 0x0D28F3CC44E9A624, 0xF0A1B7875844C3AE,
|
||||
0x21FBDC5793903EB6, 0x1192B6E4BDEC029C, 0x280ABB25EE957ACB,
|
||||
0xF983F1F5CF4BD0F5, 0x8F8DA51908599678, 0x8BF1794930B31D48,
|
||||
0xE035C38FE2581543, 0x99B340ACCCD6137D, 0x76610E7F8041E29D,
|
||||
0x79C81D3CF596E134, 0xB5E234BF4F2E2F2F, 0xA630621B389E0269,
|
||||
0xA32BEE851AA8195F, 0x1916D3919A37F28B, 0x52BD93F5CF2BB1C9,
|
||||
0x203A83F7BC429000, 0xB941961D7FD0DC88, 0x52AE42D747CC9B7F,
|
||||
0x779C702B13086F27, 0x2C40420C10F6C5C9, 0x89E082DA67E7A2BA,
|
||||
0xD62C06AE3B1262D5, 0x4E0846AEFE097B34, 0x5E6DED4E901BE009,
|
||||
0x9A74E9A524DEF058, 0x13FA1A8D6184DE71, 0x1BEDE46B96346B8E,
|
||||
0x8BFE4F313A316226, 0x0D2B653DA3F00458, 0x676C5640EC523D07,
|
||||
0xDA7B1A41CCAE7D4E, 0x641FB4D8D2D13726, 0xCEE611F144692B66,
|
||||
0x987643879977A1BD, 0xFB1904FC6EE0D915, 0x70FE652365FEDCF9,
|
||||
0x124A7D6202DE83FC, 0x137C66C93DD8A735, 0x4A43DA05BCD32DBA,
|
||||
0x6E172C87859B68E3, 0xD909261806A23376, 0x71DCC0C5DB9810FE,
|
||||
0x1743C2DA282BE204, 0xE574568E07C2F447, 0x47004C6705CF1330,
|
||||
0x189F8C3D310C9189, 0xFFBB604311CBA061, 0x57C45B1D54E9293D,
|
||||
0x407FD98EA2EC9790, 0xA3A1BA2CAD658AEF, 0xE177F3D9A301E214,
|
||||
0xEBF75EB10D6B8225, 0x9449C881047FEF89, 0x345EAEF124098DFF,
|
||||
0x76293F79FA5D6837, 0xBA81CC1276BFF143, 0x8194DA38905F2A76,
|
||||
0x57496BFA62C36212, 0x5CC7F80FCA76488B, 0x27F6EF06C05A6667,
|
||||
0x859A911428426908, 0xAC839788AD1E3AFE, 0xBBCF0E62C9C98465,
|
||||
0x16C99E22FE8F336D, 0x7944DCB715D2B48E, 0x6D500BA806F21FED,
|
||||
0xE2C0783E3EA9F6BE, 0xAD95772328B63AA4, 0x9F2DAA9DD934B738,
|
||||
0x19B67552963DBA24, 0x4AA889C916C78EEC, 0xE183CB786F7D0225,
|
||||
0x8204624FB1DF4072, 0x1C52B79198588F75, 0x5215491F588E9061,
|
||||
0xC0ECB4BF497B3D24, 0xA3DDCF951C863B90, 0x3DC34E03715D1E86,
|
||||
0x93C7003309B2B16D, 0xDB8DC55940E6D405, 0x22A674F0A5C51BEE,
|
||||
0xB9CC42BE352273A4, 0x5288081DC7BE6307, 0x3ABFFE72285284CB,
|
||||
0xB03A58DF3811A955, 0x4D937AB0E3F28BC7, 0xFF1260C7907EBD92,
|
||||
0xEA012389BB29FCFA, 0xA6F634F7B0A91D90, 0xA1C732F0466BA190,
|
||||
0x1694A93FA04F924F, 0x7A68A298FBBE78F8, 0x688784515705B894,
|
||||
0x7BF3B2235A9BFCCF, 0x3A8D7B10D3E16143, 0xBEA09BF0EBEC453C,
|
||||
0x7A964C634DF35A00, 0xA578BC3FB1805216, 0x22511DCBA44BE006,
|
||||
0x473CF801B7E7DC82, 0x2E61B3D57F5A6400, 0xECFA2730978ECD31,
|
||||
0x4D76B0F79873109D, 0xA5E570AA856BEFC9, 0x85D50A9055BCC917,
|
||||
0x09B71ACFE36EC46A, 0xB7219D64858B1D1B, 0x6322E0AEA4762644,
|
||||
0x6110A33948746949, 0xA3834380FA84B98C, 0x416827D9BD10517B,
|
||||
0x205191477BA5E2D4, 0x8583927ED0D61E42, 0xF23C26620985246C,
|
||||
0x463FA0BD48E2D9CD, 0x5BE1E31786234856, 0x076B608F1F16EC54,
|
||||
0xFCF291E7DE66100D, 0x027B9593BE686708, 0xF7ECCC236C2F031F,
|
||||
0x101C24CB8038FFA2, 0x36FBD8565EE584ED, 0x981E43EE73218C77,
|
||||
0xE99B6E19BF8CE8DA, 0x5A45E8D434AD96C8, 0x949668B5F689B688,
|
||||
0x2596516D1350B71E, 0x6739DB9427BB8C02, 0x8031B2D3C446DD6E,
|
||||
0x4C2224CC1742F920, 0x59093F03EDBA8CD1, 0x7CB4BB75F9E08F1A,
|
||||
0x6B64AEB9CD1CDFF5, 0x2CA127A0C57C6D6C, 0xE1D9E0F0471EB1AC,
|
||||
0x3A335F3D7180856D, 0xD87D65A08487BF82, 0x07864D342C10C819,
|
||||
0x511BF7E38AF42BAE, 0x8B5D843EC502DA3B, 0x80125447E4888B8F,
|
||||
0xA1CC69B692DEA1B2, 0xDDD2B9DB35EEFC4E, 0x49F11DA1947B362E,
|
||||
0x34E40280999D3EA6, 0xA491F7A67A19442E, 0x38CD84D6A14D87F1,
|
||||
0xD3A19502C9450B5F, 0xDF47D72860C62910, 0xB29D464603F6E8F0,
|
||||
0x82F22502D37F5561, 0x4B4450DC4DC1583D, 0x85BADFAFE321525E,
|
||||
0x8296939672321D16, 0x36E12D7A4AB1B08A, 0x860650B802184FD4,
|
||||
0xE94462C6B55C3FF6, 0xE83FED74E65B3EDD, 0x3EE9B1254D10432D,
|
||||
0x78E5956D6BC70090, 0xF6F0EB6D1E334F56, 0xD7452F3FB84E4A36,
|
||||
0x6B6356F7826A9DD1, 0xF8B38562F8AF7F5A, 0x83442AE9FE5BE79B,
|
||||
0x9B6E82F6BCF031AB, 0xF36FDF177673476D, 0x112E1F92164E0E52,
|
||||
0x0BFA74605FB8A9B8, 0x48E45F150E86DEC8, 0xC4BA24790041D453,
|
||||
0x9AA2B91B81053FC2, 0x2A7A944B1AF44A23, 0x4A471FF96E24FDB7,
|
||||
0x9A2C561F8A2401C2, 0xA7AF4303D32EF538, 0xF6D40B18E4846693,
|
||||
0xF73C7D03097E2A85, 0x5963AAAC8B2E391A, 0x2326CF3AD8A24949,
|
||||
0x2955AA4CFD0955B0, 0xEFB503670B6B1CDA, 0x8F36DD3C25A09004,
|
||||
0x72C73ED09101189B, 0xE48C7DBF4C345FFA, 0xF465188486D12732,
|
||||
0x8F7191F537DC3023, 0xD76FBBE816AB8193, 0x78971FF1C5759434,
|
||||
0x9EBB4D1E515EE18A, 0x9F34BC53A2BEACEF, 0xA0DA75B06F9F8EA6,
|
||||
0x38E11C269938E34C, 0x47ADCCF552546D6D, 0x4728ED1535C94B4A,
|
||||
0xEC794468363C2E0E, 0x2938E9D38B388722, 0x2DC07DBB29AF4947,
|
||||
0x1E3B4531213FFBA2, 0x957E8DCC3E00727C, 0xD6C75341415F04D6,
|
||||
0xE336F0579666B64F, 0x1BA3345394F98EB3, 0x375B0F6C5B15DD3D,
|
||||
0xE04DB04888B4380D, 0xF83213CF696EE88C, 0x9B31BCE678AD6B18,
|
||||
0xF8EFC9964ADE38E4, 0xBC2004109A0E3AFA, 0xFAF1EA27888B1A3C,
|
||||
0x5E98EAF21609A0A7, 0x118C1DB41DA78E81, 0x86C4619A31B85BFC,
|
||||
0x5F8C9067ACAA4269, 0xF0B267621ACC79EA, 0x9C6050C66D54D3BC,
|
||||
0x24818E3F7A769CBD, 0x2250FA7C3FCB1CBB, 0xB61B7A8E81ED778D,
|
||||
0x4538060EB1141D17, 0xA221626CF97D97CB, 0x8A7723D63091967E,
|
||||
0x080F04C095C14517, 0x323E944917F9EB93, 0xA3EF852EDF53A001,
|
||||
0xA4353F820201EE29, 0x4F73E39FEE8BDBFE, 0xF0ACAAA72D2B62F7,
|
||||
0x1BE147496E7750CA, 0x91189876D80EDE4C, 0x3389F591EE806FBB,
|
||||
0x7C74F4B2303DAD0D, 0x5FBECE9186741846, 0xB04B9AE381183FAE,
|
||||
0xEE6D1C39B794CE62, 0x9016FB0579FA9402, 0x97EC8D2C65EA43B8,
|
||||
0xF2D37ED8E008422A, 0xA88DFD8B0F3AAB89, 0xD7CF6CDF34BFD209,
|
||||
0xE3628B3721931FDB, 0x0C451B3E3B436D15, 0x239BB072E5B34E41,
|
||||
0x3DC51A97B5A940C1, 0xAC0161A0DA84D53B, 0x345394823D66FC62,
|
||||
0x1B7F7E176A836AEE, 0x6612B6D3AFB30CA8, 0x01C47C26E7B2CC00,
|
||||
0x043B730599D20260, 0x3F9E463CB7C946B2, 0x4A8DAAEBFB336D43,
|
||||
0xF9B617983070ED60, 0x9AF2AF0BA91EA0D7, 0x0AC44EF9103AE372,
|
||||
0x8B66DBF1D2C5E991, 0xC3B16BB058908557, 0xBD8240471D86C144,
|
||||
0x3E2C14E27BC64098, 0xDDCD99498E58F066, 0xE388E41366082790,
|
||||
0xA63D08B8AF4977D9, 0x0BCF499AFA092637, 0xDBB0A064FFA9E303,
|
||||
0xBD45DDD5BA1477EE, 0xB8F750B4D84076E9, 0x3A535BB3BDE3D3D9,
|
||||
0x9525F2A6EE6F38D3, 0x6CDF53C189D3E726, 0x538AB825624B96DD,
|
||||
0x730DE4A6B79DD8B1, 0x51B74D121690D957, 0x8E3E7626617E0B24,
|
||||
0xC44263402923D601, 0xD0530C69581EF7EF, 0xBA6C3F80FCF5DB55,
|
||||
0x4B7E7C204C8ACD97, 0xB0E7053FD43FACD4, 0xED5F518F302EFD69,
|
||||
0x1624AE47324832FC, 0x7F17547B953914AD, 0x525C47949C18BCEA,
|
||||
0x313955A415351A58, 0x307E18AD60ED4B54, 0xB03344E911DF01D6,
|
||||
0x20C38803D44CF9CD, 0xDDB3956944628B64, 0x11A5DEA12D3DB3EC,
|
||||
0x593659D66BC87815, 0xE5AF653BAE6F1869, 0xF47815E9DE6A716E,
|
||||
0x2508DCD62F17EAD9, 0x64A61858259ED57B, 0xFDAAE31E9178B455,
|
||||
0x266008D2BEBD6ECC, 0x01A7BC2FBD4F1FF1, 0x75D074C7FE629A1D,
|
||||
0x726F46CB272A92A1, 0x217F12238920FE7A, 0x99A0B1A4A8EB311C,
|
||||
0x48E5BD99F0A5CDDE, 0x0CC73F9EFFEA61E2, 0x142BADB1DCD76ED6,
|
||||
0x6B6696D8D16E993E, 0xF73977B29D3332B2, 0x3532EC396A463E8D,
|
||||
0x08485AF320F6EF4A, 0x3BE313B7F5F5462D, 0xC7EDDABFD3A52DEC,
|
||||
0xE3C0AE2EE970AB95, 0x59DACF3BB3C53E2B, 0x3E135135F158E39C,
|
||||
0x4B25757F5EF36523, 0xDCE58EEC3A4E8B12, 0x27A7532E62B6147F,
|
||||
0xAA5D819242B97295, 0x815E4E99C89F0115, 0x90AD0232C1A6A145,
|
||||
0xE6FC5968AC8C1AFE, 0xB24A3CF866116B23, 0x3134AEF31EA120B2,
|
||||
0xFBD01F222353BCFA, 0xC5C85E7FE228C34A, 0x385ABA08C78A08FB,
|
||||
0x28EEFFB4F741E27D, 0x10F7CA989D8373CE, 0x99E053B9784F8535,
|
||||
0x350A957CEEA5AA93,
|
||||
};
|
||||
|
||||
for (int i = 0; i < 100; i++) {
|
||||
wuffs_base__bitvec256 have = wuffs_base__make_bitvec256(0u, 0u, 0u, 0u);
|
||||
wuffs_base__slice_u8 data = ((wuffs_base__slice_u8){
|
||||
.ptr = (uint8_t*)(digits),
|
||||
.len = (size_t)(i),
|
||||
});
|
||||
|
||||
if (mimic) {
|
||||
have = mimic_sha256_one_shot_checksum_bitvec256(data);
|
||||
|
||||
} else {
|
||||
wuffs_sha256__hasher checksum;
|
||||
CHECK_STATUS("initialize",
|
||||
wuffs_sha256__hasher__initialize(
|
||||
&checksum, sizeof checksum, WUFFS_VERSION,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED));
|
||||
have = wuffs_sha256__hasher__update_bitvec256(&checksum, data);
|
||||
}
|
||||
|
||||
if ((have.elements_u64[0] != wants[(4 * i) + 0]) ||
|
||||
(have.elements_u64[1] != wants[(4 * i) + 1]) ||
|
||||
(have.elements_u64[2] != wants[(4 * i) + 2]) ||
|
||||
(have.elements_u64[3] != wants[(4 * i) + 3])) {
|
||||
RETURN_FAIL(
|
||||
"i=%d: " //
|
||||
"have 0x%016" PRIX64 "_%016" PRIX64 //
|
||||
"_%016" PRIX64 "_%016" PRIX64 //
|
||||
", want 0x%016" PRIX64 "_%016" PRIX64 //
|
||||
"_%016" PRIX64 "_%016" PRIX64, //
|
||||
i, //
|
||||
have.elements_u64[3], have.elements_u64[2], //
|
||||
have.elements_u64[1], have.elements_u64[0], //
|
||||
wants[(4 * i) + 3], wants[(4 * i) + 2], //
|
||||
wants[(4 * i) + 1], wants[(4 * i) + 0]);
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
test_wuffs_sha256_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_xxxxx_sha256_pi(false);
|
||||
}
|
||||
|
||||
// ---------------- Mimic Tests
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* //
|
||||
test_mimic_sha256_pi() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_test_xxxxx_sha256_pi(true);
|
||||
}
|
||||
|
||||
#endif // WUFFS_MIMIC
|
||||
|
||||
// ---------------- SHA256 Benches
|
||||
|
||||
wuffs_base__bitvec256 g_wuffs_sha256_unused_bitvec256;
|
||||
|
||||
const char* //
|
||||
wuffs_bench_sha256(wuffs_base__io_buffer* dst,
|
||||
wuffs_base__io_buffer* src,
|
||||
uint32_t wuffs_initialize_flags,
|
||||
uint64_t wlimit,
|
||||
uint64_t rlimit) {
|
||||
uint64_t len = src->meta.wi - src->meta.ri;
|
||||
if (rlimit) {
|
||||
len = wuffs_base__u64__min(len, rlimit);
|
||||
}
|
||||
wuffs_sha256__hasher checksum = {0};
|
||||
CHECK_STATUS("initialize", wuffs_sha256__hasher__initialize(
|
||||
&checksum, sizeof checksum, WUFFS_VERSION,
|
||||
wuffs_initialize_flags));
|
||||
g_wuffs_sha256_unused_bitvec256 = wuffs_sha256__hasher__update_bitvec256(
|
||||
&checksum, ((wuffs_base__slice_u8){
|
||||
.ptr = src->data.ptr + src->meta.ri,
|
||||
.len = len,
|
||||
}));
|
||||
src->meta.ri += len;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
bench_wuffs_sha256_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_bench_sha256,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_src,
|
||||
&g_sha256_midsummer_gt, UINT64_MAX, UINT64_MAX, 100);
|
||||
}
|
||||
|
||||
const char* //
|
||||
bench_wuffs_sha256_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
wuffs_bench_sha256,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_src,
|
||||
&g_sha256_pi_gt, UINT64_MAX, UINT64_MAX, 10);
|
||||
}
|
||||
|
||||
// ---------------- Mimic Benches
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
const char* //
|
||||
bench_mimic_sha256_10k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
mimic_bench_sha256,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_src,
|
||||
&g_sha256_midsummer_gt, UINT64_MAX, UINT64_MAX, 100);
|
||||
}
|
||||
|
||||
const char* //
|
||||
bench_mimic_sha256_100k() {
|
||||
CHECK_FOCUS(__func__);
|
||||
return do_bench_io_buffers(
|
||||
mimic_bench_sha256,
|
||||
WUFFS_INITIALIZE__LEAVE_INTERNAL_BUFFERS_UNINITIALIZED, tcounter_src,
|
||||
&g_sha256_pi_gt, UINT64_MAX, UINT64_MAX, 10);
|
||||
}
|
||||
|
||||
#endif // WUFFS_MIMIC
|
||||
|
||||
// ---------------- Manifest
|
||||
|
||||
proc g_tests[] = {
|
||||
|
||||
test_wuffs_sha256_golden,
|
||||
test_wuffs_sha256_interface,
|
||||
test_wuffs_sha256_pi,
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
test_mimic_sha256_pi,
|
||||
|
||||
#endif // WUFFS_MIMIC
|
||||
|
||||
NULL,
|
||||
};
|
||||
|
||||
proc g_benches[] = {
|
||||
|
||||
bench_wuffs_sha256_10k,
|
||||
bench_wuffs_sha256_100k,
|
||||
|
||||
#ifdef WUFFS_MIMIC
|
||||
|
||||
bench_mimic_sha256_10k,
|
||||
bench_mimic_sha256_100k,
|
||||
|
||||
#endif // WUFFS_MIMIC
|
||||
|
||||
NULL,
|
||||
};
|
||||
|
||||
int //
|
||||
main(int argc, char** argv) {
|
||||
g_proc_package_name = "std/sha256";
|
||||
return test_main(argc, argv, g_tests, g_benches);
|
||||
}
|
||||
@@ -1184,6 +1184,37 @@ do_test__wuffs_base__hasher_u64(wuffs_base__hasher_u64* b,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
do_test__wuffs_base__hasher_bitvec256(wuffs_base__hasher_bitvec256* b,
|
||||
const char* src_filename,
|
||||
size_t src_ri,
|
||||
size_t src_wi,
|
||||
wuffs_base__bitvec256 want) {
|
||||
wuffs_base__io_buffer src = ((wuffs_base__io_buffer){
|
||||
.data = g_src_slice_u8,
|
||||
});
|
||||
CHECK_STRING(read_file_fragment(&src, src_filename, src_ri, src_wi));
|
||||
wuffs_base__bitvec256 have = wuffs_base__hasher_bitvec256__update_bitvec256(
|
||||
b, ((wuffs_base__slice_u8){
|
||||
.ptr = (uint8_t*)(src.data.ptr + src.meta.ri),
|
||||
.len = (size_t)(src.meta.wi - src.meta.ri),
|
||||
}));
|
||||
if ((have.elements_u64[0] != want.elements_u64[0]) ||
|
||||
(have.elements_u64[1] != want.elements_u64[1]) ||
|
||||
(have.elements_u64[2] != want.elements_u64[2]) ||
|
||||
(have.elements_u64[3] != want.elements_u64[3])) {
|
||||
RETURN_FAIL("have 0x%016" PRIX64 "_%016" PRIX64 //
|
||||
"_%016" PRIX64 "_%016" PRIX64 //
|
||||
", want 0x%016" PRIX64 "_%016" PRIX64 //
|
||||
"_%016" PRIX64 "_%016" PRIX64, //
|
||||
have.elements_u64[3], have.elements_u64[2], //
|
||||
have.elements_u64[1], have.elements_u64[0], //
|
||||
want.elements_u64[3], want.elements_u64[2], //
|
||||
want.elements_u64[1], want.elements_u64[0]);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
const char* //
|
||||
do_test__wuffs_base__image_decoder(
|
||||
wuffs_base__image_decoder* b,
|
||||
|
||||
Reference in new issue
Block a user