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