diff options
Diffstat (limited to 'libparc/parc/security/parc_CryptoHasher.c')
| -rwxr-xr-x | libparc/parc/security/parc_CryptoHasher.c | 530 |
1 files changed, 530 insertions, 0 deletions
diff --git a/libparc/parc/security/parc_CryptoHasher.c b/libparc/parc/security/parc_CryptoHasher.c new file mode 100755 index 00000000..f2c00967 --- /dev/null +++ b/libparc/parc/security/parc_CryptoHasher.c @@ -0,0 +1,530 @@ +/* + * Copyright (c) 2017 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * Implements SHA256, and SHA512 with OpenSSL or Apple's CommonCrypto, depending on platform. + * It all follows the OpenSSL calling conventions: + * CTX_* is the digest's context + * INIT_* initializes the digest + * UPDATE_* updates the digest given a buffer + * FINAL_* finalizes the digest, returning the digest + * LENGTH_* is the byte length of the digest. + * + */ + +#include <config.h> +#include <stdio.h> + +#include <parc/security/parc_CryptoHasher.h> +#include <parc/algol/parc_Buffer.h> +#include <parc/algol/parc_Memory.h> +#include <LongBow/runtime.h> +#include <parc/algol/parc_Object.h> + +#ifdef __APPLE__ +#include <CommonCrypto/CommonDigest.h> + +#define CTX_SHA256 CC_SHA256_CTX +#define INIT_SHA256 CC_SHA256_Init +#define UPDATE_SHA256 CC_SHA256_Update +#define FINAL_SHA256 CC_SHA256_Final +#define LENGTH_SHA256 CC_SHA256_DIGEST_LENGTH + +#define CTX_SHA512 CC_SHA512_CTX +#define INIT_SHA512 CC_SHA512_Init +#define UPDATE_SHA512 CC_SHA512_Update +#define FINAL_SHA512 CC_SHA512_Final +#define LENGTH_SHA512 CC_SHA512_DIGEST_LENGTH + +#else +#include <openssl/sha.h> +#define CTX_SHA256 SHA256_CTX +#define INIT_SHA256 SHA256_Init +#define UPDATE_SHA256 SHA256_Update +#define FINAL_SHA256 SHA256_Final +#define LENGTH_SHA256 SHA256_DIGEST_LENGTH + +#define CTX_SHA512 SHA512_CTX +#define INIT_SHA512 SHA512_Init +#define UPDATE_SHA512 SHA512_Update +#define FINAL_SHA512 SHA512_Final +#define LENGTH_SHA512 SHA512_DIGEST_LENGTH +#endif + +// ------------------------------------------------------------- +// function prototypes for use in the function structures +static void *_sha256_create(void *env); +static int _sha256_init(void *ctx); +static int _sha256_update(void *ctx, const void *buffer, size_t length); +static PARCBuffer *_sha256_finalize(void *ctx); +static void _sha256_destroy(void **ctxPtr); + +static void *_sha512_create(void *env); +static int _sha512_init(void *ctx); +static int _sha512_update(void *ctx, const void *buffer, size_t length); +static PARCBuffer *_sha512_finalize(void *ctx); +static void _sha512_destroy(void **ctxPtr); + +static void *_crc32_create(void *env); +static int _crc32_init(void *ctx); +static int _crc32_update(void *ctx, const void *buffer, size_t length); +static PARCBuffer *_crc32_finalize(void *ctx); +static void _crc32_destroy(void **ctxPtr); +// ------------------------------------------------------------- + +// These are templates for the environments. SHA256 and SHA512 do not +// have a functor_env, all the state is carried in the setup context. + +static PARCCryptoHasherInterface functor_sha256 = { + .functor_env = NULL, + .hasher_setup = _sha256_create, + .hasher_init = _sha256_init, + .hasher_update = _sha256_update, + .hasher_finalize = _sha256_finalize, + .hasher_destroy = _sha256_destroy +}; + +static PARCCryptoHasherInterface functor_sha512 = { + .functor_env = NULL, + .hasher_setup = _sha512_create, + .hasher_init = _sha512_init, + .hasher_update = _sha512_update, + .hasher_finalize = _sha512_finalize, + .hasher_destroy = _sha512_destroy +}; + +static PARCCryptoHasherInterface functor_crc32 = { + .functor_env = NULL, + .hasher_setup = _crc32_create, + .hasher_init = _crc32_init, + .hasher_update = _crc32_update, + .hasher_finalize = _crc32_finalize, + .hasher_destroy = _crc32_destroy +}; + +struct parc_crypto_hasher { + PARCCryptoHashType type; + PARCCryptoHasherInterface functor; + void *hasher_ctx; +}; + +static void +_parcCryptoHasher_FinalRelease(PARCCryptoHasher **hasherP) +{ + PARCCryptoHasher *hasher = (PARCCryptoHasher *) *hasherP; + hasher->functor.hasher_destroy(&(hasher->hasher_ctx)); +} + +parcObject_ExtendPARCObject(PARCCryptoHasher, _parcCryptoHasher_FinalRelease, NULL, NULL, NULL, NULL, NULL, NULL); + +parcObject_ImplementAcquire(parcCryptoHasher, PARCCryptoHasher); + +parcObject_ImplementRelease(parcCryptoHasher, PARCCryptoHasher); + +PARCCryptoHasher * +parcCryptoHasher_Create(PARCCryptoHashType type) +{ + PARCCryptoHasher *hasher = parcObject_CreateInstance(PARCCryptoHasher); + assertNotNull(hasher, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCCryptoHasher)); + + hasher->type = type; + + switch (type) { + case PARCCryptoHashType_SHA256: + hasher->functor = functor_sha256; + break; + + case PARCCryptoHashType_SHA512: + hasher->functor = functor_sha512; + break; + + case PARCCryptoHashType_CRC32C: + hasher->functor = functor_crc32; + break; + + default: + parcMemory_Deallocate((void **) &hasher); + trapIllegalValue(type, "Unknown hasher type: %d", type); + } + + hasher->hasher_ctx = hasher->functor.hasher_setup(hasher->functor.functor_env); + return hasher; +} + +PARCCryptoHasher * +parcCryptoHasher_CustomHasher(PARCCryptoHashType type, PARCCryptoHasherInterface functor) +{ + PARCCryptoHasher *hasher = parcObject_CreateInstance(PARCCryptoHasher); + assertNotNull(hasher, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCCryptoHasher)); + hasher->type = type; + hasher->functor = functor; + hasher->hasher_ctx = hasher->functor.hasher_setup(hasher->functor.functor_env); + return hasher; +} + +/** + * Reset the internal state of the digest to start a new session + * Returns 0 on success, -1 on failure + * + * Example: + * @code + * <#example#> + * @endcode + */ +int +parcCryptoHasher_Init(PARCCryptoHasher *digester) +{ + assertNotNull(digester, "Parameter must be non-null"); + + int success = digester->functor.hasher_init(digester->hasher_ctx); + return (success == 1) ? 0 : -1; +} + +int +parcCryptoHasher_UpdateBytes(PARCCryptoHasher *digester, const void *buffer, size_t length) +{ + assertNotNull(digester, "Parameter must be non-null"); + int success = digester->functor.hasher_update(digester->hasher_ctx, buffer, length); + return (success == 1) ? 0 : -1; +} + +int +parcCryptoHasher_UpdateBuffer(PARCCryptoHasher *digester, const PARCBuffer *buffer) +{ + assertNotNull(digester, "Parameter must be non-null"); + PARCBuffer *buf = parcBuffer_Slice(buffer); + size_t length = parcBuffer_Limit(buf); + void *byteArray = parcBuffer_Overlay(buf, length); + int success = digester->functor.hasher_update(digester->hasher_ctx, byteArray, length); + + parcBuffer_Release(&buf); + return (success == 1) ? 0 : -1; +} + +PARCCryptoHash * +parcCryptoHasher_Finalize(PARCCryptoHasher *digester) +{ + assertNotNull(digester, "Parameter must be non-null"); + PARCBuffer *digestBuffer = digester->functor.hasher_finalize(digester->hasher_ctx); + + if (parcBuffer_Position(digestBuffer) != 0) { + parcBuffer_Flip(digestBuffer); + } + + PARCCryptoHash *parcDigest = parcCryptoHash_Create(digester->type, digestBuffer); + + parcBuffer_Release(&digestBuffer); + return parcDigest; +} + +// =============================================== + +static void * +_sha256_create(void *dummy) +{ + void *ctx = parcMemory_AllocateAndClear(sizeof(CTX_SHA256)); + return ctx; +} + +static int +_sha256_init(void *ctx) +{ + return INIT_SHA256(ctx); +} + +static int +_sha256_update(void *ctx, const void *buffer, size_t length) +{ + return UPDATE_SHA256(ctx, buffer, (unsigned) length); +} + +static PARCBuffer * +_sha256_finalize(void *ctx) +{ + uint8_t buffer[LENGTH_SHA256]; + FINAL_SHA256(buffer, ctx); + + PARCBuffer *output = parcBuffer_Allocate(LENGTH_SHA256); + parcBuffer_PutArray(output, LENGTH_SHA256, buffer); + + return output; +} + +static void +_sha256_destroy(void **ctxPtr) +{ + parcMemory_Deallocate((void **) ctxPtr); + *ctxPtr = NULL; +} + +// =============================================== + +static void * +_sha512_create(void *dummy) +{ + void *ctx = parcMemory_AllocateAndClear(sizeof(CTX_SHA512)); + return ctx; +} + +static int +_sha512_init(void *ctx) +{ + return INIT_SHA512(ctx); +} + +static int +_sha512_update(void *ctx, const void *buffer, size_t length) +{ + return UPDATE_SHA512(ctx, buffer, (unsigned) length); +} + +static PARCBuffer * +_sha512_finalize(void *ctx) +{ + uint8_t buffer[LENGTH_SHA512]; + FINAL_SHA512(buffer, ctx); + + PARCBuffer *output = parcBuffer_Allocate(LENGTH_SHA512); + parcBuffer_PutArray(output, LENGTH_SHA512, buffer); + + return output; +} + +static void +_sha512_destroy(void **ctxPtr) +{ + parcMemory_Deallocate((void **) ctxPtr); + *ctxPtr = NULL; +} + +// ================================================== +// CRC32C Implementation PARCCryptoHasher + +typedef struct crc32c_state { + uint32_t crc32; +} _CRC32CState; + +// ===================================== +// Hardware calculation + +#ifdef __SSE4_2__ +#include <nmmintrin.h> + +#ifdef __x86_64__ +// The length rounded to 8-bytes +#define CRC_ROUNDING_MASK 0xFFFFFFFFFFFFFFF8ULL +#define LARGEST_CRC_INTRINSIC _mm_crc32_u64 +#define CRC_CAST_TYPE uint64_t +#else +// The length rounded to 4-bytes +#define CRC_ROUNDING_MASK 0xFFFFFFFCUL +#define LARGEST_CRC_INTRINSIC _mm_crc32_u32 +#define CRC_CAST_TYPE uint32_t +#endif //__x86_64__ + +static uint32_t +_crc32c_UpdateIntel(uint32_t crc, size_t len, uint8_t p[len]) +{ + size_t blocks = len & CRC_ROUNDING_MASK; + size_t offset = 0; + + while (offset < blocks) { + crc = (uint32_t) LARGEST_CRC_INTRINSIC((CRC_CAST_TYPE) crc, *(CRC_CAST_TYPE *) &p[offset]); + offset += sizeof(CRC_CAST_TYPE); + } + + // now do the last bytes if it was not 8-byte aligned + size_t position = blocks; + while (position < len) { + crc = _mm_crc32_u8((uint32_t) crc, p[position]); + position++; + } + + return crc; +} +#endif + +// ===================================== +// Software calculation + +// Table generated from CRC Calculator http://sourceforge.net/projects/crccalculator/files/CRC/ +// The table is for bit-reversed bytes + +static const uint32_t _crc32c_table[] = { + 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, + 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB, + 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, + 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24, + 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, + 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384, + 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, + 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B, + 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, + 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35, + 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, + 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA, + 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, + 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A, + 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, + 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595, + 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, + 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957, + 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, + 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198, + 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, + 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38, + 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, + 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7, + 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, + 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789, + 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, + 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46, + 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, + 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6, + 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, + 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829, + 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, + 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93, + 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, + 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C, + 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, + 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC, + 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, + 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033, + 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, + 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D, + 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, + 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982, + 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, + 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622, + 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, + 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED, + 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, + 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F, + 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, + 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0, + 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, + 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540, + 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, + 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F, + 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, + 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1, + 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, + 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E, + 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, + 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E, + 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, + 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351 +}; + +/* + * If we use the hardware implementation, this function may be unused, but + * we keep it around for unit testing + */ +__attribute__((unused)) +static uint32_t +_crc32c_UpdateSoftware(uint32_t crc, size_t len, uint8_t p[len]) +{ + for (int i = 0; i < len; i++) { + crc = (crc >> 8) ^ _crc32c_table[((uint8_t) (crc & 0xFF)) ^ p[i]]; + } + + return crc; +} + +/** + * Initializes the CRC32C value (init to 0xFFFFFFFF) + */ +static uint32_t +_crc32c_Init(void) +{ + return ~0; +} + + +/** + * Finalizes the CRC32 (xor with 0xFFFFFFFF) + */ +static uint32_t +_crc32c_Finalize(uint32_t crc) +{ + return crc ^ ~0; +} + +/** + * Updates the CRC32 value with a byte array. Does + * bit mirroring to match either the Intel instruction set or + * the CRC table used by the software calculation. + */ +static uint32_t +_crc32c_Update(uint32_t crc, size_t len, uint8_t p[len]) +{ +#ifdef __SSE4_2__ + crc = _crc32c_UpdateIntel(crc, len, p); +#else + crc = _crc32c_UpdateSoftware(crc, len, p); +#endif + return crc; +} + +/* + * Creates a new context variable for starting a hash + */ +static void * +_crc32_create(void *env __attribute__ ((unused))) +{ + _CRC32CState *ctx = parcMemory_AllocateAndClear(sizeof(_CRC32CState)); + assertNotNull(ctx, "parcMemory_AllocateAndClear(%zu) returned NULL for _CRC32CState", sizeof(_CRC32CState)); + + // Now initialize it with our digest and key, so in hmac_init we can avoid using those + return ctx; +} + +static int +_crc32_init(void *ctx) +{ + _CRC32CState *state = ctx; + + // initialize the CRC32C with all 1's + state->crc32 = _crc32c_Init(); + + return 0; +} + +static int +_crc32_update(void *ctx, const void *buffer, size_t length) +{ + _CRC32CState *state = ctx; + state->crc32 = _crc32c_Update(state->crc32, length, (uint8_t *) buffer); + return 0; +} + +static PARCBuffer * +_crc32_finalize(void *ctx) +{ + _CRC32CState *state = ctx; + state->crc32 = _crc32c_Finalize(state->crc32); + PARCBuffer *crcDigest = parcBuffer_Allocate(sizeof(uint32_t)); + parcBuffer_PutUint32(crcDigest, state->crc32); + return parcBuffer_Flip(crcDigest); +} + +static void +_crc32_destroy(void **ctxPtr) +{ + _CRC32CState *state = *ctxPtr; + parcMemory_Deallocate((void **) &state); + *ctxPtr = NULL; +} |