← Back to branch summary

~ubuntu-branches/debian/wheezy/zfsutils/wheezy

« back to all changes in this revision

Viewing changes to lib/libmd/sha512c.c

  • Committer: Package Import Robot
  • Author(s): Robert Millan, Robert Millan
  • Date: 2012-02-04 17:16:40 UTC
  • mfrom: (1.1.3)
  • Revision ID: package-import@ubuntu.com-20120204171640-zkmubmewnswspzku
Tags: 9.0-1
* New upstream release.

[ Robert Millan ]
* zfsutils.cron.daily: Fix to avoid listing children file systems'
  snapshots as candidates for removal.
* zfsutils.cron.daily: Remove verbose output.
* Remove X-Start-Before & X-Stop-After (no longer needed since ZVOL
  subsystem is not started by userland anymore).

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/libmd/sha512c.c
 
1
/*-
 
2
 * Copyright 2005 Colin Percival
 
3
 * All rights reserved.
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 * 1. Redistributions of source code must retain the above copyright
 
9
 *    notice, this list of conditions and the following disclaimer.
 
10
 * 2. Redistributions in binary form must reproduce the above copyright
 
11
 *    notice, this list of conditions and the following disclaimer in the
 
12
 *    documentation and/or other materials provided with the distribution.
 
13
 *
 
14
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 
15
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 
16
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 
17
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 
18
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
19
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 
20
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 
21
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 
22
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 
23
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 
24
 * SUCH DAMAGE.
 
25
 */
 
26
 
 
27
#include <sys/cdefs.h>
 
28
__FBSDID("$FreeBSD$");
 
29
 
 
30
#include <sys/endian.h>
 
31
#include <sys/types.h>
 
32
 
 
33
#include <string.h>
 
34
 
 
35
#include "sha512.h"
 
36
 
 
37
#if BYTE_ORDER == BIG_ENDIAN
 
38
 
 
39
/* Copy a vector of big-endian uint64_t into a vector of bytes */
 
40
#define be64enc_vect(dst, src, len)     \
 
41
        memcpy((void *)dst, (const void *)src, (size_t)len)
 
42
 
 
43
/* Copy a vector of bytes into a vector of big-endian uint64_t */
 
44
#define be64dec_vect(dst, src, len)     \
 
45
        memcpy((void *)dst, (const void *)src, (size_t)len)
 
46
 
 
47
#else /* BYTE_ORDER != BIG_ENDIAN */
 
48
 
 
49
/*
 
50
 * Encode a length len/4 vector of (uint64_t) into a length len vector of
 
51
 * (unsigned char) in big-endian form.  Assumes len is a multiple of 8.
 
52
 */
 
53
static void
 
54
be64enc_vect(unsigned char *dst, const uint64_t *src, size_t len)
 
55
{
 
56
        size_t i;
 
57
 
 
58
        for (i = 0; i < len / 8; i++)
 
59
                be64enc(dst + i * 8, src[i]);
 
60
}
 
61
 
 
62
/*
 
63
 * Decode a big-endian length len vector of (unsigned char) into a length
 
64
 * len/4 vector of (uint64_t).  Assumes len is a multiple of 8.
 
65
 */
 
66
static void
 
67
be64dec_vect(uint64_t *dst, const unsigned char *src, size_t len)
 
68
{
 
69
        size_t i;
 
70
 
 
71
        for (i = 0; i < len / 8; i++)
 
72
                dst[i] = be64dec(src + i * 8);
 
73
}
 
74
 
 
75
#endif /* BYTE_ORDER != BIG_ENDIAN */
 
76
 
 
77
/* Elementary functions used by SHA512 */
 
78
#define Ch(x, y, z)     ((x & (y ^ z)) ^ z)
 
79
#define Maj(x, y, z)    ((x & (y | z)) | (y & z))
 
80
#define SHR(x, n)       (x >> n)
 
81
#define ROTR(x, n)      ((x >> n) | (x << (64 - n)))
 
82
#define S0(x)           (ROTR(x, 28) ^ ROTR(x, 34) ^ ROTR(x, 39))
 
83
#define S1(x)           (ROTR(x, 14) ^ ROTR(x, 18) ^ ROTR(x, 41))
 
84
#define s0(x)           (ROTR(x, 1) ^ ROTR(x, 8) ^ SHR(x, 7))
 
85
#define s1(x)           (ROTR(x, 19) ^ ROTR(x, 61) ^ SHR(x, 6))
 
86
 
 
87
/* SHA512 round function */
 
88
#define RND(a, b, c, d, e, f, g, h, k)                  \
 
89
        t0 = h + S1(e) + Ch(e, f, g) + k;               \
 
90
        t1 = S0(a) + Maj(a, b, c);                      \
 
91
        d += t0;                                        \
 
92
        h  = t0 + t1;
 
93
 
 
94
/* Adjusted round function for rotating state */
 
95
#define RNDr(S, W, i, k)                        \
 
96
        RND(S[(80 - i) % 8], S[(81 - i) % 8],   \
 
97
            S[(82 - i) % 8], S[(83 - i) % 8],   \
 
98
            S[(84 - i) % 8], S[(85 - i) % 8],   \
 
99
            S[(86 - i) % 8], S[(87 - i) % 8],   \
 
100
            W[i] + k)
 
101
 
 
102
/*
 
103
 * SHA512 block compression function.  The 512-bit state is transformed via
 
104
 * the 512-bit input block to produce a new state.
 
105
 */
 
106
static void
 
107
SHA512_Transform(uint64_t * state, const unsigned char block[128])
 
108
{
 
109
        uint64_t W[80];
 
110
        uint64_t S[8];
 
111
        uint64_t t0, t1;
 
112
        int i;
 
113
 
 
114
        /* 1. Prepare message schedule W. */
 
115
        be64dec_vect(W, block, 128);
 
116
        for (i = 16; i < 80; i++)
 
117
                W[i] = s1(W[i - 2]) + W[i - 7] + s0(W[i - 15]) + W[i - 16];
 
118
 
 
119
        /* 2. Initialize working variables. */
 
120
        memcpy(S, state, 64);
 
121
 
 
122
        /* 3. Mix. */
 
123
        RNDr(S, W, 0, 0x428a2f98d728ae22ULL);
 
124
        RNDr(S, W, 1, 0x7137449123ef65cdULL);
 
125
        RNDr(S, W, 2, 0xb5c0fbcfec4d3b2fULL);
 
126
        RNDr(S, W, 3, 0xe9b5dba58189dbbcULL);
 
127
        RNDr(S, W, 4, 0x3956c25bf348b538ULL);
 
128
        RNDr(S, W, 5, 0x59f111f1b605d019ULL);
 
129
        RNDr(S, W, 6, 0x923f82a4af194f9bULL);
 
130
        RNDr(S, W, 7, 0xab1c5ed5da6d8118ULL);
 
131
        RNDr(S, W, 8, 0xd807aa98a3030242ULL);
 
132
        RNDr(S, W, 9, 0x12835b0145706fbeULL);
 
133
        RNDr(S, W, 10, 0x243185be4ee4b28cULL);
 
134
        RNDr(S, W, 11, 0x550c7dc3d5ffb4e2ULL);
 
135
        RNDr(S, W, 12, 0x72be5d74f27b896fULL);
 
136
        RNDr(S, W, 13, 0x80deb1fe3b1696b1ULL);
 
137
        RNDr(S, W, 14, 0x9bdc06a725c71235ULL);
 
138
        RNDr(S, W, 15, 0xc19bf174cf692694ULL);
 
139
        RNDr(S, W, 16, 0xe49b69c19ef14ad2ULL);
 
140
        RNDr(S, W, 17, 0xefbe4786384f25e3ULL);
 
141
        RNDr(S, W, 18, 0x0fc19dc68b8cd5b5ULL);
 
142
        RNDr(S, W, 19, 0x240ca1cc77ac9c65ULL);
 
143
        RNDr(S, W, 20, 0x2de92c6f592b0275ULL);
 
144
        RNDr(S, W, 21, 0x4a7484aa6ea6e483ULL);
 
145
        RNDr(S, W, 22, 0x5cb0a9dcbd41fbd4ULL);
 
146
        RNDr(S, W, 23, 0x76f988da831153b5ULL);
 
147
        RNDr(S, W, 24, 0x983e5152ee66dfabULL);
 
148
        RNDr(S, W, 25, 0xa831c66d2db43210ULL);
 
149
        RNDr(S, W, 26, 0xb00327c898fb213fULL);
 
150
        RNDr(S, W, 27, 0xbf597fc7beef0ee4ULL);
 
151
        RNDr(S, W, 28, 0xc6e00bf33da88fc2ULL);
 
152
        RNDr(S, W, 29, 0xd5a79147930aa725ULL);
 
153
        RNDr(S, W, 30, 0x06ca6351e003826fULL);
 
154
        RNDr(S, W, 31, 0x142929670a0e6e70ULL);
 
155
        RNDr(S, W, 32, 0x27b70a8546d22ffcULL);
 
156
        RNDr(S, W, 33, 0x2e1b21385c26c926ULL);
 
157
        RNDr(S, W, 34, 0x4d2c6dfc5ac42aedULL);
 
158
        RNDr(S, W, 35, 0x53380d139d95b3dfULL);
 
159
        RNDr(S, W, 36, 0x650a73548baf63deULL);
 
160
        RNDr(S, W, 37, 0x766a0abb3c77b2a8ULL);
 
161
        RNDr(S, W, 38, 0x81c2c92e47edaee6ULL);
 
162
        RNDr(S, W, 39, 0x92722c851482353bULL);
 
163
        RNDr(S, W, 40, 0xa2bfe8a14cf10364ULL);
 
164
        RNDr(S, W, 41, 0xa81a664bbc423001ULL);
 
165
        RNDr(S, W, 42, 0xc24b8b70d0f89791ULL);
 
166
        RNDr(S, W, 43, 0xc76c51a30654be30ULL);
 
167
        RNDr(S, W, 44, 0xd192e819d6ef5218ULL);
 
168
        RNDr(S, W, 45, 0xd69906245565a910ULL);
 
169
        RNDr(S, W, 46, 0xf40e35855771202aULL);
 
170
        RNDr(S, W, 47, 0x106aa07032bbd1b8ULL);
 
171
        RNDr(S, W, 48, 0x19a4c116b8d2d0c8ULL);
 
172
        RNDr(S, W, 49, 0x1e376c085141ab53ULL);
 
173
        RNDr(S, W, 50, 0x2748774cdf8eeb99ULL);
 
174
        RNDr(S, W, 51, 0x34b0bcb5e19b48a8ULL);
 
175
        RNDr(S, W, 52, 0x391c0cb3c5c95a63ULL);
 
176
        RNDr(S, W, 53, 0x4ed8aa4ae3418acbULL);
 
177
        RNDr(S, W, 54, 0x5b9cca4f7763e373ULL);
 
178
        RNDr(S, W, 55, 0x682e6ff3d6b2b8a3ULL);
 
179
        RNDr(S, W, 56, 0x748f82ee5defb2fcULL);
 
180
        RNDr(S, W, 57, 0x78a5636f43172f60ULL);
 
181
        RNDr(S, W, 58, 0x84c87814a1f0ab72ULL);
 
182
        RNDr(S, W, 59, 0x8cc702081a6439ecULL);
 
183
        RNDr(S, W, 60, 0x90befffa23631e28ULL);
 
184
        RNDr(S, W, 61, 0xa4506cebde82bde9ULL);
 
185
        RNDr(S, W, 62, 0xbef9a3f7b2c67915ULL);
 
186
        RNDr(S, W, 63, 0xc67178f2e372532bULL);
 
187
        RNDr(S, W, 64, 0xca273eceea26619cULL);
 
188
        RNDr(S, W, 65, 0xd186b8c721c0c207ULL);
 
189
        RNDr(S, W, 66, 0xeada7dd6cde0eb1eULL);
 
190
        RNDr(S, W, 67, 0xf57d4f7fee6ed178ULL);
 
191
        RNDr(S, W, 68, 0x06f067aa72176fbaULL);
 
192
        RNDr(S, W, 69, 0x0a637dc5a2c898a6ULL);
 
193
        RNDr(S, W, 70, 0x113f9804bef90daeULL);
 
194
        RNDr(S, W, 71, 0x1b710b35131c471bULL);
 
195
        RNDr(S, W, 72, 0x28db77f523047d84ULL);
 
196
        RNDr(S, W, 73, 0x32caab7b40c72493ULL);
 
197
        RNDr(S, W, 74, 0x3c9ebe0a15c9bebcULL);
 
198
        RNDr(S, W, 75, 0x431d67c49c100d4cULL);
 
199
        RNDr(S, W, 76, 0x4cc5d4becb3e42b6ULL);
 
200
        RNDr(S, W, 77, 0x597f299cfc657e2aULL);
 
201
        RNDr(S, W, 78, 0x5fcb6fab3ad6faecULL);
 
202
        RNDr(S, W, 79, 0x6c44198c4a475817ULL);
 
203
 
 
204
        /* 4. Mix local working variables into global state */
 
205
        for (i = 0; i < 8; i++)
 
206
                state[i] += S[i];
 
207
}
 
208
 
 
209
static unsigned char PAD[128] = {
 
210
        0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
211
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
212
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
213
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
214
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
215
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
216
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
217
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 
218
};
 
219
 
 
220
/* Add padding and terminating bit-count. */
 
221
static void
 
222
SHA512_Pad(SHA512_CTX * ctx)
 
223
{
 
224
        unsigned char len[16];
 
225
        uint64_t r, plen;
 
226
 
 
227
        /*
 
228
         * Convert length to a vector of bytes -- we do this now rather
 
229
         * than later because the length will change after we pad.
 
230
         */
 
231
        be64enc_vect(len, ctx->count, 16);
 
232
 
 
233
        /* Add 1--128 bytes so that the resulting length is 112 mod 128 */
 
234
        r = (ctx->count[1] >> 3) & 0x7f;
 
235
        plen = (r < 112) ? (112 - r) : (240 - r);
 
236
        SHA512_Update(ctx, PAD, (size_t)plen);
 
237
 
 
238
        /* Add the terminating bit-count */
 
239
        SHA512_Update(ctx, len, 16);
 
240
}
 
241
 
 
242
/* SHA-512 initialization.  Begins a SHA-512 operation. */
 
243
void
 
244
SHA512_Init(SHA512_CTX * ctx)
 
245
{
 
246
 
 
247
        /* Zero bits processed so far */
 
248
        ctx->count[0] = ctx->count[1] = 0;
 
249
 
 
250
        /* Magic initialization constants */
 
251
        ctx->state[0] = 0x6a09e667f3bcc908ULL;
 
252
        ctx->state[1] = 0xbb67ae8584caa73bULL;
 
253
        ctx->state[2] = 0x3c6ef372fe94f82bULL;
 
254
        ctx->state[3] = 0xa54ff53a5f1d36f1ULL;
 
255
        ctx->state[4] = 0x510e527fade682d1ULL;
 
256
        ctx->state[5] = 0x9b05688c2b3e6c1fULL;
 
257
        ctx->state[6] = 0x1f83d9abfb41bd6bULL;
 
258
        ctx->state[7] = 0x5be0cd19137e2179ULL;
 
259
}
 
260
 
 
261
/* Add bytes into the hash */
 
262
void
 
263
SHA512_Update(SHA512_CTX * ctx, const void *in, size_t len)
 
264
{
 
265
        uint64_t bitlen[2];
 
266
        uint64_t r;
 
267
        const unsigned char *src = in;
 
268
 
 
269
        /* Number of bytes left in the buffer from previous updates */
 
270
        r = (ctx->count[1] >> 3) & 0x7f;
 
271
 
 
272
        /* Convert the length into a number of bits */
 
273
        bitlen[1] = ((uint64_t)len) << 3;
 
274
        bitlen[0] = ((uint64_t)len) >> 61;
 
275
 
 
276
        /* Update number of bits */
 
277
        if ((ctx->count[1] += bitlen[1]) < bitlen[1])
 
278
                ctx->count[0]++;
 
279
        ctx->count[0] += bitlen[0];
 
280
 
 
281
        /* Handle the case where we don't need to perform any transforms */
 
282
        if (len < 128 - r) {
 
283
                memcpy(&ctx->buf[r], src, len);
 
284
                return;
 
285
        }
 
286
 
 
287
        /* Finish the current block */
 
288
        memcpy(&ctx->buf[r], src, 128 - r);
 
289
        SHA512_Transform(ctx->state, ctx->buf);
 
290
        src += 128 - r;
 
291
        len -= 128 - r;
 
292
 
 
293
        /* Perform complete blocks */
 
294
        while (len >= 128) {
 
295
                SHA512_Transform(ctx->state, src);
 
296
                src += 128;
 
297
                len -= 128;
 
298
        }
 
299
 
 
300
        /* Copy left over data into buffer */
 
301
        memcpy(ctx->buf, src, len);
 
302
}
 
303
 
 
304
/*
 
305
 * SHA-512 finalization.  Pads the input data, exports the hash value,
 
306
 * and clears the context state.
 
307
 */
 
308
void
 
309
SHA512_Final(unsigned char digest[64], SHA512_CTX * ctx)
 
310
{
 
311
 
 
312
        /* Add padding */
 
313
        SHA512_Pad(ctx);
 
314
 
 
315
        /* Write the hash */
 
316
        be64enc_vect(digest, ctx->state, 64);
 
317
 
 
318
        /* Clear the context state */
 
319
        memset((void *)ctx, 0, sizeof(*ctx));
 
320
}