1/*
2 * Copyright (c) 1999, 2000-2013 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_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. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28
29/*
30SHA-1 in C
31By Steve Reid <steve@edmweb.com>
32100% Public Domain
33*/
34/* Header portion split from main code for convenience (AYB 3/02/98) */
35#include "sha1mod.h"
36#ifdef SHA1HANDSOFF
37#include <string.h>
38#endif
39
40#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
41
42/*
43 * Apple change...
44 */
45#if	defined(macintosh) || defined (__APPLE__)
46#undef LITTLE_ENDIAN
47#endif
48
49/* blk0() and blk() perform the initial expand. */
50/* I got the idea of expanding during the round function from SSLeay */
51#ifdef LITTLE_ENDIAN
52#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
53    |(rol(block->l[i],8)&0x00FF00FF))
54#else
55#define blk0(i) block->l[i]
56#endif
57#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
58    ^block->l[(i+2)&15]^block->l[i&15],1))
59
60/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
61#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
62#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
63#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
64#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
65#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
66
67
68/* Hash a single 512-bit block. This is the core of the algorithm. */
69
70__private_extern__ void
71YSHA1Transform(u_int32_t state[5], const unsigned char buffer[64])
72{
73u_int32_t a, b, c, d, e;
74typedef union {
75    unsigned char c[64];
76    u_int32_t l[16];
77} CHAR64LONG16;
78CHAR64LONG16* block;
79#ifdef SHA1HANDSOFF
80static unsigned char workspace[64];
81    block = (CHAR64LONG16*)workspace;
82    memcpy(block, buffer, 64);
83#else
84    block = (CHAR64LONG16*)buffer;
85#endif
86    /* Copy context->state[] to working vars */
87    a = state[0];
88    b = state[1];
89    c = state[2];
90    d = state[3];
91    e = state[4];
92    /* 4 rounds of 20 operations each. Loop unrolled. */
93    R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
94    R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
95    R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
96    R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
97    R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
98    R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
99    R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
100    R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
101    R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
102    R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
103    R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
104    R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
105    R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
106    R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
107    R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
108    R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
109    R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
110    R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
111    R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
112    R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
113    /* Add the working vars back into context.state[] */
114    state[0] += a;
115    state[1] += b;
116    state[2] += c;
117    state[3] += d;
118    state[4] += e;
119    /* Wipe variables */
120    a = b = c = d = e = 0;
121}
122
123
124/* YSHA1Init - Initialize new context */
125
126__private_extern__ void
127YSHA1Init(YSHA1_CTX* context)
128{
129    /* SHA1 initialization constants */
130    context->state[0] = 0x67452301;
131    context->state[1] = 0xEFCDAB89;
132    context->state[2] = 0x98BADCFE;
133    context->state[3] = 0x10325476;
134    context->state[4] = 0xC3D2E1F0;
135    context->count[0] = context->count[1] = 0;
136}
137
138
139/* Run your data through this. */
140
141__private_extern__ void
142YSHA1Update(YSHA1_CTX* context, const unsigned char* data, unsigned int len)
143{
144unsigned int i, j;
145
146    j = (context->count[0] >> 3) & 63;
147    if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
148    context->count[1] += (len >> 29);
149    if ((j + len) > 63) {
150        memcpy(&context->buffer[j], data, (i = 64-j));
151        YSHA1Transform(context->state, context->buffer);
152        for ( ; i + 63 < len; i += 64) {
153            YSHA1Transform(context->state, &data[i]);
154        }
155        j = 0;
156    }
157    else i = 0;
158    memcpy(&context->buffer[j], &data[i], len - i);
159}
160
161
162/* Add padding and return the message digest. */
163
164__private_extern__ void
165YSHA1Final(unsigned char digest[20], YSHA1_CTX* context)
166{
167u_int32_t i, j;
168unsigned char finalcount[8];
169
170    for (i = 0; i < 8; i++) {
171        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
172         >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
173    }
174    YSHA1Update(context, (const unsigned char *)"\200", 1);
175    while ((context->count[0] & 504) != 448) {
176        YSHA1Update(context, (const unsigned char *)"\0", 1);
177    }
178    YSHA1Update(context, finalcount, 8);  /* Should cause a YSHA1Transform() */
179    for (i = 0; i < 20; i++) {
180        digest[i] = (unsigned char)
181         ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
182    }
183    /* Wipe variables */
184    i = j = 0;
185    memset(context->buffer, 0, 64);
186    memset(context->state, 0, 20);
187    memset(context->count, 0, 8);
188    memset(finalcount, 0, 8);
189#ifdef SHA1HANDSOFF  /* make YSHA1Transform overwrite it's own static vars */
190    YSHA1Transform(context->state, context->buffer);
191#endif
192}
193
194
195/*************************************************************/
196
197/* Test Code */
198
199#if 0
200
201int main(int argc, char** argv)
202{
203int i, j;
204YSHA1_CTX context;
205unsigned char digest[20], buffer[16384];
206FILE* file;
207
208    if (argc > 2) {
209        puts("Public domain SHA-1 implementation - by Steve Reid <steve@edmweb.com>");
210        puts("Produces the SHA-1 hash of a file, or stdin if no file is specified.");
211        exit(0);
212    }
213    if (argc < 2) {
214        file = stdin;
215    }
216    else {
217        if (!(file = fopen(argv[1], "rb"))) {
218            fputs("Unable to open file.", stderr);
219            exit(-1);
220        }
221    }
222    YSHA1Init(&context);
223    while (!feof(file)) {  /* note: what if ferror(file) */
224        i = fread(buffer, 1, 16384, file);
225        YSHA1Update(&context, buffer, i);
226    }
227    YSHA1Final(digest, &context);
228    fclose(file);
229    for (i = 0; i < 5; i++) {
230        for (j = 0; j < 4; j++) {
231            printf("%02X", digest[i*4+j]);
232        }
233        putchar(' ');
234    }
235    putchar('\n');
236    exit(0);
237}
238
239#endif
240