Mercurial > pidgin.yaz
comparison src/sha.c @ 6985:0e5a5e5e07f0
[gaim-migrate @ 7541]
sean wants these here
committer: Tailor Script <tailor@pidgin.im>
author | Nathan Walp <nwalp@pidgin.im> |
---|---|
date | Sat, 27 Sep 2003 23:42:22 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
6984:38a767776cb2 | 6985:0e5a5e5e07f0 |
---|---|
1 /* | |
2 * The contents of this file are subject to the Mozilla Public | |
3 * License Version 1.1 (the "License"); you may not use this file | |
4 * except in compliance with the License. You may obtain a copy of | |
5 * the License at http://www.mozilla.org/MPL/ | |
6 * | |
7 * Software distributed under the License is distributed on an "AS | |
8 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or | |
9 * implied. See the License for the specific language governing | |
10 * rights and limitations under the License. | |
11 * | |
12 * The Original Code is SHA 180-1 Reference Implementation (Compact version) | |
13 * | |
14 * The Initial Developer of the Original Code is Paul Kocher of | |
15 * Cryptography Research. Portions created by Paul Kocher are | |
16 * Copyright (C) 1995-9 by Cryptography Research, Inc. All | |
17 * Rights Reserved. | |
18 * | |
19 * Contributor(s): | |
20 * | |
21 */ | |
22 | |
23 #include "sha.h" | |
24 #include "string.h" | |
25 #include "stdio.h" | |
26 | |
27 #ifdef _WIN32 | |
28 #include "win32dep.h" | |
29 #endif | |
30 | |
31 typedef struct { | |
32 unsigned long H[5]; | |
33 unsigned long W[80]; | |
34 int lenW; | |
35 unsigned long sizeHi, sizeLo; | |
36 } j_SHA_CTX; | |
37 | |
38 static void shaHashBlock(j_SHA_CTX *ctx); | |
39 | |
40 void shaInit(j_SHA_CTX *ctx) { | |
41 int i; | |
42 | |
43 ctx->lenW = 0; | |
44 ctx->sizeHi = ctx->sizeLo = 0; | |
45 | |
46 /* Initialize H with the magic constants (see FIPS180 for constants) | |
47 */ | |
48 ctx->H[0] = 0x67452301L; | |
49 ctx->H[1] = 0xefcdab89L; | |
50 ctx->H[2] = 0x98badcfeL; | |
51 ctx->H[3] = 0x10325476L; | |
52 ctx->H[4] = 0xc3d2e1f0L; | |
53 | |
54 for (i = 0; i < 80; i++) | |
55 ctx->W[i] = 0; | |
56 } | |
57 | |
58 | |
59 void shaUpdate(j_SHA_CTX *ctx, unsigned char *dataIn, int len) { | |
60 int i; | |
61 | |
62 /* Read the data into W and process blocks as they get full | |
63 */ | |
64 for (i = 0; i < len; i++) { | |
65 ctx->W[ctx->lenW / 4] <<= 8; | |
66 ctx->W[ctx->lenW / 4] |= (unsigned long)dataIn[i]; | |
67 if ((++ctx->lenW) % 64 == 0) { | |
68 shaHashBlock(ctx); | |
69 ctx->lenW = 0; | |
70 } | |
71 ctx->sizeLo += 8; | |
72 ctx->sizeHi += (ctx->sizeLo < 8); | |
73 } | |
74 } | |
75 | |
76 | |
77 void shaFinal(j_SHA_CTX *ctx, unsigned char hashout[20]) { | |
78 unsigned char pad0x80 = 0x80; | |
79 unsigned char pad0x00 = 0x00; | |
80 unsigned char padlen[8]; | |
81 int i; | |
82 | |
83 /* Pad with a binary 1 (e.g. 0x80), then zeroes, then length | |
84 */ | |
85 padlen[0] = (unsigned char)((ctx->sizeHi >> 24) & 255); | |
86 padlen[1] = (unsigned char)((ctx->sizeHi >> 16) & 255); | |
87 padlen[2] = (unsigned char)((ctx->sizeHi >> 8) & 255); | |
88 padlen[3] = (unsigned char)((ctx->sizeHi >> 0) & 255); | |
89 padlen[4] = (unsigned char)((ctx->sizeLo >> 24) & 255); | |
90 padlen[5] = (unsigned char)((ctx->sizeLo >> 16) & 255); | |
91 padlen[6] = (unsigned char)((ctx->sizeLo >> 8) & 255); | |
92 padlen[7] = (unsigned char)((ctx->sizeLo >> 0) & 255); | |
93 shaUpdate(ctx, &pad0x80, 1); | |
94 while (ctx->lenW != 56) | |
95 shaUpdate(ctx, &pad0x00, 1); | |
96 shaUpdate(ctx, padlen, 8); | |
97 | |
98 /* Output hash | |
99 */ | |
100 for (i = 0; i < 20; i++) { | |
101 hashout[i] = (unsigned char)(ctx->H[i / 4] >> 24); | |
102 ctx->H[i / 4] <<= 8; | |
103 } | |
104 | |
105 /* | |
106 * Re-initialize the context (also zeroizes contents) | |
107 */ | |
108 shaInit(ctx); | |
109 } | |
110 | |
111 | |
112 void shaBlock(unsigned char *dataIn, int len, unsigned char hashout[20]) { | |
113 j_SHA_CTX ctx; | |
114 | |
115 shaInit(&ctx); | |
116 shaUpdate(&ctx, dataIn, len); | |
117 shaFinal(&ctx, hashout); | |
118 } | |
119 | |
120 | |
121 #define SHA_ROTL(X,n) ((((X) << (n)) | ((X) >> (32-(n)))) & 0xffffffffL) | |
122 | |
123 static void shaHashBlock(j_SHA_CTX *ctx) { | |
124 int t; | |
125 unsigned long A,B,C,D,E,TEMP; | |
126 | |
127 for (t = 16; t <= 79; t++) | |
128 ctx->W[t] = | |
129 SHA_ROTL(ctx->W[t-3] ^ ctx->W[t-8] ^ ctx->W[t-14] ^ ctx->W[t-16], 1); | |
130 | |
131 A = ctx->H[0]; | |
132 B = ctx->H[1]; | |
133 C = ctx->H[2]; | |
134 D = ctx->H[3]; | |
135 E = ctx->H[4]; | |
136 | |
137 for (t = 0; t <= 19; t++) { | |
138 TEMP = (SHA_ROTL(A,5) + (((C^D)&B)^D) + E + ctx->W[t] + 0x5a827999L) & 0xffffffffL; | |
139 E = D; D = C; C = SHA_ROTL(B, 30); B = A; A = TEMP; | |
140 } | |
141 for (t = 20; t <= 39; t++) { | |
142 TEMP = (SHA_ROTL(A,5) + (B^C^D) + E + ctx->W[t] + 0x6ed9eba1L) & 0xffffffffL; | |
143 E = D; D = C; C = SHA_ROTL(B, 30); B = A; A = TEMP; | |
144 } | |
145 for (t = 40; t <= 59; t++) { | |
146 TEMP = (SHA_ROTL(A,5) + ((B&C)|(D&(B|C))) + E + ctx->W[t] + 0x8f1bbcdcL) & 0xffffffffL; | |
147 E = D; D = C; C = SHA_ROTL(B, 30); B = A; A = TEMP; | |
148 } | |
149 for (t = 60; t <= 79; t++) { | |
150 TEMP = (SHA_ROTL(A,5) + (B^C^D) + E + ctx->W[t] + 0xca62c1d6L) & 0xffffffffL; | |
151 E = D; D = C; C = SHA_ROTL(B, 30); B = A; A = TEMP; | |
152 } | |
153 | |
154 ctx->H[0] += A; | |
155 ctx->H[1] += B; | |
156 ctx->H[2] += C; | |
157 ctx->H[3] += D; | |
158 ctx->H[4] += E; | |
159 } | |
160 | |
161 /*---------------------------------------------------------------------------- | |
162 * | |
163 * This code added by Thomas "temas" Muldowney for Jabber compatability | |
164 * | |
165 *---------------------------------------------------------------------------*/ | |
166 char *shahash(char *str) | |
167 { | |
168 static char final[41]; | |
169 char *pos; | |
170 unsigned char hashval[20]; | |
171 int x; | |
172 | |
173 if(!str || strlen(str) == 0) | |
174 return NULL; | |
175 | |
176 shaBlock((unsigned char *)str, strlen(str), hashval); | |
177 | |
178 pos = final; | |
179 for(x=0;x<20;x++) | |
180 { | |
181 snprintf(pos, 3, "%02x", hashval[x]); | |
182 pos += 2; | |
183 } | |
184 return (char *)final; | |
185 } | |
186 | |
187 void shahash_r(const char* str, char hashbuf[41]) | |
188 { | |
189 int x; | |
190 char *pos; | |
191 unsigned char hashval[20]; | |
192 | |
193 if(!str || strlen(str) == 0) | |
194 return; | |
195 | |
196 shaBlock((unsigned char *)str, strlen(str), hashval); | |
197 | |
198 pos = hashbuf; | |
199 for(x=0;x<20;x++) | |
200 { | |
201 snprintf(pos, 3, "%02x", hashval[x]); | |
202 pos += 2; | |
203 } | |
204 | |
205 return; | |
206 } |