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