diff options
Diffstat (limited to '3rdparty/plibsys/src/pcryptohash-sha2-256.c')
| -rw-r--r-- | 3rdparty/plibsys/src/pcryptohash-sha2-256.c | 286 |
1 files changed, 286 insertions, 0 deletions
diff --git a/3rdparty/plibsys/src/pcryptohash-sha2-256.c b/3rdparty/plibsys/src/pcryptohash-sha2-256.c new file mode 100644 index 0000000..29bb0ba --- /dev/null +++ b/3rdparty/plibsys/src/pcryptohash-sha2-256.c @@ -0,0 +1,286 @@ +/* + * The MIT License + * + * Copyright (C) 2016 Alexander Saprykin <saprykin.spb@gmail.com> + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * 'Software'), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. + * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY + * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include <string.h> +#include <stdlib.h> + +#include "pmem.h" +#include "pcryptohash-sha2-256.h" + +struct PHashSHA2_256_ { + union buf_ { + puchar buf[64]; + puint32 buf_w[16]; + } buf; + puint32 hash[8]; + + puint32 len_high; + puint32 len_low; + + pboolean is224; +}; + +static const puchar pp_crypto_hash_sha2_256_pad[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +static const puint32 pp_crypto_hash_sha2_256_K[] = { + 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, + 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5, + 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, + 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174, + 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC, + 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA, + 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7, + 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967, + 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13, + 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85, + 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3, + 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070, + 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5, + 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3, + 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208, + 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2 +}; + +static void pp_crypto_hash_sha2_256_swap_bytes (puint32 *data, puint words); +static void pp_crypto_hash_sha2_256_process (PHashSHA2_256 *ctx, const puint32 data[16]); +static PHashSHA2_256 * pp_crypto_hash_sha2_256_new_internal (pboolean is224); + +#define P_SHA2_256_SHR(val, shift) (((val) & 0xFFFFFFFF) >> (shift)) +#define P_SHA2_256_ROTR(val, shift) (P_SHA2_256_SHR(val, shift) | ((val) << (32 - (shift)))) + +#define P_SHA2_256_S0(x) (P_SHA2_256_ROTR (x, 7) ^ P_SHA2_256_ROTR (x, 18) ^ P_SHA2_256_SHR (x, 3)) +#define P_SHA2_256_S1(x) (P_SHA2_256_ROTR (x, 17) ^ P_SHA2_256_ROTR (x, 19) ^ P_SHA2_256_SHR (x, 10)) +#define P_SHA2_256_S2(x) (P_SHA2_256_ROTR (x, 2) ^ P_SHA2_256_ROTR (x, 13) ^ P_SHA2_256_ROTR (x, 22)) +#define P_SHA2_256_S3(x) (P_SHA2_256_ROTR (x, 6) ^ P_SHA2_256_ROTR (x, 11) ^ P_SHA2_256_ROTR (x, 25)) + +#define P_SHA2_256_F0(x, y, z) ((x & y) | (z & (x | y))) +#define P_SHA2_256_F1(x, y, z) (z ^ (x & (y ^ z))) + +#define P_SHA2_256_R(t) \ +( \ + W[t] = P_SHA2_256_S1 (W[t - 2]) + W[t - 7] + \ + P_SHA2_256_S0 (W[t - 15]) + W[t - 16] \ +) + +#define P_SHA2_256_P(a, b, c, d, e, f, g, h, x, K) \ +{ \ + tmp_sum1 = h + P_SHA2_256_S3 (e) + P_SHA2_256_F1 (e, f, g) + K + x; \ + tmp_sum2 = P_SHA2_256_S2 (a) + P_SHA2_256_F0 (a, b, c); \ + d += tmp_sum1; \ + h = tmp_sum1 + tmp_sum2; \ +} + +static void +pp_crypto_hash_sha2_256_swap_bytes (puint32 *data, + puint words) +{ +#ifdef PLIBSYS_IS_BIGENDIAN + P_UNUSED (data); + P_UNUSED (words); +#else + while (words-- > 0) { + *data = PUINT32_TO_BE (*data); + ++data; + } +#endif +} + +static void +pp_crypto_hash_sha2_256_process (PHashSHA2_256 *ctx, + const puint32 data[16]) +{ + puint32 tmp_sum1, tmp_sum2; + puint32 W[64]; + puint32 A[8]; + puint i; + + for (i = 0; i < 8; i++) + A[i] = ctx->hash[i]; + + memcpy (W, data, 64); + + for (i = 0; i < 16; i += 8) { + P_SHA2_256_P (A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i + 0], pp_crypto_hash_sha2_256_K[i + 0]); + P_SHA2_256_P (A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], W[i + 1], pp_crypto_hash_sha2_256_K[i + 1]); + P_SHA2_256_P (A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], W[i + 2], pp_crypto_hash_sha2_256_K[i + 2]); + P_SHA2_256_P (A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], W[i + 3], pp_crypto_hash_sha2_256_K[i + 3]); + P_SHA2_256_P (A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], W[i + 4], pp_crypto_hash_sha2_256_K[i + 4]); + P_SHA2_256_P (A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], W[i + 5], pp_crypto_hash_sha2_256_K[i + 5]); + P_SHA2_256_P (A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], W[i + 6], pp_crypto_hash_sha2_256_K[i + 6]); + P_SHA2_256_P (A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], W[i + 7], pp_crypto_hash_sha2_256_K[i + 7]); + } + + for (i = 16; i < 64; i += 8) { + P_SHA2_256_P (A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], P_SHA2_256_R (i + 0), pp_crypto_hash_sha2_256_K[i + 0]); + P_SHA2_256_P (A[7], A[0], A[1], A[2], A[3], A[4], A[5], A[6], P_SHA2_256_R (i + 1), pp_crypto_hash_sha2_256_K[i + 1]); + P_SHA2_256_P (A[6], A[7], A[0], A[1], A[2], A[3], A[4], A[5], P_SHA2_256_R (i + 2), pp_crypto_hash_sha2_256_K[i + 2]); + P_SHA2_256_P (A[5], A[6], A[7], A[0], A[1], A[2], A[3], A[4], P_SHA2_256_R (i + 3), pp_crypto_hash_sha2_256_K[i + 3]); + P_SHA2_256_P (A[4], A[5], A[6], A[7], A[0], A[1], A[2], A[3], P_SHA2_256_R (i + 4), pp_crypto_hash_sha2_256_K[i + 4]); + P_SHA2_256_P (A[3], A[4], A[5], A[6], A[7], A[0], A[1], A[2], P_SHA2_256_R (i + 5), pp_crypto_hash_sha2_256_K[i + 5]); + P_SHA2_256_P (A[2], A[3], A[4], A[5], A[6], A[7], A[0], A[1], P_SHA2_256_R (i + 6), pp_crypto_hash_sha2_256_K[i + 6]); + P_SHA2_256_P (A[1], A[2], A[3], A[4], A[5], A[6], A[7], A[0], P_SHA2_256_R (i + 7), pp_crypto_hash_sha2_256_K[i + 7]); + } + + for (i = 0; i < 8; i++) + ctx->hash[i] += A[i]; +} + +static PHashSHA2_256 * +pp_crypto_hash_sha2_256_new_internal (pboolean is224) +{ + PHashSHA2_256 *ret; + + if (P_UNLIKELY ((ret = p_malloc0 (sizeof (PHashSHA2_256))) == NULL)) + return NULL; + + ret->is224 = is224; + + p_crypto_hash_sha2_256_reset (ret); + + return ret; +} + +void +p_crypto_hash_sha2_256_reset (PHashSHA2_256 *ctx) +{ + memset (ctx->buf.buf, 0, 64); + + ctx->len_low = 0; + ctx->len_high = 0; + + if (ctx->is224 == FALSE) { + /* SHA2-256 */ + ctx->hash[0] = 0x6A09E667; + ctx->hash[1] = 0xBB67AE85; + ctx->hash[2] = 0x3C6EF372; + ctx->hash[3] = 0xA54FF53A; + ctx->hash[4] = 0x510E527F; + ctx->hash[5] = 0x9B05688C; + ctx->hash[6] = 0x1F83D9AB; + ctx->hash[7] = 0x5BE0CD19; + } else { + /* SHA2-224 */ + ctx->hash[0] = 0xC1059ED8; + ctx->hash[1] = 0x367CD507; + ctx->hash[2] = 0x3070DD17; + ctx->hash[3] = 0xF70E5939; + ctx->hash[4] = 0xFFC00B31; + ctx->hash[5] = 0x68581511; + ctx->hash[6] = 0x64F98FA7; + ctx->hash[7] = 0xBEFA4FA4; + } +} + +PHashSHA2_256 * +p_crypto_hash_sha2_256_new (void) +{ + return pp_crypto_hash_sha2_256_new_internal (FALSE); +} + +PHashSHA2_256 * +p_crypto_hash_sha2_224_new (void) +{ + return pp_crypto_hash_sha2_256_new_internal (TRUE); +} + +void +p_crypto_hash_sha2_256_update (PHashSHA2_256 *ctx, + const puchar *data, + psize len) +{ + puint32 left, to_fill; + + left = ctx->len_low & 0x3F; + to_fill = 64 - left; + + ctx->len_low += (puint32) len; + + if (ctx->len_low < (puint32) len) + ++ctx->len_high; + + if (left && (puint32) len >= to_fill) { + memcpy (ctx->buf.buf + left, data, to_fill); + pp_crypto_hash_sha2_256_swap_bytes (ctx->buf.buf_w, 16); + pp_crypto_hash_sha2_256_process (ctx, ctx->buf.buf_w); + + data += to_fill; + len -= to_fill; + left = 0; + } + + while (len >= 64) { + memcpy (ctx->buf.buf, data, 64); + pp_crypto_hash_sha2_256_swap_bytes (ctx->buf.buf_w, 16); + pp_crypto_hash_sha2_256_process (ctx, ctx->buf.buf_w); + + data += 64; + len -= 64; + } + + if (len > 0) + memcpy (ctx->buf.buf + left, data, len); +} + +void +p_crypto_hash_sha2_256_finish (PHashSHA2_256 *ctx) +{ + puint32 high, low; + pint left, last; + + left = ctx->len_low & 0x3F; + last = (left < 56) ? (56 - left) : (120 - left); + + low = ctx->len_low << 3; + high = ctx->len_high << 3 + | ctx->len_low >> 29; + + if (last > 0) + p_crypto_hash_sha2_256_update (ctx, pp_crypto_hash_sha2_256_pad, (psize) last); + + ctx->buf.buf_w[14] = high; + ctx->buf.buf_w[15] = low; + + pp_crypto_hash_sha2_256_swap_bytes (ctx->buf.buf_w, 14); + pp_crypto_hash_sha2_256_process (ctx, ctx->buf.buf_w); + + pp_crypto_hash_sha2_256_swap_bytes (ctx->hash, ctx->is224 == FALSE ? 8 : 7); +} + +const puchar * +p_crypto_hash_sha2_256_digest (PHashSHA2_256 *ctx) +{ + return (const puchar *) ctx->hash; +} + +void +p_crypto_hash_sha2_256_free (PHashSHA2_256 *ctx) +{ + p_free (ctx); +} |