← Back to branch summary

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

« back to all changes in this revision

Viewing changes to grub-core/lib/libgcrypt-grub/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:
grub-core/lib/libgcrypt-grub/cipher/sha512.c
 
1
/* This file was automatically imported with 
 
2
   import_gcry.py. Please don't modify it */
 
3
/* sha512.c - SHA384 and SHA512 hash functions
 
4
 *      Copyright (C) 2003, 2008 Free Software Foundation, Inc.
 
5
 *
 
6
 * This file is part of Libgcrypt.
 
7
 *
 
8
 * Libgcrypt is free software; you can redistribute it and/or modify
 
9
 * it under the terms of the GNU Lesser general Public License as
 
10
 * published by the Free Software Foundation; either version 2.1 of
 
11
 * the License, or (at your option) any later version.
 
12
 *
 
13
 * Libgcrypt is distributed in the hope that it will be useful,
 
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
16
 * GNU Lesser General Public License for more details.
 
17
 *
 
18
 * You should have received a copy of the GNU Lesser General Public
 
19
 * License along with this program; if not, see <http://www.gnu.org/licenses/>.
 
20
 */
 
21
 
 
22
 
 
23
/*  Test vectors from FIPS-180-2:
 
24
 *
 
25
 *  "abc"
 
26
 * 384:
 
27
 *  CB00753F 45A35E8B B5A03D69 9AC65007 272C32AB 0EDED163
 
28
 *  1A8B605A 43FF5BED 8086072B A1E7CC23 58BAECA1 34C825A7
 
29
 * 512:
 
30
 *  DDAF35A1 93617ABA CC417349 AE204131 12E6FA4E 89A97EA2 0A9EEEE6 4B55D39A
 
31
 *  2192992A 274FC1A8 36BA3C23 A3FEEBBD 454D4423 643CE80E 2A9AC94F A54CA49F
 
32
 *
 
33
 *  "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"
 
34
 * 384:
 
35
 *  09330C33 F71147E8 3D192FC7 82CD1B47 53111B17 3B3B05D2
 
36
 *  2FA08086 E3B0F712 FCC7C71A 557E2DB9 66C3E9FA 91746039
 
37
 * 512:
 
38
 *  8E959B75 DAE313DA 8CF4F728 14FC143F 8F7779C6 EB9F7FA1 7299AEAD B6889018
 
39
 *  501D289E 4900F7E4 331B99DE C4B5433A C7D329EE B6DD2654 5E96E55B 874BE909
 
40
 *
 
41
 *  "a" x 1000000
 
42
 * 384:
 
43
 *  9D0E1809 716474CB 086E834E 310A4A1C ED149E9C 00F24852
 
44
 *  7972CEC5 704C2A5B 07B8B3DC 38ECC4EB AE97DDD8 7F3D8985
 
45
 * 512:
 
46
 *  E718483D 0CE76964 4E2E42C7 BC15B463 8E1F98B1 3B204428 5632A803 AFA973EB
 
47
 *  DE0FF244 877EA60A 4CB0432C E577C31B EB009C5C 2C49AA2E 4EADB217 AD8CC09B
 
48
 */
 
49
 
 
50
 
 
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
 
 
371
 
 
372
 
 
373
/* Run a full self-test for ALGO and return 0 on success.  */
 
374
 
 
375
 
 
376
 
 
377
 
 
378
static byte sha512_asn[] =      /* Object ID is 2.16.840.1.101.3.4.2.3 */
 
379
  {
 
380
    0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
 
381
    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x03, 0x05,
 
382
    0x00, 0x04, 0x40
 
383
  };
 
384
 
 
385
static gcry_md_oid_spec_t oid_spec_sha512[] =
 
386
  {
 
387
    { "2.16.840.1.101.3.4.2.3" },
 
388
 
 
389
    /* PKCS#1 sha512WithRSAEncryption */
 
390
    { "1.2.840.113549.1.1.13" },
 
391
 
 
392
    { NULL }
 
393
  };
 
394
 
 
395
gcry_md_spec_t _gcry_digest_spec_sha512 = 
 
396
  {
 
397
    "SHA512", sha512_asn, DIM (sha512_asn), oid_spec_sha512, 64,
 
398
    sha512_init, sha512_write, sha512_final, sha512_read,
 
399
    sizeof (SHA512_CONTEXT),
 
400
    .blocksize = 128
 
401
  };
 
402
 
 
403
static byte sha384_asn[] =      /* Object ID is 2.16.840.1.101.3.4.2.2 */
 
404
  {
 
405
    0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
 
406
    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x02, 0x05,
 
407
    0x00, 0x04, 0x30
 
408
  };
 
409
 
 
410
static gcry_md_oid_spec_t oid_spec_sha384[] =
 
411
  {
 
412
    { "2.16.840.1.101.3.4.2.2" }, 
 
413
 
 
414
    /* PKCS#1 sha384WithRSAEncryption */
 
415
    { "1.2.840.113549.1.1.12" },
 
416
 
 
417
    { NULL },
 
418
  };
 
419
 
 
420
gcry_md_spec_t _gcry_digest_spec_sha384 = 
 
421
  {
 
422
    "SHA384", sha384_asn, DIM (sha384_asn), oid_spec_sha384, 48,
 
423
    sha384_init, sha512_write, sha512_final, sha512_read,
 
424
    sizeof (SHA512_CONTEXT),
 
425
    .blocksize = 128
 
426
  };
 
427
 
 
428
 
 
429
GRUB_MOD_INIT(gcry_sha512)
 
430
{
 
431
  grub_md_register (&_gcry_digest_spec_sha512);
 
432
  grub_md_register (&_gcry_digest_spec_sha384);
 
433
}
 
434
 
 
435
GRUB_MOD_FINI(gcry_sha512)
 
436
{
 
437
  grub_md_unregister (&_gcry_digest_spec_sha512);
 
438
  grub_md_unregister (&_gcry_digest_spec_sha384);
 
439
}