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