← Back to branch summary

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

« back to all changes in this revision

Viewing changes to lib/libgcrypt/cipher/dsa.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/dsa.c
1
 
/* dsa.c - DSA signature algorithm
2
 
 * Copyright (C) 1998, 2000, 2001, 2002, 2003,
3
 
 *               2006, 2008  Free Software Foundation, Inc.
4
 
 *
5
 
 * This file is part of Libgcrypt.
6
 
 *
7
 
 * Libgcrypt is free software; you can redistribute it and/or modify
8
 
 * it under the terms of the GNU Lesser General Public License as
9
 
 * published by the Free Software Foundation; either version 2.1 of
10
 
 * the License, or (at your option) any later version.
11
 
 *
12
 
 * Libgcrypt is distributed in the hope that it will be useful,
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 * GNU Lesser General Public License for more details.
16
 
 *
17
 
 * You should have received a copy of the GNU Lesser General Public
18
 
 * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19
 
 */
20
 
 
21
 
#include <config.h>
22
 
#include <stdio.h>
23
 
#include <stdlib.h>
24
 
#include <string.h>
25
 
 
26
 
#include "g10lib.h"
27
 
#include "mpi.h"
28
 
#include "cipher.h"
29
 
 
30
 
typedef struct
31
 
{
32
 
  gcry_mpi_t p;     /* prime */
33
 
  gcry_mpi_t q;     /* group order */
34
 
  gcry_mpi_t g;     /* group generator */
35
 
  gcry_mpi_t y;     /* g^x mod p */
36
 
} DSA_public_key;
37
 
 
38
 
 
39
 
typedef struct
40
 
{
41
 
  gcry_mpi_t p;     /* prime */
42
 
  gcry_mpi_t q;     /* group order */
43
 
  gcry_mpi_t g;     /* group generator */
44
 
  gcry_mpi_t y;     /* g^x mod p */
45
 
  gcry_mpi_t x;     /* secret exponent */
46
 
} DSA_secret_key;
47
 
 
48
 
 
49
 
/* A structure used to hold domain parameters.  */
50
 
typedef struct
51
 
{
52
 
  gcry_mpi_t p;     /* prime */
53
 
  gcry_mpi_t q;     /* group order */
54
 
  gcry_mpi_t g;     /* group generator */
55
 
} dsa_domain_t;
56
 
 
57
 
 
58
 
/* A sample 1024 bit DSA key used for the selftests.  */
59
 
static const char sample_secret_key[] =
60
 
"(private-key"
61
 
" (dsa"
62
 
"  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
63
 
"      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
64
 
"      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
65
 
"      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D8777B#)"
66
 
"  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)"
67
 
"  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
68
 
"      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
69
 
"      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
70
 
"      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15#)"
71
 
"  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
72
 
"      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
73
 
"      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
74
 
"      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB#)"
75
 
"  (x #11D54E4ADBD3034160F2CED4B7CD292A4EBF3EC0#)))";
76
 
/* A sample 1024 bit DSA key used for the selftests (public only).  */
77
 
static const char sample_public_key[] = 
78
 
"(public-key"
79
 
" (dsa"
80
 
"  (p #00AD7C0025BA1A15F775F3F2D673718391D00456978D347B33D7B49E7F32EDAB"
81
 
"      96273899DD8B2BB46CD6ECA263FAF04A28903503D59062A8865D2AE8ADFB5191"
82
 
"      CF36FFB562D0E2F5809801A1F675DAE59698A9E01EFE8D7DCFCA084F4C6F5A44"
83
 
"      44D499A06FFAEA5E8EF5E01F2FD20A7B7EF3F6968AFBA1FB8D91F1559D52D8777B#)"
84
 
"  (q #00EB7B5751D25EBBB7BD59D920315FD840E19AEBF9#)"
85
 
"  (g #1574363387FDFD1DDF38F4FBE135BB20C7EE4772FB94C337AF86EA8E49666503"
86
 
"      AE04B6BE81A2F8DD095311E0217ACA698A11E6C5D33CCDAE71498ED35D13991E"
87
 
"      B02F09AB40BD8F4C5ED8C75DA779D0AE104BC34C960B002377068AB4B5A1F984"
88
 
"      3FBA91F537F1B7CAC4D8DD6D89B0D863AF7025D549F9C765D2FC07EE208F8D15#)"
89
 
"  (y #64B11EF8871BE4AB572AA810D5D3CA11A6CDBC637A8014602C72960DB135BF46"
90
 
"      A1816A724C34F87330FC9E187C5D66897A04535CC2AC9164A7150ABFA8179827"
91
 
"      6E45831AB811EEE848EBB24D9F5F2883B6E5DDC4C659DEF944DCFD80BF4D0A20"
92
 
"      42CAA7DC289F0C5A9D155F02D3D551DB741A81695B74D4C8F477F9C7838EB0FB#)))";
93
 
 
94
 
 
95
 
 
96
 
 
97
 
static gcry_mpi_t gen_k (gcry_mpi_t q);
98
 
static int test_keys (DSA_secret_key *sk, unsigned int qbits);
99
 
static int check_secret_key (DSA_secret_key *sk);
100
 
static gpg_err_code_t generate (DSA_secret_key *sk,
101
 
                                unsigned int nbits,
102
 
                                unsigned int qbits,
103
 
                                int transient_key,
104
 
                                dsa_domain_t *domain,
105
 
                                gcry_mpi_t **ret_factors);
106
 
static void sign (gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t input,
107
 
                  DSA_secret_key *skey);
108
 
static int verify (gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t input,
109
 
                   DSA_public_key *pkey);
110
 
 
111
 
static void (*progress_cb) (void *,const char *, int, int, int );
112
 
static void *progress_cb_data;
113
 
 
114
 
 
115
 
void
116
 
_gcry_register_pk_dsa_progress (void (*cb) (void *, const char *,
117
 
                                            int, int, int),
118
 
                                void *cb_data)
119
 
{
120
 
  progress_cb = cb;
121
 
  progress_cb_data = cb_data;
122
 
}
123
 
 
124
 
 
125
 
static void
126
 
progress (int c)
127
 
{
128
 
  if (progress_cb)
129
 
    progress_cb (progress_cb_data, "pk_dsa", c, 0, 0);
130
 
}
131
 
 
132
 
 
133
 
/*
134
 
 * Generate a random secret exponent k less than q.
135
 
 */
136
 
static gcry_mpi_t
137
 
gen_k( gcry_mpi_t q )
138
 
{
139
 
  gcry_mpi_t k = mpi_alloc_secure( mpi_get_nlimbs(q) );
140
 
  unsigned int nbits = mpi_get_nbits(q);
141
 
  unsigned int nbytes = (nbits+7)/8;
142
 
  char *rndbuf = NULL;
143
 
 
144
 
  if ( DBG_CIPHER )
145
 
    log_debug("choosing a random k ");
146
 
  for (;;) 
147
 
    {
148
 
      if( DBG_CIPHER )
149
 
        progress('.');
150
 
 
151
 
      if ( !rndbuf || nbits < 32 ) 
152
 
        {
153
 
          gcry_free(rndbuf);
154
 
          rndbuf = gcry_random_bytes_secure( (nbits+7)/8, GCRY_STRONG_RANDOM );
155
 
        }
156
 
      else
157
 
        { /* Change only some of the higher bits.  We could improve
158
 
             this by directly requesting more memory at the first call
159
 
             to get_random_bytes() and use this the here maybe it is
160
 
             easier to do this directly in random.c. */
161
 
          char *pp = gcry_random_bytes_secure( 4, GCRY_STRONG_RANDOM );
162
 
          memcpy( rndbuf,pp, 4 );
163
 
          gcry_free(pp);
164
 
        }
165
 
      _gcry_mpi_set_buffer( k, rndbuf, nbytes, 0 );
166
 
      if ( mpi_test_bit( k, nbits-1 ) )
167
 
        mpi_set_highbit( k, nbits-1 );
168
 
      else
169
 
        {
170
 
          mpi_set_highbit( k, nbits-1 );
171
 
          mpi_clear_bit( k, nbits-1 );
172
 
        }
173
 
 
174
 
      if( !(mpi_cmp( k, q ) < 0) ) /* check: k < q */
175
 
        {       
176
 
          if( DBG_CIPHER )
177
 
            progress('+');
178
 
          continue; /* no  */
179
 
        }
180
 
      if( !(mpi_cmp_ui( k, 0 ) > 0) )  /* check: k > 0 */
181
 
        {
182
 
          if( DBG_CIPHER )
183
 
            progress('-');
184
 
          continue; /* no */
185
 
        }
186
 
      break;    /* okay */
187
 
    }
188
 
  gcry_free(rndbuf);
189
 
  if( DBG_CIPHER )
190
 
    progress('\n');
191
 
  
192
 
  return k;
193
 
}
194
 
 
195
 
 
196
 
/* Check that a freshly generated key actually works.  Returns 0 on success. */
197
 
static int
198
 
test_keys (DSA_secret_key *sk, unsigned int qbits)
199
 
{
200
 
  int result = -1;  /* Default to failure.  */
201
 
  DSA_public_key pk;
202
 
  gcry_mpi_t data  = gcry_mpi_new (qbits);
203
 
  gcry_mpi_t sig_a = gcry_mpi_new (qbits);
204
 
  gcry_mpi_t sig_b = gcry_mpi_new (qbits);
205
 
 
206
 
  /* Put the relevant parameters into a public key structure.  */
207
 
  pk.p = sk->p;
208
 
  pk.q = sk->q;
209
 
  pk.g = sk->g;
210
 
  pk.y = sk->y;
211
 
 
212
 
  /* Create a random plaintext.  */
213
 
  gcry_mpi_randomize (data, qbits, GCRY_WEAK_RANDOM);
214
 
 
215
 
  /* Sign DATA using the secret key.  */
216
 
  sign (sig_a, sig_b, data, sk);
217
 
 
218
 
  /* Verify the signature using the public key.  */
219
 
  if ( !verify (sig_a, sig_b, data, &pk) )
220
 
    goto leave; /* Signature does not match.  */
221
 
 
222
 
  /* Modify the data and check that the signing fails.  */
223
 
  gcry_mpi_add_ui (data, data, 1);
224
 
  if ( verify (sig_a, sig_b, data, &pk) )
225
 
    goto leave; /* Signature matches but should not.  */
226
 
 
227
 
  result = 0; /* The test succeeded.  */
228
 
 
229
 
 leave:
230
 
  gcry_mpi_release (sig_b);
231
 
  gcry_mpi_release (sig_a);
232
 
  gcry_mpi_release (data);
233
 
  return result;
234
 
}
235
 
 
236
 
 
237
 
 
238
 
/*
239
 
   Generate a DSA key pair with a key of size NBITS.  If transient_key
240
 
   is true the key is generated using the standard RNG and not the
241
 
   very secure one.
242
 
 
243
 
   Returns: 2 structures filled with all needed values
244
 
            and an array with the n-1 factors of (p-1)
245
 
 */
246
 
static gpg_err_code_t
247
 
generate (DSA_secret_key *sk, unsigned int nbits, unsigned int qbits,
248
 
          int transient_key, dsa_domain_t *domain, gcry_mpi_t **ret_factors )
249
 
{
250
 
  gcry_mpi_t p;    /* the prime */
251
 
  gcry_mpi_t q;    /* the 160 bit prime factor */
252
 
  gcry_mpi_t g;    /* the generator */
253
 
  gcry_mpi_t y;    /* g^x mod p */
254
 
  gcry_mpi_t x;    /* the secret exponent */
255
 
  gcry_mpi_t h, e;  /* helper */
256
 
  unsigned char *rndbuf;
257
 
  gcry_random_level_t random_level;
258
 
 
259
 
  if (qbits)
260
 
    ; /* Caller supplied qbits.  Use this value.  */
261
 
  else if ( nbits >= 512 && nbits <= 1024 )
262
 
    qbits = 160;
263
 
  else if ( nbits == 2048 )
264
 
    qbits = 224;
265
 
  else if ( nbits == 3072 )
266
 
    qbits = 256;
267
 
  else if ( nbits == 7680 )
268
 
    qbits = 384;
269
 
  else if ( nbits == 15360 )
270
 
    qbits = 512;
271
 
  else
272
 
    return GPG_ERR_INV_VALUE;
273
 
 
274
 
  if (qbits < 160 || qbits > 512 || (qbits%8) )
275
 
    return GPG_ERR_INV_VALUE;
276
 
  if (nbits < 2*qbits || nbits > 15360)
277
 
    return GPG_ERR_INV_VALUE;
278
 
 
279
 
  if (fips_mode ())
280
 
    {
281
 
      if (nbits < 1024)
282
 
        return GPG_ERR_INV_VALUE;
283
 
      if (transient_key)
284
 
        return GPG_ERR_INV_VALUE;
285
 
    }
286
 
 
287
 
  if (domain->p && domain->q && domain->g)
288
 
    {
289
 
      /* Domain parameters are given; use them.  */
290
 
      p = mpi_copy (domain->p);
291
 
      q = mpi_copy (domain->q);
292
 
      g = mpi_copy (domain->g);
293
 
      gcry_assert (mpi_get_nbits (p) == nbits);
294
 
      gcry_assert (mpi_get_nbits (q) == qbits);
295
 
      h = mpi_alloc (0);
296
 
      e = NULL;
297
 
    }
298
 
  else
299
 
    {
300
 
      /* Generate new domain parameters.  */
301
 
      p = _gcry_generate_elg_prime (1, nbits, qbits, NULL, ret_factors);
302
 
      /* Get q out of factors.  */
303
 
      q = mpi_copy ((*ret_factors)[0]);
304
 
      gcry_assert (mpi_get_nbits (q) == qbits);
305
 
 
306
 
      /* Find a generator g (h and e are helpers).
307
 
         e = (p-1)/q */
308
 
      e = mpi_alloc (mpi_get_nlimbs (p));
309
 
      mpi_sub_ui (e, p, 1);
310
 
      mpi_fdiv_q (e, e, q);
311
 
      g = mpi_alloc (mpi_get_nlimbs (p));
312
 
      h = mpi_alloc_set_ui (1); /* (We start with 2.) */
313
 
      do
314
 
        {
315
 
          mpi_add_ui (h, h, 1);
316
 
          /* g = h^e mod p */
317
 
          gcry_mpi_powm (g, h, e, p);
318
 
        } 
319
 
      while (!mpi_cmp_ui (g, 1));  /* Continue until g != 1. */
320
 
    }
321
 
 
322
 
  /* Select a random number X with the property:
323
 
   *     0 < x < q-1
324
 
   * This must be a very good random number because this is the secret
325
 
   * part.  The random quality depends on the transient_key flag.  */
326
 
  random_level = transient_key ? GCRY_STRONG_RANDOM : GCRY_VERY_STRONG_RANDOM;
327
 
  if (DBG_CIPHER)
328
 
    log_debug("choosing a random x%s", transient_key? " (transient-key)":"");
329
 
  gcry_assert( qbits >= 160 );
330
 
  x = mpi_alloc_secure( mpi_get_nlimbs(q) );
331
 
  mpi_sub_ui( h, q, 1 );  /* put q-1 into h */
332
 
  rndbuf = NULL;
333
 
  do 
334
 
    {
335
 
      if( DBG_CIPHER )
336
 
        progress('.');
337
 
      if( !rndbuf )
338
 
        rndbuf = gcry_random_bytes_secure ((qbits+7)/8, random_level);
339
 
      else 
340
 
        { /* Change only some of the higher bits (= 2 bytes)*/
341
 
          char *r = gcry_random_bytes_secure (2, random_level);
342
 
          memcpy(rndbuf, r, 2 );
343
 
          gcry_free(r);
344
 
        }
345
 
 
346
 
      _gcry_mpi_set_buffer( x, rndbuf, (qbits+7)/8, 0 );
347
 
      mpi_clear_highbit( x, qbits+1 );
348
 
    } 
349
 
  while ( !( mpi_cmp_ui( x, 0 )>0 && mpi_cmp( x, h )<0 ) );
350
 
  gcry_free(rndbuf);
351
 
  mpi_free( e );
352
 
  mpi_free( h );
353
 
 
354
 
  /* y = g^x mod p */
355
 
  y = mpi_alloc( mpi_get_nlimbs(p) );
356
 
  gcry_mpi_powm( y, g, x, p );
357
 
 
358
 
  if( DBG_CIPHER ) 
359
 
    {
360
 
      progress('\n');
361
 
      log_mpidump("dsa  p", p );
362
 
      log_mpidump("dsa  q", q );
363
 
      log_mpidump("dsa  g", g );
364
 
      log_mpidump("dsa  y", y );
365
 
      log_mpidump("dsa  x", x );
366
 
    }
367
 
 
368
 
  /* Copy the stuff to the key structures. */
369
 
  sk->p = p;
370
 
  sk->q = q;
371
 
  sk->g = g;
372
 
  sk->y = y;
373
 
  sk->x = x;
374
 
 
375
 
  /* Now we can test our keys (this should never fail!). */
376
 
  if ( test_keys (sk, qbits) )
377
 
    {
378
 
      gcry_mpi_release (sk->p); sk->p = NULL;
379
 
      gcry_mpi_release (sk->q); sk->q = NULL;
380
 
      gcry_mpi_release (sk->g); sk->g = NULL;
381
 
      gcry_mpi_release (sk->y); sk->y = NULL;
382
 
      gcry_mpi_release (sk->x); sk->x = NULL;
383
 
      fips_signal_error ("self-test after key generation failed");
384
 
      return GPG_ERR_SELFTEST_FAILED;
385
 
    }
386
 
  return 0;
387
 
}
388
 
 
389
 
 
390
 
/* Generate a DSA key pair with a key of size NBITS using the
391
 
   algorithm given in FIPS-186-3.  If USE_FIPS186_2 is true,
392
 
   FIPS-186-2 is used and thus the length is restricted to 1024/160.
393
 
   If DERIVEPARMS is not NULL it may contain a seed value.  If domain
394
 
   parameters are specified in DOMAIN, DERIVEPARMS may not be given
395
 
   and NBITS and QBITS must match the specified domain parameters.  */
396
 
static gpg_err_code_t
397
 
generate_fips186 (DSA_secret_key *sk, unsigned int nbits, unsigned int qbits,
398
 
                  gcry_sexp_t deriveparms, int use_fips186_2,
399
 
                  dsa_domain_t *domain,
400
 
                  int *r_counter, void **r_seed, size_t *r_seedlen,
401
 
                  gcry_mpi_t *r_h)
402
 
{
403
 
  gpg_err_code_t ec;
404
 
  struct {
405
 
    gcry_sexp_t sexp;
406
 
    const void *seed;
407
 
    size_t seedlen;
408
 
  } initial_seed = { NULL, NULL, 0 };
409
 
  gcry_mpi_t prime_q = NULL; 
410
 
  gcry_mpi_t prime_p = NULL; 
411
 
  gcry_mpi_t value_g = NULL; /* The generator. */
412
 
  gcry_mpi_t value_y = NULL; /* g^x mod p */
413
 
  gcry_mpi_t value_x = NULL; /* The secret exponent. */
414
 
  gcry_mpi_t value_h = NULL; /* Helper.  */
415
 
  gcry_mpi_t value_e = NULL; /* Helper.  */
416
 
 
417
 
  /* Preset return values.  */
418
 
  *r_counter = 0;
419
 
  *r_seed = NULL;
420
 
  *r_seedlen = 0;
421
 
  *r_h = NULL;
422
 
 
423
 
  /* Derive QBITS from NBITS if requested  */
424
 
  if (!qbits)
425
 
    {
426
 
      if (nbits == 1024)
427
 
        qbits = 160;
428
 
      else if (nbits == 2048)
429
 
        qbits = 224;
430
 
      else if (nbits == 3072)
431
 
        qbits = 256;
432
 
    }
433
 
 
434
 
  /* Check that QBITS and NBITS match the standard.  Note that FIPS
435
 
     186-3 uses N for QBITS and L for NBITS.  */
436
 
  if (nbits == 1024 && qbits == 160)
437
 
    ;
438
 
  else if (nbits == 2048 && qbits == 224)
439
 
    ;
440
 
  else if (nbits == 2048 && qbits == 256)
441
 
    ;
442
 
  else if (nbits == 3072 && qbits == 256)
443
 
    ;
444
 
  else
445
 
    return GPG_ERR_INV_VALUE;
446
 
 
447
 
  if (domain->p && domain->q && domain->g)
448
 
    {
449
 
      /* Domain parameters are given; use them.  */
450
 
      prime_p = mpi_copy (domain->p);
451
 
      prime_q = mpi_copy (domain->q);
452
 
      value_g = mpi_copy (domain->g);
453
 
      gcry_assert (mpi_get_nbits (prime_p) == nbits);
454
 
      gcry_assert (mpi_get_nbits (prime_q) == qbits);
455
 
      gcry_assert (!deriveparms);
456
 
      ec = 0;
457
 
    }
458
 
  else
459
 
    {
460
 
      /* Generate new domain parameters.  */
461
 
 
462
 
      /* Get an initial seed value.  */
463
 
      if (deriveparms)
464
 
        {
465
 
          initial_seed.sexp = gcry_sexp_find_token (deriveparms, "seed", 0);
466
 
          if (initial_seed.sexp)
467
 
            initial_seed.seed = gcry_sexp_nth_data (initial_seed.sexp, 1,
468
 
                                                    &initial_seed.seedlen);
469
 
        }
470
 
      
471
 
      /* Fixme: Enable 186-3 after it has been approved and after fixing
472
 
         the generation function.  */
473
 
      /*   if (use_fips186_2) */
474
 
      (void)use_fips186_2;
475
 
      ec = _gcry_generate_fips186_2_prime (nbits, qbits, 
476
 
                                           initial_seed.seed, 
477
 
                                           initial_seed.seedlen,
478
 
                                           &prime_q, &prime_p, 
479
 
                                           r_counter,
480
 
                                           r_seed, r_seedlen);
481
 
      /*   else */
482
 
      /*     ec = _gcry_generate_fips186_3_prime (nbits, qbits, NULL, 0, */
483
 
      /*                                          &prime_q, &prime_p, */
484
 
      /*                                          r_counter, */
485
 
      /*                                          r_seed, r_seedlen, NULL); */
486
 
      gcry_sexp_release (initial_seed.sexp);
487
 
      if (ec)
488
 
        goto leave;
489
 
 
490
 
      /* Find a generator g (h and e are helpers).
491
 
         e = (p-1)/q */
492
 
      value_e = mpi_alloc_like (prime_p);
493
 
      mpi_sub_ui (value_e, prime_p, 1);
494
 
      mpi_fdiv_q (value_e, value_e, prime_q );
495
 
      value_g = mpi_alloc_like (prime_p);
496
 
      value_h = mpi_alloc_set_ui (1); 
497
 
      do
498
 
        {
499
 
          mpi_add_ui (value_h, value_h, 1);
500
 
          /* g = h^e mod p */
501
 
          mpi_powm (value_g, value_h, value_e, prime_p);
502
 
        } 
503
 
      while (!mpi_cmp_ui (value_g, 1));  /* Continue until g != 1.  */
504
 
    }
505
 
 
506
 
 
507
 
  /* Select a random number x with:  0 < x < q  */
508
 
  value_x = gcry_mpi_snew (qbits);
509
 
  do 
510
 
    {
511
 
      if( DBG_CIPHER )
512
 
        progress('.');
513
 
      gcry_mpi_randomize (value_x, qbits, GCRY_VERY_STRONG_RANDOM);
514
 
      mpi_clear_highbit (value_x, qbits+1);
515
 
    } 
516
 
  while (!(mpi_cmp_ui (value_x, 0) > 0 && mpi_cmp (value_x, prime_q) < 0));
517
 
 
518
 
  /* y = g^x mod p */
519
 
  value_y = mpi_alloc_like (prime_p);
520
 
  gcry_mpi_powm (value_y, value_g, value_x, prime_p);
521
 
 
522
 
  if (DBG_CIPHER) 
523
 
    {
524
 
      progress('\n');
525
 
      log_mpidump("dsa  p", prime_p );
526
 
      log_mpidump("dsa  q", prime_q );
527
 
      log_mpidump("dsa  g", value_g );
528
 
      log_mpidump("dsa  y", value_y );
529
 
      log_mpidump("dsa  x", value_x );
530
 
      log_mpidump("dsa  h", value_h );
531
 
    }
532
 
 
533
 
  /* Copy the stuff to the key structures. */
534
 
  sk->p = prime_p; prime_p = NULL;
535
 
  sk->q = prime_q; prime_q = NULL;
536
 
  sk->g = value_g; value_g = NULL;
537
 
  sk->y = value_y; value_y = NULL;
538
 
  sk->x = value_x; value_x = NULL;
539
 
  *r_h = value_h; value_h = NULL;
540
 
 
541
 
 leave:
542
 
  gcry_mpi_release (prime_p);
543
 
  gcry_mpi_release (prime_q);
544
 
  gcry_mpi_release (value_g);
545
 
  gcry_mpi_release (value_y);
546
 
  gcry_mpi_release (value_x);
547
 
  gcry_mpi_release (value_h);
548
 
  gcry_mpi_release (value_e);
549
 
 
550
 
  /* As a last step test this keys (this should never fail of course). */
551
 
  if (!ec && test_keys (sk, qbits) )
552
 
    {
553
 
      gcry_mpi_release (sk->p); sk->p = NULL;
554
 
      gcry_mpi_release (sk->q); sk->q = NULL;
555
 
      gcry_mpi_release (sk->g); sk->g = NULL;
556
 
      gcry_mpi_release (sk->y); sk->y = NULL;
557
 
      gcry_mpi_release (sk->x); sk->x = NULL;
558
 
      fips_signal_error ("self-test after key generation failed");
559
 
      ec = GPG_ERR_SELFTEST_FAILED;
560
 
    }
561
 
 
562
 
  if (ec)
563
 
    {
564
 
      *r_counter = 0;
565
 
      gcry_free (*r_seed); *r_seed = NULL;
566
 
      *r_seedlen = 0;
567
 
      gcry_mpi_release (*r_h); *r_h = NULL;
568
 
    }
569
 
 
570
 
  return ec;
571
 
}
572
 
 
573
 
 
574
 
 
575
 
/*
576
 
   Test whether the secret key is valid.
577
 
   Returns: if this is a valid key.
578
 
 */
579
 
static int
580
 
check_secret_key( DSA_secret_key *sk )
581
 
{
582
 
  int rc;
583
 
  gcry_mpi_t y = mpi_alloc( mpi_get_nlimbs(sk->y) );
584
 
 
585
 
  gcry_mpi_powm( y, sk->g, sk->x, sk->p );
586
 
  rc = !mpi_cmp( y, sk->y );
587
 
  mpi_free( y );
588
 
  return rc;
589
 
}
590
 
 
591
 
 
592
 
 
593
 
/*
594
 
   Make a DSA signature from HASH and put it into r and s.
595
 
 */
596
 
static void
597
 
sign(gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t hash, DSA_secret_key *skey )
598
 
{
599
 
  gcry_mpi_t k;
600
 
  gcry_mpi_t kinv;
601
 
  gcry_mpi_t tmp;
602
 
 
603
 
  /* Select a random k with 0 < k < q */
604
 
  k = gen_k( skey->q );
605
 
 
606
 
  /* r = (a^k mod p) mod q */
607
 
  gcry_mpi_powm( r, skey->g, k, skey->p );
608
 
  mpi_fdiv_r( r, r, skey->q );
609
 
 
610
 
  /* kinv = k^(-1) mod q */
611
 
  kinv = mpi_alloc( mpi_get_nlimbs(k) );
612
 
  mpi_invm(kinv, k, skey->q );
613
 
 
614
 
  /* s = (kinv * ( hash + x * r)) mod q */
615
 
  tmp = mpi_alloc( mpi_get_nlimbs(skey->p) );
616
 
  mpi_mul( tmp, skey->x, r );
617
 
  mpi_add( tmp, tmp, hash );
618
 
  mpi_mulm( s , kinv, tmp, skey->q );
619
 
 
620
 
  mpi_free(k);
621
 
  mpi_free(kinv);
622
 
  mpi_free(tmp);
623
 
}
624
 
 
625
 
 
626
 
/*
627
 
   Returns true if the signature composed from R and S is valid.
628
 
 */
629
 
static int
630
 
verify (gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t hash, DSA_public_key *pkey )
631
 
{
632
 
  int rc;
633
 
  gcry_mpi_t w, u1, u2, v;
634
 
  gcry_mpi_t base[3];
635
 
  gcry_mpi_t ex[3];
636
 
 
637
 
  if( !(mpi_cmp_ui( r, 0 ) > 0 && mpi_cmp( r, pkey->q ) < 0) )
638
 
    return 0; /* assertion      0 < r < q  failed */
639
 
  if( !(mpi_cmp_ui( s, 0 ) > 0 && mpi_cmp( s, pkey->q ) < 0) )
640
 
    return 0; /* assertion      0 < s < q  failed */
641
 
 
642
 
  w  = mpi_alloc( mpi_get_nlimbs(pkey->q) );
643
 
  u1 = mpi_alloc( mpi_get_nlimbs(pkey->q) );
644
 
  u2 = mpi_alloc( mpi_get_nlimbs(pkey->q) );
645
 
  v  = mpi_alloc( mpi_get_nlimbs(pkey->p) );
646
 
 
647
 
  /* w = s^(-1) mod q */
648
 
  mpi_invm( w, s, pkey->q );
649
 
 
650
 
  /* u1 = (hash * w) mod q */
651
 
  mpi_mulm( u1, hash, w, pkey->q );
652
 
 
653
 
  /* u2 = r * w mod q  */
654
 
  mpi_mulm( u2, r, w, pkey->q );
655
 
 
656
 
  /* v =  g^u1 * y^u2 mod p mod q */
657
 
  base[0] = pkey->g; ex[0] = u1;
658
 
  base[1] = pkey->y; ex[1] = u2;
659
 
  base[2] = NULL;    ex[2] = NULL;
660
 
  mpi_mulpowm( v, base, ex, pkey->p );
661
 
  mpi_fdiv_r( v, v, pkey->q );
662
 
 
663
 
  rc = !mpi_cmp( v, r );
664
 
 
665
 
  mpi_free(w);
666
 
  mpi_free(u1);
667
 
  mpi_free(u2);
668
 
  mpi_free(v);
669
 
 
670
 
  return rc;
671
 
}
672
 
 
673
 
 
674
 
/*********************************************
675
 
 **************  interface  ******************
676
 
 *********************************************/
677
 
 
678
 
static gcry_err_code_t
679
 
dsa_generate_ext (int algo, unsigned int nbits, unsigned long evalue,
680
 
                  const gcry_sexp_t genparms,
681
 
                  gcry_mpi_t *skey, gcry_mpi_t **retfactors,
682
 
                  gcry_sexp_t *r_extrainfo)
683
 
{
684
 
  gpg_err_code_t ec;
685
 
  DSA_secret_key sk;
686
 
  gcry_sexp_t l1;
687
 
  unsigned int qbits = 0;
688
 
  gcry_sexp_t deriveparms = NULL;
689
 
  gcry_sexp_t seedinfo = NULL;
690
 
  int transient_key = 0;
691
 
  int use_fips186_2 = 0;
692
 
  int use_fips186 = 0;
693
 
  dsa_domain_t domain;
694
 
 
695
 
  (void)algo;    /* No need to check it.  */
696
 
  (void)evalue;  /* Not required for DSA. */
697
 
 
698
 
  memset (&domain, 0, sizeof domain);
699
 
 
700
 
  if (genparms)
701
 
    {
702
 
      gcry_sexp_t domainsexp;
703
 
  
704
 
      /* Parse the optional qbits element.  */
705
 
      l1 = gcry_sexp_find_token (genparms, "qbits", 0);
706
 
      if (l1)
707
 
        {
708
 
          char buf[50];
709
 
          const char *s;
710
 
          size_t n;
711
 
          
712
 
          s = gcry_sexp_nth_data (l1, 1, &n);
713
 
          if (!s || n >= DIM (buf) - 1 )
714
 
            {
715
 
              gcry_sexp_release (l1);
716
 
              return GPG_ERR_INV_OBJ; /* No value or value too large.  */
717
 
            }
718
 
          memcpy (buf, s, n);
719
 
          buf[n] = 0;
720
 
          qbits = (unsigned int)strtoul (buf, NULL, 0);
721
 
          gcry_sexp_release (l1);
722
 
        }
723
 
 
724
 
      /* Parse the optional transient-key flag.  */
725
 
      l1 = gcry_sexp_find_token (genparms, "transient-key", 0);
726
 
      if (l1)
727
 
        {
728
 
          transient_key = 1;
729
 
          gcry_sexp_release (l1);
730
 
        }
731
 
 
732
 
      /* Get the optional derive parameters.  */
733
 
      deriveparms = gcry_sexp_find_token (genparms, "derive-parms", 0);
734
 
 
735
 
      /* Parse the optional "use-fips186" flags.  */
736
 
      l1 = gcry_sexp_find_token (genparms, "use-fips186", 0);
737
 
      if (l1)
738
 
        {
739
 
          use_fips186 = 1;
740
 
          gcry_sexp_release (l1);
741
 
        }
742
 
      l1 = gcry_sexp_find_token (genparms, "use-fips186-2", 0);
743
 
      if (l1)
744
 
        {
745
 
          use_fips186_2 = 1;
746
 
          gcry_sexp_release (l1);
747
 
        }
748
 
 
749
 
      /* Check whether domain parameters are given.  */
750
 
      domainsexp = gcry_sexp_find_token (genparms, "domain", 0);
751
 
      if (domainsexp)
752
 
        {
753
 
          /* DERIVEPARMS can't be used together with domain
754
 
             parameters.  NBITS abnd QBITS may not be specified
755
 
             because there values are derived from the domain
756
 
             parameters.  */
757
 
          if (deriveparms || qbits || nbits)
758
 
            {
759
 
              gcry_sexp_release (domainsexp);
760
 
              gcry_sexp_release (deriveparms);
761
 
              return GPG_ERR_INV_VALUE;
762
 
            }
763
 
          
764
 
          /* Put all domain parameters into the domain object.  */
765
 
          l1 = gcry_sexp_find_token (domainsexp, "p", 0);
766
 
          domain.p = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
767
 
          gcry_sexp_release (l1);
768
 
          l1 = gcry_sexp_find_token (domainsexp, "q", 0);
769
 
          domain.q = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
770
 
          gcry_sexp_release (l1);
771
 
          l1 = gcry_sexp_find_token (domainsexp, "g", 0);
772
 
          domain.g = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
773
 
          gcry_sexp_release (l1);
774
 
          gcry_sexp_release (domainsexp);
775
 
 
776
 
          /* Check that all domain parameters are available.  */
777
 
          if (!domain.p || !domain.q || !domain.g)
778
 
            {
779
 
              gcry_mpi_release (domain.p);
780
 
              gcry_mpi_release (domain.q);
781
 
              gcry_mpi_release (domain.g);
782
 
              gcry_sexp_release (deriveparms);
783
 
              return GPG_ERR_MISSING_VALUE;
784
 
            }
785
 
 
786
 
          /* Get NBITS and QBITS from the domain parameters.  */
787
 
          nbits = mpi_get_nbits (domain.p);
788
 
          qbits = mpi_get_nbits (domain.q);
789
 
        }
790
 
    }
791
 
 
792
 
  if (deriveparms || use_fips186 || use_fips186_2 || fips_mode ())
793
 
    {
794
 
      int counter;
795
 
      void *seed;
796
 
      size_t seedlen;
797
 
      gcry_mpi_t h_value;
798
 
 
799
 
      ec = generate_fips186 (&sk, nbits, qbits, deriveparms, use_fips186_2,
800
 
                             &domain,
801
 
                             &counter, &seed, &seedlen, &h_value);
802
 
      gcry_sexp_release (deriveparms);
803
 
      if (!ec && h_value)
804
 
        {
805
 
          /* Format the seed-values unless domain parameters are used
806
 
             for which a H_VALUE of NULL is an indication.  */
807
 
          ec = gpg_err_code (gcry_sexp_build 
808
 
                             (&seedinfo, NULL,
809
 
                              "(seed-values(counter %d)(seed %b)(h %m))",
810
 
                              counter, (int)seedlen, seed, h_value));
811
 
          if (ec)
812
 
            {
813
 
              gcry_mpi_release (sk.p); sk.p = NULL;
814
 
              gcry_mpi_release (sk.q); sk.q = NULL;
815
 
              gcry_mpi_release (sk.g); sk.g = NULL;
816
 
              gcry_mpi_release (sk.y); sk.y = NULL;
817
 
              gcry_mpi_release (sk.x); sk.x = NULL;
818
 
            }
819
 
          gcry_free (seed);
820
 
          gcry_mpi_release (h_value);
821
 
        }
822
 
    }
823
 
  else
824
 
    {
825
 
      ec = generate (&sk, nbits, qbits, transient_key, &domain, retfactors);
826
 
    }
827
 
 
828
 
  gcry_mpi_release (domain.p);
829
 
  gcry_mpi_release (domain.q);
830
 
  gcry_mpi_release (domain.g);
831
 
 
832
 
  if (!ec)
833
 
    {
834
 
      skey[0] = sk.p;
835
 
      skey[1] = sk.q;
836
 
      skey[2] = sk.g;
837
 
      skey[3] = sk.y;
838
 
      skey[4] = sk.x;
839
 
 
840
 
      if (!r_extrainfo)
841
 
        {
842
 
          /* Old style interface - return the factors - if any - at
843
 
             retfactors.  */
844
 
        }
845
 
      else if (!*retfactors && !seedinfo)
846
 
        {
847
 
          /* No factors and no seedinfo, thus there is nothing to return.  */
848
 
          *r_extrainfo = NULL;
849
 
        }
850
 
      else
851
 
        {
852
 
          /* Put the factors into extrainfo and set retfactors to NULL
853
 
             to make use of the new interface.  Note that the factors
854
 
             are not confidential thus we can store them in standard
855
 
             memory.  */
856
 
          int nfactors, i, j;
857
 
          char *p;
858
 
          char *format = NULL;
859
 
          void **arg_list = NULL;
860
 
 
861
 
          for (nfactors=0; *retfactors && (*retfactors)[nfactors]; nfactors++)
862
 
            ;
863
 
          /* Allocate space for the format string:
864
 
               "(misc-key-info%S(pm1-factors%m))"
865
 
             with one "%m" for each factor and construct it.  */
866
 
          format = gcry_malloc (50 + 2*nfactors);
867
 
          if (!format)
868
 
            ec = gpg_err_code_from_syserror ();
869
 
          else
870
 
            {
871
 
              p = stpcpy (format, "(misc-key-info");
872
 
              if (seedinfo)
873
 
                p = stpcpy (p, "%S");
874
 
              if (nfactors)
875
 
                {
876
 
                  p = stpcpy (p, "(pm1-factors");
877
 
                  for (i=0; i < nfactors; i++)
878
 
                    p = stpcpy (p, "%m");
879
 
                  p = stpcpy (p, ")");
880
 
                }
881
 
              p = stpcpy (p, ")");
882
 
              
883
 
              /* Allocate space for the list of factors plus one for
884
 
                 an S-expression plus an extra NULL entry for safety
885
 
                 and fill it with the factors.  */
886
 
              arg_list = gcry_calloc (nfactors+1+1, sizeof *arg_list);
887
 
              if (!arg_list)
888
 
                ec = gpg_err_code_from_syserror ();
889
 
              else
890
 
                {
891
 
                  i = 0;
892
 
                  if (seedinfo)
893
 
                    arg_list[i++] = &seedinfo;
894
 
                  for (j=0; j < nfactors; j++)
895
 
                    arg_list[i++] = (*retfactors) + j;
896
 
                  arg_list[i] = NULL;
897
 
                  
898
 
                  ec = gpg_err_code (gcry_sexp_build_array 
899
 
                                     (r_extrainfo, NULL, format, arg_list));
900
 
                }
901
 
            }
902
 
 
903
 
          gcry_free (arg_list);
904
 
          gcry_free (format);
905
 
          for (i=0; i < nfactors; i++)
906
 
            {
907
 
              gcry_mpi_release ((*retfactors)[i]);
908
 
              (*retfactors)[i] = NULL;
909
 
            }
910
 
          *retfactors = NULL;
911
 
          if (ec)
912
 
            {
913
 
              for (i=0; i < 5; i++)
914
 
                {
915
 
                  gcry_mpi_release (skey[i]);
916
 
                  skey[i] = NULL;
917
 
                }
918
 
            }
919
 
        }
920
 
    }
921
 
 
922
 
  gcry_sexp_release (seedinfo);
923
 
  return ec;
924
 
}
925
 
 
926
 
 
927
 
static gcry_err_code_t
928
 
dsa_generate (int algo, unsigned int nbits, unsigned long evalue,
929
 
              gcry_mpi_t *skey, gcry_mpi_t **retfactors)
930
 
{
931
 
  (void)evalue;
932
 
  return dsa_generate_ext (algo, nbits, 0, NULL, skey, retfactors, NULL);
933
 
}
934
 
 
935
 
 
936
 
 
937
 
static gcry_err_code_t
938
 
dsa_check_secret_key (int algo, gcry_mpi_t *skey)
939
 
{
940
 
  gcry_err_code_t err = GPG_ERR_NO_ERROR;
941
 
  DSA_secret_key sk;
942
 
 
943
 
  (void)algo;
944
 
 
945
 
  if ((! skey[0]) || (! skey[1]) || (! skey[2]) || (! skey[3]) || (! skey[4]))
946
 
    err = GPG_ERR_BAD_MPI;
947
 
  else
948
 
    {
949
 
      sk.p = skey[0];
950
 
      sk.q = skey[1];
951
 
      sk.g = skey[2];
952
 
      sk.y = skey[3];
953
 
      sk.x = skey[4];
954
 
      if (! check_secret_key (&sk))
955
 
        err = GPG_ERR_BAD_SECKEY;
956
 
    }
957
 
 
958
 
  return err;
959
 
}
960
 
 
961
 
 
962
 
static gcry_err_code_t
963
 
dsa_sign (int algo, gcry_mpi_t *resarr, gcry_mpi_t data, gcry_mpi_t *skey)
964
 
{
965
 
  gcry_err_code_t err = GPG_ERR_NO_ERROR;
966
 
  DSA_secret_key sk;
967
 
 
968
 
  (void)algo;
969
 
 
970
 
  if ((! data)
971
 
      || (! skey[0]) || (! skey[1]) || (! skey[2])
972
 
      || (! skey[3]) || (! skey[4]))
973
 
    err = GPG_ERR_BAD_MPI;
974
 
  else
975
 
    {
976
 
      sk.p = skey[0];
977
 
      sk.q = skey[1];
978
 
      sk.g = skey[2];
979
 
      sk.y = skey[3];
980
 
      sk.x = skey[4];
981
 
      resarr[0] = mpi_alloc (mpi_get_nlimbs (sk.p));
982
 
      resarr[1] = mpi_alloc (mpi_get_nlimbs (sk.p));
983
 
      sign (resarr[0], resarr[1], data, &sk);
984
 
    }
985
 
  return err;
986
 
}
987
 
 
988
 
static gcry_err_code_t
989
 
dsa_verify (int algo, gcry_mpi_t hash, gcry_mpi_t *data, gcry_mpi_t *pkey,
990
 
            int (*cmp) (void *, gcry_mpi_t), void *opaquev)
991
 
{
992
 
  gcry_err_code_t err = GPG_ERR_NO_ERROR;
993
 
  DSA_public_key pk;
994
 
 
995
 
  (void)algo;
996
 
  (void)cmp;
997
 
  (void)opaquev;
998
 
 
999
 
  if ((! data[0]) || (! data[1]) || (! hash)
1000
 
      || (! pkey[0]) || (! pkey[1]) || (! pkey[2]) || (! pkey[3]))
1001
 
    err = GPG_ERR_BAD_MPI;
1002
 
  else
1003
 
    {
1004
 
      pk.p = pkey[0];
1005
 
      pk.q = pkey[1];
1006
 
      pk.g = pkey[2];
1007
 
      pk.y = pkey[3];
1008
 
      if (! verify (data[0], data[1], hash, &pk))
1009
 
        err = GPG_ERR_BAD_SIGNATURE;
1010
 
    }
1011
 
  return err;
1012
 
}
1013
 
 
1014
 
 
1015
 
static unsigned int
1016
 
dsa_get_nbits (int algo, gcry_mpi_t *pkey)
1017
 
{
1018
 
  (void)algo;
1019
 
 
1020
 
  return mpi_get_nbits (pkey[0]);
1021
 
}
1022
 
 
1023
 
 
1024
 
 
1025
 
/* 
1026
 
     Self-test section.
1027
 
 */
1028
 
 
1029
 
static const char *
1030
 
selftest_sign_1024 (gcry_sexp_t pkey, gcry_sexp_t skey)
1031
 
{
1032
 
  static const char sample_data[] = 
1033
 
    "(data (flags pkcs1)"
1034
 
    " (hash sha1 #a0b1c2d3e4f500102030405060708090a1b2c3d4#))";
1035
 
  static const char sample_data_bad[] = 
1036
 
    "(data (flags pkcs1)"
1037
 
    " (hash sha1 #a0b1c2d3e4f510102030405060708090a1b2c3d4#))";
1038
 
 
1039
 
  const char *errtxt = NULL;
1040
 
  gcry_error_t err;
1041
 
  gcry_sexp_t data = NULL;
1042
 
  gcry_sexp_t data_bad = NULL;
1043
 
  gcry_sexp_t sig = NULL;
1044
 
 
1045
 
  err = gcry_sexp_sscan (&data, NULL,
1046
 
                         sample_data, strlen (sample_data));
1047
 
  if (!err)
1048
 
    err = gcry_sexp_sscan (&data_bad, NULL, 
1049
 
                           sample_data_bad, strlen (sample_data_bad));
1050
 
  if (err)
1051
 
    {
1052
 
      errtxt = "converting data failed";
1053
 
      goto leave;
1054
 
    }
1055
 
 
1056
 
  err = gcry_pk_sign (&sig, data, skey);
1057
 
  if (err)
1058
 
    {
1059
 
      errtxt = "signing failed";
1060
 
      goto leave;
1061
 
    }
1062
 
  err = gcry_pk_verify (sig, data, pkey);
1063
 
  if (err)
1064
 
    {
1065
 
      errtxt = "verify failed";
1066
 
      goto leave;
1067
 
    }
1068
 
  err = gcry_pk_verify (sig, data_bad, pkey);
1069
 
  if (gcry_err_code (err) != GPG_ERR_BAD_SIGNATURE)
1070
 
    {
1071
 
      errtxt = "bad signature not detected";
1072
 
      goto leave;
1073
 
    }
1074
 
 
1075
 
 
1076
 
 leave:
1077
 
  gcry_sexp_release (sig);
1078
 
  gcry_sexp_release (data_bad);
1079
 
  gcry_sexp_release (data);
1080
 
  return errtxt;
1081
 
}
1082
 
 
1083
 
 
1084
 
static gpg_err_code_t
1085
 
selftests_dsa (selftest_report_func_t report)
1086
 
{
1087
 
  const char *what;
1088
 
  const char *errtxt;
1089
 
  gcry_error_t err;
1090
 
  gcry_sexp_t skey = NULL;
1091
 
  gcry_sexp_t pkey = NULL;
1092
 
 
1093
 
  /* Convert the S-expressions into the internal representation.  */
1094
 
  what = "convert";
1095
 
  err = gcry_sexp_sscan (&skey, NULL, 
1096
 
                         sample_secret_key, strlen (sample_secret_key));
1097
 
  if (!err)
1098
 
    err = gcry_sexp_sscan (&pkey, NULL, 
1099
 
                           sample_public_key, strlen (sample_public_key));
1100
 
  if (err)
1101
 
    {
1102
 
      errtxt = gcry_strerror (err);
1103
 
      goto failed;
1104
 
    }
1105
 
 
1106
 
  what = "key consistency";
1107
 
  err = gcry_pk_testkey (skey);
1108
 
  if (err)
1109
 
    {
1110
 
      errtxt = gcry_strerror (err);
1111
 
      goto failed;
1112
 
    }
1113
 
 
1114
 
  what = "sign";
1115
 
  errtxt = selftest_sign_1024 (pkey, skey);
1116
 
  if (errtxt)
1117
 
    goto failed;
1118
 
 
1119
 
  gcry_sexp_release (pkey);
1120
 
  gcry_sexp_release (skey);
1121
 
  return 0; /* Succeeded. */
1122
 
 
1123
 
 failed:
1124
 
  gcry_sexp_release (pkey);
1125
 
  gcry_sexp_release (skey);
1126
 
  if (report)
1127
 
    report ("pubkey", GCRY_PK_DSA, what, errtxt);
1128
 
  return GPG_ERR_SELFTEST_FAILED;
1129
 
}
1130
 
 
1131
 
 
1132
 
/* Run a full self-test for ALGO and return 0 on success.  */
1133
 
static gpg_err_code_t
1134
 
run_selftests (int algo, int extended, selftest_report_func_t report)
1135
 
{
1136
 
  gpg_err_code_t ec;
1137
 
 
1138
 
  (void)extended;
1139
 
 
1140
 
  switch (algo)
1141
 
    {
1142
 
    case GCRY_PK_DSA:
1143
 
      ec = selftests_dsa (report);
1144
 
      break;
1145
 
    default:
1146
 
      ec = GPG_ERR_PUBKEY_ALGO;
1147
 
      break;
1148
 
        
1149
 
    }
1150
 
  return ec;
1151
 
}
1152
 
 
1153
 
 
1154
 
 
1155
 
 
1156
 
static const char *dsa_names[] =
1157
 
  {
1158
 
    "dsa",
1159
 
    "openpgp-dsa",
1160
 
    NULL,
1161
 
  };
1162
 
 
1163
 
gcry_pk_spec_t _gcry_pubkey_spec_dsa =
1164
 
  {
1165
 
    "DSA", dsa_names, 
1166
 
    "pqgy", "pqgyx", "", "rs", "pqgy",
1167
 
    GCRY_PK_USAGE_SIGN,
1168
 
    dsa_generate,
1169
 
    dsa_check_secret_key,
1170
 
    NULL,
1171
 
    NULL,
1172
 
    dsa_sign,
1173
 
    dsa_verify,
1174
 
    dsa_get_nbits
1175
 
  };
1176
 
pk_extra_spec_t _gcry_pubkey_extraspec_dsa = 
1177
 
  {
1178
 
    run_selftests,
1179
 
    dsa_generate_ext
1180
 
  };
1181