Debian Codegraph @

ext/digest/sha2.h

raw
1 /*
2 * FILE: sha2.h
3 * AUTHOR: Aaron D. Gifford
4 * http://www.aarongifford.com/computers/sha.html
5 *
6 * Copyright (c) 2000-2003, Aaron D. Gifford
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the copyright holder nor the names of contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 *
33 * $Id: sha2.h,v 1.4 2004/01/07 19:06:18 adg Exp $
34 */
35
36 #ifndef __SHA2_H__
37 #define __SHA2_H__
38
39 /*[SK] refer to the Gauche's config */
40 #include <gauche/config.h>
41 #include "renaming.h"
42
43 #include <stdint.h>
44 #include <inttypes.h>
45 #define SHA2_USE_INTTYPES_H
46
47 /* gauche/config.h provides WORDS_BIGENDIAN. */
48 #undef BYTE_ORDER
49 #ifndef LITTLE_ENDIAN
50 #define LITTLE_ENDIAN 1234
51 #endif
52 #ifndef BIG_ENDIAN
53 #define BIG_ENDIAN 4321
54 #endif
55 #if WORDS_BIGENDIAN
56 #define BYTE_ORDER BIG_ENDIAN
57 #else
58 #define BYTE_ORDER LITTLE_ENDIAN
59 #endif
60 /*[/SK]*/
61
62 #ifdef __cplusplus
63 extern "C" {
64 #endif
65
66
67 /*
68 * Import u_intXX_t size_t type definitions from system headers. You
69 * may need to change this, or define these things yourself in this
70 * file.
71 */
72 #include <sys/types.h>
73
74 #ifdef SHA2_USE_INTTYPES_H
75
76 #include <inttypes.h>
77
78 #endif /* SHA2_USE_INTTYPES_H */
79
80
81 /*** SHA-224/256/384/512 Various Length Definitions *******************/
82
83 /* Digest lengths for SHA-1/224/256/384/512 */
84 #define SHA1_DIGEST_LENGTH 20
85 #define SHA1_DIGEST_STRING_LENGTH (SHA1_DIGEST_LENGTH * 2 + 1)
86 #define SHA224_DIGEST_LENGTH 28
87 #define SHA224_DIGEST_STRING_LENGTH (SHA224_DIGEST_LENGTH * 2 + 1)
88 #define SHA256_DIGEST_LENGTH 32
89 #define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1)
90 #define SHA384_DIGEST_LENGTH 48
91 #define SHA384_DIGEST_STRING_LENGTH (SHA384_DIGEST_LENGTH * 2 + 1)
92 #define SHA512_DIGEST_LENGTH 64
93 #define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1)
94
95
96 /*** SHA-224/256/384/512 Context Structures ***************************/
97 /* NOTE: If your architecture does not define either u_intXX_t types or
98 * uintXX_t (from inttypes.h), you may need to define things by hand
99 * for your system:
100 */
101 #if 0
102 typedef unsigned char u_int8_t; /* 1-byte (8-bits) */
103 typedef unsigned int u_int32_t; /* 4-bytes (32-bits) */
104 typedef unsigned long long u_int64_t; /* 8-bytes (64-bits) */
105 #endif
106 /*
107 * Most BSD systems already define u_intXX_t types, as does Linux.
108 * Some systems, however, like Compaq's Tru64 Unix instead can use
109 * uintXX_t types defined by very recent ANSI C standards and included
110 * in the file:
111 *
112 * #include <inttypes.h>
113 *
114 * If you choose to use <inttypes.h> then please define:
115 *
116 * #define SHA2_USE_INTTYPES_H
117 *
118 * Or on the command line during compile:
119 *
120 * cc -DSHA2_USE_INTTYPES_H ...
121 */
122 #ifdef SHA2_USE_INTTYPES_H
123
124 typedef union _SHA_CTX {
125 /* SHA-1 uses this part of the union: */
126 struct {
127 uint32_t state[5];
128 uint64_t bitcount;
129 uint8_t buffer[64];
130 } s1;
131
132 /* SHA-224 and SHA-256 use this part of the union: */
133 struct {
134 uint32_t state[8];
135 uint64_t bitcount;
136 uint8_t buffer[64];
137 } s256;
138
139 /* SHA-384 and SHA-512 use this part of the union: */
140 struct {
141 uint64_t state[8];
142 uint64_t bitcount[2];
143 uint8_t buffer[128];
144 } s512;
145 } SHA_CTX;
146
147 #else /* SHA2_USE_INTTYPES_H */
148
149 typedef union _SHA_CTX {
150 /* SHA-1 uses this part of the union: */
151 struct {
152 u_int32_t state[5];
153 u_int64_t bitcount;
154 u_int8_t buffer[64];
155 } s1;
156
157 /* SHA-224 and SHA-256 use this part of the union: */
158 struct {
159 u_int32_t state[8];
160 u_int64_t bitcount;
161 u_int8_t buffer[64];
162 } s256;
163
164 /* SHA-384 and SHA-512 use this part of the union: */
165 struct {
166 u_int64_t state[8];
167 u_int64_t bitcount[2];
168 u_int8_t buffer[128];
169 } s512;
170 } SHA_CTX;
171
172 #endif /* SHA2_USE_INTTYPES_H */
173
174
175 /*** SHA-256/384/512 Function Prototypes ******************************/
176 #ifndef NOPROTO
177 #ifdef SHA2_USE_INTTYPES_H
178
179 void SHA1_Init(SHA_CTX*);
180 void SHA1_Update(SHA_CTX*, const uint8_t*, size_t);
181 void SHA1_Final(uint8_t[SHA1_DIGEST_LENGTH], SHA_CTX*);
182 char* SHA1_End(SHA_CTX*, char[SHA1_DIGEST_STRING_LENGTH]);
183 char* SHA1_Data(const uint8_t*, size_t, char[SHA1_DIGEST_STRING_LENGTH]);
184
185 void SHA224_Init(SHA_CTX*);
186 void SHA224_Update(SHA_CTX*, const uint8_t*, size_t);
187 void SHA224_Final(uint8_t[SHA224_DIGEST_LENGTH], SHA_CTX*);
188 char* SHA224_End(SHA_CTX*, char[SHA224_DIGEST_STRING_LENGTH]);
189 char* SHA224_Data(const uint8_t*, size_t, char[SHA224_DIGEST_STRING_LENGTH]);
190
191 void SHA256_Init(SHA_CTX*);
192 void SHA256_Update(SHA_CTX*, const uint8_t*, size_t);
193 void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA_CTX*);
194 char* SHA256_End(SHA_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
195 char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
196
197 void SHA384_Init(SHA_CTX*);
198 void SHA384_Update(SHA_CTX*, const uint8_t*, size_t);
199 void SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA_CTX*);
200 char* SHA384_End(SHA_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
201 char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
202
203 void SHA512_Init(SHA_CTX*);
204 void SHA512_Update(SHA_CTX*, const uint8_t*, size_t);
205 void SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA_CTX*);
206 char* SHA512_End(SHA_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
207 char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
208
209 #else /* SHA2_USE_INTTYPES_H */
210
211 void SHA1_Init(SHA_CTX*);
212 void SHA1_Update(SHA_CTX*, const u_int8_t*, size_t);
213 void SHA1_Final(u_int8_t[SHA1_DIGEST_LENGTH], SHA_CTX*);
214 char* SHA1_End(SHA_CTX*, char[SHA1_DIGEST_STRING_LENGTH]);
215 char* SHA1_Data(const u_int8_t*, size_t, char[SHA1_DIGEST_STRING_LENGTH]);
216
217 void SHA224_Init(SHA_CTX*);
218 void SHA224_Update(SHA_CTX*, const u_int8_t*, size_t);
219 void SHA224_Final(u_int8_t[SHA224_DIGEST_LENGTH], SHA_CTX*);
220 char* SHA224_End(SHA_CTX*, char[SHA224_DIGEST_STRING_LENGTH]);
221 char* SHA224_Data(const u_int8_t*, size_t, char[SHA224_DIGEST_STRING_LENGTH]);
222
223 void SHA256_Init(SHA_CTX*);
224 void SHA256_Update(SHA_CTX*, const u_int8_t*, size_t);
225 void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], SHA_CTX*);
226 char* SHA256_End(SHA_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
227 char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
228
229 void SHA384_Init(SHA_CTX*);
230 void SHA384_Update(SHA_CTX*, const u_int8_t*, size_t);
231 void SHA384_Final(u_int8_t[SHA384_DIGEST_LENGTH], SHA_CTX*);
232 char* SHA384_End(SHA_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
233 char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
234
235 void SHA512_Init(SHA_CTX*);
236 void SHA512_Update(SHA_CTX*, const u_int8_t*, size_t);
237 void SHA512_Final(u_int8_t[SHA512_DIGEST_LENGTH], SHA_CTX*);
238 char* SHA512_End(SHA_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
239 char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
240
241 #endif /* SHA2_USE_INTTYPES_H */
242
243 #else /* NOPROTO */
244
245 void SHA1_Init();
246 void SHA1_Update();
247 void SHA1_Final();
248 char* SHA1_End();
249 char* SHA1_Data();
250
251 void SHA224_Init();
252 void SHA224_Update();
253 void SHA224_Final();
254 char* SHA224_End();
255 char* SHA224_Data();
256
257 void SHA256_Init();
258 void SHA256_Update();
259 void SHA256_Final();
260 char* SHA256_End();
261 char* SHA256_Data();
262
263 void SHA384_Init();
264 void SHA384_Update();
265 void SHA384_Final();
266 char* SHA384_End();
267 char* SHA384_Data();
268
269 void SHA512_Init();
270 void SHA512_Update();
271 void SHA512_Final();
272 char* SHA512_End();
273 char* SHA512_Data();
274
275 #endif /* NOPROTO */
276
277 #ifdef __cplusplus
278 }
279 #endif /* __cplusplus */
280
281 #endif /* __SHA2_H__ */