1/* 2 * Copyright (c) 2004 Apple Computer, Inc. All Rights Reserved. 3 * 4 * @APPLE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. Please obtain a copy of the License at 10 * http://www.opensource.apple.com/apsl/ and read it before using this 11 * file. 12 * 13 * The Original Code and all software distributed under the License are 14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 18 * Please see the License for the specific language governing rights and 19 * limitations under the License. 20 * 21 * @APPLE_LICENSE_HEADER_END@ 22 */ 23 24/* 25 * CommonDigest.h - common digest routines: MD2, MD4, MD5, SHA1. 26 */ 27 28#ifndef _CC_COMMON_DIGEST_H_ 29#define _CC_COMMON_DIGEST_H_ 30 31#include <stdint.h> 32#include <Availability.h> 33 34#ifdef __cplusplus 35extern "C" { 36#endif 37 38/* 39 * For compatibility with legacy implementations, the *Init(), *Update(), 40 * and *Final() functions declared here *always* return a value of 1 (one). 41 * This corresponds to "success" in the similar openssl implementations. 42 * There are no errors of any kind which can be, or are, reported here, 43 * so you can safely ignore the return values of all of these functions 44 * if you are implementing new code. 45 * 46 * The one-shot functions (CC_MD2(), CC_SHA1(), etc.) perform digest 47 * calculation and place the result in the caller-supplied buffer 48 * indicated by the md parameter. They return the md parameter. 49 * Unlike the opensssl counterparts, these one-shot functions require 50 * a non-NULL md pointer. Passing in NULL for the md parameter 51 * results in a NULL return and no digest calculation. 52 */ 53 54typedef uint32_t CC_LONG; /* 32 bit unsigned integer */ 55typedef uint64_t CC_LONG64; /* 64 bit unsigned integer */ 56 57/*** MD2 ***/ 58 59#define CC_MD2_DIGEST_LENGTH 16 /* digest length in bytes */ 60#define CC_MD2_BLOCK_BYTES 64 /* block size in bytes */ 61#define CC_MD2_BLOCK_LONG (CC_MD2_BLOCK_BYTES / sizeof(CC_LONG)) 62 63typedef struct CC_MD2state_st 64{ 65 int num; 66 unsigned char data[CC_MD2_DIGEST_LENGTH]; 67 CC_LONG cksm[CC_MD2_BLOCK_LONG]; 68 CC_LONG state[CC_MD2_BLOCK_LONG]; 69} CC_MD2_CTX; 70 71extern int CC_MD2_Init(CC_MD2_CTX *c) 72__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 73 74extern int CC_MD2_Update(CC_MD2_CTX *c, const void *data, CC_LONG len) 75__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 76 77extern int CC_MD2_Final(unsigned char *md, CC_MD2_CTX *c) 78__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 79 80extern unsigned char *CC_MD2(const void *data, CC_LONG len, unsigned char *md) 81__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 82 83/*** MD4 ***/ 84 85#define CC_MD4_DIGEST_LENGTH 16 /* digest length in bytes */ 86#define CC_MD4_BLOCK_BYTES 64 /* block size in bytes */ 87#define CC_MD4_BLOCK_LONG (CC_MD4_BLOCK_BYTES / sizeof(CC_LONG)) 88 89typedef struct CC_MD4state_st 90{ 91 CC_LONG A,B,C,D; 92 CC_LONG Nl,Nh; 93 CC_LONG data[CC_MD4_BLOCK_LONG]; 94 uint32_t num; 95} CC_MD4_CTX; 96 97extern int CC_MD4_Init(CC_MD4_CTX *c) 98__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 99 100extern int CC_MD4_Update(CC_MD4_CTX *c, const void *data, CC_LONG len) 101__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 102 103extern int CC_MD4_Final(unsigned char *md, CC_MD4_CTX *c) 104__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 105 106extern unsigned char *CC_MD4(const void *data, CC_LONG len, unsigned char *md) 107__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 108 109 110/*** MD5 ***/ 111 112#define CC_MD5_DIGEST_LENGTH 16 /* digest length in bytes */ 113#define CC_MD5_BLOCK_BYTES 64 /* block size in bytes */ 114#define CC_MD5_BLOCK_LONG (CC_MD5_BLOCK_BYTES / sizeof(CC_LONG)) 115 116typedef struct CC_MD5state_st 117{ 118 CC_LONG A,B,C,D; 119 CC_LONG Nl,Nh; 120 CC_LONG data[CC_MD5_BLOCK_LONG]; 121 int num; 122} CC_MD5_CTX; 123 124extern int CC_MD5_Init(CC_MD5_CTX *c) 125__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 126 127extern int CC_MD5_Update(CC_MD5_CTX *c, const void *data, CC_LONG len) 128__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 129 130extern int CC_MD5_Final(unsigned char *md, CC_MD5_CTX *c) 131__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 132 133extern unsigned char *CC_MD5(const void *data, CC_LONG len, unsigned char *md) 134__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 135 136 137/*** SHA1 ***/ 138 139#define CC_SHA1_DIGEST_LENGTH 20 /* digest length in bytes */ 140#define CC_SHA1_BLOCK_BYTES 64 /* block size in bytes */ 141#define CC_SHA1_BLOCK_LONG (CC_SHA1_BLOCK_BYTES / sizeof(CC_LONG)) 142 143typedef struct CC_SHA1state_st 144{ 145 CC_LONG h0,h1,h2,h3,h4; 146 CC_LONG Nl,Nh; 147 CC_LONG data[CC_SHA1_BLOCK_LONG]; 148 int num; 149} CC_SHA1_CTX; 150 151extern int CC_SHA1_Init(CC_SHA1_CTX *c) 152__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 153 154extern int CC_SHA1_Update(CC_SHA1_CTX *c, const void *data, CC_LONG len) 155__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 156 157extern int CC_SHA1_Final(unsigned char *md, CC_SHA1_CTX *c) 158__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 159 160extern unsigned char *CC_SHA1(const void *data, CC_LONG len, unsigned char *md) 161__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 162 163 164/*** SHA224 ***/ 165#define CC_SHA224_DIGEST_LENGTH 28 /* digest length in bytes */ 166#define CC_SHA224_BLOCK_BYTES 64 /* block size in bytes */ 167 168/* same context struct is used for SHA224 and SHA256 */ 169typedef struct CC_SHA256state_st 170{ CC_LONG count[2]; 171 CC_LONG hash[8]; 172 CC_LONG wbuf[16]; 173} CC_SHA256_CTX; 174 175extern int CC_SHA224_Init(CC_SHA256_CTX *c) 176__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 177 178extern int CC_SHA224_Update(CC_SHA256_CTX *c, const void *data, CC_LONG len) 179__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 180 181extern int CC_SHA224_Final(unsigned char *md, CC_SHA256_CTX *c) 182__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 183 184extern unsigned char *CC_SHA224(const void *data, CC_LONG len, unsigned char *md) 185__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 186 187 188/*** SHA256 ***/ 189 190#define CC_SHA256_DIGEST_LENGTH 32 /* digest length in bytes */ 191#define CC_SHA256_BLOCK_BYTES 64 /* block size in bytes */ 192 193extern int CC_SHA256_Init(CC_SHA256_CTX *c) 194__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 195 196extern int CC_SHA256_Update(CC_SHA256_CTX *c, const void *data, CC_LONG len) 197__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 198 199extern int CC_SHA256_Final(unsigned char *md, CC_SHA256_CTX *c) 200__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 201 202extern unsigned char *CC_SHA256(const void *data, CC_LONG len, unsigned char *md) 203__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 204 205 206/*** SHA384 ***/ 207 208#define CC_SHA384_DIGEST_LENGTH 48 /* digest length in bytes */ 209#define CC_SHA384_BLOCK_BYTES 128 /* block size in bytes */ 210 211/* same context struct is used for SHA384 and SHA512 */ 212typedef struct CC_SHA512state_st 213{ CC_LONG64 count[2]; 214 CC_LONG64 hash[8]; 215 CC_LONG64 wbuf[16]; 216} CC_SHA512_CTX; 217 218extern int CC_SHA384_Init(CC_SHA512_CTX *c) 219__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 220 221extern int CC_SHA384_Update(CC_SHA512_CTX *c, const void *data, CC_LONG len) 222__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 223 224extern int CC_SHA384_Final(unsigned char *md, CC_SHA512_CTX *c) 225__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 226 227extern unsigned char *CC_SHA384(const void *data, CC_LONG len, unsigned char *md) 228__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 229 230 231/*** SHA512 ***/ 232 233#define CC_SHA512_DIGEST_LENGTH 64 /* digest length in bytes */ 234#define CC_SHA512_BLOCK_BYTES 128 /* block size in bytes */ 235 236extern int CC_SHA512_Init(CC_SHA512_CTX *c) 237__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 238 239extern int CC_SHA512_Update(CC_SHA512_CTX *c, const void *data, CC_LONG len) 240__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 241 242extern int CC_SHA512_Final(unsigned char *md, CC_SHA512_CTX *c) 243__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 244 245extern unsigned char *CC_SHA512(const void *data, CC_LONG len, unsigned char *md) 246__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 247 248/* 249 * To use the above digest functions with existing code which uses 250 * the corresponding openssl functions, #define the symbol 251 * COMMON_DIGEST_FOR_OPENSSL in your client code (BEFORE including 252 * this file), and simply link against libSystem (or System.framework) 253 * instead of libcrypto. 254 * 255 * You can *NOT* mix and match functions operating on a given data 256 * type from the two implementations; i.e., if you do a CC_MD5_Init() 257 * on a CC_MD5_CTX object, do not assume that you can do an openssl-style 258 * MD5_Update() on that same context. 259 */ 260 261#ifdef COMMON_DIGEST_FOR_OPENSSL 262 263#define MD2_DIGEST_LENGTH CC_MD2_DIGEST_LENGTH 264#define MD2_CTX CC_MD2_CTX 265#define MD2_Init CC_MD2_Init 266#define MD2_Update CC_MD2_Update 267#define MD2_Final CC_MD2_Final 268 269#define MD4_DIGEST_LENGTH CC_MD4_DIGEST_LENGTH 270#define MD4_CTX CC_MD4_CTX 271#define MD4_Init CC_MD4_Init 272#define MD4_Update CC_MD4_Update 273#define MD4_Final CC_MD4_Final 274 275#define MD5_DIGEST_LENGTH CC_MD5_DIGEST_LENGTH 276#define MD5_CTX CC_MD5_CTX 277#define MD5_Init CC_MD5_Init 278#define MD5_Update CC_MD5_Update 279#define MD5_Final CC_MD5_Final 280 281#define SHA_DIGEST_LENGTH CC_SHA1_DIGEST_LENGTH 282#define SHA_CTX CC_SHA1_CTX 283#define SHA1_Init CC_SHA1_Init 284#define SHA1_Update CC_SHA1_Update 285#define SHA1_Final CC_SHA1_Final 286 287#define SHA224_DIGEST_LENGTH CC_SHA224_DIGEST_LENGTH 288#define SHA256_CTX CC_SHA256_CTX 289#define SHA224_Init CC_SHA224_Init 290#define SHA224_Update CC_SHA224_Update 291#define SHA224_Final CC_SHA224_Final 292 293#define SHA256_DIGEST_LENGTH CC_SHA256_DIGEST_LENGTH 294#define SHA256_Init CC_SHA256_Init 295#define SHA256_Update CC_SHA256_Update 296#define SHA256_Final CC_SHA256_Final 297 298#define SHA384_DIGEST_LENGTH CC_SHA384_DIGEST_LENGTH 299#define SHA512_CTX CC_SHA512_CTX 300#define SHA384_Init CC_SHA384_Init 301#define SHA384_Update CC_SHA384_Update 302#define SHA384_Final CC_SHA384_Final 303 304#define SHA512_DIGEST_LENGTH CC_SHA512_DIGEST_LENGTH 305#define SHA512_Init CC_SHA512_Init 306#define SHA512_Update CC_SHA512_Update 307#define SHA512_Final CC_SHA512_Final 308 309 310#endif /* COMMON_DIGEST_FOR_OPENSSL */ 311 312/* 313 * In a manner similar to that described above for openssl 314 * compatibility, these macros can be used to provide compatiblity 315 * with legacy implementations of MD5 using the interface defined 316 * in RFC 1321. 317 */ 318 319#ifdef COMMON_DIGEST_FOR_RFC_1321 320 321#define MD5_CTX CC_MD5_CTX 322#define MD5Init CC_MD5_Init 323#define MD5Update CC_MD5_Update 324void MD5Final (unsigned char [16], MD5_CTX *) 325__OSX_AVAILABLE_STARTING(__MAC_10_4, __IPHONE_2_0); 326 327#endif /* COMMON_DIGEST_FOR_RFC_1321 */ 328 329#ifdef __cplusplus 330} 331#endif 332 333#endif /* _CC_COMMON_DIGEST_H_ */ 334