1/* 2 * ccdigest.h 3 * corecrypto 4 * 5 * Created by Michael Brouwer on 11/30/10. 6 * Copyright 2010,2011 Apple Inc. All rights reserved. 7 * 8 */ 9 10#ifndef _CORECRYPTO_CCDIGEST_H_ 11#define _CORECRYPTO_CCDIGEST_H_ 12 13#include <corecrypto/cc.h> 14#include <corecrypto/ccn.h> 15#ifdef USE_SUPER_COOL_NEW_CCOID_T 16#include <corecrypto/ccasn1.h> 17#endif /* USE_SUPER_COOL_NEW_CCOID_T */ 18 19/* To malloc a digest context for a given di, use malloc(ccdigest_di_size(di)) 20 and assign the result to a pointer to a struct ccdigest_ctx. */ 21struct ccdigest_ctx { 22 union { 23 uint8_t u8; 24 uint32_t u32; 25 uint64_t u64; 26 cc_unit ccn; 27 } state; 28} __attribute((aligned(8))); 29 30typedef union { 31 struct ccdigest_ctx *hdr; 32} ccdigest_ctx_t __attribute__((transparent_union)); 33 34struct ccdigest_state { 35 union { 36 uint8_t u8; 37 uint32_t u32; 38 uint64_t u64; 39 cc_unit ccn; 40 } state; 41} __attribute((aligned(8))); 42 43typedef union { 44 struct ccdigest_state *hdr; 45 struct ccdigest_ctx *_ctx; 46 ccdigest_ctx_t _ctxt; 47} ccdigest_state_t __attribute__((transparent_union)); 48 49struct ccdigest_info { 50 unsigned long output_size; 51 unsigned long state_size; 52 unsigned long block_size; 53 unsigned long oid_size; 54#ifdef USE_SUPER_COOL_NEW_CCOID_T 55 ccoid_t oid; 56#else 57 unsigned char *oid; 58#endif 59 const void *initial_state; 60 void(*compress)(ccdigest_state_t state, unsigned long nblocks, 61 const void *data); 62 void(*final)(const struct ccdigest_info *di, ccdigest_ctx_t ctx, 63 unsigned char *digest); 64}; 65 66/* Return sizeof a ccdigest_ctx for a given size_t _state_size_ and 67 size_t _block_size_. */ 68#define ccdigest_ctx_size(_state_size_, _block_size_) ((_state_size_) + sizeof(uint64_t) + (_block_size_) + sizeof(unsigned int)) 69/* Return sizeof a ccdigest_ctx for a given struct ccdigest_info *_di_. */ 70#define ccdigest_di_size(_di_) (ccdigest_ctx_size((_di_)->state_size, (_di_)->block_size)) 71 72/* Declare a ccdigest_ctx for a given size_t _state_size_ and 73 size_t _block_size_, named _name_. Can be used in structs or on the 74 stack. */ 75#define ccdigest_ctx_decl(_state_size_, _block_size_, _name_) cc_ctx_decl(struct ccdigest_ctx, ccdigest_ctx_size(_state_size_, _block_size_), _name_) 76#define ccdigest_ctx_clear(_state_size_, _block_size_, _name_) cc_zero(ccdigest_ctx_size(_state_size_, _block_size_), _name_) 77/* Declare a ccdigest_ctx for a given size_t _state_size_ and 78 size_t _block_size_, named _name_. Can be used on the stack. */ 79#define ccdigest_di_decl(_di_, _name_) cc_ctx_decl(struct ccdigest_ctx, ccdigest_di_size(_di_), _name_) 80#define ccdigest_di_clear(_di_, _name_) cc_zero(ccdigest_di_size(_di_), _name_) 81 82/* Digest context field accessors. Consider the implementation private. */ 83 84#define ccdigest_state(_di_, _ctx_) ((struct ccdigest_state *)(&((ccdigest_ctx_t)(_ctx_)).hdr->state.u8 + sizeof(uint64_t))) 85#define ccdigest_state_u8(_di_, _ctx_) ccdigest_u8(ccdigest_state((_di_), (_ctx_))) 86#define ccdigest_state_u32(_di_, _ctx_) ccdigest_u32(ccdigest_state((_di_), (_ctx_))) 87#define ccdigest_state_u64(_di_, _ctx_) ccdigest_u64(ccdigest_state((_di_), (_ctx_))) 88#define ccdigest_state_ccn(_di_, _ctx_) ccdigest_ccn(ccdigest_state((_di_), (_ctx_))) 89#define ccdigest_nbits(_di_, _ctx_) (((uint64_t *)(&((ccdigest_ctx_t)(_ctx_)).hdr->state.u8))[0]) 90 91#define ccdigest_data(_di_, _ctx_) (&((ccdigest_ctx_t)(_ctx_)).hdr->state.u8 + (_di_)->state_size + sizeof(uint64_t)) 92#define ccdigest_num(_di_, _ctx_) (((unsigned int *)(&((ccdigest_ctx_t)(_ctx_)).hdr->state.u8 + (_di_)->state_size + sizeof(uint64_t) + (_di_)->block_size))[0]) 93 94/* Digest state field accessors. Consider the implementation private. */ 95#define ccdigest_u8(_state_) (&((ccdigest_state_t)(_state_)).hdr->state.u8) 96#define ccdigest_u32(_state_) (&((ccdigest_state_t)(_state_)).hdr->state.u32) 97#define ccdigest_u64(_state_) (&((ccdigest_state_t)(_state_)).hdr->state.u64) 98#define ccdigest_ccn(_state_) (&((ccdigest_state_t)(_state_)).hdr->state.ccn) 99 100/* We could just use memcpy instead of this special macro, but this allows us 101 to use the optimized ccn_set() assembly routine if we have one, which for 102 32 bit arm is about 200% quicker than generic memcpy(). */ 103#if CCN_SET_ASM && CCN_UNIT_SIZE <= 4 104#define ccdigest_copy_state(_di_, _dst_, _src_) ccn_set((_di_)->state_size / CCN_UNIT_SIZE, _dst_, _src_) 105#else 106#define ccdigest_copy_state(_di_, _dst_, _src_) CC_MEMCPY(_dst_, _src_, (_di_)->state_size) 107#endif 108 109void ccdigest_init(const struct ccdigest_info *di, ccdigest_ctx_t ctx); 110void ccdigest_update(const struct ccdigest_info *di, ccdigest_ctx_t ctx, 111 unsigned long len, const void *data); 112 113CC_INLINE 114void ccdigest_final(const struct ccdigest_info *di, ccdigest_ctx_t ctx, unsigned char *digest) 115{ 116 di->final(di,ctx,digest); 117} 118 119void ccdigest(const struct ccdigest_info *di, unsigned long len, 120 const void *data, void *digest); 121 122/* test functions */ 123int ccdigest_test(const struct ccdigest_info *di, unsigned long len, 124 const void *data, const void *digest); 125 126int ccdigest_test_chunk(const struct ccdigest_info *di, unsigned long len, 127 const void *data, const void *digest, unsigned long chunk); 128 129struct ccdigest_vector { 130 unsigned long len; 131 const void *message; 132 const void *digest; 133}; 134 135int ccdigest_test_vector(const struct ccdigest_info *di, const struct ccdigest_vector *v); 136int ccdigest_test_chunk_vector(const struct ccdigest_info *di, const struct ccdigest_vector *v, unsigned long chunk); 137 138#ifdef USE_SUPER_COOL_NEW_CCOID_T 139#define OID_DEF(_NAME_, _VALUE_) _NAME_ {((unsigned char *) _VALUE_)} 140#define CC_DIGEST_OID_MD2 {((unsigned char *)"\x06\x08\x2A\x86\x48\x86\xF7\x0D\x02\x02")} 141#define CC_DIGEST_OID_MD4 {((unsigned char *)"\x06\x08\x2A\x86\x48\x86\xF7\x0D\x02\x04")} 142#define CC_DIGEST_OID_MD5 {((unsigned char *)"\x06\x08\x2A\x86\x48\x86\xF7\x0D\x02\x05")} 143#define CC_DIGEST_OID_SHA1 {((unsigned char *)"\x06\x05\x2b\x0e\x03\x02\x1a")} 144#define CC_DIGEST_OID_SHA224 {((unsigned char *)"\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x04")} 145#define CC_DIGEST_OID_SHA256 {((unsigned char *)"\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x01")} 146#define CC_DIGEST_OID_SHA384 {((unsigned char *)"\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x02")} 147#define CC_DIGEST_OID_SHA512 {((unsigned char *)"\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x03")} 148#define CC_DIGEST_OID_RMD128 {((unsigned char *)"\x06\x06\x28\xCF\x06\x03\x00\x32")} 149#define CC_DIGEST_OID_RMD160 {((unsigned char *)"\x06\x05\x2B\x24\x03\x02\x01")} 150#define CC_DIGEST_OID_RMD256 {((unsigned char *)"\x06\x05\x2B\x24\x03\x02\x03")} 151#define CC_DIGEST_OID_RMD320 {((unsigned char *)NULL)} 152#else 153#define CC_DIGEST_OID_MD2 "\x06\x08\x2A\x86\x48\x86\xF7\x0D\x02\x02" 154#define CC_DIGEST_OID_MD4 "\x06\x08\x2A\x86\x48\x86\xF7\x0D\x02\x04" 155#define CC_DIGEST_OID_MD5 "\x06\x08\x2A\x86\x48\x86\xF7\x0D\x02\x05" 156#define CC_DIGEST_OID_SHA1 "\x06\x05\x2b\x0e\x03\x02\x1a" 157#define CC_DIGEST_OID_SHA224 "\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x04" 158#define CC_DIGEST_OID_SHA256 "\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x01" 159#define CC_DIGEST_OID_SHA384 "\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x02" 160#define CC_DIGEST_OID_SHA512 "\x06\x09\x60\x86\x48\x01\x65\x03\x04\x02\x03" 161#define CC_DIGEST_OID_RMD128 "\x06\x06\x28\xCF\x06\x03\x00\x32" 162#define CC_DIGEST_OID_RMD160 "\x06\x05\x2B\x24\x03\x02\x01" 163#define CC_DIGEST_OID_RMD256 "\x06\x05\x2B\x24\x03\x02\x03" 164#define CC_DIGEST_OID_RMD320 NULL 165#endif 166 167#ifdef USE_SUPER_COOL_NEW_CCOID_T 168CC_INLINE CC_NONNULL_TU((1)) CC_NONNULL_TU((2)) 169bool ccdigest_oid_equal(const struct ccdigest_info *di, ccoid_t oid) { 170 if(di->oid.oid == NULL && oid.oid == NULL) return true; 171 return ccoid_equal(di->oid, oid); 172} 173 174typedef const struct ccdigest_info *(ccdigest_lookup)(ccoid_t oid); 175 176#include <stdarg.h> 177const struct ccdigest_info *ccdigest_oid_lookup(ccoid_t oid, ...); 178#endif /* USE_SUPER_COOL_NEW_CCOID_T*/ 179#endif /* _CORECRYPTO_CCDIGEST_H_ */ 180