← Back to branch summary

~hamo/ubuntu/precise/grub2/grub2.hi_res

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson, Colin Watson, Robert Millan, Updated translations
  • Date: 2010-11-22 12:24:56 UTC
  • mfrom: (1.26.4 upstream) (17.3.36 sid)
  • mto: (17.3.43 sid)
  • mto: This revision was merged to the branch mainline in revision 89.
  • Revision ID: james.westby@ubuntu.com-20101122122456-y82z3sfb7k4zfdcc
Tags: 1.99~20101122-1
http://bugs.debian.org/550658
http://bugs.debian.org/550702
http://bugs.debian.org/591416
http://bugs.debian.org/593347
http://bugs.debian.org/551627
http://bugs.debian.org/589325
http://bugs.debian.org/543924
http://bugs.debian.org/603354
http://bugs.debian.org/604003
http://bugs.debian.org/604102
[ Colin Watson ]
* New Bazaar snapshot.  Too many changes to list in full, but some of the
  more user-visible ones are as follows:
  - GRUB script:
    + Function parameters, "break", "continue", "shift", "setparams",
      "return", and "!".
    + "export" command supports multiple variable names.
    + Multi-line quoted strings support.
    + Wildcard expansion.
  - sendkey support.
  - USB hotunplugging and USB serial support.
  - Rename CD-ROM to cd on BIOS.
  - Add new --boot-directory option to grub-install, grub-reboot, and
    grub-set-default; the old --root-directory option is still accepted
    but was often confusing.
  - Basic btrfs detection/UUID support (but no file reading yet).
  - bash-completion for utilities.
  - If a device is listed in device.map, always assume that it is
    BIOS-visible rather than using extra layers such as LVM or RAID.
  - Add grub-mknetdir script (closes: #550658).
  - Remove deprecated "root" command.
  - Handle RAID devices containing virtio components.
  - GRUB Legacy configuration file support (via grub-menulst2cfg).
  - Keyboard layout support (via grub-mklayout and grub-kbdcomp).
  - Check generated grub.cfg for syntax errors before saving.
  - Pause execution for at most ten seconds if any errors are displayed,
    so that the user has a chance to see them.
  - Support submenus.
  - Write embedding zone using Reed-Solomon, so that it's robust against
    being partially overwritten (closes: #550702, #591416, #593347).
  - GRUB_DISABLE_LINUX_RECOVERY and GRUB_DISABLE_NETBSD_RECOVERY merged
    into a single GRUB_DISABLE_RECOVERY variable.
  - Fix loader memory allocation failure (closes: #551627).
  - Don't call savedefault on recovery entries (closes: #589325).
  - Support triple-indirect blocks on ext2 (closes: #543924).
  - Recognise DDF1 fake RAID (closes: #603354).

[ Robert Millan ]
* Use dpkg architecture wildcards.

[ Updated translations ]
* Slovenian (Vanja Cvelbar).  Closes: #604003
* Dzongkha (dawa pemo via Tenzin Dendup).  Closes: #604102

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/libgcrypt/cipher/sha256.c
1
 
/* sha256.c - SHA256 hash function
2
 
 *      Copyright (C) 2003, 2006, 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:
22
 
    
23
 
    "abc"
24
 
    SHA224: 23097d22 3405d822 8642a477 bda255b3 2aadbce4 bda0b3f7 e36c9da7
25
 
    SHA256: ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad
26
 
 
27
 
    "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
28
 
    SHA224: 75388b16 512776cc 5dba5da1 fd890150 b0c6455c b4f58b19 52522525
29
 
    SHA256: 248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1
30
 
 
31
 
    "a" one million times
32
 
    SHA224: 20794655 980c91d8 bbb4c1ea 97618a4b f03f4258 1948b2ee 4ee7ad67
33
 
    SHA256: cdc76e5c 9914fb92 81a1c7e2 84d73e67 f1809a48 a497200e 046d39cc c7112cd0
34
 
 
35
 
 */
36
 
 
37
 
 
38
 
#include <config.h>
39
 
#include <stdio.h>
40
 
#include <stdlib.h>
41
 
#include <string.h>
42
 
 
43
 
#include "g10lib.h"
44
 
#include "memory.h"
45
 
#include "bithelp.h"
46
 
#include "cipher.h"
47
 
#include "hash-common.h"
48
 
 
49
 
typedef struct {
50
 
  u32  h0,h1,h2,h3,h4,h5,h6,h7;
51
 
  u32  nblocks;
52
 
  byte buf[64];
53
 
  int  count;
54
 
} SHA256_CONTEXT;
55
 
 
56
 
 
57
 
static void
58
 
sha256_init (void *context)
59
 
{
60
 
  SHA256_CONTEXT *hd = context;
61
 
 
62
 
  hd->h0 = 0x6a09e667;
63
 
  hd->h1 = 0xbb67ae85;
64
 
  hd->h2 = 0x3c6ef372;
65
 
  hd->h3 = 0xa54ff53a;
66
 
  hd->h4 = 0x510e527f;
67
 
  hd->h5 = 0x9b05688c;
68
 
  hd->h6 = 0x1f83d9ab;
69
 
  hd->h7 = 0x5be0cd19;
70
 
 
71
 
  hd->nblocks = 0;
72
 
  hd->count = 0;
73
 
}
74
 
 
75
 
 
76
 
static void
77
 
sha224_init (void *context)
78
 
{
79
 
  SHA256_CONTEXT *hd = context;
80
 
 
81
 
  hd->h0 = 0xc1059ed8;
82
 
  hd->h1 = 0x367cd507;
83
 
  hd->h2 = 0x3070dd17;
84
 
  hd->h3 = 0xf70e5939;
85
 
  hd->h4 = 0xffc00b31;
86
 
  hd->h5 = 0x68581511;
87
 
  hd->h6 = 0x64f98fa7;
88
 
  hd->h7 = 0xbefa4fa4;
89
 
 
90
 
  hd->nblocks = 0;
91
 
  hd->count = 0;
92
 
}
93
 
 
94
 
 
95
 
/*
96
 
  Transform the message X which consists of 16 32-bit-words. See FIPS
97
 
  180-2 for details.  */
98
 
#define Cho(x,y,z) (z ^ (x & (y ^ z)))      /* (4.2) same as SHA-1's F1 */
99
 
#define Maj(x,y,z) ((x & y) | (z & (x|y)))  /* (4.3) same as SHA-1's F3 */
100
 
#define Sum0(x) (ror ((x), 2) ^ ror ((x), 13) ^ ror ((x), 22))  /* (4.4) */
101
 
#define Sum1(x) (ror ((x), 6) ^ ror ((x), 11) ^ ror ((x), 25))  /* (4.5) */
102
 
#define S0(x) (ror ((x), 7) ^ ror ((x), 18) ^ ((x) >> 3))       /* (4.6) */
103
 
#define S1(x) (ror ((x), 17) ^ ror ((x), 19) ^ ((x) >> 10))     /* (4.7) */
104
 
#define R(a,b,c,d,e,f,g,h,k,w) do                                 \
105
 
          {                                                       \
106
 
            t1 = (h) + Sum1((e)) + Cho((e),(f),(g)) + (k) + (w);  \
107
 
            t2 = Sum0((a)) + Maj((a),(b),(c));                    \
108
 
            h = g;                                                \
109
 
            g = f;                                                \
110
 
            f = e;                                                \
111
 
            e = d + t1;                                           \
112
 
            d = c;                                                \
113
 
            c = b;                                                \
114
 
            b = a;                                                \
115
 
            a = t1 + t2;                                          \
116
 
          } while (0)
117
 
 
118
 
static void
119
 
transform (SHA256_CONTEXT *hd, const unsigned char *data)
120
 
{
121
 
  static const u32 K[64] = {
122
 
    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
123
 
    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
124
 
    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
125
 
    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 
126
 
    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
127
 
    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
128
 
    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
129
 
    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
130
 
    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
131
 
    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
132
 
    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
133
 
    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
134
 
    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
135
 
    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
136
 
    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
137
 
    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
138
 
  };
139
 
 
140
 
  u32 a,b,c,d,e,f,g,h,t1,t2;
141
 
  u32 x[16];
142
 
  u32 w[64];
143
 
  int i;
144
 
  
145
 
  a = hd->h0;
146
 
  b = hd->h1;
147
 
  c = hd->h2;
148
 
  d = hd->h3;
149
 
  e = hd->h4;
150
 
  f = hd->h5;
151
 
  g = hd->h6;
152
 
  h = hd->h7;
153
 
  
154
 
#ifdef WORDS_BIGENDIAN
155
 
  memcpy (x, data, 64);
156
 
#else
157
 
  { 
158
 
    byte *p2;
159
 
  
160
 
    for (i=0, p2=(byte*)x; i < 16; i++, p2 += 4 ) 
161
 
      {
162
 
        p2[3] = *data++;
163
 
        p2[2] = *data++;
164
 
        p2[1] = *data++;
165
 
        p2[0] = *data++;
166
 
      }
167
 
  }
168
 
#endif
169
 
 
170
 
  for (i=0; i < 16; i++)
171
 
    w[i] = x[i];
172
 
  for (; i < 64; i++)
173
 
    w[i] = S1(w[i-2]) + w[i-7] + S0(w[i-15]) + w[i-16];
174
 
 
175
 
  for (i=0; i < 64; i++)
176
 
    R(a,b,c,d,e,f,g,h,K[i],w[i]);
177
 
 
178
 
  hd->h0 += a;
179
 
  hd->h1 += b;
180
 
  hd->h2 += c;
181
 
  hd->h3 += d;
182
 
  hd->h4 += e;
183
 
  hd->h5 += f;
184
 
  hd->h6 += g;
185
 
  hd->h7 += h;
186
 
}
187
 
#undef Cho
188
 
#undef Maj
189
 
#undef Sum0
190
 
#undef Sum1
191
 
#undef S0
192
 
#undef S1
193
 
#undef R
194
 
 
195
 
 
196
 
/* Update the message digest with the contents of INBUF with length
197
 
  INLEN.  */
198
 
static void
199
 
sha256_write (void *context, const void *inbuf_arg, size_t inlen)
200
 
{
201
 
  const unsigned char *inbuf = inbuf_arg;
202
 
  SHA256_CONTEXT *hd = context;
203
 
 
204
 
  if (hd->count == 64)
205
 
    { /* flush the buffer */
206
 
      transform (hd, hd->buf);
207
 
      _gcry_burn_stack (74*4+32);
208
 
      hd->count = 0;
209
 
      hd->nblocks++;
210
 
    }
211
 
  if (!inbuf)
212
 
    return;
213
 
  if (hd->count)
214
 
    {
215
 
      for (; inlen && hd->count < 64; inlen--)
216
 
        hd->buf[hd->count++] = *inbuf++;
217
 
      sha256_write (hd, NULL, 0);
218
 
      if (!inlen)
219
 
        return;
220
 
    }
221
 
 
222
 
  while (inlen >= 64)
223
 
    {
224
 
      transform (hd, inbuf);
225
 
      hd->count = 0;
226
 
      hd->nblocks++;
227
 
      inlen -= 64;
228
 
      inbuf += 64;
229
 
    }
230
 
  _gcry_burn_stack (74*4+32);
231
 
  for (; inlen && hd->count < 64; inlen--)
232
 
    hd->buf[hd->count++] = *inbuf++;
233
 
}
234
 
 
235
 
 
236
 
/*
237
 
   The routine finally terminates the computation and returns the
238
 
   digest.  The handle is prepared for a new cycle, but adding bytes
239
 
   to the handle will the destroy the returned buffer.  Returns: 32
240
 
   bytes with the message the digest.  */
241
 
static void
242
 
sha256_final(void *context)
243
 
{
244
 
  SHA256_CONTEXT *hd = context;
245
 
  u32 t, msb, lsb;
246
 
  byte *p;
247
 
  
248
 
  sha256_write (hd, NULL, 0); /* flush */;
249
 
 
250
 
  t = hd->nblocks;
251
 
  /* multiply by 64 to make a byte count */
252
 
  lsb = t << 6;
253
 
  msb = t >> 26;
254
 
  /* add the count */
255
 
  t = lsb;
256
 
  if ((lsb += hd->count) < t)
257
 
    msb++;
258
 
  /* multiply by 8 to make a bit count */
259
 
  t = lsb;
260
 
  lsb <<= 3;
261
 
  msb <<= 3;
262
 
  msb |= t >> 29;
263
 
 
264
 
  if (hd->count < 56)
265
 
    { /* enough room */
266
 
      hd->buf[hd->count++] = 0x80; /* pad */
267
 
      while (hd->count < 56)
268
 
        hd->buf[hd->count++] = 0;  /* pad */
269
 
    }
270
 
  else
271
 
    { /* need one extra block */
272
 
      hd->buf[hd->count++] = 0x80; /* pad character */
273
 
      while (hd->count < 64)
274
 
        hd->buf[hd->count++] = 0;
275
 
      sha256_write (hd, NULL, 0);  /* flush */;
276
 
      memset (hd->buf, 0, 56 ); /* fill next block with zeroes */
277
 
    }
278
 
  /* append the 64 bit count */
279
 
  hd->buf[56] = msb >> 24;
280
 
  hd->buf[57] = msb >> 16;
281
 
  hd->buf[58] = msb >>  8;
282
 
  hd->buf[59] = msb;
283
 
  hd->buf[60] = lsb >> 24;
284
 
  hd->buf[61] = lsb >> 16;
285
 
  hd->buf[62] = lsb >>  8;
286
 
  hd->buf[63] = lsb;
287
 
  transform (hd, hd->buf);
288
 
  _gcry_burn_stack (74*4+32);
289
 
 
290
 
  p = hd->buf;
291
 
#ifdef WORDS_BIGENDIAN
292
 
#define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
293
 
#else /* little endian */
294
 
#define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;  \
295
 
                  *p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)
296
 
#endif
297
 
  X(0);
298
 
  X(1);
299
 
  X(2);
300
 
  X(3);
301
 
  X(4);
302
 
  X(5);
303
 
  X(6);
304
 
  X(7);
305
 
#undef X
306
 
}
307
 
 
308
 
static byte *
309
 
sha256_read (void *context)
310
 
{
311
 
  SHA256_CONTEXT *hd = context;
312
 
 
313
 
  return hd->buf;
314
 
}
315
 
 
316
 
 
317
 
 
318
 
/* 
319
 
     Self-test section.
320
 
 */
321
 
 
322
 
 
323
 
static gpg_err_code_t
324
 
selftests_sha224 (int extended, selftest_report_func_t report)
325
 
{
326
 
  const char *what;
327
 
  const char *errtxt;
328
 
  
329
 
  what = "short string";
330
 
  errtxt = _gcry_hash_selftest_check_one
331
 
    (GCRY_MD_SHA224, 0, 
332
 
     "abc", 3,
333
 
     "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
334
 
     "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7", 28);
335
 
  if (errtxt)
336
 
    goto failed;
337
 
 
338
 
  if (extended)
339
 
    {
340
 
      what = "long string";
341
 
      errtxt = _gcry_hash_selftest_check_one
342
 
        (GCRY_MD_SHA224, 0, 
343
 
         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
344
 
         "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01\x50"
345
 
         "\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25", 28);
346
 
      if (errtxt)
347
 
        goto failed;
348
 
      
349
 
      what = "one million \"a\"";
350
 
      errtxt = _gcry_hash_selftest_check_one
351
 
        (GCRY_MD_SHA224, 1,
352
 
         NULL, 0,
353
 
         "\x20\x79\x46\x55\x98\x0c\x91\xd8\xbb\xb4\xc1\xea\x97\x61\x8a\x4b"
354
 
         "\xf0\x3f\x42\x58\x19\x48\xb2\xee\x4e\xe7\xad\x67", 28);
355
 
      if (errtxt)
356
 
        goto failed;
357
 
    }
358
 
 
359
 
  return 0; /* Succeeded. */
360
 
 
361
 
 failed:
362
 
  if (report)
363
 
    report ("digest", GCRY_MD_SHA224, what, errtxt);
364
 
  return GPG_ERR_SELFTEST_FAILED;
365
 
}
366
 
 
367
 
static gpg_err_code_t
368
 
selftests_sha256 (int extended, selftest_report_func_t report)
369
 
{
370
 
  const char *what;
371
 
  const char *errtxt;
372
 
  
373
 
  what = "short string";
374
 
  errtxt = _gcry_hash_selftest_check_one
375
 
    (GCRY_MD_SHA256, 0, 
376
 
     "abc", 3,
377
 
     "\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
378
 
     "\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad", 32);
379
 
  if (errtxt)
380
 
    goto failed;
381
 
 
382
 
  if (extended)
383
 
    {
384
 
      what = "long string";
385
 
      errtxt = _gcry_hash_selftest_check_one
386
 
        (GCRY_MD_SHA256, 0, 
387
 
         "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
388
 
         "\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
389
 
         "\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1",
390
 
         32);
391
 
      if (errtxt)
392
 
        goto failed;
393
 
      
394
 
      what = "one million \"a\"";
395
 
      errtxt = _gcry_hash_selftest_check_one
396
 
        (GCRY_MD_SHA256, 1,
397
 
         NULL, 0,
398
 
         "\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67"
399
 
         "\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0",
400
 
         32);
401
 
      if (errtxt)
402
 
        goto failed;
403
 
    }
404
 
 
405
 
  return 0; /* Succeeded. */
406
 
 
407
 
 failed:
408
 
  if (report)
409
 
    report ("digest", GCRY_MD_SHA256, what, errtxt);
410
 
  return GPG_ERR_SELFTEST_FAILED;
411
 
}
412
 
 
413
 
 
414
 
/* Run a full self-test for ALGO and return 0 on success.  */
415
 
static gpg_err_code_t
416
 
run_selftests (int algo, int extended, selftest_report_func_t report)
417
 
{
418
 
  gpg_err_code_t ec;
419
 
 
420
 
  switch (algo)
421
 
    {
422
 
    case GCRY_MD_SHA224:
423
 
      ec = selftests_sha224 (extended, report);
424
 
      break;
425
 
    case GCRY_MD_SHA256:
426
 
      ec = selftests_sha256 (extended, report);
427
 
      break;
428
 
    default:
429
 
      ec = GPG_ERR_DIGEST_ALGO;
430
 
      break;
431
 
        
432
 
    }
433
 
  return ec;
434
 
}
435
 
 
436
 
 
437
 
 
438
 
 
439
 
static byte asn224[19] = /* Object ID is 2.16.840.1.101.3.4.2.4 */
440
 
  { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
441
 
    0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
442
 
    0x1C
443
 
  };
444
 
 
445
 
static gcry_md_oid_spec_t oid_spec_sha224[] =
446
 
  {
447
 
    /* From RFC3874, Section 4 */
448
 
    { "2.16.840.1.101.3.4.2.4" }, 
449
 
    { NULL },
450
 
  };
451
 
 
452
 
static byte asn256[19] = /* Object ID is  2.16.840.1.101.3.4.2.1 */
453
 
  { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
454
 
    0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
455
 
    0x00, 0x04, 0x20 };
456
 
 
457
 
static gcry_md_oid_spec_t oid_spec_sha256[] =
458
 
  {
459
 
    /* According to the OpenPGP draft rfc2440-bis06 */
460
 
    { "2.16.840.1.101.3.4.2.1" }, 
461
 
    /* PKCS#1 sha256WithRSAEncryption */
462
 
    { "1.2.840.113549.1.1.11" },
463
 
 
464
 
    { NULL },
465
 
  };
466
 
 
467
 
gcry_md_spec_t _gcry_digest_spec_sha224 =
468
 
  {
469
 
    "SHA224", asn224, DIM (asn224), oid_spec_sha224, 28,
470
 
    sha224_init, sha256_write, sha256_final, sha256_read,
471
 
    sizeof (SHA256_CONTEXT)
472
 
  };
473
 
md_extra_spec_t _gcry_digest_extraspec_sha224 = 
474
 
  {
475
 
    run_selftests
476
 
  };
477
 
 
478
 
gcry_md_spec_t _gcry_digest_spec_sha256 =
479
 
  {
480
 
    "SHA256", asn256, DIM (asn256), oid_spec_sha256, 32,
481
 
    sha256_init, sha256_write, sha256_final, sha256_read,
482
 
    sizeof (SHA256_CONTEXT)
483
 
  };
484
 
md_extra_spec_t _gcry_digest_extraspec_sha256 = 
485
 
  {
486
 
    run_selftests
487
 
  };