]> git.saurik.com Git - apt.git/blame - apt-pkg/contrib/sha2_internal.cc
projects / apt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
German translation proof read by Helge Kreutzmann
[apt.git] / apt-pkg / contrib / sha2_internal.cc
CommitLineData
84a0890e
MV		 1/*
2 * FILE: sha2.c
3 * AUTHOR: Aaron D. Gifford - http://www.aarongifford.com/
4 *
5 * Copyright (c) 2000-2001, Aaron D. Gifford
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the copyright holder nor the names of contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 *
32 * $Id: sha2.c,v 1.1 2001/11/08 00:01:51 adg Exp adg $
33 */
ea542140 34#include <config.h>
84a0890e 35
453b82a3 36#include <endian.h>
84a0890e
MV		 37#include <string.h> /* memcpy()/memset() or bcopy()/bzero() */
38#include <assert.h> /* assert() */
39#include "sha2_internal.h"
40
41/*
42 * ASSERT NOTE:
43 * Some sanity checking code is included using assert(). On my FreeBSD
44 * system, this additional code can be removed by compiling with NDEBUG
45 * defined. Check your own systems manpage on assert() to see how to
46 * compile WITHOUT the sanity checking code on your system.
47 *
48 * UNROLLED TRANSFORM LOOP NOTE:
49 * You can define SHA2_UNROLL_TRANSFORM to use the unrolled transform
50 * loop version for the hash transform rounds (defined using macros
51 * later in this file). Either define on the command line, for example:
52 *
53 * cc -DSHA2_UNROLL_TRANSFORM -o sha2 sha2.c sha2prog.c
54 *
55 * or define below:
56 *
57 * #define SHA2_UNROLL_TRANSFORM
58 *
59 */
60
61
62/*** SHA-256/384/512 Machine Architecture Definitions *****************/
63/*
64 * BYTE_ORDER NOTE:
65 *
66 * Please make sure that your system defines BYTE_ORDER. If your
67 * architecture is little-endian, make sure it also defines
68 * LITTLE_ENDIAN and that the two (BYTE_ORDER and LITTLE_ENDIAN) are
1e3f4083 69 * equivalent.
84a0890e
MV		 70 *
71 * If your system does not define the above, then you can do so by
72 * hand like this:
73 *
74 * #define LITTLE_ENDIAN 1234
75 * #define BIG_ENDIAN 4321
76 *
77 * And for little-endian machines, add:
78 *
79 * #define BYTE_ORDER LITTLE_ENDIAN
80 *
81 * Or for big-endian machines:
82 *
83 * #define BYTE_ORDER BIG_ENDIAN
84 *
85 * The FreeBSD machine this was written on defines BYTE_ORDER
86 * appropriately by including <sys/types.h> (which in turn includes
87 * <machine/endian.h> where the appropriate definitions are actually
88 * made).
89 */
90#if !defined(BYTE_ORDER) || (BYTE_ORDER != LITTLE_ENDIAN && BYTE_ORDER != BIG_ENDIAN)
91#error Define BYTE_ORDER to be equal to either LITTLE_ENDIAN or BIG_ENDIAN
92#endif
93
94/*
95 * Define the followingsha2_* types to types of the correct length on
96 * the native archtecture. Most BSD systems and Linux define u_intXX_t
97 * types. Machines with very recent ANSI C headers, can use the
98 * uintXX_t definintions from inttypes.h by defining SHA2_USE_INTTYPES_H
99 * during compile or in the sha.h header file.
100 *
101 * Machines that support neither u_intXX_t nor inttypes.h's uintXX_t
102 * will need to define these three typedefs below (and the appropriate
103 * ones in sha.h too) by hand according to their system architecture.
104 *
105 * Thank you, Jun-ichiro itojun Hagino, for suggesting using u_intXX_t
106 * types and pointing out recent ANSI C support for uintXX_t in inttypes.h.
107 */
108#ifdef SHA2_USE_INTTYPES_H
109
110typedef uint8_t sha2_byte; /* Exactly 1 byte */
111typedef uint32_t sha2_word32; /* Exactly 4 bytes */
112typedef uint64_t sha2_word64; /* Exactly 8 bytes */
113
114#else /* SHA2_USE_INTTYPES_H */
115
116typedef u_int8_t sha2_byte; /* Exactly 1 byte */
117typedef u_int32_t sha2_word32; /* Exactly 4 bytes */
118typedef u_int64_t sha2_word64; /* Exactly 8 bytes */
119
120#endif /* SHA2_USE_INTTYPES_H */
121
122
123/*** SHA-256/384/512 Various Length Definitions ***********************/
124/* NOTE: Most of these are in sha2.h */
125#define SHA256_SHORT_BLOCK_LENGTH (SHA256_BLOCK_LENGTH - 8)
126#define SHA384_SHORT_BLOCK_LENGTH (SHA384_BLOCK_LENGTH - 16)
127#define SHA512_SHORT_BLOCK_LENGTH (SHA512_BLOCK_LENGTH - 16)
128
129
130/*** ENDIAN REVERSAL MACROS *******************************************/
131#if BYTE_ORDER == LITTLE_ENDIAN
76cbc9ab
DK		 132#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
133#define REVERSE32(w,x) { \
134 (x) = __builtin_bswap32(w); \
135}
136#define REVERSE64(w,x) { \
137 (x) = __builtin_bswap64(w); \
138}
139#else
84a0890e
MV		 140#define REVERSE32(w,x) { \
141 sha2_word32 tmp = (w); \
142 tmp = (tmp >> 16) | (tmp << 16); \
143 (x) = ((tmp & 0xff00ff00UL) >> 8) | ((tmp & 0x00ff00ffUL) << 8); \
144}
145#define REVERSE64(w,x) { \
146 sha2_word64 tmp = (w); \
147 tmp = (tmp >> 32) | (tmp << 32); \
148 tmp = ((tmp & 0xff00ff00ff00ff00ULL) >> 8) | \
149 ((tmp & 0x00ff00ff00ff00ffULL) << 8); \
150 (x) = ((tmp & 0xffff0000ffff0000ULL) >> 16) | \
151 ((tmp & 0x0000ffff0000ffffULL) << 16); \
152}
76cbc9ab 153#endif
84a0890e
MV		 154#endif /* BYTE_ORDER == LITTLE_ENDIAN */
155
156/*
157 * Macro for incrementally adding the unsigned 64-bit integer n to the
158 * unsigned 128-bit integer (represented using a two-element array of
159 * 64-bit words):
160 */
161#define ADDINC128(w,n) { \
162 (w)[0] += (sha2_word64)(n); \
163 if ((w)[0] < (n)) { \
164 (w)[1]++; \
165 } \
166}
167
168/*
169 * Macros for copying blocks of memory and for zeroing out ranges
170 * of memory. Using these macros makes it easy to switch from
171 * using memset()/memcpy() and using bzero()/bcopy().
172 *
173 * Please define either SHA2_USE_MEMSET_MEMCPY or define
174 * SHA2_USE_BZERO_BCOPY depending on which function set you
175 * choose to use:
176 */
177#if !defined(SHA2_USE_MEMSET_MEMCPY) && !defined(SHA2_USE_BZERO_BCOPY)
178/* Default to memset()/memcpy() if no option is specified */
179#define SHA2_USE_MEMSET_MEMCPY 1
180#endif
181#if defined(SHA2_USE_MEMSET_MEMCPY) && defined(SHA2_USE_BZERO_BCOPY)
182/* Abort with an error if BOTH options are defined */
183#error Define either SHA2_USE_MEMSET_MEMCPY or SHA2_USE_BZERO_BCOPY, not both!
184#endif
185
186#ifdef SHA2_USE_MEMSET_MEMCPY
187#define MEMSET_BZERO(p,l) memset((p), 0, (l))
188#define MEMCPY_BCOPY(d,s,l) memcpy((d), (s), (l))
189#endif
190#ifdef SHA2_USE_BZERO_BCOPY
191#define MEMSET_BZERO(p,l) bzero((p), (l))
192#define MEMCPY_BCOPY(d,s,l) bcopy((s), (d), (l))
193#endif
194
195
196/*** THE SIX LOGICAL FUNCTIONS ****************************************/
197/*
198 * Bit shifting and rotation (used by the six SHA-XYZ logical functions:
199 *
200 * NOTE: The naming of R and S appears backwards here (R is a SHIFT and
201 * S is a ROTATION) because the SHA-256/384/512 description document
202 * (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this
203 * same "backwards" definition.
204 */
205/* Shift-right (used in SHA-256, SHA-384, and SHA-512): */
206#define R(b,x) ((x) >> (b))
207/* 32-bit Rotate-right (used in SHA-256): */
208#define S32(b,x) (((x) >> (b)) | ((x) << (32 - (b))))
209/* 64-bit Rotate-right (used in SHA-384 and SHA-512): */
210#define S64(b,x) (((x) >> (b)) | ((x) << (64 - (b))))
211
212/* Two of six logical functions used in SHA-256, SHA-384, and SHA-512: */
213#define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
214#define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
215
216/* Four of six logical functions used in SHA-256: */
217#define Sigma0_256(x) (S32(2, (x)) ^ S32(13, (x)) ^ S32(22, (x)))
218#define Sigma1_256(x) (S32(6, (x)) ^ S32(11, (x)) ^ S32(25, (x)))
219#define sigma0_256(x) (S32(7, (x)) ^ S32(18, (x)) ^ R(3 , (x)))
220#define sigma1_256(x) (S32(17, (x)) ^ S32(19, (x)) ^ R(10, (x)))
221
222/* Four of six logical functions used in SHA-384 and SHA-512: */
223#define Sigma0_512(x) (S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x)))
224#define Sigma1_512(x) (S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x)))
225#define sigma0_512(x) (S64( 1, (x)) ^ S64( 8, (x)) ^ R( 7, (x)))
226#define sigma1_512(x) (S64(19, (x)) ^ S64(61, (x)) ^ R( 6, (x)))
227
228/*** INTERNAL FUNCTION PROTOTYPES *************************************/
229/* NOTE: These should not be accessed directly from outside this
230 * library -- they are intended for private internal visibility/use
231 * only.
232 */
ef25649c
ME		 233static void SHA512_Last(SHA512_CTX*);
234static void SHA256_Transform(SHA256_CTX*, const sha2_word32*);
235static void SHA512_Transform(SHA512_CTX*, const sha2_word64*);
84a0890e
MV		 236
237
238/*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
239/* Hash constant words K for SHA-256: */
240const static sha2_word32 K256[64] = {
241 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
242 0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
243 0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
244 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL,
245 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
246 0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL,
247 0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL,
248 0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL,
249 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL,
250 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
251 0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL,
252 0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL,
253 0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL,
254 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL,
255 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
256 0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
257};
258
259/* Initial hash value H for SHA-256: */
260const static sha2_word32 sha256_initial_hash_value[8] = {
261 0x6a09e667UL,
262 0xbb67ae85UL,
263 0x3c6ef372UL,
264 0xa54ff53aUL,
265 0x510e527fUL,
266 0x9b05688cUL,
267 0x1f83d9abUL,
268 0x5be0cd19UL
269};
270
271/* Hash constant words K for SHA-384 and SHA-512: */
272const static sha2_word64 K512[80] = {
273 0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
274 0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
275 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
276 0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
277 0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,
278 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
279 0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,
280 0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
281 0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
282 0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
283 0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,
284 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
285 0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,
286 0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
287 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
288 0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
289 0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,
290 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
291 0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,
292 0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
293 0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
294 0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
295 0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,
296 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
297 0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,
298 0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
299 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
300 0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
301 0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,
302 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
303 0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,
304 0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
305 0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
306 0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
307 0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,
308 0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
309 0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,
310 0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
311 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
312 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL
313};
314
315/* Initial hash value H for SHA-384 */
316const static sha2_word64 sha384_initial_hash_value[8] = {
317 0xcbbb9d5dc1059ed8ULL,
318 0x629a292a367cd507ULL,
319 0x9159015a3070dd17ULL,
320 0x152fecd8f70e5939ULL,
321 0x67332667ffc00b31ULL,
322 0x8eb44a8768581511ULL,
323 0xdb0c2e0d64f98fa7ULL,
324 0x47b5481dbefa4fa4ULL
325};
326
327/* Initial hash value H for SHA-512 */
328const static sha2_word64 sha512_initial_hash_value[8] = {
329 0x6a09e667f3bcc908ULL,
330 0xbb67ae8584caa73bULL,
331 0x3c6ef372fe94f82bULL,
332 0xa54ff53a5f1d36f1ULL,
333 0x510e527fade682d1ULL,
334 0x9b05688c2b3e6c1fULL,
335 0x1f83d9abfb41bd6bULL,
336 0x5be0cd19137e2179ULL
337};
338
339/*
340 * Constant used by SHA256/384/512_End() functions for converting the
341 * digest to a readable hexadecimal character string:
342 */
343static const char *sha2_hex_digits = "0123456789abcdef";
344
345
346/*** SHA-256: *********************************************************/
347void SHA256_Init(SHA256_CTX* context) {
348 if (context == (SHA256_CTX*)0) {
349 return;
350 }
351 MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
352 MEMSET_BZERO(context->buffer, SHA256_BLOCK_LENGTH);
353 context->bitcount = 0;
354}
355
356#ifdef SHA2_UNROLL_TRANSFORM
357
358/* Unrolled SHA-256 round macros: */
359
360#if BYTE_ORDER == LITTLE_ENDIAN
361
362#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \
363 REVERSE32(*data++, W256[j]); \
364 T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
365 K256[j] + W256[j]; \
366 (d) += T1; \
367 (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
368 j++
369
370
371#else /* BYTE_ORDER == LITTLE_ENDIAN */
372
373#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \
374 T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
375 K256[j] + (W256[j] = *data++); \
376 (d) += T1; \
377 (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
378 j++
379
380#endif /* BYTE_ORDER == LITTLE_ENDIAN */
381
382#define ROUND256(a,b,c,d,e,f,g,h) \
383 s0 = W256[(j+1)&0x0f]; \
384 s0 = sigma0_256(s0); \
385 s1 = W256[(j+14)&0x0f]; \
386 s1 = sigma1_256(s1); \
387 T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \
388 (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \
389 (d) += T1; \
390 (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
391 j++
392
ef25649c 393static void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
84a0890e
MV		 394 sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
395 sha2_word32 T1, *W256;
396 int j;
397
398 W256 = (sha2_word32*)context->buffer;
399
400 /* Initialize registers with the prev. intermediate value */
401 a = context->state[0];
402 b = context->state[1];
403 c = context->state[2];
404 d = context->state[3];
405 e = context->state[4];
406 f = context->state[5];
407 g = context->state[6];
408 h = context->state[7];
409
410 j = 0;
411 do {
412 /* Rounds 0 to 15 (unrolled): */
413 ROUND256_0_TO_15(a,b,c,d,e,f,g,h);
414 ROUND256_0_TO_15(h,a,b,c,d,e,f,g);
415 ROUND256_0_TO_15(g,h,a,b,c,d,e,f);
416 ROUND256_0_TO_15(f,g,h,a,b,c,d,e);
417 ROUND256_0_TO_15(e,f,g,h,a,b,c,d);
418 ROUND256_0_TO_15(d,e,f,g,h,a,b,c);
419 ROUND256_0_TO_15(c,d,e,f,g,h,a,b);
420 ROUND256_0_TO_15(b,c,d,e,f,g,h,a);
421 } while (j < 16);
422
423 /* Now for the remaining rounds to 64: */
424 do {
425 ROUND256(a,b,c,d,e,f,g,h);
426 ROUND256(h,a,b,c,d,e,f,g);
427 ROUND256(g,h,a,b,c,d,e,f);
428 ROUND256(f,g,h,a,b,c,d,e);
429 ROUND256(e,f,g,h,a,b,c,d);
430 ROUND256(d,e,f,g,h,a,b,c);
431 ROUND256(c,d,e,f,g,h,a,b);
432 ROUND256(b,c,d,e,f,g,h,a);
433 } while (j < 64);
434
435 /* Compute the current intermediate hash value */
436 context->state[0] += a;
437 context->state[1] += b;
438 context->state[2] += c;
439 context->state[3] += d;
440 context->state[4] += e;
441 context->state[5] += f;
442 context->state[6] += g;
443 context->state[7] += h;
444
445 /* Clean up */
446 a = b = c = d = e = f = g = h = T1 = 0;
447}
448
449#else /* SHA2_UNROLL_TRANSFORM */
450
ef25649c 451static void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
84a0890e
MV		 452 sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
453 sha2_word32 T1, T2, *W256;
454 int j;
455
456 W256 = (sha2_word32*)context->buffer;
457
458 /* Initialize registers with the prev. intermediate value */
459 a = context->state[0];
460 b = context->state[1];
461 c = context->state[2];
462 d = context->state[3];
463 e = context->state[4];
464 f = context->state[5];
465 g = context->state[6];
466 h = context->state[7];
467
468 j = 0;
469 do {
470#if BYTE_ORDER == LITTLE_ENDIAN
471 /* Copy data while converting to host byte order */
472 REVERSE32(*data++,W256[j]);
473 /* Apply the SHA-256 compression function to update a..h */
474 T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j];
475#else /* BYTE_ORDER == LITTLE_ENDIAN */
476 /* Apply the SHA-256 compression function to update a..h with copy */
477 T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++);
478#endif /* BYTE_ORDER == LITTLE_ENDIAN */
479 T2 = Sigma0_256(a) + Maj(a, b, c);
480 h = g;
481 g = f;
482 f = e;
483 e = d + T1;
484 d = c;
485 c = b;
486 b = a;
487 a = T1 + T2;
488
489 j++;
490 } while (j < 16);
491
492 do {
493 /* Part of the message block expansion: */
494 s0 = W256[(j+1)&0x0f];
495 s0 = sigma0_256(s0);
496 s1 = W256[(j+14)&0x0f];
497 s1 = sigma1_256(s1);
498
499 /* Apply the SHA-256 compression function to update a..h */
500 T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] +
501 (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0);
502 T2 = Sigma0_256(a) + Maj(a, b, c);
503 h = g;
504 g = f;
505 f = e;
506 e = d + T1;
507 d = c;
508 c = b;
509 b = a;
510 a = T1 + T2;
511
512 j++;
513 } while (j < 64);
514
515 /* Compute the current intermediate hash value */
516 context->state[0] += a;
517 context->state[1] += b;
518 context->state[2] += c;
519 context->state[3] += d;
520 context->state[4] += e;
521 context->state[5] += f;
522 context->state[6] += g;
523 context->state[7] += h;
524
525 /* Clean up */
526 a = b = c = d = e = f = g = h = T1 = T2 = 0;
527}
528
529#endif /* SHA2_UNROLL_TRANSFORM */
530
531void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
532 unsigned int freespace, usedspace;
533
534 if (len == 0) {
535 /* Calling with no data is valid - we do nothing */
536 return;
537 }
538
539 /* Sanity check: */
540 assert(context != (SHA256_CTX*)0 && data != (sha2_byte*)0);
541
542 usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
543 if (usedspace > 0) {
544 /* Calculate how much free space is available in the buffer */
545 freespace = SHA256_BLOCK_LENGTH - usedspace;
546
547 if (len >= freespace) {
548 /* Fill the buffer completely and process it */
549 MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
550 context->bitcount += freespace << 3;
551 len -= freespace;
552 data += freespace;
553 SHA256_Transform(context, (sha2_word32*)context->buffer);
554 } else {
555 /* The buffer is not yet full */
556 MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
557 context->bitcount += len << 3;
558 /* Clean up: */
559 usedspace = freespace = 0;
560 return;
561 }
562 }
563 while (len >= SHA256_BLOCK_LENGTH) {
564 /* Process as many complete blocks as we can */
5149632e
DK		 565 sha2_byte buffer[SHA256_BLOCK_LENGTH];
566 MEMCPY_BCOPY(buffer, data, SHA256_BLOCK_LENGTH);
567 SHA256_Transform(context, (sha2_word32*)buffer);
84a0890e
MV		 568 context->bitcount += SHA256_BLOCK_LENGTH << 3;
569 len -= SHA256_BLOCK_LENGTH;
570 data += SHA256_BLOCK_LENGTH;
571 }
572 if (len > 0) {
573 /* There's left-overs, so save 'em */
574 MEMCPY_BCOPY(context->buffer, data, len);
575 context->bitcount += len << 3;
576 }
577 /* Clean up: */
578 usedspace = freespace = 0;
579}
580
581void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
582 sha2_word32 *d = (sha2_word32*)digest;
583 unsigned int usedspace;
584
585 /* Sanity check: */
586 assert(context != (SHA256_CTX*)0);
587
588 /* If no digest buffer is passed, we don't bother doing this: */
589 if (digest != (sha2_byte*)0) {
590 usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
591#if BYTE_ORDER == LITTLE_ENDIAN
592 /* Convert FROM host byte order */
593 REVERSE64(context->bitcount,context->bitcount);
594#endif
595 if (usedspace > 0) {
596 /* Begin padding with a 1 bit: */
597 context->buffer[usedspace++] = 0x80;
598
599 if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) {
600 /* Set-up for the last transform: */
601 MEMSET_BZERO(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LENGTH - usedspace);
602 } else {
603 if (usedspace < SHA256_BLOCK_LENGTH) {
604 MEMSET_BZERO(&context->buffer[usedspace], SHA256_BLOCK_LENGTH - usedspace);
605 }
606 /* Do second-to-last transform: */
607 SHA256_Transform(context, (sha2_word32*)context->buffer);
608
609 /* And set-up for the last transform: */
610 MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
611 }
612 } else {
613 /* Set-up for the last transform: */
614 MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
615
616 /* Begin padding with a 1 bit: */
617 *context->buffer = 0x80;
618 }
619 /* Set the bit count: */
1f8fe502
DK		 620 union {
621 sha2_byte* c;
622 sha2_word64* l;
623 } bitcount;
624 bitcount.c = &context->buffer[SHA256_SHORT_BLOCK_LENGTH];
625 *(bitcount.l) = context->bitcount;
84a0890e
MV		 626
627 /* Final transform: */
628 SHA256_Transform(context, (sha2_word32*)context->buffer);
629
630#if BYTE_ORDER == LITTLE_ENDIAN
631 {
632 /* Convert TO host byte order */
633 int j;
634 for (j = 0; j < 8; j++) {
635 REVERSE32(context->state[j],context->state[j]);
636 *d++ = context->state[j];
637 }
638 }
639#else
640 MEMCPY_BCOPY(d, context->state, SHA256_DIGEST_LENGTH);
641#endif
642 }
643
644 /* Clean up state data: */
f58a9890 645 MEMSET_BZERO(context, sizeof(*context));
84a0890e
MV		 646 usedspace = 0;
647}
648
649char *SHA256_End(SHA256_CTX* context, char buffer[]) {
650 sha2_byte digest[SHA256_DIGEST_LENGTH], *d = digest;
651 int i;
652
653 /* Sanity check: */
654 assert(context != (SHA256_CTX*)0);
655
656 if (buffer != (char*)0) {
657 SHA256_Final(digest, context);
658
659 for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
660 *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
661 *buffer++ = sha2_hex_digits[*d & 0x0f];
662 d++;
663 }
664 *buffer = (char)0;
665 } else {
f58a9890 666 MEMSET_BZERO(context, sizeof(*context));
84a0890e
MV		 667 }
668 MEMSET_BZERO(digest, SHA256_DIGEST_LENGTH);
669 return buffer;
670}
671
672char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {
673 SHA256_CTX context;
674
675 SHA256_Init(&context);
676 SHA256_Update(&context, data, len);
677 return SHA256_End(&context, digest);
678}
679
680
681/*** SHA-512: *********************************************************/
682void SHA512_Init(SHA512_CTX* context) {
683 if (context == (SHA512_CTX*)0) {
684 return;
685 }
686 MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
687 MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH);
688 context->bitcount[0] = context->bitcount[1] = 0;
689}
690
691#ifdef SHA2_UNROLL_TRANSFORM
692
693/* Unrolled SHA-512 round macros: */
694#if BYTE_ORDER == LITTLE_ENDIAN
695
696#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \
697 REVERSE64(*data++, W512[j]); \
698 T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
699 K512[j] + W512[j]; \
700 (d) += T1, \
701 (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)), \
702 j++
703
704
705#else /* BYTE_ORDER == LITTLE_ENDIAN */
706
707#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \
708 T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
709 K512[j] + (W512[j] = *data++); \
710 (d) += T1; \
711 (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
712 j++
713
714#endif /* BYTE_ORDER == LITTLE_ENDIAN */
715
716#define ROUND512(a,b,c,d,e,f,g,h) \
717 s0 = W512[(j+1)&0x0f]; \
718 s0 = sigma0_512(s0); \
719 s1 = W512[(j+14)&0x0f]; \
720 s1 = sigma1_512(s1); \
721 T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \
722 (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \
723 (d) += T1; \
724 (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
725 j++
726
ef25649c 727static void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
84a0890e
MV		 728 sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
729 sha2_word64 T1, *W512 = (sha2_word64*)context->buffer;
730 int j;
731
732 /* Initialize registers with the prev. intermediate value */
733 a = context->state[0];
734 b = context->state[1];
735 c = context->state[2];
736 d = context->state[3];
737 e = context->state[4];
738 f = context->state[5];
739 g = context->state[6];
740 h = context->state[7];
741
742 j = 0;
743 do {
744 ROUND512_0_TO_15(a,b,c,d,e,f,g,h);
745 ROUND512_0_TO_15(h,a,b,c,d,e,f,g);
746 ROUND512_0_TO_15(g,h,a,b,c,d,e,f);
747 ROUND512_0_TO_15(f,g,h,a,b,c,d,e);
748 ROUND512_0_TO_15(e,f,g,h,a,b,c,d);
749 ROUND512_0_TO_15(d,e,f,g,h,a,b,c);
750 ROUND512_0_TO_15(c,d,e,f,g,h,a,b);
751 ROUND512_0_TO_15(b,c,d,e,f,g,h,a);
752 } while (j < 16);
753
754 /* Now for the remaining rounds up to 79: */
755 do {
756 ROUND512(a,b,c,d,e,f,g,h);
757 ROUND512(h,a,b,c,d,e,f,g);
758 ROUND512(g,h,a,b,c,d,e,f);
759 ROUND512(f,g,h,a,b,c,d,e);
760 ROUND512(e,f,g,h,a,b,c,d);
761 ROUND512(d,e,f,g,h,a,b,c);
762 ROUND512(c,d,e,f,g,h,a,b);
763 ROUND512(b,c,d,e,f,g,h,a);
764 } while (j < 80);
765
766 /* Compute the current intermediate hash value */
767 context->state[0] += a;
768 context->state[1] += b;
769 context->state[2] += c;
770 context->state[3] += d;
771 context->state[4] += e;
772 context->state[5] += f;
773 context->state[6] += g;
774 context->state[7] += h;
775
776 /* Clean up */
777 a = b = c = d = e = f = g = h = T1 = 0;
778}
779
780#else /* SHA2_UNROLL_TRANSFORM */
781
ef25649c 782static void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
84a0890e
MV		 783 sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
784 sha2_word64 T1, T2, *W512 = (sha2_word64*)context->buffer;
785 int j;
786
787 /* Initialize registers with the prev. intermediate value */
788 a = context->state[0];
789 b = context->state[1];
790 c = context->state[2];
791 d = context->state[3];
792 e = context->state[4];
793 f = context->state[5];
794 g = context->state[6];
795 h = context->state[7];
796
797 j = 0;
798 do {
799#if BYTE_ORDER == LITTLE_ENDIAN
800 /* Convert TO host byte order */
801 REVERSE64(*data++, W512[j]);
802 /* Apply the SHA-512 compression function to update a..h */
803 T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j];
804#else /* BYTE_ORDER == LITTLE_ENDIAN */
805 /* Apply the SHA-512 compression function to update a..h with copy */
806 T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j] = *data++);
807#endif /* BYTE_ORDER == LITTLE_ENDIAN */
808 T2 = Sigma0_512(a) + Maj(a, b, c);
809 h = g;
810 g = f;
811 f = e;
812 e = d + T1;
813 d = c;
814 c = b;
815 b = a;
816 a = T1 + T2;
817
818 j++;
819 } while (j < 16);
820
821 do {
822 /* Part of the message block expansion: */
823 s0 = W512[(j+1)&0x0f];
824 s0 = sigma0_512(s0);
825 s1 = W512[(j+14)&0x0f];
826 s1 = sigma1_512(s1);
827
828 /* Apply the SHA-512 compression function to update a..h */
829 T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] +
830 (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0);
831 T2 = Sigma0_512(a) + Maj(a, b, c);
832 h = g;
833 g = f;
834 f = e;
835 e = d + T1;
836 d = c;
837 c = b;
838 b = a;
839 a = T1 + T2;
840
841 j++;
842 } while (j < 80);
843
844 /* Compute the current intermediate hash value */
845 context->state[0] += a;
846 context->state[1] += b;
847 context->state[2] += c;
848 context->state[3] += d;
849 context->state[4] += e;
850 context->state[5] += f;
851 context->state[6] += g;
852 context->state[7] += h;
853
854 /* Clean up */
855 a = b = c = d = e = f = g = h = T1 = T2 = 0;
856}
857
858#endif /* SHA2_UNROLL_TRANSFORM */
859
860void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
861 unsigned int freespace, usedspace;
862
863 if (len == 0) {
864 /* Calling with no data is valid - we do nothing */
865 return;
866 }
867
868 /* Sanity check: */
869 assert(context != (SHA512_CTX*)0 && data != (sha2_byte*)0);
870
871 usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
872 if (usedspace > 0) {
873 /* Calculate how much free space is available in the buffer */
874 freespace = SHA512_BLOCK_LENGTH - usedspace;
875
876 if (len >= freespace) {
877 /* Fill the buffer completely and process it */
878 MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
879 ADDINC128(context->bitcount, freespace << 3);
880 len -= freespace;
881 data += freespace;
882 SHA512_Transform(context, (sha2_word64*)context->buffer);
883 } else {
884 /* The buffer is not yet full */
885 MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
886 ADDINC128(context->bitcount, len << 3);
887 /* Clean up: */
888 usedspace = freespace = 0;
889 return;
890 }
891 }
892 while (len >= SHA512_BLOCK_LENGTH) {
893 /* Process as many complete blocks as we can */
5149632e
DK		 894 sha2_byte buffer[SHA512_BLOCK_LENGTH];
895 MEMCPY_BCOPY(buffer, data, SHA512_BLOCK_LENGTH);
896 SHA512_Transform(context, (sha2_word64*)buffer);
84a0890e
MV		 897 ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
898 len -= SHA512_BLOCK_LENGTH;
899 data += SHA512_BLOCK_LENGTH;
900 }
901 if (len > 0) {
902 /* There's left-overs, so save 'em */
903 MEMCPY_BCOPY(context->buffer, data, len);
904 ADDINC128(context->bitcount, len << 3);
905 }
906 /* Clean up: */
907 usedspace = freespace = 0;
908}
909
ef25649c 910static void SHA512_Last(SHA512_CTX* context) {
84a0890e
MV		 911 unsigned int usedspace;
912
913 usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
914#if BYTE_ORDER == LITTLE_ENDIAN
915 /* Convert FROM host byte order */
916 REVERSE64(context->bitcount[0],context->bitcount[0]);
917 REVERSE64(context->bitcount[1],context->bitcount[1]);
918#endif
919 if (usedspace > 0) {
920 /* Begin padding with a 1 bit: */
921 context->buffer[usedspace++] = 0x80;
922
923 if (usedspace <= SHA512_SHORT_BLOCK_LENGTH) {
924 /* Set-up for the last transform: */
925 MEMSET_BZERO(&context->buffer[usedspace], SHA512_SHORT_BLOCK_LENGTH - usedspace);
926 } else {
927 if (usedspace < SHA512_BLOCK_LENGTH) {
928 MEMSET_BZERO(&context->buffer[usedspace], SHA512_BLOCK_LENGTH - usedspace);
929 }
930 /* Do second-to-last transform: */
931 SHA512_Transform(context, (sha2_word64*)context->buffer);
932
933 /* And set-up for the last transform: */
934 MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH - 2);
935 }
936 } else {
937 /* Prepare for final transform: */
938 MEMSET_BZERO(context->buffer, SHA512_SHORT_BLOCK_LENGTH);
939
940 /* Begin padding with a 1 bit: */
941 *context->buffer = 0x80;
942 }
943 /* Store the length of input data (in bits): */
1f8fe502
DK		 944 union {
945 sha2_byte* c;
946 sha2_word64* l;
947 } bitcount;
948 bitcount.c = &context->buffer[SHA512_SHORT_BLOCK_LENGTH];
949 bitcount.l[0] = context->bitcount[1];
950 bitcount.l[1] = context->bitcount[0];
84a0890e
MV		 951
952 /* Final transform: */
953 SHA512_Transform(context, (sha2_word64*)context->buffer);
954}
955
956void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
957 sha2_word64 *d = (sha2_word64*)digest;
958
959 /* Sanity check: */
960 assert(context != (SHA512_CTX*)0);
961
962 /* If no digest buffer is passed, we don't bother doing this: */
963 if (digest != (sha2_byte*)0) {
964 SHA512_Last(context);
965
966 /* Save the hash data for output: */
967#if BYTE_ORDER == LITTLE_ENDIAN
968 {
969 /* Convert TO host byte order */
970 int j;
971 for (j = 0; j < 8; j++) {
972 REVERSE64(context->state[j],context->state[j]);
973 *d++ = context->state[j];
974 }
975 }
976#else
977 MEMCPY_BCOPY(d, context->state, SHA512_DIGEST_LENGTH);
978#endif
979 }
980
981 /* Zero out state data */
f58a9890 982 MEMSET_BZERO(context, sizeof(*context));
84a0890e
MV		 983}
984
985char *SHA512_End(SHA512_CTX* context, char buffer[]) {
986 sha2_byte digest[SHA512_DIGEST_LENGTH], *d = digest;
987 int i;
988
989 /* Sanity check: */
990 assert(context != (SHA512_CTX*)0);
991
992 if (buffer != (char*)0) {
993 SHA512_Final(digest, context);
994
995 for (i = 0; i < SHA512_DIGEST_LENGTH; i++) {
996 *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
997 *buffer++ = sha2_hex_digits[*d & 0x0f];
998 d++;
999 }
1000 *buffer = (char)0;
1001 } else {
f58a9890 1002 MEMSET_BZERO(context, sizeof(*context));
84a0890e
MV		 1003 }
1004 MEMSET_BZERO(digest, SHA512_DIGEST_LENGTH);
1005 return buffer;
1006}
1007
1008char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) {
1009 SHA512_CTX context;
1010
1011 SHA512_Init(&context);
1012 SHA512_Update(&context, data, len);
1013 return SHA512_End(&context, digest);
1014}
1015
1016
1017/*** SHA-384: *********************************************************/
1018void SHA384_Init(SHA384_CTX* context) {
1019 if (context == (SHA384_CTX*)0) {
1020 return;
1021 }
1022 MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH);
1023 MEMSET_BZERO(context->buffer, SHA384_BLOCK_LENGTH);
1024 context->bitcount[0] = context->bitcount[1] = 0;
1025}
1026
1027void SHA384_Update(SHA384_CTX* context, const sha2_byte* data, size_t len) {
1028 SHA512_Update((SHA512_CTX*)context, data, len);
1029}
1030
1031void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
1032 sha2_word64 *d = (sha2_word64*)digest;
1033
1034 /* Sanity check: */
1035 assert(context != (SHA384_CTX*)0);
1036
1037 /* If no digest buffer is passed, we don't bother doing this: */
1038 if (digest != (sha2_byte*)0) {
1039 SHA512_Last((SHA512_CTX*)context);
1040
1041 /* Save the hash data for output: */
1042#if BYTE_ORDER == LITTLE_ENDIAN
1043 {
1044 /* Convert TO host byte order */
1045 int j;
1046 for (j = 0; j < 6; j++) {
1047 REVERSE64(context->state[j],context->state[j]);
1048 *d++ = context->state[j];
1049 }
1050 }
1051#else
1052 MEMCPY_BCOPY(d, context->state, SHA384_DIGEST_LENGTH);
1053#endif
1054 }
1055
1056 /* Zero out state data */
f58a9890 1057 MEMSET_BZERO(context, sizeof(*context));
84a0890e
MV		 1058}
1059
1060char *SHA384_End(SHA384_CTX* context, char buffer[]) {
1061 sha2_byte digest[SHA384_DIGEST_LENGTH], *d = digest;
1062 int i;
1063
1064 /* Sanity check: */
1065 assert(context != (SHA384_CTX*)0);
1066
1067 if (buffer != (char*)0) {
1068 SHA384_Final(digest, context);
1069
1070 for (i = 0; i < SHA384_DIGEST_LENGTH; i++) {
1071 *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
1072 *buffer++ = sha2_hex_digits[*d & 0x0f];
1073 d++;
1074 }
1075 *buffer = (char)0;
1076 } else {
f58a9890 1077 MEMSET_BZERO(context, sizeof(*context));
84a0890e
MV		 1078 }
1079 MEMSET_BZERO(digest, SHA384_DIGEST_LENGTH);
1080 return buffer;
1081}
1082
1083char* SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) {
1084 SHA384_CTX context;
1085
1086 SHA384_Init(&context);
1087 SHA384_Update(&context, data, len);
1088 return SHA384_End(&context, digest);
1089}
1090
APT (for Cydia)