← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lib/libgcrypt/cipher/hmac-tests.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/hmac-tests.c
1
 
/* hmac-tests.c - HMAC selftests.
2
 
 * Copyright (C) 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
 
   Although algorithm self-tests are usually implemented in the module
22
 
   implementing the algorithm, the case for HMAC is different because
23
 
   HMAC is implemnetd on a higher level using a special feature of the
24
 
   gcry_md_ functions.  It would be possible to do this also in the
25
 
   digest algorithm modules, but that would blow up the code too much
26
 
   and spread the hmac tests over several modules.
27
 
 
28
 
   Thus we implement all HMAC tests in this test module and provide a
29
 
   function to run the tests.
30
 
*/
31
 
 
32
 
#include <config.h>
33
 
#include <stdio.h>
34
 
#include <stdlib.h>
35
 
#include <string.h>
36
 
#ifdef HAVE_STDINT_H 
37
 
# include <stdint.h>
38
 
#endif
39
 
 
40
 
#include "g10lib.h"
41
 
#include "cipher.h"
42
 
#include "hmac256.h"
43
 
 
44
 
/* Check one HMAC with digest ALGO using the regualr HAMC
45
 
   API. (DATA,DATALEN) is the data to be MACed, (KEY,KEYLEN) the key
46
 
   and (EXPECT,EXPECTLEN) the expected result.  Returns NULL on
47
 
   succdess or a string describing the failure.  */
48
 
static const char *
49
 
check_one (int algo,
50
 
           const void *data, size_t datalen, 
51
 
           const void *key, size_t keylen,
52
 
           const void *expect, size_t expectlen)
53
 
{
54
 
  gcry_md_hd_t hd;
55
 
  const unsigned char *digest;
56
 
 
57
 
/*   printf ("HMAC algo %d\n", algo); */
58
 
  if (_gcry_md_get_algo_dlen (algo) != expectlen)
59
 
    return "invalid tests data";
60
 
  if (_gcry_md_open (&hd, algo, GCRY_MD_FLAG_HMAC))
61
 
    return "gcry_md_open failed";
62
 
  if (_gcry_md_setkey (hd, key, keylen))
63
 
    {
64
 
      _gcry_md_close (hd);
65
 
      return "gcry_md_setkey failed";
66
 
    }
67
 
  _gcry_md_write (hd, data, datalen);
68
 
  digest = _gcry_md_read (hd, algo);
69
 
  if (!digest)
70
 
    {
71
 
      _gcry_md_close (hd);
72
 
      return "gcry_md_read failed";
73
 
    }
74
 
  if (memcmp (digest, expect, expectlen))
75
 
    {
76
 
/*       int i; */
77
 
 
78
 
/*       fputs ("        {", stdout); */
79
 
/*       for (i=0; i < expectlen-1; i++) */
80
 
/*         { */
81
 
/*           if (i && !(i % 8)) */
82
 
/*             fputs ("\n         ", stdout); */
83
 
/*           printf (" 0x%02x,", digest[i]); */
84
 
/*         } */
85
 
/*       printf (" 0x%02x } },\n", digest[i]); */
86
 
 
87
 
      _gcry_md_close (hd);
88
 
      return "does not match";
89
 
    }
90
 
  _gcry_md_close (hd);
91
 
  return NULL;  
92
 
}
93
 
 
94
 
 
95
 
static gpg_err_code_t
96
 
selftests_sha1 (int extended, selftest_report_func_t report)
97
 
{
98
 
  const char *what;
99
 
  const char *errtxt;
100
 
  unsigned char key[128];
101
 
  int i, j;
102
 
 
103
 
  what = "FIPS-198a, A.1";
104
 
  for (i=0; i < 64; i++)
105
 
    key[i] = i;
106
 
  errtxt = check_one (GCRY_MD_SHA1,
107
 
                      "Sample #1", 9,
108
 
                      key, 64,
109
 
                      "\x4f\x4c\xa3\xd5\xd6\x8b\xa7\xcc\x0a\x12"
110
 
                      "\x08\xc9\xc6\x1e\x9c\x5d\xa0\x40\x3c\x0a", 20);
111
 
  if (errtxt)
112
 
    goto failed;
113
 
 
114
 
  if (extended)
115
 
    {
116
 
      what = "FIPS-198a, A.2";
117
 
      for (i=0, j=0x30; i < 20; i++)
118
 
        key[i] = j++;
119
 
      errtxt = check_one (GCRY_MD_SHA1,
120
 
                          "Sample #2", 9,
121
 
                          key, 20,
122
 
                          "\x09\x22\xd3\x40\x5f\xaa\x3d\x19\x4f\x82"
123
 
                          "\xa4\x58\x30\x73\x7d\x5c\xc6\xc7\x5d\x24", 20);
124
 
      if (errtxt)
125
 
        goto failed;
126
 
      
127
 
      what = "FIPS-198a, A.3";
128
 
      for (i=0, j=0x50; i < 100; i++)
129
 
        key[i] = j++;
130
 
      errtxt = check_one (GCRY_MD_SHA1,
131
 
                          "Sample #3", 9,
132
 
                          key, 100,
133
 
                          "\xbc\xf4\x1e\xab\x8b\xb2\xd8\x02\xf3\xd0"
134
 
                          "\x5c\xaf\x7c\xb0\x92\xec\xf8\xd1\xa3\xaa", 20 );
135
 
      if (errtxt)
136
 
        goto failed;
137
 
      
138
 
      what = "FIPS-198a, A.4";
139
 
      for (i=0, j=0x70; i < 49; i++)
140
 
        key[i] = j++;
141
 
      errtxt = check_one (GCRY_MD_SHA1,
142
 
                          "Sample #4", 9,
143
 
                          key, 49,
144
 
                          "\x9e\xa8\x86\xef\xe2\x68\xdb\xec\xce\x42"
145
 
                          "\x0c\x75\x24\xdf\x32\xe0\x75\x1a\x2a\x26", 20 );
146
 
      if (errtxt)
147
 
        goto failed;
148
 
    }
149
 
 
150
 
  return 0; /* Succeeded. */
151
 
 
152
 
 failed:
153
 
  if (report)
154
 
    report ("hmac", GCRY_MD_SHA1, what, errtxt);
155
 
  return GPG_ERR_SELFTEST_FAILED;
156
 
}
157
 
 
158
 
 
159
 
 
160
 
static gpg_err_code_t
161
 
selftests_sha224 (int extended, selftest_report_func_t report)
162
 
{
163
 
  static struct 
164
 
  {
165
 
    const char * const desc;
166
 
    const char * const data;
167
 
    const char * const key;
168
 
    const char expect[28];
169
 
  } tv[] =
170
 
    {
171
 
      { "data-28 key-4",
172
 
        "what do ya want for nothing?", 
173
 
        "Jefe",
174
 
        { 0xa3, 0x0e, 0x01, 0x09, 0x8b, 0xc6, 0xdb, 0xbf,
175
 
          0x45, 0x69, 0x0f, 0x3a, 0x7e, 0x9e, 0x6d, 0x0f,
176
 
          0x8b, 0xbe, 0xa2, 0xa3, 0x9e, 0x61, 0x48, 0x00,
177
 
          0x8f, 0xd0, 0x5e, 0x44 } },
178
 
 
179
 
      { "data-9 key-20",
180
 
        "Hi There",
181
 
        "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
182
 
        "\x0b\x0b\x0b\x0b",
183
 
        { 0x89, 0x6f, 0xb1, 0x12, 0x8a, 0xbb, 0xdf, 0x19,
184
 
          0x68, 0x32, 0x10, 0x7c, 0xd4, 0x9d, 0xf3, 0x3f,
185
 
          0x47, 0xb4, 0xb1, 0x16, 0x99, 0x12, 0xba, 0x4f,
186
 
          0x53, 0x68, 0x4b, 0x22 } },
187
 
 
188
 
      { "data-50 key-20",
189
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
190
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
191
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
192
 
        "\xdd\xdd",
193
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
194
 
        "\xaa\xaa\xaa\xaa",
195
 
        { 0x7f, 0xb3, 0xcb, 0x35, 0x88, 0xc6, 0xc1, 0xf6,
196
 
          0xff, 0xa9, 0x69, 0x4d, 0x7d, 0x6a, 0xd2, 0x64,
197
 
          0x93, 0x65, 0xb0, 0xc1, 0xf6, 0x5d, 0x69, 0xd1,
198
 
          0xec, 0x83, 0x33, 0xea } },
199
 
 
200
 
      { "data-50 key-26",
201
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
202
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
203
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
204
 
        "\xcd\xcd",
205
 
        "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
206
 
        "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
207
 
        { 0x6c, 0x11, 0x50, 0x68, 0x74, 0x01, 0x3c, 0xac,
208
 
          0x6a, 0x2a, 0xbc, 0x1b, 0xb3, 0x82, 0x62, 0x7c,
209
 
          0xec, 0x6a, 0x90, 0xd8, 0x6e, 0xfc, 0x01, 0x2d,
210
 
          0xe7, 0xaf, 0xec, 0x5a } },
211
 
 
212
 
      { "data-54 key-131",
213
 
        "Test Using Larger Than Block-Size Key - Hash Key First",
214
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
215
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
216
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
217
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
218
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
219
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
220
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
221
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
222
 
        "\xaa\xaa\xaa",
223
 
        { 0x95, 0xe9, 0xa0, 0xdb, 0x96, 0x20, 0x95, 0xad,
224
 
          0xae, 0xbe, 0x9b, 0x2d, 0x6f, 0x0d, 0xbc, 0xe2,
225
 
          0xd4, 0x99, 0xf1, 0x12, 0xf2, 0xd2, 0xb7, 0x27,
226
 
          0x3f, 0xa6, 0x87, 0x0e } },
227
 
 
228
 
      { "data-152 key-131",
229
 
        "This is a test using a larger than block-size key and a larger "
230
 
        "than block-size data. The key needs to be hashed before being "
231
 
        "used by the HMAC algorithm.",
232
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
233
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
234
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
235
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
236
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
237
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
238
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
239
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
240
 
        "\xaa\xaa\xaa",
241
 
        { 0x3a, 0x85, 0x41, 0x66, 0xac, 0x5d, 0x9f, 0x02,
242
 
          0x3f, 0x54, 0xd5, 0x17, 0xd0, 0xb3, 0x9d, 0xbd,
243
 
          0x94, 0x67, 0x70, 0xdb, 0x9c, 0x2b, 0x95, 0xc9,
244
 
          0xf6, 0xf5, 0x65, 0xd1 } },
245
 
 
246
 
      { NULL }
247
 
    };
248
 
  const char *what;
249
 
  const char *errtxt;
250
 
  int tvidx;
251
 
  
252
 
  for (tvidx=0; tv[tvidx].desc; tvidx++)
253
 
    {
254
 
      what = tv[tvidx].desc;
255
 
      errtxt = check_one (GCRY_MD_SHA224,
256
 
                          tv[tvidx].data, strlen (tv[tvidx].data),
257
 
                          tv[tvidx].key, strlen (tv[tvidx].key),
258
 
                          tv[tvidx].expect, DIM (tv[tvidx].expect) );
259
 
      if (errtxt)
260
 
        goto failed;
261
 
      if (!extended)
262
 
        break;
263
 
    }
264
 
 
265
 
  return 0; /* Succeeded. */
266
 
 
267
 
 failed:
268
 
  if (report)
269
 
    report ("hmac", GCRY_MD_SHA224, what, errtxt);
270
 
  return GPG_ERR_SELFTEST_FAILED;
271
 
}
272
 
 
273
 
 
274
 
static gpg_err_code_t
275
 
selftests_sha256 (int extended, selftest_report_func_t report)
276
 
{
277
 
  static struct 
278
 
  {
279
 
    const char * const desc;
280
 
    const char * const data;
281
 
    const char * const key;
282
 
    const char expect[32];
283
 
  } tv[] =
284
 
    {
285
 
      { "data-28 key-4",
286
 
        "what do ya want for nothing?", 
287
 
        "Jefe",
288
 
        { 0x5b, 0xdc, 0xc1, 0x46, 0xbf, 0x60, 0x75, 0x4e,
289
 
          0x6a, 0x04, 0x24, 0x26, 0x08, 0x95, 0x75, 0xc7,
290
 
          0x5a, 0x00, 0x3f, 0x08, 0x9d, 0x27, 0x39, 0x83,
291
 
          0x9d, 0xec, 0x58, 0xb9, 0x64, 0xec, 0x38, 0x43 } },
292
 
 
293
 
      { "data-9 key-20",
294
 
        "Hi There",
295
 
        "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
296
 
        "\x0b\x0b\x0b\x0b",
297
 
        { 0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
298
 
          0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b,
299
 
          0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7,
300
 
          0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7 } },
301
 
 
302
 
      { "data-50 key-20",
303
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
304
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
305
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
306
 
        "\xdd\xdd",
307
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
308
 
        "\xaa\xaa\xaa\xaa",
309
 
        { 0x77, 0x3e, 0xa9, 0x1e, 0x36, 0x80, 0x0e, 0x46,
310
 
          0x85, 0x4d, 0xb8, 0xeb, 0xd0, 0x91, 0x81, 0xa7,
311
 
          0x29, 0x59, 0x09, 0x8b, 0x3e, 0xf8, 0xc1, 0x22,
312
 
          0xd9, 0x63, 0x55, 0x14, 0xce, 0xd5, 0x65, 0xfe } },
313
 
 
314
 
      { "data-50 key-26",
315
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
316
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
317
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
318
 
        "\xcd\xcd",
319
 
        "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
320
 
        "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
321
 
        { 0x82, 0x55, 0x8a, 0x38, 0x9a, 0x44, 0x3c, 0x0e,
322
 
          0xa4, 0xcc, 0x81, 0x98, 0x99, 0xf2, 0x08, 0x3a,
323
 
          0x85, 0xf0, 0xfa, 0xa3, 0xe5, 0x78, 0xf8, 0x07,
324
 
          0x7a, 0x2e, 0x3f, 0xf4, 0x67, 0x29, 0x66, 0x5b } },
325
 
 
326
 
      { "data-54 key-131",
327
 
        "Test Using Larger Than Block-Size Key - Hash Key First",
328
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
329
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
330
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
331
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
332
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
333
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
334
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
335
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
336
 
        "\xaa\xaa\xaa",
337
 
        { 0x60, 0xe4, 0x31, 0x59, 0x1e, 0xe0, 0xb6, 0x7f,
338
 
          0x0d, 0x8a, 0x26, 0xaa, 0xcb, 0xf5, 0xb7, 0x7f,
339
 
          0x8e, 0x0b, 0xc6, 0x21, 0x37, 0x28, 0xc5, 0x14,
340
 
          0x05, 0x46, 0x04, 0x0f, 0x0e, 0xe3, 0x7f, 0x54 } },
341
 
 
342
 
      { "data-152 key-131",
343
 
        "This is a test using a larger than block-size key and a larger "
344
 
        "than block-size data. The key needs to be hashed before being "
345
 
        "used by the HMAC algorithm.",
346
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
347
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
348
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
349
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
350
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
351
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
352
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
353
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
354
 
        "\xaa\xaa\xaa",
355
 
        { 0x9b, 0x09, 0xff, 0xa7, 0x1b, 0x94, 0x2f, 0xcb,
356
 
          0x27, 0x63, 0x5f, 0xbc, 0xd5, 0xb0, 0xe9, 0x44,
357
 
          0xbf, 0xdc, 0x63, 0x64, 0x4f, 0x07, 0x13, 0x93,
358
 
          0x8a, 0x7f, 0x51, 0x53, 0x5c, 0x3a, 0x35, 0xe2 } },
359
 
 
360
 
      { NULL }
361
 
    };
362
 
  const char *what;
363
 
  const char *errtxt;
364
 
  int tvidx;
365
 
  
366
 
  for (tvidx=0; tv[tvidx].desc; tvidx++)
367
 
    {
368
 
      hmac256_context_t hmachd;
369
 
      const unsigned char *digest;
370
 
      size_t dlen;
371
 
 
372
 
      what = tv[tvidx].desc;
373
 
      errtxt = check_one (GCRY_MD_SHA256,
374
 
                          tv[tvidx].data, strlen (tv[tvidx].data),
375
 
                          tv[tvidx].key, strlen (tv[tvidx].key),
376
 
                          tv[tvidx].expect, DIM (tv[tvidx].expect) );
377
 
      if (errtxt)
378
 
        goto failed;
379
 
 
380
 
      hmachd = _gcry_hmac256_new (tv[tvidx].key, strlen (tv[tvidx].key));
381
 
      if (!hmachd)
382
 
        {
383
 
          errtxt = "_gcry_hmac256_new failed";
384
 
          goto failed;
385
 
        }
386
 
      _gcry_hmac256_update (hmachd, tv[tvidx].data, strlen (tv[tvidx].data));
387
 
      digest = _gcry_hmac256_finalize (hmachd, &dlen);
388
 
      if (!digest)
389
 
        {
390
 
          errtxt = "_gcry_hmac256_finalize failed";
391
 
          _gcry_hmac256_release (hmachd);
392
 
          goto failed;
393
 
        }
394
 
      if (dlen != DIM (tv[tvidx].expect)
395
 
          || memcmp (digest, tv[tvidx].expect, DIM (tv[tvidx].expect)))
396
 
        {
397
 
          errtxt = "does not match in second implementation";
398
 
          _gcry_hmac256_release (hmachd);
399
 
          goto failed;
400
 
        }
401
 
      _gcry_hmac256_release (hmachd);
402
 
 
403
 
      if (!extended)
404
 
        break;
405
 
    }
406
 
 
407
 
  return 0; /* Succeeded. */
408
 
 
409
 
 failed:
410
 
  if (report)
411
 
    report ("hmac", GCRY_MD_SHA256, what, errtxt);
412
 
  return GPG_ERR_SELFTEST_FAILED;
413
 
}
414
 
 
415
 
 
416
 
static gpg_err_code_t
417
 
selftests_sha384 (int extended, selftest_report_func_t report)
418
 
{
419
 
  static struct 
420
 
  {
421
 
    const char * const desc;
422
 
    const char * const data;
423
 
    const char * const key;
424
 
    const char expect[48];
425
 
  } tv[] =
426
 
    {
427
 
      { "data-28 key-4",
428
 
        "what do ya want for nothing?", 
429
 
        "Jefe",
430
 
        { 0xaf, 0x45, 0xd2, 0xe3, 0x76, 0x48, 0x40, 0x31,
431
 
          0x61, 0x7f, 0x78, 0xd2, 0xb5, 0x8a, 0x6b, 0x1b,
432
 
          0x9c, 0x7e, 0xf4, 0x64, 0xf5, 0xa0, 0x1b, 0x47,
433
 
          0xe4, 0x2e, 0xc3, 0x73, 0x63, 0x22, 0x44, 0x5e,
434
 
          0x8e, 0x22, 0x40, 0xca, 0x5e, 0x69, 0xe2, 0xc7,
435
 
          0x8b, 0x32, 0x39, 0xec, 0xfa, 0xb2, 0x16, 0x49 } },
436
 
 
437
 
      { "data-9 key-20",
438
 
        "Hi There",
439
 
        "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
440
 
        "\x0b\x0b\x0b\x0b",
441
 
        { 0xaf, 0xd0, 0x39, 0x44, 0xd8, 0x48, 0x95, 0x62,
442
 
          0x6b, 0x08, 0x25, 0xf4, 0xab, 0x46, 0x90, 0x7f,
443
 
          0x15, 0xf9, 0xda, 0xdb, 0xe4, 0x10, 0x1e, 0xc6,
444
 
          0x82, 0xaa, 0x03, 0x4c, 0x7c, 0xeb, 0xc5, 0x9c,
445
 
          0xfa, 0xea, 0x9e, 0xa9, 0x07, 0x6e, 0xde, 0x7f,
446
 
          0x4a, 0xf1, 0x52, 0xe8, 0xb2, 0xfa, 0x9c, 0xb6 } },
447
 
 
448
 
      { "data-50 key-20",
449
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
450
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
451
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
452
 
        "\xdd\xdd",
453
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
454
 
        "\xaa\xaa\xaa\xaa",
455
 
        { 0x88, 0x06, 0x26, 0x08, 0xd3, 0xe6, 0xad, 0x8a,
456
 
          0x0a, 0xa2, 0xac, 0xe0, 0x14, 0xc8, 0xa8, 0x6f,
457
 
          0x0a, 0xa6, 0x35, 0xd9, 0x47, 0xac, 0x9f, 0xeb,
458
 
          0xe8, 0x3e, 0xf4, 0xe5, 0x59, 0x66, 0x14, 0x4b,
459
 
          0x2a, 0x5a, 0xb3, 0x9d, 0xc1, 0x38, 0x14, 0xb9,
460
 
          0x4e, 0x3a, 0xb6, 0xe1, 0x01, 0xa3, 0x4f, 0x27 } },
461
 
 
462
 
      { "data-50 key-26",
463
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
464
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
465
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
466
 
        "\xcd\xcd",
467
 
        "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
468
 
        "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
469
 
        { 0x3e, 0x8a, 0x69, 0xb7, 0x78, 0x3c, 0x25, 0x85,
470
 
          0x19, 0x33, 0xab, 0x62, 0x90, 0xaf, 0x6c, 0xa7,
471
 
          0x7a, 0x99, 0x81, 0x48, 0x08, 0x50, 0x00, 0x9c,
472
 
          0xc5, 0x57, 0x7c, 0x6e, 0x1f, 0x57, 0x3b, 0x4e,
473
 
          0x68, 0x01, 0xdd, 0x23, 0xc4, 0xa7, 0xd6, 0x79,
474
 
          0xcc, 0xf8, 0xa3, 0x86, 0xc6, 0x74, 0xcf, 0xfb } },
475
 
 
476
 
      { "data-54 key-131",
477
 
        "Test Using Larger Than Block-Size Key - Hash Key First",
478
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
479
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
480
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
481
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
482
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
483
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
484
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
485
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
486
 
        "\xaa\xaa\xaa",
487
 
        { 0x4e, 0xce, 0x08, 0x44, 0x85, 0x81, 0x3e, 0x90,
488
 
          0x88, 0xd2, 0xc6, 0x3a, 0x04, 0x1b, 0xc5, 0xb4,
489
 
          0x4f, 0x9e, 0xf1, 0x01, 0x2a, 0x2b, 0x58, 0x8f,
490
 
          0x3c, 0xd1, 0x1f, 0x05, 0x03, 0x3a, 0xc4, 0xc6,
491
 
          0x0c, 0x2e, 0xf6, 0xab, 0x40, 0x30, 0xfe, 0x82,
492
 
          0x96, 0x24, 0x8d, 0xf1, 0x63, 0xf4, 0x49, 0x52 } },
493
 
 
494
 
      { "data-152 key-131",
495
 
        "This is a test using a larger than block-size key and a larger "
496
 
        "than block-size data. The key needs to be hashed before being "
497
 
        "used by the HMAC algorithm.",
498
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
499
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
500
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
501
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
502
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
503
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
504
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
505
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
506
 
        "\xaa\xaa\xaa",
507
 
        { 0x66, 0x17, 0x17, 0x8e, 0x94, 0x1f, 0x02, 0x0d,
508
 
          0x35, 0x1e, 0x2f, 0x25, 0x4e, 0x8f, 0xd3, 0x2c,
509
 
          0x60, 0x24, 0x20, 0xfe, 0xb0, 0xb8, 0xfb, 0x9a,
510
 
          0xdc, 0xce, 0xbb, 0x82, 0x46, 0x1e, 0x99, 0xc5,
511
 
          0xa6, 0x78, 0xcc, 0x31, 0xe7, 0x99, 0x17, 0x6d,
512
 
          0x38, 0x60, 0xe6, 0x11, 0x0c, 0x46, 0x52, 0x3e } },
513
 
 
514
 
      { NULL }
515
 
    };
516
 
  const char *what;
517
 
  const char *errtxt;
518
 
  int tvidx;
519
 
  
520
 
  for (tvidx=0; tv[tvidx].desc; tvidx++)
521
 
    {
522
 
      what = tv[tvidx].desc;
523
 
      errtxt = check_one (GCRY_MD_SHA384,
524
 
                          tv[tvidx].data, strlen (tv[tvidx].data),
525
 
                          tv[tvidx].key, strlen (tv[tvidx].key),
526
 
                          tv[tvidx].expect, DIM (tv[tvidx].expect) );
527
 
      if (errtxt)
528
 
        goto failed;
529
 
      if (!extended)
530
 
        break;
531
 
    }
532
 
 
533
 
  return 0; /* Succeeded. */
534
 
 
535
 
 failed:
536
 
  if (report)
537
 
    report ("hmac", GCRY_MD_SHA384, what, errtxt);
538
 
  return GPG_ERR_SELFTEST_FAILED;
539
 
}
540
 
 
541
 
 
542
 
static gpg_err_code_t
543
 
selftests_sha512 (int extended, selftest_report_func_t report)
544
 
{
545
 
  static struct 
546
 
  {
547
 
    const char * const desc;
548
 
    const char * const data;
549
 
    const char * const key;
550
 
    const char expect[64];
551
 
  } tv[] =
552
 
    {
553
 
      { "data-28 key-4",
554
 
        "what do ya want for nothing?", 
555
 
        "Jefe",
556
 
        { 0x16, 0x4b, 0x7a, 0x7b, 0xfc, 0xf8, 0x19, 0xe2,
557
 
          0xe3, 0x95, 0xfb, 0xe7, 0x3b, 0x56, 0xe0, 0xa3,
558
 
          0x87, 0xbd, 0x64, 0x22, 0x2e, 0x83, 0x1f, 0xd6,
559
 
          0x10, 0x27, 0x0c, 0xd7, 0xea, 0x25, 0x05, 0x54,
560
 
          0x97, 0x58, 0xbf, 0x75, 0xc0, 0x5a, 0x99, 0x4a,
561
 
          0x6d, 0x03, 0x4f, 0x65, 0xf8, 0xf0, 0xe6, 0xfd,
562
 
          0xca, 0xea, 0xb1, 0xa3, 0x4d, 0x4a, 0x6b, 0x4b,
563
 
          0x63, 0x6e, 0x07, 0x0a, 0x38, 0xbc, 0xe7, 0x37 } },
564
 
 
565
 
      { "data-9 key-20",
566
 
        "Hi There",
567
 
        "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
568
 
        "\x0b\x0b\x0b\x0b",
569
 
        { 0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d,
570
 
          0x4f, 0xf0, 0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0,
571
 
          0x23, 0x79, 0xf4, 0xe2, 0xce, 0x4e, 0xc2, 0x78,
572
 
          0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1, 0x7c, 0xde,
573
 
          0xda, 0xa8, 0x33, 0xb7, 0xd6, 0xb8, 0xa7, 0x02,
574
 
          0x03, 0x8b, 0x27, 0x4e, 0xae, 0xa3, 0xf4, 0xe4,
575
 
          0xbe, 0x9d, 0x91, 0x4e, 0xeb, 0x61, 0xf1, 0x70,
576
 
          0x2e, 0x69, 0x6c, 0x20, 0x3a, 0x12, 0x68, 0x54 } },
577
 
 
578
 
      { "data-50 key-20",
579
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
580
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
581
 
        "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
582
 
        "\xdd\xdd",
583
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
584
 
        "\xaa\xaa\xaa\xaa",
585
 
        { 0xfa, 0x73, 0xb0, 0x08, 0x9d, 0x56, 0xa2, 0x84,
586
 
          0xef, 0xb0, 0xf0, 0x75, 0x6c, 0x89, 0x0b, 0xe9,
587
 
          0xb1, 0xb5, 0xdb, 0xdd, 0x8e, 0xe8, 0x1a, 0x36,
588
 
          0x55, 0xf8, 0x3e, 0x33, 0xb2, 0x27, 0x9d, 0x39,
589
 
          0xbf, 0x3e, 0x84, 0x82, 0x79, 0xa7, 0x22, 0xc8,
590
 
          0x06, 0xb4, 0x85, 0xa4, 0x7e, 0x67, 0xc8, 0x07,
591
 
          0xb9, 0x46, 0xa3, 0x37, 0xbe, 0xe8, 0x94, 0x26,
592
 
          0x74, 0x27, 0x88, 0x59, 0xe1, 0x32, 0x92, 0xfb } },
593
 
 
594
 
      { "data-50 key-26",
595
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
596
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
597
 
        "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
598
 
        "\xcd\xcd",
599
 
        "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10"
600
 
        "\x11\x12\x13\x14\x15\x16\x17\x18\x19",
601
 
        { 0xb0, 0xba, 0x46, 0x56, 0x37, 0x45, 0x8c, 0x69,
602
 
          0x90, 0xe5, 0xa8, 0xc5, 0xf6, 0x1d, 0x4a, 0xf7,
603
 
          0xe5, 0x76, 0xd9, 0x7f, 0xf9, 0x4b, 0x87, 0x2d,
604
 
          0xe7, 0x6f, 0x80, 0x50, 0x36, 0x1e, 0xe3, 0xdb,
605
 
          0xa9, 0x1c, 0xa5, 0xc1, 0x1a, 0xa2, 0x5e, 0xb4,
606
 
          0xd6, 0x79, 0x27, 0x5c, 0xc5, 0x78, 0x80, 0x63,
607
 
          0xa5, 0xf1, 0x97, 0x41, 0x12, 0x0c, 0x4f, 0x2d,
608
 
          0xe2, 0xad, 0xeb, 0xeb, 0x10, 0xa2, 0x98, 0xdd } },
609
 
 
610
 
      { "data-54 key-131",
611
 
        "Test Using Larger Than Block-Size Key - Hash Key First",
612
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
613
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
614
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
615
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
616
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
617
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
618
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
619
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
620
 
        "\xaa\xaa\xaa",
621
 
        { 0x80, 0xb2, 0x42, 0x63, 0xc7, 0xc1, 0xa3, 0xeb,
622
 
          0xb7, 0x14, 0x93, 0xc1, 0xdd, 0x7b, 0xe8, 0xb4,
623
 
          0x9b, 0x46, 0xd1, 0xf4, 0x1b, 0x4a, 0xee, 0xc1,
624
 
          0x12, 0x1b, 0x01, 0x37, 0x83, 0xf8, 0xf3, 0x52,
625
 
          0x6b, 0x56, 0xd0, 0x37, 0xe0, 0x5f, 0x25, 0x98,
626
 
          0xbd, 0x0f, 0xd2, 0x21, 0x5d, 0x6a, 0x1e, 0x52,
627
 
          0x95, 0xe6, 0x4f, 0x73, 0xf6, 0x3f, 0x0a, 0xec,
628
 
          0x8b, 0x91, 0x5a, 0x98, 0x5d, 0x78, 0x65, 0x98 } },
629
 
 
630
 
      { "data-152 key-131",
631
 
        "This is a test using a larger than block-size key and a larger "
632
 
        "than block-size data. The key needs to be hashed before being "
633
 
        "used by the HMAC algorithm.",
634
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
635
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
636
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
637
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
638
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
639
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
640
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
641
 
        "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
642
 
        "\xaa\xaa\xaa",
643
 
        { 0xe3, 0x7b, 0x6a, 0x77, 0x5d, 0xc8, 0x7d, 0xba,
644
 
          0xa4, 0xdf, 0xa9, 0xf9, 0x6e, 0x5e, 0x3f, 0xfd,
645
 
          0xde, 0xbd, 0x71, 0xf8, 0x86, 0x72, 0x89, 0x86,
646
 
          0x5d, 0xf5, 0xa3, 0x2d, 0x20, 0xcd, 0xc9, 0x44,
647
 
          0xb6, 0x02, 0x2c, 0xac, 0x3c, 0x49, 0x82, 0xb1,
648
 
          0x0d, 0x5e, 0xeb, 0x55, 0xc3, 0xe4, 0xde, 0x15,
649
 
          0x13, 0x46, 0x76, 0xfb, 0x6d, 0xe0, 0x44, 0x60,
650
 
          0x65, 0xc9, 0x74, 0x40, 0xfa, 0x8c, 0x6a, 0x58 } },
651
 
 
652
 
      { NULL }
653
 
    };
654
 
  const char *what;
655
 
  const char *errtxt;
656
 
  int tvidx;
657
 
  
658
 
  for (tvidx=0; tv[tvidx].desc; tvidx++)
659
 
    {
660
 
      what = tv[tvidx].desc;
661
 
      errtxt = check_one (GCRY_MD_SHA512,
662
 
                          tv[tvidx].data, strlen (tv[tvidx].data),
663
 
                          tv[tvidx].key, strlen (tv[tvidx].key),
664
 
                          tv[tvidx].expect, DIM (tv[tvidx].expect) );
665
 
      if (errtxt)
666
 
        goto failed;
667
 
      if (!extended)
668
 
        break;
669
 
    }
670
 
 
671
 
  return 0; /* Succeeded. */
672
 
 
673
 
 failed:
674
 
  if (report)
675
 
    report ("hmac", GCRY_MD_SHA512, what, errtxt);
676
 
  return GPG_ERR_SELFTEST_FAILED;
677
 
}
678
 
 
679
 
 
680
 
 
681
 
/* Run a full self-test for ALGO and return 0 on success.  */
682
 
static gpg_err_code_t
683
 
run_selftests (int algo, int extended, selftest_report_func_t report)
684
 
{
685
 
  gpg_err_code_t ec;
686
 
 
687
 
  switch (algo)
688
 
    {
689
 
    case GCRY_MD_SHA1:
690
 
      ec = selftests_sha1 (extended, report);
691
 
      break;
692
 
    case GCRY_MD_SHA224:
693
 
      ec = selftests_sha224 (extended, report);
694
 
      break;
695
 
    case GCRY_MD_SHA256:
696
 
      ec = selftests_sha256 (extended, report);
697
 
      break;
698
 
    case GCRY_MD_SHA384:
699
 
      ec = selftests_sha384 (extended, report);
700
 
      break;
701
 
    case GCRY_MD_SHA512:
702
 
      ec = selftests_sha512 (extended, report);
703
 
      break;
704
 
    default:
705
 
      ec = GPG_ERR_DIGEST_ALGO;
706
 
      break;
707
 
    }
708
 
  return ec;
709
 
}
710
 
 
711
 
 
712
 
 
713
 
 
714
 
/* Run the selftests for HMAC with digest algorithm ALGO with optional
715
 
   reporting function REPORT.  */
716
 
gpg_error_t
717
 
_gcry_hmac_selftest (int algo, int extended, selftest_report_func_t report)
718
 
{
719
 
  gcry_err_code_t ec = 0;
720
 
 
721
 
  if (!gcry_md_test_algo (algo))
722
 
    {
723
 
      ec = run_selftests (algo, extended, report);
724
 
    }
725
 
  else
726
 
    {
727
 
      ec = GPG_ERR_DIGEST_ALGO;
728
 
      if (report)
729
 
        report ("hmac", algo, "module", "algorithm not available");
730
 
    }
731
 
  return gpg_error (ec);
732
 
}