From e9b7c66a541636e72659fbfcc9a3f20a85f2bee8 Mon Sep 17 00:00:00 2001 From: skallweitNV <64953474+skallweitNV@users.noreply.github.com> Date: Fri, 2 Dec 2022 16:34:53 +0100 Subject: Cleanup crypto utilities (#2549) * Consolidate crypto functions into single module * Migrate rest of code to new crypto module * Fix name conflict --- source/core/slang-crypto.cpp | 603 +++++++++++++++++++++++++++++++++++++ source/core/slang-crypto.h | 184 +++++++++++ source/core/slang-digest-builder.h | 117 ------- source/core/slang-digest-util.cpp | 66 ---- source/core/slang-digest-util.h | 43 --- source/core/slang-md5.cpp | 297 ------------------ source/core/slang-md5.h | 63 ---- 7 files changed, 787 insertions(+), 586 deletions(-) create mode 100644 source/core/slang-crypto.cpp create mode 100644 source/core/slang-crypto.h delete mode 100644 source/core/slang-digest-builder.h delete mode 100644 source/core/slang-digest-util.cpp delete mode 100644 source/core/slang-digest-util.h delete mode 100644 source/core/slang-md5.cpp delete mode 100644 source/core/slang-md5.h (limited to 'source/core') diff --git a/source/core/slang-crypto.cpp b/source/core/slang-crypto.cpp new file mode 100644 index 000000000..ece7b01e9 --- /dev/null +++ b/source/core/slang-crypto.cpp @@ -0,0 +1,603 @@ +/* + * MD5 implementation is based on: + * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 + * Original file header is at the bottom of this file. + * + * SHA1 implementation is based on: + * https://github.com/983/SHA1 + * Original LICENSE is at the bottom of this file. + */ + +#include "slang-crypto.h" +#include "../core/slang-char-util.h" + +namespace Slang +{ + +// DigestUtil + +/*static*/ String DigestUtil::digestToString(const void* digest, SlangInt digestSize) +{ + SLANG_ASSERT(digest && digestSize >= 0); + + static const char* hex = "0123456789abcdef"; + + String str; + const uint8_t* data = reinterpret_cast(digest); + for (SlangInt i = 0; i < digestSize; ++i) + { + str.append(hex[data[i] >> 4]); + str.append(hex[data[i] & 0xf]); + } + return str; +} + +/*static*/ bool DigestUtil::stringToDigest(const char* str, SlangInt strLength, void *digest, SlangInt digestSize) +{ + SLANG_ASSERT(str && strLength >= 0 && digest && digestSize >= 0); + + if (strLength != digestSize * 2) + { + ::memset(digest, 0, digestSize); + return false; + } + + uint8_t* data = reinterpret_cast(digest); + for (SlangInt i = 0; i < digestSize; ++i) + { + int upper = CharUtil::getHexDigitValue(str[i * 2]); + int lower = CharUtil::getHexDigitValue(str[i * 2 + 1]); + if (upper == -1 || lower == -1) + { + ::memset(digest, 0, digestSize); + return false; + } + data[i] = uint8_t(lower | upper << 4);; + } + + return true; +} + +// MD5 + +MD5::MD5() +{ + init(); +} + +void MD5::init() +{ + m_lo = 0; + m_hi = 0; + m_a = 0x67452301; + m_b = 0xefcdab89; + m_c = 0x98badcfe; + m_d = 0x10325476; +} + +void MD5::update(const void* data, SlangInt size) +{ + uint32_t saved_lo; + SlangInt used, available; + + saved_lo = m_lo; + if ((m_lo = (saved_lo + size) & 0x1fffffff) < saved_lo) + m_hi++; + m_hi += (uint32_t)size >> 29; + + used = saved_lo & 0x3f; + + if (used) { + available = 64 - used; + + if (size < available) { + ::memcpy(&m_buffer[used], data, size); + return; + } + + ::memcpy(&m_buffer[used], data, available); + data = reinterpret_cast(data) + available; + size -= available; + processBlock(m_buffer, 64); + } + + if (size >= 64) { + data = processBlock(data, size & ~(SlangInt)0x3f); + size &= 0x3f; + } + + ::memcpy(m_buffer, data, size); +} + +MD5::Digest MD5::finalize() +{ + uint32_t used, available; + + used = m_lo & 0x3f; + + m_buffer[used++] = 0x80; + + available = 64 - used; + + if (available < 8) { + ::memset(&m_buffer[used], 0, available); + processBlock(m_buffer, 64); + used = 0; + available = 64; + } + + ::memset(&m_buffer[used], 0, available - 8); + + m_lo <<= 3; + + m_buffer[56] = uint8_t(m_lo); + m_buffer[57] = uint8_t(m_lo >> 8); + m_buffer[58] = uint8_t(m_lo >> 16); + m_buffer[59] = uint8_t(m_lo >> 24); + m_buffer[60] = uint8_t(m_hi); + m_buffer[61] = uint8_t(m_hi >> 8); + m_buffer[62] = uint8_t(m_hi >> 16); + m_buffer[63] = uint8_t(m_hi >> 24); + + processBlock(m_buffer, 64); + + Digest digest; + digest.data[0] = m_a; + digest.data[1] = m_b; + digest.data[2] = m_c; + digest.data[3] = m_d; + + return digest; +} + +/* + * The basic MD5 functions. + * + * F and G are optimized compared to their RFC 1321 definitions for + * architectures that lack an AND-NOT instruction, just like in Colin Plumb's + * implementation. + */ +#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) +#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y)))) +#define H(x, y, z) (((x) ^ (y)) ^ (z)) +#define H2(x, y, z) ((x) ^ ((y) ^ (z))) +#define I(x, y, z) ((y) ^ ((x) | ~(z))) + +/* + * The MD5 transformation for all four rounds. + */ +#define STEP(f, a, b, c, d, x, t, s) \ + (a) += f((b), (c), (d)) + (x) + (t); \ + (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \ + (a) += (b); + +/* + * SET reads 4 input bytes in little-endian byte order and stores them in a + * properly aligned word in host byte order. + */ +#define SET(n) \ + (m_block[(n)] = \ + (uint32_t)ptr[(n) * 4] | \ + ((uint32_t)ptr[(n) * 4 + 1] << 8) | \ + ((uint32_t)ptr[(n) * 4 + 2] << 16) | \ + ((uint32_t)ptr[(n) * 4 + 3] << 24)) +#define GET(n) \ + (m_block[(n)]) + +const void* MD5::processBlock(const void* data, SlangInt size) +{ + const unsigned char* ptr; + ptr = (const unsigned char*)data; + + uint32_t a = m_a; + uint32_t b = m_b; + uint32_t c = m_c; + uint32_t d = m_d; + + do + { + uint32_t saved_a = a; + uint32_t saved_b = b; + uint32_t saved_c = c; + uint32_t saved_d = d; + + /* Round 1 */ + STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7) + STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12) + STEP(F, c, d, a, b, SET(2), 0x242070db, 17) + STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22) + STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7) + STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12) + STEP(F, c, d, a, b, SET(6), 0xa8304613, 17) + STEP(F, b, c, d, a, SET(7), 0xfd469501, 22) + STEP(F, a, b, c, d, SET(8), 0x698098d8, 7) + STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12) + STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17) + STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22) + STEP(F, a, b, c, d, SET(12), 0x6b901122, 7) + STEP(F, d, a, b, c, SET(13), 0xfd987193, 12) + STEP(F, c, d, a, b, SET(14), 0xa679438e, 17) + STEP(F, b, c, d, a, SET(15), 0x49b40821, 22) + + /* Round 2 */ + STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5) + STEP(G, d, a, b, c, GET(6), 0xc040b340, 9) + STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14) + STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20) + STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5) + STEP(G, d, a, b, c, GET(10), 0x02441453, 9) + STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14) + STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20) + STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5) + STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9) + STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14) + STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20) + STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5) + STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9) + STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14) + STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20) + + /* Round 3 */ + STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4) + STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11) + STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16) + STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23) + STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4) + STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11) + STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16) + STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23) + STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4) + STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11) + STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16) + STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23) + STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4) + STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11) + STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16) + STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23) + + /* Round 4 */ + STEP(I, a, b, c, d, GET(0), 0xf4292244, 6) + STEP(I, d, a, b, c, GET(7), 0x432aff97, 10) + STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15) + STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21) + STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6) + STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10) + STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15) + STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21) + STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6) + STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10) + STEP(I, c, d, a, b, GET(6), 0xa3014314, 15) + STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21) + STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6) + STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10) + STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15) + STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21) + + a += saved_a; + b += saved_b; + c += saved_c; + d += saved_d; + + ptr += 64; + } + while (size -= 64); + + m_a = a; + m_b = b; + m_c = c; + m_d = d; + + return ptr; +} + +#undef F +#undef G +#undef H +#undef H2 +#undef I +#undef STEP +#undef SET +#undef GET + +/*static*/ MD5::Digest MD5::compute(const void* data, SlangInt size) +{ + MD5 md5; + md5.update(data, size); + return md5.finalize(); +} + +// SHA1 + +SHA1::SHA1() +{ + init(); +} + +void SHA1::init() +{ + m_index = 0; + m_bits = 0; + m_state[0] = 0x67452301; + m_state[1] = 0xefcdab89; + m_state[2] = 0x98badcfe; + m_state[3] = 0x10325476; + m_state[4] = 0xc3d2e1f0; +} + +void SHA1::update(const void* data, SlangInt len) +{ + if (!data || len <= 0) + { + return; + } + + const uint8_t* ptr = reinterpret_cast(data); + + // Fill up buffer if not full. + while (len > 0 && m_index != 0) + { + addByte(*ptr++); + m_bits += 8; + len--; + } + + // Process full blocks. + while (len >= sizeof(m_buf)) + { + processBlock(ptr); + ptr += sizeof(m_buf); + len -= sizeof(m_buf); + m_bits += sizeof(m_buf) * 8; + } + + // Process remaining bytes. + while (len > 0) + { + addByte(*ptr++); + m_bits += 8; + len--; + } +} + +SHA1::Digest SHA1::finalize() +{ + // Finalize with 0x80, some zero padding and the length in bits. + addByte(0x80); + while (m_index % 64 != 56) + { + addByte(0); + } + for (int i = 7; i >= 0; --i) + { + addByte(uint8_t(m_bits >> i * 8)); + } + + Digest digest; + uint8_t* data = reinterpret_cast(digest.data); + for (int i = 0; i < 5; i++) + { + for (int j = 3; j >= 0; j--) + { + data[i * 4 + j] = (m_state[i] >> ((3 - j) * 8)) & 0xff; + } + } + + return digest; +} + +void SHA1::addByte(uint8_t byte) +{ + m_buf[m_index++] = byte; + + if (m_index >= sizeof(m_buf)) + { + m_index = 0; + processBlock(m_buf); + } +} + +void SHA1::processBlock(const uint8_t* ptr) +{ + auto rol32 = [](uint32_t x, uint32_t n) + { + return (x << n) | (x >> (32 - n)); + }; + + auto makeWord = [](const uint8_t* p) + { + return ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16) | ((uint32_t)p[2] << 8) | (uint32_t)p[3]; + }; + + const uint32_t c0 = 0x5a827999; + const uint32_t c1 = 0x6ed9eba1; + const uint32_t c2 = 0x8f1bbcdc; + const uint32_t c3 = 0xca62c1d6; + + uint32_t a = m_state[0]; + uint32_t b = m_state[1]; + uint32_t c = m_state[2]; + uint32_t d = m_state[3]; + uint32_t e = m_state[4]; + + uint32_t w[16]; + + for (size_t i = 0; i < 16; i++) + { + w[i] = makeWord(ptr + i * 4); + } + +#define SHA1_LOAD(i) w[i&15] = rol32(w[(i + 13) & 15] ^ w[(i + 8) & 15] ^ w[(i + 2) & 15] ^ w[i & 15], 1); +#define SHA1_ROUND_0(v,u,x,y,z,i) z += ((u & (x ^ y)) ^ y) + w[i & 15] + c0 + rol32(v, 5); u = rol32(u, 30); +#define SHA1_ROUND_1(v,u,x,y,z,i) SHA1_LOAD(i) z += ((u & (x ^ y)) ^ y) + w[i & 15] + c0 + rol32(v, 5); u = rol32(u, 30); +#define SHA1_ROUND_2(v,u,x,y,z,i) SHA1_LOAD(i) z += (u ^ x ^ y) + w[i & 15] + c1 + rol32(v, 5); u = rol32(u, 30); +#define SHA1_ROUND_3(v,u,x,y,z,i) SHA1_LOAD(i) z += (((u | x) & y) | (u & x)) + w[i & 15] + c2 + rol32(v, 5); u = rol32(u, 30); +#define SHA1_ROUND_4(v,u,x,y,z,i) SHA1_LOAD(i) z += (u ^ x ^ y) + w[i & 15] + c3 + rol32(v, 5); u = rol32(u, 30); + + SHA1_ROUND_0(a, b, c, d, e, 0); + SHA1_ROUND_0(e, a, b, c, d, 1); + SHA1_ROUND_0(d, e, a, b, c, 2); + SHA1_ROUND_0(c, d, e, a, b, 3); + SHA1_ROUND_0(b, c, d, e, a, 4); + SHA1_ROUND_0(a, b, c, d, e, 5); + SHA1_ROUND_0(e, a, b, c, d, 6); + SHA1_ROUND_0(d, e, a, b, c, 7); + SHA1_ROUND_0(c, d, e, a, b, 8); + SHA1_ROUND_0(b, c, d, e, a, 9); + SHA1_ROUND_0(a, b, c, d, e, 10); + SHA1_ROUND_0(e, a, b, c, d, 11); + SHA1_ROUND_0(d, e, a, b, c, 12); + SHA1_ROUND_0(c, d, e, a, b, 13); + SHA1_ROUND_0(b, c, d, e, a, 14); + SHA1_ROUND_0(a, b, c, d, e, 15); + SHA1_ROUND_1(e, a, b, c, d, 16); + SHA1_ROUND_1(d, e, a, b, c, 17); + SHA1_ROUND_1(c, d, e, a, b, 18); + SHA1_ROUND_1(b, c, d, e, a, 19); + SHA1_ROUND_2(a, b, c, d, e, 20); + SHA1_ROUND_2(e, a, b, c, d, 21); + SHA1_ROUND_2(d, e, a, b, c, 22); + SHA1_ROUND_2(c, d, e, a, b, 23); + SHA1_ROUND_2(b, c, d, e, a, 24); + SHA1_ROUND_2(a, b, c, d, e, 25); + SHA1_ROUND_2(e, a, b, c, d, 26); + SHA1_ROUND_2(d, e, a, b, c, 27); + SHA1_ROUND_2(c, d, e, a, b, 28); + SHA1_ROUND_2(b, c, d, e, a, 29); + SHA1_ROUND_2(a, b, c, d, e, 30); + SHA1_ROUND_2(e, a, b, c, d, 31); + SHA1_ROUND_2(d, e, a, b, c, 32); + SHA1_ROUND_2(c, d, e, a, b, 33); + SHA1_ROUND_2(b, c, d, e, a, 34); + SHA1_ROUND_2(a, b, c, d, e, 35); + SHA1_ROUND_2(e, a, b, c, d, 36); + SHA1_ROUND_2(d, e, a, b, c, 37); + SHA1_ROUND_2(c, d, e, a, b, 38); + SHA1_ROUND_2(b, c, d, e, a, 39); + SHA1_ROUND_3(a, b, c, d, e, 40); + SHA1_ROUND_3(e, a, b, c, d, 41); + SHA1_ROUND_3(d, e, a, b, c, 42); + SHA1_ROUND_3(c, d, e, a, b, 43); + SHA1_ROUND_3(b, c, d, e, a, 44); + SHA1_ROUND_3(a, b, c, d, e, 45); + SHA1_ROUND_3(e, a, b, c, d, 46); + SHA1_ROUND_3(d, e, a, b, c, 47); + SHA1_ROUND_3(c, d, e, a, b, 48); + SHA1_ROUND_3(b, c, d, e, a, 49); + SHA1_ROUND_3(a, b, c, d, e, 50); + SHA1_ROUND_3(e, a, b, c, d, 51); + SHA1_ROUND_3(d, e, a, b, c, 52); + SHA1_ROUND_3(c, d, e, a, b, 53); + SHA1_ROUND_3(b, c, d, e, a, 54); + SHA1_ROUND_3(a, b, c, d, e, 55); + SHA1_ROUND_3(e, a, b, c, d, 56); + SHA1_ROUND_3(d, e, a, b, c, 57); + SHA1_ROUND_3(c, d, e, a, b, 58); + SHA1_ROUND_3(b, c, d, e, a, 59); + SHA1_ROUND_4(a, b, c, d, e, 60); + SHA1_ROUND_4(e, a, b, c, d, 61); + SHA1_ROUND_4(d, e, a, b, c, 62); + SHA1_ROUND_4(c, d, e, a, b, 63); + SHA1_ROUND_4(b, c, d, e, a, 64); + SHA1_ROUND_4(a, b, c, d, e, 65); + SHA1_ROUND_4(e, a, b, c, d, 66); + SHA1_ROUND_4(d, e, a, b, c, 67); + SHA1_ROUND_4(c, d, e, a, b, 68); + SHA1_ROUND_4(b, c, d, e, a, 69); + SHA1_ROUND_4(a, b, c, d, e, 70); + SHA1_ROUND_4(e, a, b, c, d, 71); + SHA1_ROUND_4(d, e, a, b, c, 72); + SHA1_ROUND_4(c, d, e, a, b, 73); + SHA1_ROUND_4(b, c, d, e, a, 74); + SHA1_ROUND_4(a, b, c, d, e, 75); + SHA1_ROUND_4(e, a, b, c, d, 76); + SHA1_ROUND_4(d, e, a, b, c, 77); + SHA1_ROUND_4(c, d, e, a, b, 78); + SHA1_ROUND_4(b, c, d, e, a, 79); + +#undef SHA1_LOAD +#undef SHA1_ROUND_0 +#undef SHA1_ROUND_1 +#undef SHA1_ROUND_2 +#undef SHA1_ROUND_3 +#undef SHA1_ROUND_4 + + m_state[0] += a; + m_state[1] += b; + m_state[2] += c; + m_state[3] += d; + m_state[4] += e; +} + +/* static */SHA1::Digest SHA1::compute(const void* data, SlangInt size) +{ + SHA1 sha1; + sha1.update(data, size); + return sha1.finalize(); +} + +} + + +/* + * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. + * MD5 Message-Digest Algorithm (RFC 1321). + * + * Homepage: + * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 + * + * Author: + * Alexander Peslyak, better known as Solar Designer + * + * This software was written by Alexander Peslyak in 2001. No copyright is + * claimed, and the software is hereby placed in the public domain. + * In case this attempt to disclaim copyright and place the software in the + * public domain is deemed null and void, then the software is + * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the + * general public under the following terms: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted. + * + * There's ABSOLUTELY NO WARRANTY, express or implied. + * + * (This is a heavily cut-down "BSD license".) + * + * This differs from Colin Plumb's older public domain implementation in that + * no exactly 32-bit integer data type is required (any 32-bit or wider + * unsigned integer data type will do), there's no compile-time endianness + * configuration, and the function prototypes match OpenSSL's. No code from + * Colin Plumb's implementation has been reused; this comment merely compares + * the properties of the two independent implementations. + * + * The primary goals of this implementation are portability and ease of use. + * It is meant to be fast, but not as fast as possible. Some known + * optimizations are not included to reduce source code size and avoid + * compile-time configuration. + */ + +/* + * This is free and unencumbered software released into the public domain. + * + * Anyone is free to copy, modify, publish, use, compile, sell, or + * distribute this software, either in source code form or as a compiled + * binary, for any purpose, commercial or non-commercial, and by any + * means. + * + * In jurisdictions that recognize copyright laws, the author or authors + * of this software dedicate any and all copyright interest in the + * software to the public domain. We make this dedication for the benefit + * of the public at large and to the detriment of our heirs and + * successors. We intend this dedication to be an overt act of + * relinquishment in perpetuity of all present and future rights to this + * software under copyright law. + * + * 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 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. + * + * For more information, please refer to + */ diff --git a/source/core/slang-crypto.h b/source/core/slang-crypto.h new file mode 100644 index 000000000..0df02201c --- /dev/null +++ b/source/core/slang-crypto.h @@ -0,0 +1,184 @@ +#pragma once +#include "../../slang.h" +#include "../core/slang-string.h" +#include "../core/slang-blob.h" +#include "../core/slang-list.h" + +namespace Slang +{ + struct DigestUtil + { + /// Convert a binary digest to a string (lower-case hexadecimal). + /// Returned string is double the length of the digest. + static String digestToString(const void* digest, SlangInt digestSize); + + /// Convert a string to a binary digest. + /// Expects a string of double the length of the digest size in hexadecimal format. + /// Sets the digest to all zeros if the string is invalid. + /// Returns true if string was converted successfully. + static bool stringToDigest(const char* str, SlangInt strLength, void *digest, SlangInt digestSize); + }; + + /// Represents a hash digest. Only sizes of multiple of 4 are supported. + template + class HashDigest + { + public: + static_assert(N % 4 == 0, "size must be multiple of 4"); + uint32_t data[N / 4] = { 0 }; + + HashDigest() = default; + + HashDigest(const char* str) + { + DigestUtil::stringToDigest(str, ::strlen(str), data, N); + } + + HashDigest(const String& str) + { + DigestUtil::stringToDigest(str.getBuffer(), str.getLength(), data, N); + } + + HashDigest(const UnownedStringSlice& str) + { + DigestUtil::stringToDigest(str.begin(), str.getLength(), data, N); + } + + HashDigest(ISlangBlob* blob) + { + if (blob->getBufferSize() == N) + { + ::memcpy(data, blob->getBufferPointer(), N); + } + } + + String toString() const + { + return DigestUtil::digestToString(data, N); + } + + ComPtr toBlob() const + { + return RawBlob::create(data, sizeof(data)); + } + + bool operator==(const HashDigest& other) const + { + return ::memcmp(data, other.data, sizeof(data)) == 0; + } + + bool operator!=(const HashDigest& other) const + { + return !(*this == other); + } + + uint32_t getHashCode() const + { + return data[0]; + } + }; + + /// MD5 hash generator implementing https://www.ietf.org/rfc/rfc1321.txt + class MD5 + { + public: + using Digest = HashDigest<16>; + + MD5(); + + void init(); + void update(const void* data, SlangInt size); + Digest finalize(); + + static Digest compute(const void* data, SlangInt size); + + private: + const void* processBlock(const void* data, SlangInt size); + + uint32_t m_lo, m_hi; + uint32_t m_a, m_b, m_c, m_d; + uint32_t m_block[16]; + uint8_t m_buffer[64]; + }; + + /// SHA1 hash generator implementing https://www.ietf.org/rfc/rfc3174.txt + class SHA1 + { + public: + using Digest = HashDigest<20>; + + SHA1(); + + void init(); + void update(const void* data, SlangInt size); + Digest finalize(); + + static Digest compute(const void* data, SlangInt size); + + private: + void addByte(uint8_t x); + void processBlock(const uint8_t* ptr); + + uint32_t m_index; + uint64_t m_bits; + uint32_t m_state[5]; + uint8_t m_buf[64]; + }; + + // Helper class for building hashes. + template + struct DigestBuilder + { + public: + void append(const void* data, SlangInt size) + { + m_hash.update(data, size); + } + + template::value || std::is_enum::value, int>::type = 0> + void append(const T value) + { + append(&value, sizeof(T)); + } + + void append(const String& str) + { + append(str.getBuffer(), str.getLength()); + } + + void append(const StringSlice& str) + { + append(str.begin(), str.getLength()); + } + + void append(const UnownedStringSlice& str) + { + append(str.begin(), str.getLength()); + } + + void append(ISlangBlob* blob) + { + append(blob->getBufferPointer(), blob->getBufferSize()); + } + + template + void append(const HashDigest& digest) + { + append(digest.data, sizeof(digest.data)); + } + + template::value, int>::type = 0> + void append(const List& list) + { + append(list.getBuffer(), list.getCount() * sizeof(T)); + } + + typename Hash::Digest finalize() + { + return m_hash.finalize(); + } + + private: + Hash m_hash; + }; +} diff --git a/source/core/slang-digest-builder.h b/source/core/slang-digest-builder.h deleted file mode 100644 index c613b2239..000000000 --- a/source/core/slang-digest-builder.h +++ /dev/null @@ -1,117 +0,0 @@ -#pragma once -#include "slang-md5.h" -#include "../../slang.h" -#include "../core/slang-string.h" -#include "../core/slang-list.h" - -namespace Slang -{ - using slang::Digest; - - // Wrapper struct that holds objects necessary for hashing. - struct DigestBuilder - { - public: - DigestBuilder() - { - hashGen.init(&context); - } - - template::value || std::is_enum::value, int>::type = 0> - DigestBuilder& operator<<(const T value) - { - append(value); - return *this; - } - - DigestBuilder& operator<<(const String& str) - { - append(str); - return *this; - } - - DigestBuilder& operator<<(const StringSlice& str) - { - append(str); - return *this; - } - - DigestBuilder& operator<<(const UnownedStringSlice& str) - { - append(str); - return *this; - } - - DigestBuilder& operator<<(ISlangBlob* blob) - { - append(blob); - return *this; - } - - DigestBuilder& operator<<(const slang::Digest& digest) - { - append(digest); - return *this; - } - - template::value, int>::type = 0> - DigestBuilder& operator<<(const List& list) - { - append(list); - return *this; - } - - void append(const void* data, SlangInt size) - { - hashGen.update(&context, data, size); - } - - template::value || std::is_enum::value, int>::type = 0> - void append(const T value) - { - append(&value, sizeof(T)); - } - - void append(const String& str) - { - append(str.getBuffer(), str.getLength()); - } - - void append(const StringSlice& str) - { - append(str.begin(), str.getLength()); - } - - void append(const UnownedStringSlice& str) - { - append(str.begin(), str.getLength()); - } - - void append(ISlangBlob* blob) - { - append(blob->getBufferPointer(), blob->getBufferSize()); - } - - void append(const slang::Digest& digest) - { - append(&digest, sizeof(digest)); - } - - template::value, int>::type = 0> - void append(const List& list) - { - append(list.getBuffer(), list.getCount() * sizeof(T)); - } - - Digest finalize() - { - Digest hash; - hashGen.finalize(&context, &hash); - return hash; - } - - private: - MD5HashGen hashGen; - MD5Context context; - }; -} diff --git a/source/core/slang-digest-util.cpp b/source/core/slang-digest-util.cpp deleted file mode 100644 index 8252dce65..000000000 --- a/source/core/slang-digest-util.cpp +++ /dev/null @@ -1,66 +0,0 @@ -// string-digest-util.cpp -#include "slang-digest-util.h" - -#include "../core/slang-basic.h" -#include "../core/slang-digest-builder.h" -#include "../core/slang-md5.h" -#include "../core/slang-char-util.h" - -namespace Slang -{ - -/*static*/ Digest DigestUtil::computeDigestForStringSlice(UnownedStringSlice text) -{ - DigestBuilder builder; - builder.append(text); - return builder.finalize(); -} - -/*static*/ Digest DigestUtil::combine(const Digest& digestA, const Digest& digestB) -{ - DigestBuilder builder; - builder.append(digestA); - builder.append(digestB); - return builder.finalize(); -} - -/*static*/ String DigestUtil::toString(const Digest& digest) -{ - StringBuilder hashString; - - uint8_t* uint8Hash = (uint8_t*)digest.values; - - for (Index i = 0; i < 16; ++i) - { - auto hashSegmentString = String(uint8Hash[i], 16); - - if (hashSegmentString.getLength() == 1) - { - hashString.append("0"); - } - hashString.append(hashSegmentString.getBuffer()); - } - - return hashString; -} - -/*static*/ Digest DigestUtil::fromString(UnownedStringSlice hashString) -{ - uint8_t uint8Hash[16]; - - // When the hash is converted to a String, ReverseInternalAscii is called - // at the very end. Since there is no way to get a char* for hashString to pass - // to ReverseInternalAscii to flip the string back, we instead loop starting from - // the end and work backwards towards the beginning. - for (Index i = 0; i < 16; i++) - { - uint8Hash[i] = (uint8_t)CharUtil::getHexDigitValue(hashString[i * 2]) * 16 - + (uint8_t)CharUtil::getHexDigitValue(hashString[i * 2 + 1]); - } - - Digest digest; - memcpy(digest.values, uint8Hash, 16); - return digest; -} - -} diff --git a/source/core/slang-digest-util.h b/source/core/slang-digest-util.h deleted file mode 100644 index 1e272fd5e..000000000 --- a/source/core/slang-digest-util.h +++ /dev/null @@ -1,43 +0,0 @@ -// slang-digest-utils.h - Utility functions specifically designed to be used with slang::Digest -#pragma once -#include "../../slang.h" -#include "slang-string.h" - -namespace Slang -{ - using slang::Digest; - - struct DigestUtil - { - // Compute the digest for an UnownedStringSlice - static Digest computeDigestForStringSlice(UnownedStringSlice text); - - // Combines the two provided digests. - static Digest combine(const Digest& digestA, const Digest& digestB); - - // Returns the hash stored in digest as a String. - static String toString(const Digest& digest); - - // Returns the hash represented by hashString as a Digest. - static Digest fromString(UnownedStringSlice hashString); - }; - - inline StringBuilder& operator<<(StringBuilder& sb, const Digest& d) - { - // Must cast to uint8_t* first in order to correctly account for - // endianness. - uint8_t* uint8Hash = (uint8_t*)d.values; - - for (Index i = 0; i < 16; ++i) - { - int hashSegment = uint8Hash[i]; - // Check if we need to append a leading zero. - if (hashSegment < 16) - { - sb << "0"; - } - sb.append(hashSegment, 16); - } - return sb; - } -} diff --git a/source/core/slang-md5.cpp b/source/core/slang-md5.cpp deleted file mode 100644 index 049ebae95..000000000 --- a/source/core/slang-md5.cpp +++ /dev/null @@ -1,297 +0,0 @@ -/* - * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. - * MD5 Message-Digest Algorithm (RFC 1321). - * - * Homepage: - * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 - * - * Author: - * Alexander Peslyak, better known as Solar Designer - * - * This software was written by Alexander Peslyak in 2001. No copyright is - * claimed, and the software is hereby placed in the public domain. - * In case this attempt to disclaim copyright and place the software in the - * public domain is deemed null and void, then the software is - * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the - * general public under the following terms: - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted. - * - * There's ABSOLUTELY NO WARRANTY, express or implied. - * - * (This is a heavily cut-down "BSD license".) - * - * This differs from Colin Plumb's older public domain implementation in that - * no exactly 32-bit integer data type is required (any 32-bit or wider - * unsigned integer data type will do), there's no compile-time endianness - * configuration, and the function prototypes match OpenSSL's. No code from - * Colin Plumb's implementation has been reused; this comment merely compares - * the properties of the two independent implementations. - * - * The primary goals of this implementation are portability and ease of use. - * It is meant to be fast, but not as fast as possible. Some known - * optimizations are not included to reduce source code size and avoid - * compile-time configuration. - */ - -#ifndef HAVE_OPENSSL - -#include - -#include "slang-md5.h" - -namespace Slang -{ - /* - * The basic MD5 functions. - * - * F and G are optimized compared to their RFC 1321 definitions for - * architectures that lack an AND-NOT instruction, just like in Colin Plumb's - * implementation. - */ - #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z)))) - #define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y)))) - #define H(x, y, z) (((x) ^ (y)) ^ (z)) - #define H2(x, y, z) ((x) ^ ((y) ^ (z))) - #define I(x, y, z) ((y) ^ ((x) | ~(z))) - - /* - * The MD5 transformation for all four rounds. - */ - #define STEP(f, a, b, c, d, x, t, s) \ - (a) += f((b), (c), (d)) + (x) + (t); \ - (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \ - (a) += (b); - - /* - * SET reads 4 input bytes in little-endian byte order and stores them in a - * properly aligned word in host byte order. - * - * The check for little-endian architectures that tolerate unaligned memory - * accesses is just an optimization. Nothing will break if it fails to detect - * a suitable architecture. - * - * Unfortunately, this optimization may be a C strict aliasing rules violation - * if the caller's data buffer has effective type that cannot be aliased by - * MD5_u32plus. In practice, this problem may occur if these MD5 routines are - * inlined into a calling function, or with future and dangerously advanced - * link-time optimizations. For the time being, keeping these MD5 routines in - * their own translation unit avoids the problem. - */ - #if defined(__i386__) || defined(__x86_64__) || defined(__vax__) - #define SET(n) \ - (*(MD5_u32plus *)&ptr[(n) * 4]) - #define GET(n) \ - SET(n) - #else - #define SET(n) \ - (ctx->block[(n)] = \ - (MD5_u32plus)ptr[(n) * 4] | \ - ((MD5_u32plus)ptr[(n) * 4 + 1] << 8) | \ - ((MD5_u32plus)ptr[(n) * 4 + 2] << 16) | \ - ((MD5_u32plus)ptr[(n) * 4 + 3] << 24)) - #define GET(n) \ - (ctx->block[(n)]) - #endif - - /* - * This processes one or more 64-byte data blocks, but does NOT update the bit - * counters. There are no alignment requirements. - */ - /*static*/const void* MD5HashGen::body(MD5Context* ctx, const void* data, SlangInt size) - { - const unsigned char* ptr; - MD5_u32plus a, b, c, d; - MD5_u32plus saved_a, saved_b, saved_c, saved_d; - - ptr = (const unsigned char*)data; - - a = ctx->a; - b = ctx->b; - c = ctx->c; - d = ctx->d; - - do { - saved_a = a; - saved_b = b; - saved_c = c; - saved_d = d; - - /* Round 1 */ - STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7) - STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12) - STEP(F, c, d, a, b, SET(2), 0x242070db, 17) - STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22) - STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7) - STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12) - STEP(F, c, d, a, b, SET(6), 0xa8304613, 17) - STEP(F, b, c, d, a, SET(7), 0xfd469501, 22) - STEP(F, a, b, c, d, SET(8), 0x698098d8, 7) - STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12) - STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17) - STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22) - STEP(F, a, b, c, d, SET(12), 0x6b901122, 7) - STEP(F, d, a, b, c, SET(13), 0xfd987193, 12) - STEP(F, c, d, a, b, SET(14), 0xa679438e, 17) - STEP(F, b, c, d, a, SET(15), 0x49b40821, 22) - - /* Round 2 */ - STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5) - STEP(G, d, a, b, c, GET(6), 0xc040b340, 9) - STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14) - STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20) - STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5) - STEP(G, d, a, b, c, GET(10), 0x02441453, 9) - STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14) - STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20) - STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5) - STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9) - STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14) - STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20) - STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5) - STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9) - STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14) - STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20) - - /* Round 3 */ - STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4) - STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11) - STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16) - STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23) - STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4) - STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11) - STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16) - STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23) - STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4) - STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11) - STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16) - STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23) - STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4) - STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11) - STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16) - STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23) - - /* Round 4 */ - STEP(I, a, b, c, d, GET(0), 0xf4292244, 6) - STEP(I, d, a, b, c, GET(7), 0x432aff97, 10) - STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15) - STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21) - STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6) - STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10) - STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15) - STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21) - STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6) - STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10) - STEP(I, c, d, a, b, GET(6), 0xa3014314, 15) - STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21) - STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6) - STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10) - STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15) - STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21) - - a += saved_a; - b += saved_b; - c += saved_c; - d += saved_d; - - ptr += 64; - } while (size -= 64); - - ctx->a = a; - ctx->b = b; - ctx->c = c; - ctx->d = d; - - return ptr; - } - - void MD5HashGen::init(MD5Context* ctx) - { - ctx->a = 0x67452301; - ctx->b = 0xefcdab89; - ctx->c = 0x98badcfe; - ctx->d = 0x10325476; - - ctx->lo = 0; - ctx->hi = 0; - } - - void MD5HashGen::update(MD5Context* ctx, const void* data, SlangInt size) - { - MD5_u32plus saved_lo; - SlangInt used, available; - - saved_lo = ctx->lo; - if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo) - ctx->hi++; - ctx->hi += (MD5_u32plus)size >> 29; - - used = saved_lo & 0x3f; - - if (used) { - available = 64 - used; - - if (size < available) { - memcpy(&ctx->buffer[used], data, size); - return; - } - - memcpy(&ctx->buffer[used], data, available); - data = (const unsigned char*)data + available; - size -= available; - body(ctx, ctx->buffer, 64); - } - - if (size >= 64) { - data = body(ctx, data, size & ~(SlangInt)0x3f); - size &= 0x3f; - } - - memcpy(ctx->buffer, data, size); - } - - #define OUTUINT(dst, src) \ - (dst)[0] = (uint32_t)src; \ - - #define OUTCHAR(dst, src) \ - (dst)[0] = (unsigned char)(src); \ - (dst)[1] = (unsigned char)((src) >> 8); \ - (dst)[2] = (unsigned char)((src) >> 16); \ - (dst)[3] = (unsigned char)((src) >> 24); - - void MD5HashGen::finalize(MD5Context* ctx, slang::Digest* result) - { - unsigned long used, available; - - used = ctx->lo & 0x3f; - - ctx->buffer[used++] = 0x80; - - available = 64 - used; - - if (available < 8) { - memset(&ctx->buffer[used], 0, available); - body(ctx, ctx->buffer, 64); - used = 0; - available = 64; - } - - memset(&ctx->buffer[used], 0, available - 8); - - ctx->lo <<= 3; - OUTCHAR(&ctx->buffer[56], ctx->lo) - OUTCHAR(&ctx->buffer[60], ctx->hi) - - body(ctx, ctx->buffer, 64); - - OUTUINT(&result->values[0], ctx->a) - OUTUINT(&result->values[1], ctx->b) - OUTUINT(&result->values[2], ctx->c) - OUTUINT(&result->values[3], ctx->d) - - memset(ctx, 0, sizeof(*ctx)); - } -} - -#endif diff --git a/source/core/slang-md5.h b/source/core/slang-md5.h deleted file mode 100644 index d40102b69..000000000 --- a/source/core/slang-md5.h +++ /dev/null @@ -1,63 +0,0 @@ -/* - * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc. - * MD5 Message-Digest Algorithm (RFC 1321). - * - * Homepage: - * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5 - * - * Author: - * Alexander Peslyak, better known as Solar Designer - * - * This software was written by Alexander Peslyak in 2001. No copyright is - * claimed, and the software is hereby placed in the public domain. - * In case this attempt to disclaim copyright and place the software in the - * public domain is deemed null and void, then the software is - * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the - * general public under the following terms: - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted. - * - * There's ABSOLUTELY NO WARRANTY, express or implied. - * - * See md5.c for more information. - */ - -#ifdef HAVE_OPENSSL -#include -#elif !defined(_MD5_H) -#define _MD5_H - -#pragma once -#include "../../slang.h" -#include "../core/slang-string.h" -#include "../core/slang-list.h" - -namespace Slang -{ - /* Any 32-bit or wider unsigned integer data type will do */ - typedef uint32_t MD5_u32plus; - - struct MD5Context - { - MD5_u32plus lo, hi; - MD5_u32plus a, b, c, d; - unsigned char buffer[64]; - MD5_u32plus block[16]; - }; - - class MD5HashGen - { - public: - void init(MD5Context* ctx); - - void update(MD5Context* ctx, const void* data, SlangInt size); - - void finalize(MD5Context* ctx, slang::Digest* result); - - private: - static const void* body(MD5Context* ctx, const void* data, SlangInt size); - }; -} - -#endif -- cgit v1.2.3