← Back to branch summary

~darkmuggle-deactivatedaccount/ubuntu/quantal/grub2/fix-872244

« back to all changes in this revision

Viewing changes to lib/libgcrypt/cipher/sha512.c

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Evan Broder, Mario Limonciello
  • Date: 2010-11-24 13:59:55 UTC
  • mfrom: (1.17.6 upstream) (17.6.15 experimental)
  • Revision ID: james.westby@ubuntu.com-20101124135955-r6ii5sepayr7jt53
Tags: 1.99~20101124-1ubuntu1
https://launchpad.net/bugs/677758
[ Colin Watson ]
* Resynchronise with Debian experimental.  Remaining changes:
  - Adjust for default Ubuntu boot options ("quiet splash").
  - Default to hiding the menu; holding down Shift at boot will show it.
  - Set a monochromatic theme for Ubuntu.
  - Apply Ubuntu GRUB Legacy changes to legacy update-grub script: title,
    recovery mode, quiet option, tweak how memtest86+ is displayed, and
    use UUIDs where appropriate.
  - Fix backslash-escaping in merge_debconf_into_conf.
  - Remove "GNU/Linux" from default distributor string.
  - Add crashkernel= options if kdump and makedumpfile are available.
  - If other operating systems are installed, then automatically unhide
    the menu.  Otherwise, if GRUB_HIDDEN_TIMEOUT is 0, then use keystatus
    if available to check whether Shift is pressed.  If it is, show the
    menu, otherwise boot immediately.  If keystatus is not available, then
    fall back to a short delay interruptible with Escape.
  - Allow Shift to interrupt 'sleep --interruptible'.
  - Don't display introductory message about line editing unless we're
    actually offering a shell prompt.  Don't clear the screen just before
    booting if we never drew the menu in the first place.
  - Remove some verbose messages printed before reading the configuration
    file.
  - Suppress progress messages as the kernel and initrd load for
    non-recovery kernel menu entries.
  - Change prepare_grub_to_access_device to handle filesystems
    loop-mounted on file images.
  - Ignore devices loop-mounted from files in 10_linux.
  - Show the boot menu if the previous boot failed, that is if it failed
    to get to the end of one of the normal runlevels.
  - Don't generate /boot/grub/device.map during grub-install or
    grub-mkconfig by default.
  - Adjust upgrade version checks for Ubuntu.
  - Don't display "GRUB loading" unless Shift is held down.
  - Adjust versions of grub-doc and grub-legacy-doc conflicts to tolerate
    our backport of the grub-doc split.
  - Fix LVM/RAID probing in the absence of /boot/grub/device.map.
  - Look for .mo files in /usr/share/locale-langpack as well, in
    preference.
  - Make sure GRUB_TIMEOUT isn't quoted unnecessarily.
  - Probe all devices in 'grub-probe --target=drive' if
    /boot/grub/device.map is missing.
  - Build-depend on qemu-kvm rather than qemu-system for grub-pc tests.
  - Use qemu rather than qemu-system-i386.
  - Program vesafb on BIOS systems rather than efifb.
  - Add a grub-rescue-efi-amd64 package containing a rescue CD-ROM image
    for EFI-AMD64.
  - On Wubi, don't ask for an install device, but just update wubildr
    using the diverted grub-install.
  - When embedding the core image in a post-MBR gap, check for and avoid
    sectors matching any of a list of known signatures.
  - Disable video_bochs and video_cirrus on PC BIOS systems, as probing
    PCI space seems to break on some systems.
* Downgrade "ACPI shutdown failed" error to a debug message, since it can
  cause spurious test failures.

[ Evan Broder ]
* Enable lua from grub-extras.
* Incorporate the bitop library into lua.
* Add enum_pci function to grub module in lua.
* Switch back to gfxpayload=keep by default, unless the video hardware
  is known to not support it.

[ Mario Limonciello ]
* Built part_msdos and vfat into bootx64.efi (LP: #677758)

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/libgcrypt/cipher/sha512.c
1
 
/* sha512.c - SHA384 and SHA512 hash functions
2
 
 *      Copyright (C) 2003, 2008 Free Software Foundation, Inc.
3
 
 *
4
 
 * This file is part of Libgcrypt.
5
 
 *
6
 
 * Libgcrypt is free software; you can redistribute it and/or modify
7
 
 * it under the terms of the GNU Lesser general Public License as
8
 
 * published by the Free Software Foundation; either version 2.1 of
9
 
 * the License, or (at your option) any later version.
10
 
 *
11
 
 * Libgcrypt is distributed in the hope that it will be useful,
12
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 * GNU Lesser General Public License for more details.
15
 
 *
16
 
 * You should have received a copy of the GNU Lesser General Public
17
 
 * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18
 
 */
19
 
 
20
 
 
21
 
/*  Test vectors from FIPS-180-2:
22
 
 *
23
 
 *  "abc"
24
 
 * 384:
25
 
 *  CB00753F 45A35E8B B5A03D69 9AC65007 272C32AB 0EDED163
26
 
 *  1A8B605A 43FF5BED 8086072B A1E7CC23 58BAECA1 34C825A7
27
 
 * 512:
28
 
 *  DDAF35A1 93617ABA CC417349 AE204131 12E6FA4E 89A97EA2 0A9EEEE6 4B55D39A
29
 
 *  2192992A 274FC1A8 36BA3C23 A3FEEBBD 454D4423 643CE80E 2A9AC94F A54CA49F
30
 
 *
31
 
 *  "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"
32
 
 * 384:
33
 
 *  09330C33 F71147E8 3D192FC7 82CD1B47 53111B17 3B3B05D2
34
 
 *  2FA08086 E3B0F712 FCC7C71A 557E2DB9 66C3E9FA 91746039
35
 
 * 512:
36
 
 *  8E959B75 DAE313DA 8CF4F728 14FC143F 8F7779C6 EB9F7FA1 7299AEAD B6889018
37
 
 *  501D289E 4900F7E4 331B99DE C4B5433A C7D329EE B6DD2654 5E96E55B 874BE909
38
 
 *
39
 
 *  "a" x 1000000
40
 
 * 384:
41
 
 *  9D0E1809 716474CB 086E834E 310A4A1C ED149E9C 00F24852
42
 
 *  7972CEC5 704C2A5B 07B8B3DC 38ECC4EB AE97DDD8 7F3D8985
43
 
 * 512:
44
 
 *  E718483D 0CE76964 4E2E42C7 BC15B463 8E1F98B1 3B204428 5632A803 AFA973EB
45
 
 *  DE0FF244 877EA60A 4CB0432C E577C31B EB009C5C 2C49AA2E 4EADB217 AD8CC09B
46
 
 */
47
 
 
48
 
 
49
 
#include <config.h>
50
 
#include <string.h>
51
 
#include "g10lib.h"
52
 
#include "bithelp.h"
53
 
#include "cipher.h"
54
 
#include "hash-common.h"
55
 
 
56
 
typedef struct
57
 
{
58
 
  u64 h0, h1, h2, h3, h4, h5, h6, h7;
59
 
  u64 nblocks;
60
 
  byte buf[128];
61
 
  int count;
62
 
} SHA512_CONTEXT;
63
 
 
64
 
static void
65
 
sha512_init (void *context)
66
 
{
67
 
  SHA512_CONTEXT *hd = context;
68
 
 
69
 
  hd->h0 = U64_C(0x6a09e667f3bcc908);
70
 
  hd->h1 = U64_C(0xbb67ae8584caa73b);
71
 
  hd->h2 = U64_C(0x3c6ef372fe94f82b);
72
 
  hd->h3 = U64_C(0xa54ff53a5f1d36f1);
73
 
  hd->h4 = U64_C(0x510e527fade682d1);
74
 
  hd->h5 = U64_C(0x9b05688c2b3e6c1f);
75
 
  hd->h6 = U64_C(0x1f83d9abfb41bd6b);
76
 
  hd->h7 = U64_C(0x5be0cd19137e2179);
77
 
 
78
 
  hd->nblocks = 0;
79
 
  hd->count = 0;
80
 
}
81
 
 
82
 
static void
83
 
sha384_init (void *context)
84
 
{
85
 
  SHA512_CONTEXT *hd = context;
86
 
 
87
 
  hd->h0 = U64_C(0xcbbb9d5dc1059ed8);
88
 
  hd->h1 = U64_C(0x629a292a367cd507);
89
 
  hd->h2 = U64_C(0x9159015a3070dd17);
90
 
  hd->h3 = U64_C(0x152fecd8f70e5939);
91
 
  hd->h4 = U64_C(0x67332667ffc00b31);
92
 
  hd->h5 = U64_C(0x8eb44a8768581511);
93
 
  hd->h6 = U64_C(0xdb0c2e0d64f98fa7);
94
 
  hd->h7 = U64_C(0x47b5481dbefa4fa4);
95
 
 
96
 
  hd->nblocks = 0;
97
 
  hd->count = 0;
98
 
}
99
 
 
100
 
 
101
 
/****************
102
 
 * Transform the message W which consists of 16 64-bit-words
103
 
 */
104
 
static void
105
 
transform (SHA512_CONTEXT *hd, const unsigned char *data)
106
 
{
107
 
  u64 a, b, c, d, e, f, g, h;
108
 
  u64 w[80];
109
 
  int t;
110
 
  static const u64 k[] =
111
 
    {
112
 
      U64_C(0x428a2f98d728ae22), U64_C(0x7137449123ef65cd),
113
 
      U64_C(0xb5c0fbcfec4d3b2f), U64_C(0xe9b5dba58189dbbc),
114
 
      U64_C(0x3956c25bf348b538), U64_C(0x59f111f1b605d019),
115
 
      U64_C(0x923f82a4af194f9b), U64_C(0xab1c5ed5da6d8118),
116
 
      U64_C(0xd807aa98a3030242), U64_C(0x12835b0145706fbe),
117
 
      U64_C(0x243185be4ee4b28c), U64_C(0x550c7dc3d5ffb4e2),
118
 
      U64_C(0x72be5d74f27b896f), U64_C(0x80deb1fe3b1696b1),
119
 
      U64_C(0x9bdc06a725c71235), U64_C(0xc19bf174cf692694),
120
 
      U64_C(0xe49b69c19ef14ad2), U64_C(0xefbe4786384f25e3),
121
 
      U64_C(0x0fc19dc68b8cd5b5), U64_C(0x240ca1cc77ac9c65),
122
 
      U64_C(0x2de92c6f592b0275), U64_C(0x4a7484aa6ea6e483),
123
 
      U64_C(0x5cb0a9dcbd41fbd4), U64_C(0x76f988da831153b5),
124
 
      U64_C(0x983e5152ee66dfab), U64_C(0xa831c66d2db43210),
125
 
      U64_C(0xb00327c898fb213f), U64_C(0xbf597fc7beef0ee4),
126
 
      U64_C(0xc6e00bf33da88fc2), U64_C(0xd5a79147930aa725),
127
 
      U64_C(0x06ca6351e003826f), U64_C(0x142929670a0e6e70),
128
 
      U64_C(0x27b70a8546d22ffc), U64_C(0x2e1b21385c26c926),
129
 
      U64_C(0x4d2c6dfc5ac42aed), U64_C(0x53380d139d95b3df),
130
 
      U64_C(0x650a73548baf63de), U64_C(0x766a0abb3c77b2a8),
131
 
      U64_C(0x81c2c92e47edaee6), U64_C(0x92722c851482353b),
132
 
      U64_C(0xa2bfe8a14cf10364), U64_C(0xa81a664bbc423001),
133
 
      U64_C(0xc24b8b70d0f89791), U64_C(0xc76c51a30654be30),
134
 
      U64_C(0xd192e819d6ef5218), U64_C(0xd69906245565a910),
135
 
      U64_C(0xf40e35855771202a), U64_C(0x106aa07032bbd1b8),
136
 
      U64_C(0x19a4c116b8d2d0c8), U64_C(0x1e376c085141ab53),
137
 
      U64_C(0x2748774cdf8eeb99), U64_C(0x34b0bcb5e19b48a8),
138
 
      U64_C(0x391c0cb3c5c95a63), U64_C(0x4ed8aa4ae3418acb),
139
 
      U64_C(0x5b9cca4f7763e373), U64_C(0x682e6ff3d6b2b8a3),
140
 
      U64_C(0x748f82ee5defb2fc), U64_C(0x78a5636f43172f60),
141
 
      U64_C(0x84c87814a1f0ab72), U64_C(0x8cc702081a6439ec),
142
 
      U64_C(0x90befffa23631e28), U64_C(0xa4506cebde82bde9),
143
 
      U64_C(0xbef9a3f7b2c67915), U64_C(0xc67178f2e372532b),
144
 
      U64_C(0xca273eceea26619c), U64_C(0xd186b8c721c0c207),
145
 
      U64_C(0xeada7dd6cde0eb1e), U64_C(0xf57d4f7fee6ed178),
146
 
      U64_C(0x06f067aa72176fba), U64_C(0x0a637dc5a2c898a6),
147
 
      U64_C(0x113f9804bef90dae), U64_C(0x1b710b35131c471b),
148
 
      U64_C(0x28db77f523047d84), U64_C(0x32caab7b40c72493),
149
 
      U64_C(0x3c9ebe0a15c9bebc), U64_C(0x431d67c49c100d4c),
150
 
      U64_C(0x4cc5d4becb3e42b6), U64_C(0x597f299cfc657e2a),
151
 
      U64_C(0x5fcb6fab3ad6faec), U64_C(0x6c44198c4a475817)
152
 
    };
153
 
 
154
 
  /* get values from the chaining vars */
155
 
  a = hd->h0;
156
 
  b = hd->h1;
157
 
  c = hd->h2;
158
 
  d = hd->h3;
159
 
  e = hd->h4;
160
 
  f = hd->h5;
161
 
  g = hd->h6;
162
 
  h = hd->h7;
163
 
 
164
 
#ifdef WORDS_BIGENDIAN
165
 
  memcpy (w, data, 128);
166
 
#else
167
 
  {
168
 
    int i;
169
 
    byte *p2;
170
 
 
171
 
    for (i = 0, p2 = (byte *) w; i < 16; i++, p2 += 8)
172
 
      {
173
 
        p2[7] = *data++;
174
 
        p2[6] = *data++;
175
 
        p2[5] = *data++;
176
 
        p2[4] = *data++;
177
 
        p2[3] = *data++;
178
 
        p2[2] = *data++;
179
 
        p2[1] = *data++;
180
 
        p2[0] = *data++;
181
 
      }
182
 
  }
183
 
#endif
184
 
 
185
 
#define ROTR(x,n) (((x)>>(n)) | ((x)<<(64-(n))))
186
 
#define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
187
 
#define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
188
 
#define Sum0(x) (ROTR((x),28) ^ ROTR((x),34) ^ ROTR((x),39))
189
 
#define Sum1(x) (ROTR((x),14) ^ ROTR((x),18) ^ ROTR((x),41))
190
 
#define S0(x) (ROTR((x),1) ^ ROTR((x),8) ^ ((x)>>7))
191
 
#define S1(x) (ROTR((x),19) ^ ROTR((x),61) ^ ((x)>>6))
192
 
 
193
 
  for (t = 16; t < 80; t++)
194
 
    w[t] = S1 (w[t - 2]) + w[t - 7] + S0 (w[t - 15]) + w[t - 16];
195
 
 
196
 
  for (t = 0; t < 80; t++)
197
 
    {
198
 
      u64 t1, t2;
199
 
 
200
 
      t1 = h + Sum1 (e) + Ch (e, f, g) + k[t] + w[t];
201
 
      t2 = Sum0 (a) + Maj (a, b, c);
202
 
      h = g;
203
 
      g = f;
204
 
      f = e;
205
 
      e = d + t1;
206
 
      d = c;
207
 
      c = b;
208
 
      b = a;
209
 
      a = t1 + t2;
210
 
 
211
 
      /* printf("t=%d a=%016llX b=%016llX c=%016llX d=%016llX "
212
 
          "e=%016llX f=%016llX g=%016llX h=%016llX\n",t,a,b,c,d,e,f,g,h); */
213
 
    }
214
 
 
215
 
  /* update chaining vars */
216
 
  hd->h0 += a;
217
 
  hd->h1 += b;
218
 
  hd->h2 += c;
219
 
  hd->h3 += d;
220
 
  hd->h4 += e;
221
 
  hd->h5 += f;
222
 
  hd->h6 += g;
223
 
  hd->h7 += h;
224
 
}
225
 
 
226
 
 
227
 
/* Update the message digest with the contents
228
 
 * of INBUF with length INLEN.
229
 
 */
230
 
static void
231
 
sha512_write (void *context, const void *inbuf_arg, size_t inlen)
232
 
{
233
 
  const unsigned char *inbuf = inbuf_arg;
234
 
  SHA512_CONTEXT *hd = context;
235
 
 
236
 
  if (hd->count == 128)
237
 
    {                           /* flush the buffer */
238
 
      transform (hd, hd->buf);
239
 
      _gcry_burn_stack (768);
240
 
      hd->count = 0;
241
 
      hd->nblocks++;
242
 
    }
243
 
  if (!inbuf)
244
 
    return;
245
 
  if (hd->count)
246
 
    {
247
 
      for (; inlen && hd->count < 128; inlen--)
248
 
        hd->buf[hd->count++] = *inbuf++;
249
 
      sha512_write (context, NULL, 0);
250
 
      if (!inlen)
251
 
        return;
252
 
    }
253
 
 
254
 
  while (inlen >= 128)
255
 
    {
256
 
      transform (hd, inbuf);
257
 
      hd->count = 0;
258
 
      hd->nblocks++;
259
 
      inlen -= 128;
260
 
      inbuf += 128;
261
 
    }
262
 
  _gcry_burn_stack (768);
263
 
  for (; inlen && hd->count < 128; inlen--)
264
 
    hd->buf[hd->count++] = *inbuf++;
265
 
}
266
 
 
267
 
 
268
 
/* The routine final terminates the computation and
269
 
 * returns the digest.
270
 
 * The handle is prepared for a new cycle, but adding bytes to the
271
 
 * handle will the destroy the returned buffer.
272
 
 * Returns: 64 bytes representing the digest.  When used for sha384,
273
 
 * we take the leftmost 48 of those bytes.
274
 
 */
275
 
 
276
 
static void
277
 
sha512_final (void *context)
278
 
{
279
 
  SHA512_CONTEXT *hd = context;
280
 
  u64 t, msb, lsb;
281
 
  byte *p;
282
 
 
283
 
  sha512_write (context, NULL, 0); /* flush */ ;
284
 
 
285
 
  t = hd->nblocks;
286
 
  /* multiply by 128 to make a byte count */
287
 
  lsb = t << 7;
288
 
  msb = t >> 57;
289
 
  /* add the count */
290
 
  t = lsb;
291
 
  if ((lsb += hd->count) < t)
292
 
    msb++;
293
 
  /* multiply by 8 to make a bit count */
294
 
  t = lsb;
295
 
  lsb <<= 3;
296
 
  msb <<= 3;
297
 
  msb |= t >> 61;
298
 
 
299
 
  if (hd->count < 112)
300
 
    {                           /* enough room */
301
 
      hd->buf[hd->count++] = 0x80;      /* pad */
302
 
      while (hd->count < 112)
303
 
        hd->buf[hd->count++] = 0;       /* pad */
304
 
    }
305
 
  else
306
 
    {                           /* need one extra block */
307
 
      hd->buf[hd->count++] = 0x80;      /* pad character */
308
 
      while (hd->count < 128)
309
 
        hd->buf[hd->count++] = 0;
310
 
      sha512_write (context, NULL, 0); /* flush */ ;
311
 
      memset (hd->buf, 0, 112); /* fill next block with zeroes */
312
 
    }
313
 
  /* append the 128 bit count */
314
 
  hd->buf[112] = msb >> 56;
315
 
  hd->buf[113] = msb >> 48;
316
 
  hd->buf[114] = msb >> 40;
317
 
  hd->buf[115] = msb >> 32;
318
 
  hd->buf[116] = msb >> 24;
319
 
  hd->buf[117] = msb >> 16;
320
 
  hd->buf[118] = msb >> 8;
321
 
  hd->buf[119] = msb;
322
 
 
323
 
  hd->buf[120] = lsb >> 56;
324
 
  hd->buf[121] = lsb >> 48;
325
 
  hd->buf[122] = lsb >> 40;
326
 
  hd->buf[123] = lsb >> 32;
327
 
  hd->buf[124] = lsb >> 24;
328
 
  hd->buf[125] = lsb >> 16;
329
 
  hd->buf[126] = lsb >> 8;
330
 
  hd->buf[127] = lsb;
331
 
  transform (hd, hd->buf);
332
 
  _gcry_burn_stack (768);
333
 
 
334
 
  p = hd->buf;
335
 
#ifdef WORDS_BIGENDIAN
336
 
#define X(a) do { *(u64*)p = hd->h##a ; p += 8; } while (0)
337
 
#else /* little endian */
338
 
#define X(a) do { *p++ = hd->h##a >> 56; *p++ = hd->h##a >> 48;       \
339
 
                  *p++ = hd->h##a >> 40; *p++ = hd->h##a >> 32;       \
340
 
                  *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;       \
341
 
                  *p++ = hd->h##a >> 8;  *p++ = hd->h##a; } while (0)
342
 
#endif
343
 
  X (0);
344
 
  X (1);
345
 
  X (2);
346
 
  X (3);
347
 
  X (4);
348
 
  X (5);
349
 
  /* Note that these last two chunks are included even for SHA384.
350
 
     We just ignore them. */
351
 
  X (6);
352
 
  X (7);
353
 
#undef X
354
 
}
355
 
 
356
 
static byte *
357
 
sha512_read (void *context)
358
 
{
359
 
  SHA512_CONTEXT *hd = (SHA512_CONTEXT *) context;
360
 
  return hd->buf;
361
 
}
362
 
 
363
 
 
364
 
 
365
 
/* 
366
 
     Self-test section.
367
 
 */
368
 
 
369
 
 
370
 
static gpg_err_code_t
371
 
selftests_sha384 (int extended, selftest_report_func_t report)
372
 
{
373
 
  const char *what;
374
 
  const char *errtxt;
375
 
  
376
 
  what = "short string";
377
 
  errtxt = _gcry_hash_selftest_check_one
378
 
    (GCRY_MD_SHA384, 0, 
379
 
     "abc", 3,
380
 
     "\xcb\x00\x75\x3f\x45\xa3\x5e\x8b\xb5\xa0\x3d\x69\x9a\xc6\x50\x07"
381
 
     "\x27\x2c\x32\xab\x0e\xde\xd1\x63\x1a\x8b\x60\x5a\x43\xff\x5b\xed"
382
 
     "\x80\x86\x07\x2b\xa1\xe7\xcc\x23\x58\xba\xec\xa1\x34\xc8\x25\xa7", 48);
383
 
  if (errtxt)
384
 
    goto failed;
385
 
 
386
 
  if (extended)
387
 
    {
388
 
      what = "long string";
389
 
      errtxt = _gcry_hash_selftest_check_one
390
 
        (GCRY_MD_SHA384, 0, 
391
 
         "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
392
 
         "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", 112, 
393
 
         "\x09\x33\x0C\x33\xF7\x11\x47\xE8\x3D\x19\x2F\xC7\x82\xCD\x1B\x47"
394
 
         "\x53\x11\x1B\x17\x3B\x3B\x05\xD2\x2F\xA0\x80\x86\xE3\xB0\xF7\x12"
395
 
         "\xFC\xC7\xC7\x1A\x55\x7E\x2D\xB9\x66\xC3\xE9\xFA\x91\x74\x60\x39",
396
 
         48);
397
 
      if (errtxt)
398
 
        goto failed;
399
 
 
400
 
      what = "one million \"a\"";
401
 
      errtxt = _gcry_hash_selftest_check_one
402
 
        (GCRY_MD_SHA384, 1,
403
 
         NULL, 0,
404
 
         "\x9D\x0E\x18\x09\x71\x64\x74\xCB\x08\x6E\x83\x4E\x31\x0A\x4A\x1C"
405
 
         "\xED\x14\x9E\x9C\x00\xF2\x48\x52\x79\x72\xCE\xC5\x70\x4C\x2A\x5B"
406
 
         "\x07\xB8\xB3\xDC\x38\xEC\xC4\xEB\xAE\x97\xDD\xD8\x7F\x3D\x89\x85",
407
 
         48);
408
 
      if (errtxt)
409
 
        goto failed;
410
 
    }
411
 
 
412
 
  return 0; /* Succeeded. */
413
 
 
414
 
 failed:
415
 
  if (report)
416
 
    report ("digest", GCRY_MD_SHA384, what, errtxt);
417
 
  return GPG_ERR_SELFTEST_FAILED;
418
 
}
419
 
 
420
 
static gpg_err_code_t
421
 
selftests_sha512 (int extended, selftest_report_func_t report)
422
 
{
423
 
  const char *what;
424
 
  const char *errtxt;
425
 
  
426
 
  what = "short string";
427
 
  errtxt = _gcry_hash_selftest_check_one
428
 
    (GCRY_MD_SHA512, 0, 
429
 
     "abc", 3,
430
 
     "\xDD\xAF\x35\xA1\x93\x61\x7A\xBA\xCC\x41\x73\x49\xAE\x20\x41\x31"
431
 
     "\x12\xE6\xFA\x4E\x89\xA9\x7E\xA2\x0A\x9E\xEE\xE6\x4B\x55\xD3\x9A"
432
 
     "\x21\x92\x99\x2A\x27\x4F\xC1\xA8\x36\xBA\x3C\x23\xA3\xFE\xEB\xBD"
433
 
     "\x45\x4D\x44\x23\x64\x3C\xE8\x0E\x2A\x9A\xC9\x4F\xA5\x4C\xA4\x9F", 64);
434
 
  if (errtxt)
435
 
    goto failed;
436
 
 
437
 
  if (extended)
438
 
    {
439
 
      what = "long string";
440
 
      errtxt = _gcry_hash_selftest_check_one
441
 
        (GCRY_MD_SHA512, 0, 
442
 
         "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
443
 
         "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", 112, 
444
 
         "\x8E\x95\x9B\x75\xDA\xE3\x13\xDA\x8C\xF4\xF7\x28\x14\xFC\x14\x3F"
445
 
         "\x8F\x77\x79\xC6\xEB\x9F\x7F\xA1\x72\x99\xAE\xAD\xB6\x88\x90\x18"
446
 
         "\x50\x1D\x28\x9E\x49\x00\xF7\xE4\x33\x1B\x99\xDE\xC4\xB5\x43\x3A"
447
 
         "\xC7\xD3\x29\xEE\xB6\xDD\x26\x54\x5E\x96\xE5\x5B\x87\x4B\xE9\x09",
448
 
         64);
449
 
      if (errtxt)
450
 
        goto failed;
451
 
      
452
 
      what = "one million \"a\"";
453
 
      errtxt = _gcry_hash_selftest_check_one
454
 
        (GCRY_MD_SHA512, 1,
455
 
         NULL, 0,
456
 
         "\xE7\x18\x48\x3D\x0C\xE7\x69\x64\x4E\x2E\x42\xC7\xBC\x15\xB4\x63"
457
 
         "\x8E\x1F\x98\xB1\x3B\x20\x44\x28\x56\x32\xA8\x03\xAF\xA9\x73\xEB"
458
 
         "\xDE\x0F\xF2\x44\x87\x7E\xA6\x0A\x4C\xB0\x43\x2C\xE5\x77\xC3\x1B"
459
 
         "\xEB\x00\x9C\x5C\x2C\x49\xAA\x2E\x4E\xAD\xB2\x17\xAD\x8C\xC0\x9B",
460
 
         64);
461
 
      if (errtxt)
462
 
        goto failed;
463
 
    }
464
 
 
465
 
  return 0; /* Succeeded. */
466
 
 
467
 
 failed:
468
 
  if (report)
469
 
    report ("digest", GCRY_MD_SHA512, what, errtxt);
470
 
  return GPG_ERR_SELFTEST_FAILED;
471
 
}
472
 
 
473
 
 
474
 
/* Run a full self-test for ALGO and return 0 on success.  */
475
 
static gpg_err_code_t
476
 
run_selftests (int algo, int extended, selftest_report_func_t report)
477
 
{
478
 
  gpg_err_code_t ec;
479
 
 
480
 
  switch (algo)
481
 
    {
482
 
    case GCRY_MD_SHA384:
483
 
      ec = selftests_sha384 (extended, report);
484
 
      break;
485
 
    case GCRY_MD_SHA512:
486
 
      ec = selftests_sha512 (extended, report);
487
 
      break;
488
 
    default:
489
 
      ec = GPG_ERR_DIGEST_ALGO;
490
 
      break;
491
 
        
492
 
    }
493
 
  return ec;
494
 
}
495
 
 
496
 
 
497
 
 
498
 
 
499
 
static byte sha512_asn[] =      /* Object ID is 2.16.840.1.101.3.4.2.3 */
500
 
  {
501
 
    0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
502
 
    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
503
 
    0x00, 0x04, 0x40
504
 
  };
505
 
 
506
 
static gcry_md_oid_spec_t oid_spec_sha512[] =
507
 
  {
508
 
    { "2.16.840.1.101.3.4.2.3" },
509
 
 
510
 
    /* PKCS#1 sha512WithRSAEncryption */
511
 
    { "1.2.840.113549.1.1.13" },
512
 
 
513
 
    { NULL }
514
 
  };
515
 
 
516
 
gcry_md_spec_t _gcry_digest_spec_sha512 = 
517
 
  {
518
 
    "SHA512", sha512_asn, DIM (sha512_asn), oid_spec_sha512, 64,
519
 
    sha512_init, sha512_write, sha512_final, sha512_read,
520
 
    sizeof (SHA512_CONTEXT),
521
 
  };
522
 
md_extra_spec_t _gcry_digest_extraspec_sha512 = 
523
 
  {
524
 
    run_selftests
525
 
  };
526
 
 
527
 
static byte sha384_asn[] =      /* Object ID is 2.16.840.1.101.3.4.2.2 */
528
 
  {
529
 
    0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
530
 
    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
531
 
    0x00, 0x04, 0x30
532
 
  };
533
 
 
534
 
static gcry_md_oid_spec_t oid_spec_sha384[] =
535
 
  {
536
 
    { "2.16.840.1.101.3.4.2.2" }, 
537
 
 
538
 
    /* PKCS#1 sha384WithRSAEncryption */
539
 
    { "1.2.840.113549.1.1.12" },
540
 
 
541
 
    { NULL },
542
 
  };
543
 
 
544
 
gcry_md_spec_t _gcry_digest_spec_sha384 = 
545
 
  {
546
 
    "SHA384", sha384_asn, DIM (sha384_asn), oid_spec_sha384, 48,
547
 
    sha384_init, sha512_write, sha512_final, sha512_read,
548
 
    sizeof (SHA512_CONTEXT),
549
 
  };
550
 
md_extra_spec_t _gcry_digest_extraspec_sha384 = 
551
 
  {
552
 
    run_selftests
553
 
  };