See ChangeLog: Wed Apr 7 20:51:39 CEST 1999 Werner Koch
authorWerner Koch <wk@gnupg.org>
Wed, 7 Apr 1999 18:58:34 +0000 (18:58 +0000)
committerWerner Koch <wk@gnupg.org>
Wed, 7 Apr 1999 18:58:34 +0000 (18:58 +0000)
30 files changed:
ChangeLog
Makefile.am
NEWS
TODO
VERSION
checks/conventional.test
cipher/ChangeLog
cipher/Makefile.am
cipher/blowfish.h
cipher/cipher.c
cipher/twofish.c
configure.in
debian/changelog
debian/control
doc/gpg.1pod
g10/ChangeLog
g10/cipher.c
g10/decrypt.c
g10/encr-data.c
g10/g10.c
g10/import.c
g10/keygen.c
g10/misc.c
g10/parse-packet.c
g10/ringedit.c
g10/seckey-cert.c
mpi/ChangeLog
mpi/Makefile.am
po/ChangeLog
po/fr.po

index d1f3ec1..4fb2bee 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
+Wed Apr  7 20:51:39 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+       * Makefile.am (g10defs.h): Removed.
+       * configure.in (AC_OUTPUT_COMMANDS): Create g10defs.h
+
 Sat Mar 20 12:55:33 CET 1999  Werner Koch  <wk@isil.d.shuttle.de>
 
        * VERSION: Now 0.9.5
index b06903c..1651d0a 100644 (file)
@@ -3,24 +3,6 @@
 SUBDIRS = intl zlib util mpi cipher tools g10 po doc checks
 EXTRA_DIST = VERSION  PROJECTS BUGS
 
-all-am: g10defs.h
-all-recursive-am: g10defs.h
-
-
-g10defs.h : config.h
-       @( set -e; \
-       echo "/* Generated automatically by Makefile */" ; \
-       echo "#ifdef HAVE_DRIVE_LETTERS"; \
-       echo "#define G10_LOCALEDIR \"c:/lib/gnupg/locale\""; \
-       echo "#define GNUPG_LIBDIR \"c:/lib/gnupg\""; \
-       echo "#define GNUPG_DATADIR \"c:/lib/gnupg\""; \
-       echo "#else";\
-       echo "#define G10_LOCALEDIR \"$(prefix)/$(DATADIRNAME)/locale\""; \
-       echo "#define GNUPG_LIBDIR \"$(libdir)/gnupg\""; \
-       echo "#define GNUPG_DATADIR \"$(datadir)/gnupg\""; \
-       echo "#endif";\
-       ) >g10defs.h
-
 
 dist-hook:
        @set -e; \
@@ -40,11 +22,11 @@ dist-hook:
 # maintainer only
 cvs-get:
        rsync -Cavuzb  --exclude scratch --exclude .deps \
-                     koch@ftp.guug.de:work/gnupg .
+                     wkoch@sigtrap.guug.de:work/gnupg .
 
 cvs-put:
        rsync -Cavuzb --exclude .deps --exclude scratch \
-                     . koch@ftp.guug.de:work/gnupg
+                     . wkoch@sigtrap.guug.de:work/gnupg
 
 cvs-sync: cvs-get cvs-put
 
diff --git a/NEWS b/NEWS
index c6c5770..03e41cd 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -1,3 +1,7 @@
+
+    * Full Twofish support.  It is now statically linked by default.
+   ---->   Hmmm, still have to check the message format
+
 Noteworthy changes in version 0.9.5
 -----------------------------------
 
diff --git a/TODO b/TODO
index 63df5ac..356b289 100644 (file)
--- a/TODO
+++ b/TODO
@@ -2,8 +2,6 @@
   * add some status output put for signing and encryption.
     replace the putc in primegen with some kind of status-fd outputs.
 
-  * Implement 256 bit key Twofish.
-
   * Fix revocation and expire stuff.
 
   * Check calculation of key validity.
   * Solaris make as problems with the generated POTFILES - seems to be a
     gettext bug.
 
+  * Need suffix rules for .S to produce .s for some systems
+
+  * do a chmod as soon as the secring is created.  Print a warning if
+    the directory mode is wrong.
+
 
 Nice to have
 ------------
+  * use DEL and ^H for erasing the previous character (util/ttyio.c).
   * replace the keyserver stuff either by a call to a specialized
     utility or SOCKSify the stuff.
   * Do a real fix for bug #7 or document that it is a PGP 5 error.
diff --git a/VERSION b/VERSION
index c726cf3..278046e 100644 (file)
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-0.9.5a
+0.9.5b
index 5492ac9..6f78b01 100755 (executable)
@@ -8,16 +8,13 @@ for i in plain-2 data-32000 ; do
     echo "Hier spricht HAL" | $srcdir/run-gpg --passphrase-fd 0    -o y --yes x
     cmp $i y || error "$i: mismatch"
 done
-for i in plain-1 data-80000 ; do
-    echo "Hier spricht HAL" | $srcdir/run-gpg --passphrase-fd 0 \
-                                       --cipher-algo cast5 -c -o x --yes $i
-    echo "Hier spricht HAL" | $srcdir/run-gpg --passphrase-fd 0    -o y --yes x
-    cmp $i y || error "$i: mismatch"
-done
-for i in plain-1 data-80000 ; do
-    echo "Hier spricht HAL" | $srcdir/run-gpg --passphrase-fd 0 \
-                                       --cipher-algo 3des -c -o x --yes $i
-    echo "Hier spricht HAL" | $srcdir/run-gpg --passphrase-fd 0 -o y --yes x
-    cmp $i y || error "$i: mismatch"
+
+for a in cast5 3des twofish; do
+    for i in plain-1 data-80000 ; do
+      echo "Hier spricht HAL" | $srcdir/run-gpg --passphrase-fd 0 \
+                                         --cipher-algo $a -c -o x --yes $i
+      echo "Hier spricht HAL" | $srcdir/run-gpg --passphrase-fd 0 -o y --yes x
+      cmp $i y || error "$i: ($a) mismatch"
+    done
 done
 
index b1000c8..4ecdbc4 100644 (file)
@@ -1,3 +1,12 @@
+Wed Apr  7 20:51:39 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+       * random.c (get_random_bits): Can now handle requests > POOLSIZE
+
+       * cipher.c (cipher_open): Now uses standard CFB for automode if
+       the blocksize is gt 8 (according to rfc2440).
+
+       * twofish.c: Applied Matthew Skala's patches for 256 bit key.
+
 Tue Apr  6 19:58:12 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
 
        * random.c (get_random_bits): Can now handle requests > POOLSIZE
index ba237bf..f42d682 100644 (file)
@@ -12,10 +12,8 @@ noinst_LIBRARIES = libcipher.a
 # might also list programs which are not modules)
 # MODULES: rndunix rndlinux rndegd
 # MODULES: sha1 rmd160 md5 tiger
-# MODULES: twofish
 EXTRA_PROGRAMS = rndunix rndlinux rndegd  \
-                sha1 rmd160 md5 tiger  \
-                twofish
+                sha1 rmd160 md5 tiger
 
 EXTRA_rndlinux_SOURCES = rndlinux.c
 EXTRA_rndunix_SOURCES = rndunix.c
@@ -24,7 +22,6 @@ EXTRA_md5_SOURCES = md5.c
 EXTRA_rmd160_SOURCES = rmd160.c
 EXTRA_sha1_SOURCES = sha1.c
 EXTRA_tiger_SOURCES = tiger.c
-EXTRA_twofish_SOURCES = twofish.c
 
 
 if ENABLE_GNUPG_EXTENSIONS
@@ -43,6 +40,8 @@ libcipher_a_SOURCES = cipher.c        \
                 dynload.h      \
                 des.c          \
                 des.h          \
+                twofish.c      \
+                twofish.h      \
                 blowfish.c     \
                 blowfish.h     \
                 cast5.c        \
@@ -76,14 +75,14 @@ tiger: $(srcdir)/tiger.c
            sed -e 's/-O[2-9]*/-O1/g' `
 
 tiger.o: $(srcdir)/tiger.c
-       `echo $(COMPILE) $(srcdir)/tiger.c | sed -e 's/-O[2-9]*/-O1/g' `
+       `echo $(COMPILE) -c $(srcdir)/tiger.c | sed -e 's/-O[2-9]*/-O1/g' `
 
 twofish: $(srcdir)/twofish.c
        `echo $(COMPILE) $(DYNLINK_MOD_CFLAGS) -o twofish $(srcdir)/twofish.c | \
            sed -e 's/-O[0-9]*/  /g' `
 
 twofish.o: $(srcdir)/twofish.c
-       `echo $(COMPILE) $(srcdir)/twofish.c | sed -e 's/-O[0-9]*/  /g' `
+       `echo $(COMPILE) -c $(srcdir)/twofish.c | sed -e 's/-O[0-9]*/  /g' `
 
 
 rndunix: $(srcdir)/rndunix.c
index 827baa1..7c34bab 100644 (file)
@@ -31,4 +31,14 @@ blowfish_get_info( int algo, size_t *keylen,
                   void (**decryptf)( void *c, byte *outbuf, byte *inbuf )
                 );
 
+/* this is just a kludge for the time we have not yet chnaged the cipher
+ * stuff to the scheme we use for random and digests */
+const char *
+twofish_get_info( int algo, size_t *keylen,
+                  size_t *blocksize, size_t *contextsize,
+                  int  (**setkeyf)( void *c, byte *key, unsigned keylen ),
+                  void (**encryptf)( void *c, byte *outbuf, byte *inbuf ),
+                  void (**decryptf)( void *c, byte *outbuf, byte *inbuf )
+                );
+
 #endif /*G10_BLOWFISH_H*/
index 338b2b9..0306c37 100644 (file)
@@ -83,6 +83,17 @@ setup_cipher_table(void)
     int i;
 
     i = 0;
+    cipher_table[i].algo = CIPHER_ALGO_TWOFISH;
+    cipher_table[i].name = twofish_get_info( cipher_table[i].algo,
+                                        &cipher_table[i].keylen,
+                                        &cipher_table[i].blocksize,
+                                        &cipher_table[i].contextsize,
+                                        &cipher_table[i].setkey,
+                                        &cipher_table[i].encrypt,
+                                        &cipher_table[i].decrypt     );
+    if( !cipher_table[i].name )
+       BUG();
+    i++;
     cipher_table[i].algo = CIPHER_ALGO_BLOWFISH;
     cipher_table[i].name = blowfish_get_info( cipher_table[i].algo,
                                         &cipher_table[i].keylen,
@@ -127,6 +138,17 @@ setup_cipher_table(void)
     if( !cipher_table[i].name )
        BUG();
     i++;
+    cipher_table[i].algo = CIPHER_ALGO_TWOFISH_OLD;
+    cipher_table[i].name = twofish_get_info( cipher_table[i].algo,
+                                        &cipher_table[i].keylen,
+                                        &cipher_table[i].blocksize,
+                                        &cipher_table[i].contextsize,
+                                        &cipher_table[i].setkey,
+                                        &cipher_table[i].encrypt,
+                                        &cipher_table[i].decrypt     );
+    if( !cipher_table[i].name )
+       BUG();
+    i++;
     cipher_table[i].algo = CIPHER_ALGO_DUMMY;
     cipher_table[i].name = "DUMMY";
     cipher_table[i].blocksize = 8;
index d1e171b..94a31de 100644 (file)
@@ -1,5 +1,6 @@
 /* Twofish for GPG
  * By Matthew Skala <mskala@ansuz.sooke.bc.ca>, July 26, 1998
+ * 256-bit key length added March 20, 1999
  *
  * This code is a "clean room" implementation, written from the paper
  * _Twofish: A 128-Bit Block Cipher_ by Bruce Schneier, John Kelsey,
@@ -11,7 +12,7 @@
  * Abstract Algebra_ by Joseph A. Gallian, especially chapter 22 in the
  * Third Edition.
  *
- * Only the 128-bit block size is supported at present.  This code is intended
+ * Only the 128- and 256-bit key sizes are supported.  This code is intended
  * for GNU C on a 32-bit system, but it should work almost anywhere.  Loops
  * are unrolled, precomputation tables are used, etc., for maximum speed at
  * some cost in memory consumption. */
@@ -402,13 +403,13 @@ static const byte exp_to_poly[492] = {
       (d) ^= exp_to_poly[tmp + (z)]; \
    }
 
-/* Macros to calculate the key-dependent S-boxes using the S vector from
- * CALC_S.  CALC_SB_2 computes a single entry in all four S-boxes, where i
- * is the index of the entry to compute, and a and b are the index numbers
- * preprocessed through the q0 and q1 tables respectively.  CALC_SB is
- * simply a convenience to make the code shorter; it calls CALC_SB_2 four
- * times with consecutive indices from i to i+3, using the remaining
- * parameters two by two. */
+/* Macros to calculate the key-dependent S-boxes for a 128-bit key using
+ * the S vector from CALC_S.  CALC_SB_2 computes a single entry in all
+ * four S-boxes, where i is the index of the entry to compute, and a and b
+ * are the index numbers preprocessed through the q0 and q1 tables
+ * respectively.  CALC_SB is simply a convenience to make the code shorter;
+ * it calls CALC_SB_2 four times with consecutive indices from i to i+3,
+ * using the remaining parameters two by two. */
 
 #define CALC_SB_2(i, a, b) \
    ctx->s[0][i] = mds[0][q0[(a) ^ sa] ^ se]; \
@@ -420,30 +421,63 @@ static const byte exp_to_poly[492] = {
    CALC_SB_2 (i, a, b); CALC_SB_2 ((i)+1, c, d); \
    CALC_SB_2 ((i)+2, e, f); CALC_SB_2 ((i)+3, g, h)
 
+/* Macros exactly like CALC_SB and CALC_SB_2, but for 256-bit keys. */
+
+#define CALC_SB256_2(i, a, b) \
+   ctx->s[0][i] = mds[0][q0[q0[q1[(b) ^ sa] ^ se] ^ si] ^ sm]; \
+   ctx->s[1][i] = mds[1][q0[q1[q1[(a) ^ sb] ^ sf] ^ sj] ^ sn]; \
+   ctx->s[2][i] = mds[2][q1[q0[q0[(a) ^ sc] ^ sg] ^ sk] ^ so]; \
+   ctx->s[3][i] = mds[3][q1[q1[q0[(b) ^ sd] ^ sh] ^ sl] ^ sp];
+
+#define CALC_SB256(i, a, b, c, d, e, f, g, h) \
+   CALC_SB256_2 (i, a, b); CALC_SB256_2 ((i)+1, c, d); \
+   CALC_SB256_2 ((i)+2, e, f); CALC_SB256_2 ((i)+3, g, h)
+
 /* Macros to calculate the whitening and round subkeys.  CALC_K_2 computes the
- * h() function for a given index (either 2i or 2i+1). a and b are the index
- * preprocessed through q0 and q1 respectively; j is the index of the first
- * key byte to use.  CALC_K computes a pair of subkeys by calling CALC_K_2
+ * last two stages of the h() function for a given index (either 2i or 2i+1).
+ * a, b, c, and d are the four bytes going into the last two stages.  For
+ * 128-bit keys, this is the entire h() function and a and c are the index
+ * preprocessed through q0 and q1 respectively; for longer keys they are the
+ * output of previous stages.  j is the index of the first key byte to use.
+ * CALC_K computes a pair of subkeys for 128-bit Twofish, by calling CALC_K_2
  * twice, doing the Psuedo-Hadamard Transform, and doing the necessary
  * rotations.  Its parameters are: a, the array to write the results into,
  * j, the index of the first output entry, k and l, the preprocessed indices
- * for index 2i, and m and n, the preprocessed indices for index 2i+1. */
+ * for index 2i, and m and n, the preprocessed indices for index 2i+1.
+ * CALC_K256_2 expands CALC_K_2 to handle 256-bit keys, by doing two
+ * additional lookup-and-XOR stages.  The parameters a and b are the index
+ * preprocessed through q0 and q1 respectively; j is the index of the first
+ * key byte to use.  CALC_K256 is identical to CALC_K but for using the
+ * CALC_K256_2 macro instead of CALC_K_2. */
 
-#define CALC_K_2(a, b, j) \
+#define CALC_K_2(a, b, c, d, j) \
      mds[0][q0[a ^ key[(j) + 8]] ^ key[j]] \
    ^ mds[1][q0[b ^ key[(j) + 9]] ^ key[(j) + 1]] \
-   ^ mds[2][q1[a ^ key[(j) + 10]] ^ key[(j) + 2]] \
-   ^ mds[3][q1[b ^ key[(j) + 11]] ^ key[(j) + 3]]
+   ^ mds[2][q1[c ^ key[(j) + 10]] ^ key[(j) + 2]] \
+   ^ mds[3][q1[d ^ key[(j) + 11]] ^ key[(j) + 3]]
 
 #define CALC_K(a, j, k, l, m, n) \
-   x = CALC_K_2 (k, l, 0); \
-   y = CALC_K_2 (m, n, 4); \
+   x = CALC_K_2 (k, l, k, l, 0); \
+   y = CALC_K_2 (m, n, m, n, 4); \
+   y = (y << 8) + (y >> 24); \
+   x += y; y += x; ctx->a[j] = x; \
+   ctx->a[(j) + 1] = (y << 9) + (y >> 23)
+
+#define CALC_K256_2(a, b, j) \
+   CALC_K_2 (q0[q1[b ^ key[(j) + 24]] ^ key[(j) + 16]], \
+            q1[q1[a ^ key[(j) + 25]] ^ key[(j) + 17]], \
+            q0[q0[a ^ key[(j) + 26]] ^ key[(j) + 18]], \
+            q1[q0[b ^ key[(j) + 27]] ^ key[(j) + 19]], j)
+
+#define CALC_K256(a, j, k, l, m, n) \
+   x = CALC_K256_2 (k, l, 0); \
+   y = CALC_K256_2 (m, n, 4); \
    y = (y << 8) + (y >> 24); \
    x += y; y += x; ctx->a[j] = x; \
-   ctx->a[(j) + 1] = (y << 9) + ( y >> 23)
+   ctx->a[(j) + 1] = (y << 9) + (y >> 23)
 \f
-/* Perform the key setup.  Note that this works *only* with 128-bit keys,
- * despite the API that makes it look like it might support other sizes. */
+/* Perform the key setup.  Note that this works only with 128- and 256-bit
+ * keys, despite the API that looks like it might support other sizes. */
 
 static int
 twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen)
@@ -451,9 +485,10 @@ twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen)
    /* Temporaries for CALC_K. */
    u32 x, y;
 
-   /* The S vector used to key the S-boxes, split up into individual
-    * bytes. */
+   /* The S vector used to key the S-boxes, split up into individual bytes.
+    * 128-bit keys use only sa through sh; 256-bit use all of them. */
    byte sa = 0, sb = 0, sc = 0, sd = 0, se = 0, sf = 0, sg = 0, sh = 0;
+   byte si = 0, sj = 0, sk = 0, sl = 0, sm = 0, sn = 0, so = 0, sp = 0;
 
    /* Temporary for CALC_S. */
    byte tmp;
@@ -463,7 +498,7 @@ twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen)
    static const char *selftest_failed=0;
 
    /* Check key length. */
-   if( keylen != 16 )  /* enhance this code for 256 bit keys */
+   if( ( ( keylen - 16 ) | 16 ) != 16 )
        return G10ERR_WRONG_KEYLEN;
 
    /* Do self-test if necessary. */
@@ -476,9 +511,10 @@ twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen)
    if( selftest_failed )
       return G10ERR_SELFTEST_FAILED;
 
-   /* Compute the S vector.  The magic numbers are the entries of the RS
-    * matrix, preprocessed through poly_to_exp.  The numbers in the comments
-    * are the original (polynomial form) matrix entries. */
+   /* Compute the first two words of the S vector.  The magic numbers are
+    * the entries of the RS matrix, preprocessed through poly_to_exp.  The
+    * numbers in the comments are the original (polynomial form) matrix
+    * entries. */
    CALC_S (sa, sb, sc, sd, 0, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
    CALC_S (sa, sb, sc, sd, 1, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
    CALC_S (sa, sb, sc, sd, 2, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
@@ -496,95 +532,208 @@ twofish_setkey (TWOFISH_context *ctx, const byte *key, const unsigned keylen)
    CALC_S (se, sf, sg, sh, 14, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
    CALC_S (se, sf, sg, sh, 15, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
 
-   /* Compute the S-boxes.  The constants are indices of
-    * S-box entries, preprocessed through q0 and q1. */
-   CALC_SB (0, 0xA9, 0x75, 0x67, 0xF3, 0xB3, 0xC6, 0xE8, 0xF4);
-   CALC_SB (4, 0x04, 0xDB, 0xFD, 0x7B, 0xA3, 0xFB, 0x76, 0xC8);
-   CALC_SB (8, 0x9A, 0x4A, 0x92, 0xD3, 0x80, 0xE6, 0x78, 0x6B);
-   CALC_SB (12, 0xE4, 0x45, 0xDD, 0x7D, 0xD1, 0xE8, 0x38, 0x4B);
-   CALC_SB (16, 0x0D, 0xD6, 0xC6, 0x32, 0x35, 0xD8, 0x98, 0xFD);
-   CALC_SB (20, 0x18, 0x37, 0xF7, 0x71, 0xEC, 0xF1, 0x6C, 0xE1);
-   CALC_SB (24, 0x43, 0x30, 0x75, 0x0F, 0x37, 0xF8, 0x26, 0x1B);
-   CALC_SB (28, 0xFA, 0x87, 0x13, 0xFA, 0x94, 0x06, 0x48, 0x3F);
-   CALC_SB (32, 0xF2, 0x5E, 0xD0, 0xBA, 0x8B, 0xAE, 0x30, 0x5B);
-   CALC_SB (36, 0x84, 0x8A, 0x54, 0x00, 0xDF, 0xBC, 0x23, 0x9D);
-   CALC_SB (40, 0x19, 0x6D, 0x5B, 0xC1, 0x3D, 0xB1, 0x59, 0x0E);
-   CALC_SB (44, 0xF3, 0x80, 0xAE, 0x5D, 0xA2, 0xD2, 0x82, 0xD5);
-   CALC_SB (48, 0x63, 0xA0, 0x01, 0x84, 0x83, 0x07, 0x2E, 0x14);
-   CALC_SB (52, 0xD9, 0xB5, 0x51, 0x90, 0x9B, 0x2C, 0x7C, 0xA3);
-   CALC_SB (56, 0xA6, 0xB2, 0xEB, 0x73, 0xA5, 0x4C, 0xBE, 0x54);
-   CALC_SB (60, 0x16, 0x92, 0x0C, 0x74, 0xE3, 0x36, 0x61, 0x51);
-   CALC_SB (64, 0xC0, 0x38, 0x8C, 0xB0, 0x3A, 0xBD, 0xF5, 0x5A);
-   CALC_SB (68, 0x73, 0xFC, 0x2C, 0x60, 0x25, 0x62, 0x0B, 0x96);
-   CALC_SB (72, 0xBB, 0x6C, 0x4E, 0x42, 0x89, 0xF7, 0x6B, 0x10);
-   CALC_SB (76, 0x53, 0x7C, 0x6A, 0x28, 0xB4, 0x27, 0xF1, 0x8C);
-   CALC_SB (80, 0xE1, 0x13, 0xE6, 0x95, 0xBD, 0x9C, 0x45, 0xC7);
-   CALC_SB (84, 0xE2, 0x24, 0xF4, 0x46, 0xB6, 0x3B, 0x66, 0x70);
-   CALC_SB (88, 0xCC, 0xCA, 0x95, 0xE3, 0x03, 0x85, 0x56, 0xCB);
-   CALC_SB (92, 0xD4, 0x11, 0x1C, 0xD0, 0x1E, 0x93, 0xD7, 0xB8);
-   CALC_SB (96, 0xFB, 0xA6, 0xC3, 0x83, 0x8E, 0x20, 0xB5, 0xFF);
-   CALC_SB (100, 0xE9, 0x9F, 0xCF, 0x77, 0xBF, 0xC3, 0xBA, 0xCC);
-   CALC_SB (104, 0xEA, 0x03, 0x77, 0x6F, 0x39, 0x08, 0xAF, 0xBF);
-   CALC_SB (108, 0x33, 0x40, 0xC9, 0xE7, 0x62, 0x2B, 0x71, 0xE2);
-   CALC_SB (112, 0x81, 0x79, 0x79, 0x0C, 0x09, 0xAA, 0xAD, 0x82);
-   CALC_SB (116, 0x24, 0x41, 0xCD, 0x3A, 0xF9, 0xEA, 0xD8, 0xB9);
-   CALC_SB (120, 0xE5, 0xE4, 0xC5, 0x9A, 0xB9, 0xA4, 0x4D, 0x97);
-   CALC_SB (124, 0x44, 0x7E, 0x08, 0xDA, 0x86, 0x7A, 0xE7, 0x17);
-   CALC_SB (128, 0xA1, 0x66, 0x1D, 0x94, 0xAA, 0xA1, 0xED, 0x1D);
-   CALC_SB (132, 0x06, 0x3D, 0x70, 0xF0, 0xB2, 0xDE, 0xD2, 0xB3);
-   CALC_SB (136, 0x41, 0x0B, 0x7B, 0x72, 0xA0, 0xA7, 0x11, 0x1C);
-   CALC_SB (140, 0x31, 0xEF, 0xC2, 0xD1, 0x27, 0x53, 0x90, 0x3E);
-   CALC_SB (144, 0x20, 0x8F, 0xF6, 0x33, 0x60, 0x26, 0xFF, 0x5F);
-   CALC_SB (148, 0x96, 0xEC, 0x5C, 0x76, 0xB1, 0x2A, 0xAB, 0x49);
-   CALC_SB (152, 0x9E, 0x81, 0x9C, 0x88, 0x52, 0xEE, 0x1B, 0x21);
-   CALC_SB (156, 0x5F, 0xC4, 0x93, 0x1A, 0x0A, 0xEB, 0xEF, 0xD9);
-   CALC_SB (160, 0x91, 0xC5, 0x85, 0x39, 0x49, 0x99, 0xEE, 0xCD);
-   CALC_SB (164, 0x2D, 0xAD, 0x4F, 0x31, 0x8F, 0x8B, 0x3B, 0x01);
-   CALC_SB (168, 0x47, 0x18, 0x87, 0x23, 0x6D, 0xDD, 0x46, 0x1F);
-   CALC_SB (172, 0xD6, 0x4E, 0x3E, 0x2D, 0x69, 0xF9, 0x64, 0x48);
-   CALC_SB (176, 0x2A, 0x4F, 0xCE, 0xF2, 0xCB, 0x65, 0x2F, 0x8E);
-   CALC_SB (180, 0xFC, 0x78, 0x97, 0x5C, 0x05, 0x58, 0x7A, 0x19);
-   CALC_SB (184, 0xAC, 0x8D, 0x7F, 0xE5, 0xD5, 0x98, 0x1A, 0x57);
-   CALC_SB (188, 0x4B, 0x67, 0x0E, 0x7F, 0xA7, 0x05, 0x5A, 0x64);
-   CALC_SB (192, 0x28, 0xAF, 0x14, 0x63, 0x3F, 0xB6, 0x29, 0xFE);
-   CALC_SB (196, 0x88, 0xF5, 0x3C, 0xB7, 0x4C, 0x3C, 0x02, 0xA5);
-   CALC_SB (200, 0xB8, 0xCE, 0xDA, 0xE9, 0xB0, 0x68, 0x17, 0x44);
-   CALC_SB (204, 0x55, 0xE0, 0x1F, 0x4D, 0x8A, 0x43, 0x7D, 0x69);
-   CALC_SB (208, 0x57, 0x29, 0xC7, 0x2E, 0x8D, 0xAC, 0x74, 0x15);
-   CALC_SB (212, 0xB7, 0x59, 0xC4, 0xA8, 0x9F, 0x0A, 0x72, 0x9E);
-   CALC_SB (216, 0x7E, 0x6E, 0x15, 0x47, 0x22, 0xDF, 0x12, 0x34);
-   CALC_SB (220, 0x58, 0x35, 0x07, 0x6A, 0x99, 0xCF, 0x34, 0xDC);
-   CALC_SB (224, 0x6E, 0x22, 0x50, 0xC9, 0xDE, 0xC0, 0x68, 0x9B);
-   CALC_SB (228, 0x65, 0x89, 0xBC, 0xD4, 0xDB, 0xED, 0xF8, 0xAB);
-   CALC_SB (232, 0xC8, 0x12, 0xA8, 0xA2, 0x2B, 0x0D, 0x40, 0x52);
-   CALC_SB (236, 0xDC, 0xBB, 0xFE, 0x02, 0x32, 0x2F, 0xA4, 0xA9);
-   CALC_SB (240, 0xCA, 0xD7, 0x10, 0x61, 0x21, 0x1E, 0xF0, 0xB4);
-   CALC_SB (244, 0xD3, 0x50, 0x5D, 0x04, 0x0F, 0xF6, 0x00, 0xC2);
-   CALC_SB (248, 0x6F, 0x16, 0x9D, 0x25, 0x36, 0x86, 0x42, 0x56);
-   CALC_SB (252, 0x4A, 0x55, 0x5E, 0x09, 0xC1, 0xBE, 0xE0, 0x91);
-
-   /* Calculate whitening and round subkeys.  The constants are
-    * indices of subkeys, preprocessed through q0 and q1. */
-   CALC_K (w, 0, 0xA9, 0x75, 0x67, 0xF3);
-   CALC_K (w, 2, 0xB3, 0xC6, 0xE8, 0xF4);
-   CALC_K (w, 4, 0x04, 0xDB, 0xFD, 0x7B);
-   CALC_K (w, 6, 0xA3, 0xFB, 0x76, 0xC8);
-   CALC_K (k, 0, 0x9A, 0x4A, 0x92, 0xD3);
-   CALC_K (k, 2, 0x80, 0xE6, 0x78, 0x6B);
-   CALC_K (k, 4, 0xE4, 0x45, 0xDD, 0x7D);
-   CALC_K (k, 6, 0xD1, 0xE8, 0x38, 0x4B);
-   CALC_K (k, 8, 0x0D, 0xD6, 0xC6, 0x32);
-   CALC_K (k, 10, 0x35, 0xD8, 0x98, 0xFD);
-   CALC_K (k, 12, 0x18, 0x37, 0xF7, 0x71);
-   CALC_K (k, 14, 0xEC, 0xF1, 0x6C, 0xE1);
-   CALC_K (k, 16, 0x43, 0x30, 0x75, 0x0F);
-   CALC_K (k, 18, 0x37, 0xF8, 0x26, 0x1B);
-   CALC_K (k, 20, 0xFA, 0x87, 0x13, 0xFA);
-   CALC_K (k, 22, 0x94, 0x06, 0x48, 0x3F);
-   CALC_K (k, 24, 0xF2, 0x5E, 0xD0, 0xBA);
-   CALC_K (k, 26, 0x8B, 0xAE, 0x30, 0x5B);
-   CALC_K (k, 28, 0x84, 0x8A, 0x54, 0x00);
-   CALC_K (k, 30, 0xDF, 0xBC, 0x23, 0x9D);
+   if (keylen == 32) { /* 256-bit key */
+
+      /* Calculate the remaining two words of the S vector */
+      CALC_S (si, sj, sk, sl, 16, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
+      CALC_S (si, sj, sk, sl, 17, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
+      CALC_S (si, sj, sk, sl, 18, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
+      CALC_S (si, sj, sk, sl, 19, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
+      CALC_S (si, sj, sk, sl, 20, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
+      CALC_S (si, sj, sk, sl, 21, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
+      CALC_S (si, sj, sk, sl, 22, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
+      CALC_S (si, sj, sk, sl, 23, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
+      CALC_S (sm, sn, so, sp, 24, 0x00, 0x2D, 0x01, 0x2D); /* 01 A4 02 A4 */
+      CALC_S (sm, sn, so, sp, 25, 0x2D, 0xA4, 0x44, 0x8A); /* A4 56 A1 55 */
+      CALC_S (sm, sn, so, sp, 26, 0x8A, 0xD5, 0xBF, 0xD1); /* 55 82 FC 87 */
+      CALC_S (sm, sn, so, sp, 27, 0xD1, 0x7F, 0x3D, 0x99); /* 87 F3 C1 5A */
+      CALC_S (sm, sn, so, sp, 28, 0x99, 0x46, 0x66, 0x96); /* 5A 1E 47 58 */
+      CALC_S (sm, sn, so, sp, 29, 0x96, 0x3C, 0x5B, 0xED); /* 58 C6 AE DB */
+      CALC_S (sm, sn, so, sp, 30, 0xED, 0x37, 0x4F, 0xE0); /* DB 68 3D 9E */
+      CALC_S (sm, sn, so, sp, 31, 0xE0, 0xD0, 0x8C, 0x17); /* 9E E5 19 03 */
+
+      /* Compute the S-boxes.  The constants are indices of
+       * S-box entries, preprocessed through q0 and q1. */
+      CALC_SB256 (0, 0xA9, 0x75, 0x67, 0xF3, 0xB3, 0xC6, 0xE8, 0xF4);
+      CALC_SB256 (4, 0x04, 0xDB, 0xFD, 0x7B, 0xA3, 0xFB, 0x76, 0xC8);
+      CALC_SB256 (8, 0x9A, 0x4A, 0x92, 0xD3, 0x80, 0xE6, 0x78, 0x6B);
+      CALC_SB256 (12, 0xE4, 0x45, 0xDD, 0x7D, 0xD1, 0xE8, 0x38, 0x4B);
+      CALC_SB256 (16, 0x0D, 0xD6, 0xC6, 0x32, 0x35, 0xD8, 0x98, 0xFD);
+      CALC_SB256 (20, 0x18, 0x37, 0xF7, 0x71, 0xEC, 0xF1, 0x6C, 0xE1);
+      CALC_SB256 (24, 0x43, 0x30, 0x75, 0x0F, 0x37, 0xF8, 0x26, 0x1B);
+      CALC_SB256 (28, 0xFA, 0x87, 0x13, 0xFA, 0x94, 0x06, 0x48, 0x3F);
+      CALC_SB256 (32, 0xF2, 0x5E, 0xD0, 0xBA, 0x8B, 0xAE, 0x30, 0x5B);
+      CALC_SB256 (36, 0x84, 0x8A, 0x54, 0x00, 0xDF, 0xBC, 0x23, 0x9D);
+      CALC_SB256 (40, 0x19, 0x6D, 0x5B, 0xC1, 0x3D, 0xB1, 0x59, 0x0E);
+      CALC_SB256 (44, 0xF3, 0x80, 0xAE, 0x5D, 0xA2, 0xD2, 0x82, 0xD5);
+      CALC_SB256 (48, 0x63, 0xA0, 0x01, 0x84, 0x83, 0x07, 0x2E, 0x14);
+      CALC_SB256 (52, 0xD9, 0xB5, 0x51, 0x90, 0x9B, 0x2C, 0x7C, 0xA3);
+      CALC_SB256 (56, 0xA6, 0xB2, 0xEB, 0x73, 0xA5, 0x4C, 0xBE, 0x54);
+      CALC_SB256 (60, 0x16, 0x92, 0x0C, 0x74, 0xE3, 0x36, 0x61, 0x51);
+      CALC_SB256 (64, 0xC0, 0x38, 0x8C, 0xB0, 0x3A, 0xBD, 0xF5, 0x5A);
+      CALC_SB256 (68, 0x73, 0xFC, 0x2C, 0x60, 0x25, 0x62, 0x0B, 0x96);
+      CALC_SB256 (72, 0xBB, 0x6C, 0x4E, 0x42, 0x89, 0xF7, 0x6B, 0x10);
+      CALC_SB256 (76, 0x53, 0x7C, 0x6A, 0x28, 0xB4, 0x27, 0xF1, 0x8C);
+      CALC_SB256 (80, 0xE1, 0x13, 0xE6, 0x95, 0xBD, 0x9C, 0x45, 0xC7);
+      CALC_SB256 (84, 0xE2, 0x24, 0xF4, 0x46, 0xB6, 0x3B, 0x66, 0x70);
+      CALC_SB256 (88, 0xCC, 0xCA, 0x95, 0xE3, 0x03, 0x85, 0x56, 0xCB);
+      CALC_SB256 (92, 0xD4, 0x11, 0x1C, 0xD0, 0x1E, 0x93, 0xD7, 0xB8);
+      CALC_SB256 (96, 0xFB, 0xA6, 0xC3, 0x83, 0x8E, 0x20, 0xB5, 0xFF);
+      CALC_SB256 (100, 0xE9, 0x9F, 0xCF, 0x77, 0xBF, 0xC3, 0xBA, 0xCC);
+      CALC_SB256 (104, 0xEA, 0x03, 0x77, 0x6F, 0x39, 0x08, 0xAF, 0xBF);
+      CALC_SB256 (108, 0x33, 0x40, 0xC9, 0xE7, 0x62, 0x2B, 0x71, 0xE2);
+      CALC_SB256 (112, 0x81, 0x79, 0x79, 0x0C, 0x09, 0xAA, 0xAD, 0x82);
+      CALC_SB256 (116, 0x24, 0x41, 0xCD, 0x3A, 0xF9, 0xEA, 0xD8, 0xB9);
+      CALC_SB256 (120, 0xE5, 0xE4, 0xC5, 0x9A, 0xB9, 0xA4, 0x4D, 0x97);
+      CALC_SB256 (124, 0x44, 0x7E, 0x08, 0xDA, 0x86, 0x7A, 0xE7, 0x17);
+      CALC_SB256 (128, 0xA1, 0x66, 0x1D, 0x94, 0xAA, 0xA1, 0xED, 0x1D);
+      CALC_SB256 (132, 0x06, 0x3D, 0x70, 0xF0, 0xB2, 0xDE, 0xD2, 0xB3);
+      CALC_SB256 (136, 0x41, 0x0B, 0x7B, 0x72, 0xA0, 0xA7, 0x11, 0x1C);
+      CALC_SB256 (140, 0x31, 0xEF, 0xC2, 0xD1, 0x27, 0x53, 0x90, 0x3E);
+      CALC_SB256 (144, 0x20, 0x8F, 0xF6, 0x33, 0x60, 0x26, 0xFF, 0x5F);
+      CALC_SB256 (148, 0x96, 0xEC, 0x5C, 0x76, 0xB1, 0x2A, 0xAB, 0x49);
+      CALC_SB256 (152, 0x9E, 0x81, 0x9C, 0x88, 0x52, 0xEE, 0x1B, 0x21);
+      CALC_SB256 (156, 0x5F, 0xC4, 0x93, 0x1A, 0x0A, 0xEB, 0xEF, 0xD9);
+      CALC_SB256 (160, 0x91, 0xC5, 0x85, 0x39, 0x49, 0x99, 0xEE, 0xCD);
+      CALC_SB256 (164, 0x2D, 0xAD, 0x4F, 0x31, 0x8F, 0x8B, 0x3B, 0x01);
+      CALC_SB256 (168, 0x47, 0x18, 0x87, 0x23, 0x6D, 0xDD, 0x46, 0x1F);
+      CALC_SB256 (172, 0xD6, 0x4E, 0x3E, 0x2D, 0x69, 0xF9, 0x64, 0x48);
+      CALC_SB256 (176, 0x2A, 0x4F, 0xCE, 0xF2, 0xCB, 0x65, 0x2F, 0x8E);
+      CALC_SB256 (180, 0xFC, 0x78, 0x97, 0x5C, 0x05, 0x58, 0x7A, 0x19);
+      CALC_SB256 (184, 0xAC, 0x8D, 0x7F, 0xE5, 0xD5, 0x98, 0x1A, 0x57);
+      CALC_SB256 (188, 0x4B, 0x67, 0x0E, 0x7F, 0xA7, 0x05, 0x5A, 0x64);
+      CALC_SB256 (192, 0x28, 0xAF, 0x14, 0x63, 0x3F, 0xB6, 0x29, 0xFE);
+      CALC_SB256 (196, 0x88, 0xF5, 0x3C, 0xB7, 0x4C, 0x3C, 0x02, 0xA5);
+      CALC_SB256 (200, 0xB8, 0xCE, 0xDA, 0xE9, 0xB0, 0x68, 0x17, 0x44);
+      CALC_SB256 (204, 0x55, 0xE0, 0x1F, 0x4D, 0x8A, 0x43, 0x7D, 0x69);
+      CALC_SB256 (208, 0x57, 0x29, 0xC7, 0x2E, 0x8D, 0xAC, 0x74, 0x15);
+      CALC_SB256 (212, 0xB7, 0x59, 0xC4, 0xA8, 0x9F, 0x0A, 0x72, 0x9E);
+      CALC_SB256 (216, 0x7E, 0x6E, 0x15, 0x47, 0x22, 0xDF, 0x12, 0x34);
+      CALC_SB256 (220, 0x58, 0x35, 0x07, 0x6A, 0x99, 0xCF, 0x34, 0xDC);
+      CALC_SB256 (224, 0x6E, 0x22, 0x50, 0xC9, 0xDE, 0xC0, 0x68, 0x9B);
+      CALC_SB256 (228, 0x65, 0x89, 0xBC, 0xD4, 0xDB, 0xED, 0xF8, 0xAB);
+      CALC_SB256 (232, 0xC8, 0x12, 0xA8, 0xA2, 0x2B, 0x0D, 0x40, 0x52);
+      CALC_SB256 (236, 0xDC, 0xBB, 0xFE, 0x02, 0x32, 0x2F, 0xA4, 0xA9);
+      CALC_SB256 (240, 0xCA, 0xD7, 0x10, 0x61, 0x21, 0x1E, 0xF0, 0xB4);
+      CALC_SB256 (244, 0xD3, 0x50, 0x5D, 0x04, 0x0F, 0xF6, 0x00, 0xC2);
+      CALC_SB256 (248, 0x6F, 0x16, 0x9D, 0x25, 0x36, 0x86, 0x42, 0x56);
+      CALC_SB256 (252, 0x4A, 0x55, 0x5E, 0x09, 0xC1, 0xBE, 0xE0, 0x91);
+
+      /* Calculate whitening and round subkeys.  The constants are
+       * indices of subkeys, preprocessed through q0 and q1. */
+      CALC_K256 (w, 0, 0xA9, 0x75, 0x67, 0xF3);
+      CALC_K256 (w, 2, 0xB3, 0xC6, 0xE8, 0xF4);
+      CALC_K256 (w, 4, 0x04, 0xDB, 0xFD, 0x7B);
+      CALC_K256 (w, 6, 0xA3, 0xFB, 0x76, 0xC8);
+      CALC_K256 (k, 0, 0x9A, 0x4A, 0x92, 0xD3);
+      CALC_K256 (k, 2, 0x80, 0xE6, 0x78, 0x6B);
+      CALC_K256 (k, 4, 0xE4, 0x45, 0xDD, 0x7D);
+      CALC_K256 (k, 6, 0xD1, 0xE8, 0x38, 0x4B);
+      CALC_K256 (k, 8, 0x0D, 0xD6, 0xC6, 0x32);
+      CALC_K256 (k, 10, 0x35, 0xD8, 0x98, 0xFD);
+      CALC_K256 (k, 12, 0x18, 0x37, 0xF7, 0x71);
+      CALC_K256 (k, 14, 0xEC, 0xF1, 0x6C, 0xE1);
+      CALC_K256 (k, 16, 0x43, 0x30, 0x75, 0x0F);
+      CALC_K256 (k, 18, 0x37, 0xF8, 0x26, 0x1B);
+      CALC_K256 (k, 20, 0xFA, 0x87, 0x13, 0xFA);
+      CALC_K256 (k, 22, 0x94, 0x06, 0x48, 0x3F);
+      CALC_K256 (k, 24, 0xF2, 0x5E, 0xD0, 0xBA);
+      CALC_K256 (k, 26, 0x8B, 0xAE, 0x30, 0x5B);
+      CALC_K256 (k, 28, 0x84, 0x8A, 0x54, 0x00);
+      CALC_K256 (k, 30, 0xDF, 0xBC, 0x23, 0x9D);
+
+   } else { /* 128-bit key */
+
+      /* Compute the S-boxes.  The constants are indices of
+       * S-box entries, preprocessed through q0 and q1. */
+      CALC_SB (0, 0xA9, 0x75, 0x67, 0xF3, 0xB3, 0xC6, 0xE8, 0xF4);
+      CALC_SB (4, 0x04, 0xDB, 0xFD, 0x7B, 0xA3, 0xFB, 0x76, 0xC8);
+      CALC_SB (8, 0x9A, 0x4A, 0x92, 0xD3, 0x80, 0xE6, 0x78, 0x6B);
+      CALC_SB (12, 0xE4, 0x45, 0xDD, 0x7D, 0xD1, 0xE8, 0x38, 0x4B);
+      CALC_SB (16, 0x0D, 0xD6, 0xC6, 0x32, 0x35, 0xD8, 0x98, 0xFD);
+      CALC_SB (20, 0x18, 0x37, 0xF7, 0x71, 0xEC, 0xF1, 0x6C, 0xE1);
+      CALC_SB (24, 0x43, 0x30, 0x75, 0x0F, 0x37, 0xF8, 0x26, 0x1B);
+      CALC_SB (28, 0xFA, 0x87, 0x13, 0xFA, 0x94, 0x06, 0x48, 0x3F);
+      CALC_SB (32, 0xF2, 0x5E, 0xD0, 0xBA, 0x8B, 0xAE, 0x30, 0x5B);
+      CALC_SB (36, 0x84, 0x8A, 0x54, 0x00, 0xDF, 0xBC, 0x23, 0x9D);
+      CALC_SB (40, 0x19, 0x6D, 0x5B, 0xC1, 0x3D, 0xB1, 0x59, 0x0E);
+      CALC_SB (44, 0xF3, 0x80, 0xAE, 0x5D, 0xA2, 0xD2, 0x82, 0xD5);
+      CALC_SB (48, 0x63, 0xA0, 0x01, 0x84, 0x83, 0x07, 0x2E, 0x14);
+      CALC_SB (52, 0xD9, 0xB5, 0x51, 0x90, 0x9B, 0x2C, 0x7C, 0xA3);
+      CALC_SB (56, 0xA6, 0xB2, 0xEB, 0x73, 0xA5, 0x4C, 0xBE, 0x54);
+      CALC_SB (60, 0x16, 0x92, 0x0C, 0x74, 0xE3, 0x36, 0x61, 0x51);
+      CALC_SB (64, 0xC0, 0x38, 0x8C, 0xB0, 0x3A, 0xBD, 0xF5, 0x5A);
+      CALC_SB (68, 0x73, 0xFC, 0x2C, 0x60, 0x25, 0x62, 0x0B, 0x96);
+      CALC_SB (72, 0xBB, 0x6C, 0x4E, 0x42, 0x89, 0xF7, 0x6B, 0x10);
+      CALC_SB (76, 0x53, 0x7C, 0x6A, 0x28, 0xB4, 0x27, 0xF1, 0x8C);
+      CALC_SB (80, 0xE1, 0x13, 0xE6, 0x95, 0xBD, 0x9C, 0x45, 0xC7);
+      CALC_SB (84, 0xE2, 0x24, 0xF4, 0x46, 0xB6, 0x3B, 0x66, 0x70);
+      CALC_SB (88, 0xCC, 0xCA, 0x95, 0xE3, 0x03, 0x85, 0x56, 0xCB);
+      CALC_SB (92, 0xD4, 0x11, 0x1C, 0xD0, 0x1E, 0x93, 0xD7, 0xB8);
+      CALC_SB (96, 0xFB, 0xA6, 0xC3, 0x83, 0x8E, 0x20, 0xB5, 0xFF);
+      CALC_SB (100, 0xE9, 0x9F, 0xCF, 0x77, 0xBF, 0xC3, 0xBA, 0xCC);
+      CALC_SB (104, 0xEA, 0x03, 0x77, 0x6F, 0x39, 0x08, 0xAF, 0xBF);
+      CALC_SB (108, 0x33, 0x40, 0xC9, 0xE7, 0x62, 0x2B, 0x71, 0xE2);
+      CALC_SB (112, 0x81, 0x79, 0x79, 0x0C, 0x09, 0xAA, 0xAD, 0x82);
+      CALC_SB (116, 0x24, 0x41, 0xCD, 0x3A, 0xF9, 0xEA, 0xD8, 0xB9);
+      CALC_SB (120, 0xE5, 0xE4, 0xC5, 0x9A, 0xB9, 0xA4, 0x4D, 0x97);
+      CALC_SB (124, 0x44, 0x7E, 0x08, 0xDA, 0x86, 0x7A, 0xE7, 0x17);
+      CALC_SB (128, 0xA1, 0x66, 0x1D, 0x94, 0xAA, 0xA1, 0xED, 0x1D);
+      CALC_SB (132, 0x06, 0x3D, 0x70, 0xF0, 0xB2, 0xDE, 0xD2, 0xB3);
+      CALC_SB (136, 0x41, 0x0B, 0x7B, 0x72, 0xA0, 0xA7, 0x11, 0x1C);
+      CALC_SB (140, 0x31, 0xEF, 0xC2, 0xD1, 0x27, 0x53, 0x90, 0x3E);
+      CALC_SB (144, 0x20, 0x8F, 0xF6, 0x33, 0x60, 0x26, 0xFF, 0x5F);
+      CALC_SB (148, 0x96, 0xEC, 0x5C, 0x76, 0xB1, 0x2A, 0xAB, 0x49);
+      CALC_SB (152, 0x9E, 0x81, 0x9C, 0x88, 0x52, 0xEE, 0x1B, 0x21);
+      CALC_SB (156, 0x5F, 0xC4, 0x93, 0x1A, 0x0A, 0xEB, 0xEF, 0xD9);
+      CALC_SB (160, 0x91, 0xC5, 0x85, 0x39, 0x49, 0x99, 0xEE, 0xCD);
+      CALC_SB (164, 0x2D, 0xAD, 0x4F, 0x31, 0x8F, 0x8B, 0x3B, 0x01);
+      CALC_SB (168, 0x47, 0x18, 0x87, 0x23, 0x6D, 0xDD, 0x46, 0x1F);
+      CALC_SB (172, 0xD6, 0x4E, 0x3E, 0x2D, 0x69, 0xF9, 0x64, 0x48);
+      CALC_SB (176, 0x2A, 0x4F, 0xCE, 0xF2, 0xCB, 0x65, 0x2F, 0x8E);
+      CALC_SB (180, 0xFC, 0x78, 0x97, 0x5C, 0x05, 0x58, 0x7A, 0x19);
+      CALC_SB (184, 0xAC, 0x8D, 0x7F, 0xE5, 0xD5, 0x98, 0x1A, 0x57);
+      CALC_SB (188, 0x4B, 0x67, 0x0E, 0x7F, 0xA7, 0x05, 0x5A, 0x64);
+      CALC_SB (192, 0x28, 0xAF, 0x14, 0x63, 0x3F, 0xB6, 0x29, 0xFE);
+      CALC_SB (196, 0x88, 0xF5, 0x3C, 0xB7, 0x4C, 0x3C, 0x02, 0xA5);
+      CALC_SB (200, 0xB8, 0xCE, 0xDA, 0xE9, 0xB0, 0x68, 0x17, 0x44);
+      CALC_SB (204, 0x55, 0xE0, 0x1F, 0x4D, 0x8A, 0x43, 0x7D, 0x69);
+      CALC_SB (208, 0x57, 0x29, 0xC7, 0x2E, 0x8D, 0xAC, 0x74, 0x15);
+      CALC_SB (212, 0xB7, 0x59, 0xC4, 0xA8, 0x9F, 0x0A, 0x72, 0x9E);
+      CALC_SB (216, 0x7E, 0x6E, 0x15, 0x47, 0x22, 0xDF, 0x12, 0x34);
+      CALC_SB (220, 0x58, 0x35, 0x07, 0x6A, 0x99, 0xCF, 0x34, 0xDC);
+      CALC_SB (224, 0x6E, 0x22, 0x50, 0xC9, 0xDE, 0xC0, 0x68, 0x9B);
+      CALC_SB (228, 0x65, 0x89, 0xBC, 0xD4, 0xDB, 0xED, 0xF8, 0xAB);
+      CALC_SB (232, 0xC8, 0x12, 0xA8, 0xA2, 0x2B, 0x0D, 0x40, 0x52);
+      CALC_SB (236, 0xDC, 0xBB, 0xFE, 0x02, 0x32, 0x2F, 0xA4, 0xA9);
+      CALC_SB (240, 0xCA, 0xD7, 0x10, 0x61, 0x21, 0x1E, 0xF0, 0xB4);
+      CALC_SB (244, 0xD3, 0x50, 0x5D, 0x04, 0x0F, 0xF6, 0x00, 0xC2);
+      CALC_SB (248, 0x6F, 0x16, 0x9D, 0x25, 0x36, 0x86, 0x42, 0x56);
+      CALC_SB (252, 0x4A, 0x55, 0x5E, 0x09, 0xC1, 0xBE, 0xE0, 0x91);
+
+      /* Calculate whitening and round subkeys.  The constants are
+       * indices of subkeys, preprocessed through q0 and q1. */
+      CALC_K (w, 0, 0xA9, 0x75, 0x67, 0xF3);
+      CALC_K (w, 2, 0xB3, 0xC6, 0xE8, 0xF4);
+      CALC_K (w, 4, 0x04, 0xDB, 0xFD, 0x7B);
+      CALC_K (w, 6, 0xA3, 0xFB, 0x76, 0xC8);
+      CALC_K (k, 0, 0x9A, 0x4A, 0x92, 0xD3);
+      CALC_K (k, 2, 0x80, 0xE6, 0x78, 0x6B);
+      CALC_K (k, 4, 0xE4, 0x45, 0xDD, 0x7D);
+      CALC_K (k, 6, 0xD1, 0xE8, 0x38, 0x4B);
+      CALC_K (k, 8, 0x0D, 0xD6, 0xC6, 0x32);
+      CALC_K (k, 10, 0x35, 0xD8, 0x98, 0xFD);
+      CALC_K (k, 12, 0x18, 0x37, 0xF7, 0x71);
+      CALC_K (k, 14, 0xEC, 0xF1, 0x6C, 0xE1);
+      CALC_K (k, 16, 0x43, 0x30, 0x75, 0x0F);
+      CALC_K (k, 18, 0x37, 0xF8, 0x26, 0x1B);
+      CALC_K (k, 20, 0xFA, 0x87, 0x13, 0xFA);
+      CALC_K (k, 22, 0x94, 0x06, 0x48, 0x3F);
+      CALC_K (k, 24, 0xF2, 0x5E, 0xD0, 0xBA);
+      CALC_K (k, 26, 0x8B, 0xAE, 0x30, 0x5B);
+      CALC_K (k, 28, 0x84, 0x8A, 0x54, 0x00);
+      CALC_K (k, 30, 0xDF, 0xBC, 0x23, 0x9D);
+   }
 
    return 0;
 }
@@ -715,7 +864,7 @@ twofish_decrypt (const TWOFISH_context *ctx, byte *out, const byte *in)
    OUTUNPACK (3, d, 3);
 }
 \f
-/* Test a single encryption and decryption, as a sanity check. */
+/* Test a single encryption and decryption with each key size. */
 
 static const char*
 selftest (void)
@@ -723,11 +872,11 @@ selftest (void)
    TWOFISH_context ctx; /* Expanded key. */
    byte scratch[16];   /* Encryption/decryption result buffer. */
 
-   /* Test vector for single encryption/decryption.  Note that I am using
-    * the vector from the Twofish paper's "known answer test", I=3, instead
-    * of the all-0 vector from the "intermediate value test", because an
-    * all-0 key would trigger all the special cases in the RS matrix multiply,
-    * leaving the actual math untested. */
+   /* Test vectors for single encryption/decryption.  Note that I am using
+    * the vectors from the Twofish paper's "known answer test", I=3 for
+    * 128-bit and I=4 for 256-bit, instead of the all-0 vectors from the
+    * "intermediate value test", because an all-0 key would trigger all the
+    * special cases in the RS matrix multiply, leaving the math untested. */
    static const byte plaintext[16] = {
       0xD4, 0x91, 0xDB, 0x16, 0xE7, 0xB1, 0xC3, 0x9E,
       0x86, 0xCB, 0x08, 0x6B, 0x78, 0x9F, 0x54, 0x19
@@ -740,23 +889,46 @@ selftest (void)
       0x01, 0x9F, 0x98, 0x09, 0xDE, 0x17, 0x11, 0x85,
       0x8F, 0xAA, 0xC3, 0xA3, 0xBA, 0x20, 0xFB, 0xC3
    };
+   static const byte plaintext_256[16] = {
+      0x90, 0xAF, 0xE9, 0x1B, 0xB2, 0x88, 0x54, 0x4F,
+      0x2C, 0x32, 0xDC, 0x23, 0x9B, 0x26, 0x35, 0xE6
+   };
+   static const byte key_256[32] = {
+      0xD4, 0x3B, 0xB7, 0x55, 0x6E, 0xA3, 0x2E, 0x46,
+      0xF2, 0xA2, 0x82, 0xB7, 0xD4, 0x5B, 0x4E, 0x0D,
+      0x57, 0xFF, 0x73, 0x9D, 0x4D, 0xC9, 0x2C, 0x1B,
+      0xD7, 0xFC, 0x01, 0x70, 0x0C, 0xC8, 0x21, 0x6F
+   };
+   static const byte ciphertext_256[16] = {
+      0x6C, 0xB4, 0x56, 0x1C, 0x40, 0xBF, 0x0A, 0x97,
+      0x05, 0x93, 0x1C, 0xB6, 0xD4, 0x08, 0xE7, 0xFA
+   };
 
    twofish_setkey (&ctx, key, sizeof(key));
    twofish_encrypt (&ctx, scratch, plaintext);
    if (memcmp (scratch, ciphertext, sizeof (ciphertext)))
-     return "Twofish test encryption failed.";
+     return "Twofish-128 test encryption failed.";
    twofish_decrypt (&ctx, scratch, scratch);
    if (memcmp (scratch, plaintext, sizeof (plaintext)))
-     return "Twofish test decryption failed.";
+     return "Twofish-128 test decryption failed.";
+
+   twofish_setkey (&ctx, key_256, sizeof(key_256));
+   twofish_encrypt (&ctx, scratch, plaintext_256);
+   if (memcmp (scratch, ciphertext_256, sizeof (ciphertext_256)))
+     return "Twofish-256 test encryption failed.";
+   twofish_decrypt (&ctx, scratch, scratch);
+   if (memcmp (scratch, plaintext_256, sizeof (plaintext_256)))
+     return "Twofish-256 test decryption failed.";
+
    return NULL;
 }
 \f
-/* More complete test program. This does a thousand encryptions and
- * decryptions with each of five hundred keys using a feedback scheme similar
- * to a Feistel cipher, so as to be sure of testing all the table entries
- * pretty thoroughly.  We keep changing the keys so as to get a more
- * meaningful performance number, since the key setup is non-trivial for
- * Twofish. */
+/* More complete test program. This does 1000 encryptions and decryptions
+ * with each of 250 128-bit keys and 2000 encryptions and decryptions with
+ * each of 125 256-bit keys, using a feedback scheme similar to a Feistel
+ * cipher, so as to be sure of testing all the table entries pretty
+ * thoroughly. We keep changing the keys so as to get a more meaningful
+ * performance number, since the key setup is non-trivial for Twofish. */
 
 #ifdef TEST
 
@@ -769,56 +941,79 @@ main()
 {
    TWOFISH_context ctx;     /* Expanded key. */
    int i, j;               /* Loop counters. */
+
    const char *encrypt_msg; /* Message to print regarding encryption test;
                             * the printf is done outside the loop to avoid
                             * stuffing up the timing. */
    clock_t timer; /* For computing elapsed time. */
 
    /* Test buffer. */
-   byte buffer[2][16] = {
+   byte buffer[4][16] = {
       {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF},
       {0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78,
-       0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0}
+       0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0},
+      {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
+       0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54 ,0x32, 0x10},
+      {0x01, 0x23, 0x45, 0x67, 0x76, 0x54 ,0x32, 0x10,
+       0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98}
    };
 
    /* Expected outputs for the million-operation test */
-   static const byte test_encrypt[2][16] = {
-      {0xD6, 0xD9, 0x74, 0x06, 0x93, 0x9C, 0x9A, 0x5E,
-       0xAA, 0x34, 0x18, 0x5B, 0xD3, 0x92, 0x5B, 0xC5},
-      {0x9C, 0xCD, 0x01, 0x30, 0xF9, 0x96, 0x00, 0x60,
-       0x49, 0x91, 0x73, 0x28, 0x9D, 0x8E, 0x8F, 0xC4}
+   static const byte test_encrypt[4][16] = {
+      {0xC8, 0x23, 0xB8, 0xB7, 0x6B, 0xFE, 0x91, 0x13,
+       0x2F, 0xA7, 0x5E, 0xE6, 0x94, 0x77, 0x6F, 0x6B},
+      {0x90, 0x36, 0xD8, 0x29, 0xD5, 0x96, 0xC2, 0x8E,
+       0xE4, 0xFF, 0x76, 0xBC, 0xE5, 0x77, 0x88, 0x27},
+      {0xB8, 0x78, 0x69, 0xAF, 0x42, 0x8B, 0x48, 0x64,
+       0xF7, 0xE9, 0xF3, 0x9C, 0x42, 0x18, 0x7B, 0x73},
+      {0x7A, 0x88, 0xFB, 0xEB, 0x90, 0xA4, 0xB4, 0xA8,
+       0x43, 0xA3, 0x1D, 0xF1, 0x26, 0xC4, 0x53, 0x57}
    };
-   static const byte test_decrypt[2][16] = {
+   static const byte test_decrypt[4][16] = {
       {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
        0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF},
       {0x0F, 0x1E, 0x2D, 0x3C, 0x4B, 0x5A, 0x69, 0x78,
-       0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0}
+       0x87, 0x96, 0xA5, 0xB4, 0xC3, 0xD2 ,0xE1, 0xF0},
+      {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
+       0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54 ,0x32, 0x10},
+      {0x01, 0x23, 0x45, 0x67, 0x76, 0x54 ,0x32, 0x10,
+       0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98}
    };
 
    /* Start the timer ticking. */
    timer = clock ();
 
    /* Encryption test. */
-   for (i = 0; i < 250; i++) {
+   for (i = 0; i < 125; i++) {
       twofish_setkey (&ctx, buffer[0], sizeof (buffer[0]));
       for (j = 0; j < 1000; j++)
-       twofish_encrypt (&ctx, buffer[1], buffer[1]);
+       twofish_encrypt (&ctx, buffer[2], buffer[2]);
       twofish_setkey (&ctx, buffer[1], sizeof (buffer[1]));
       for (j = 0; j < 1000; j++)
+       twofish_encrypt (&ctx, buffer[3], buffer[3]);
+      twofish_setkey (&ctx, buffer[2], sizeof (buffer[2])*2);
+      for (j = 0; j < 1000; j++) {
        twofish_encrypt (&ctx, buffer[0], buffer[0]);
+       twofish_encrypt (&ctx, buffer[1], buffer[1]);
+      }
    }
    encrypt_msg = memcmp (buffer, test_encrypt, sizeof (test_encrypt)) ?
                 "encryption failure!\n" : "encryption OK!\n";
 
    /* Decryption test. */
-   for (i = 0; i < 250; i++) {
+   for (i = 0; i < 125; i++) {
+      twofish_setkey (&ctx, buffer[2], sizeof (buffer[2])*2);
+      for (j = 0; j < 1000; j++) {
+       twofish_decrypt (&ctx, buffer[0], buffer[0]);
+       twofish_decrypt (&ctx, buffer[1], buffer[1]);
+      }
       twofish_setkey (&ctx, buffer[1], sizeof (buffer[1]));
       for (j = 0; j < 1000; j++)
-       twofish_decrypt (&ctx, buffer[0], buffer[0]);
+       twofish_decrypt (&ctx, buffer[3], buffer[3]);
       twofish_setkey (&ctx, buffer[0], sizeof (buffer[0]));
       for (j = 0; j < 1000; j++)
-       twofish_decrypt (&ctx, buffer[1], buffer[1]);
+       twofish_decrypt (&ctx, buffer[2], buffer[2]);
    }
 
    /* Stop the timer, and print results. */
@@ -833,7 +1028,10 @@ main()
 
 #endif /* TEST */
 \f
-static const char *
+#ifdef IS_MODULE
+static
+#endif
+       const char *
 twofish_get_info (int algo, size_t *keylen,
                  size_t *blocksize, size_t *contextsize,
                  int  (**r_setkey) (void *c, byte *key, unsigned keylen),
@@ -873,7 +1071,7 @@ static struct {
 
 
 /****************
- * Enumerate the names of the functions together with informations about
+ * Enumerate the names of the functions together with information about
  * this function. Set sequence to an integer with a initial value of 0 and
  * do not change it.
  * If what is 0 all kind of functions are returned.
index e4760fb..a792ec0 100644 (file)
@@ -50,7 +50,7 @@ case "$use_static_rnd" in
 esac
 
 dnl
-dnl See whether the user wants to disable checking for 7dev/random
+dnl See whether the user wants to disable checking for /dev/random
 
 AC_MSG_CHECKING([whether use of /dev/random is requested])
 AC_ARG_ENABLE(dev-random,
@@ -392,17 +392,17 @@ dnl And build the constructor file
 dnl
 
 test -d cipher || mkdir cipher
-cat <<EOF >cipher/construct.c
+cat <<G10EOF >cipher/construct.c
 /* automatically generated by configure - do not edit */
 
-EOF
+G10EOF
 GNUPG_MSG_PRINT([statically linked cipher modules:])
 for name in $STATIC_CIPHER_NAMES; do
     echo "void ${name}_constructor(void);" >>cipher/construct.c
     GNUPG_MSG_PRINT([$name])
 done
 AC_MSG_RESULT()
-cat <<EOF >>cipher/construct.c
+cat <<G10EOF >>cipher/construct.c
 
 void
 cipher_modules_constructor(void)
@@ -412,7 +412,7 @@ cipher_modules_constructor(void)
         return;
     done = 1;
 
-EOF
+G10EOF
 for name in $STATIC_CIPHER_NAMES; do
     echo "   ${name}_constructor();" >>cipher/construct.c
 done
@@ -483,6 +483,36 @@ fi
 GNUPG_DO_LINK_FILES
 
 
+AC_OUTPUT_COMMANDS([
+cat >g10defs.tmp <<G10EOF
+/* Generated automatically by configure */
+#ifdef HAVE_DRIVE_LETTERS
+  #define G10_LOCALEDIR "c:/lib/gnupg/locale"
+  #define GNUPG_LIBDIR  "c:/lib/gnupg"
+  #define GNUPG_DATADIR "c:/lib/gnupg"
+#else
+  #define G10_LOCALEDIR "${prefix}/${DATADIRNAME}/locale"
+  #define GNUPG_LIBDIR  "${libdir}/gnupg"
+  #define GNUPG_DATADIR "${datadir}/gnupg"
+#endif
+G10EOF
+if cmp -s g10defs.h g10defs.tmp 2>/dev/null; then
+    echo "g10defs.h is unchanged"
+    rm -f g10defs.tmp
+else
+    rm -f g10defs.h
+    mv g10defs.tmp g10defs.h
+    echo "g10defs.h created"
+fi
+],[
+prefix=$prefix
+exec_prefix=$exec_prefix
+libdir=$libdir
+datadir=$datadir
+DATADIRNAME=$DATADIRNAME
+])
+
+
 AC_OUTPUT([
 Makefile
 intl/Makefile
index 6d71f15..ad01648 100644 (file)
@@ -1,10 +1,23 @@
-gnupg (0.9.4) unstable; urgency=low
+gnupg (0.9.5-1) unstable; urgency=low
+
+  * New upstream version.
+  * debian/control (Description): no tabs.  [Lintian]
+
+ -- James Troup <james@nocrew.org>  Wed, 24 Mar 1999 22:37:40 +0000
+
+gnupg (0.9.4-1) unstable; urgency=low
 
   * New version.
   * debian/control: s/GNUPG/GnuPG/
 
  -- Werner Koch <wk@isil.d.suttle.de>  Mon, 8 Mar 1999 19:58:28 +0100
 
+gnupg (0.9.3-1) unstable; urgency=low
+
+  * New upstream version.
+
+ -- James Troup <james@nocrew.org>  Mon, 22 Feb 1999 22:55:04 +0000
+
 gnupg (0.9.2-1) unstable; urgency=low
 
   * New version.
index dfb4546..9e900f8 100644 (file)
@@ -8,7 +8,7 @@ Package: gnupg
 Architecture: any
 Depends: ${shlibs:Depends}
 Description: GNU privacy guard - a free PGP replacement.
- GnuPG is the GNU encryption and signing tool. As you can see from the
+ GnuPG is the GNU encryption and signing tool.  As you can see from the
  version number, the program may have some bugs and some features may not
  work at all.
  .
index 644f4c8..fee6d58 100644 (file)
@@ -13,7 +13,7 @@ B<gpgm> [--homedir name] [--options file] [options] command [args]
 B<gpg> is the main program for the GnuPG system. B<gpgm> is a maintenance
 tool which has some commands B<gpg> does not have; it is there because
 it does not handle sensitive data and therefore has no need to allocate
-secure memory.
+secure memory.  Both programs may be merged in the future.
 
 =head1 COMMANDS
 
@@ -37,7 +37,7 @@ B<-c>, B<--symmetric>
     This command asks for a passphrase.
 
 B<--store>
-    store only (make a simple RFC1991 packet).
+    Store only (make a simple RFC1991 packet).
 
 B<--decrypt> [I<file>]
     Decrypt file (or stdin if no file is specified) and
@@ -50,7 +50,7 @@ B<--decrypt> [I<file>]
     message.
 
 B<--verify> [[I<sigfile>] {I<signed-files>}]
-    Assume that I<filename> is a signature and verify it
+    Assume that I<sigfile> is a signature and verify it
     without generating any output.  With no arguments,
     the signature packet is read from stdin (it may be a
     detached signature when not used in batch mode). If
@@ -75,7 +75,10 @@ B<-k> [I<username>] [I<keyring>]
     B<-kvc>   List fingerprints
     B<-kvvc>  List fingerprints and signatures
 
+    B<This command may be removed in the future!>
+
 B<--list-keys>  [I<names>]
+B<--list-public-keys>  [I<names>]
     List all keys from the public keyrings, or just the
     ones given on the command line.
 
index 91a45a9..c2885b4 100644 (file)
@@ -1,3 +1,18 @@
+Wed Apr  7 20:51:39 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+       * encr-data.c (decrypt_data): Fixes for 128 bit blocksize
+       * cipher.c (write_header): Ditto.
+       * seckey-cert.c (do_check): Ditto.
+       (protect_secret_key). Ditto.
+       * misc.c (print_cipher_algo_note): Twofish is now a standard algo.
+
+       * keygen.c (do_create): Fixed spelling (Gaël Quéri)
+       (ask_keysize): Only allow keysizes up to 4096
+
+       * ringedit.c (add_keyblock_resource): chmod newly created secrings.
+
+       * import.c (delete_inv_parts): Fixed accidently deleted subkeys.
+
 Tue Apr  6 19:58:12 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
 
        * armor.c: Removed duped include (John Bley)
index 0d6e54f..98c5e84 100644 (file)
@@ -1,5 +1,5 @@
 /* cipher.c - En-/De-ciphering filter
- *     Copyright (C) 1998 Free Software Foundation, Inc.
+ *     Copyright (C) 1998,1999 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -45,6 +45,7 @@ write_header( cipher_filter_context_t *cfx, IOBUF a )
     PKT_encrypted ed;
     byte temp[18];
     unsigned blocksize;
+    unsigned nprefix;
 
     memset( &ed, 0, sizeof ed );
     ed.len = cfx->datalen;
@@ -57,16 +58,22 @@ write_header( cipher_filter_context_t *cfx, IOBUF a )
     blocksize = cipher_get_blocksize( cfx->dek->algo );
     if( blocksize < 8 || blocksize > 16 )
        log_fatal("unsupported blocksize %u\n", blocksize );
-    randomize_buffer( temp, blocksize, 1 );
-    temp[blocksize] = temp[blocksize-2];
-    temp[blocksize+1] = temp[blocksize-1];
+    /* FIXME: remove the kludge for the experimental twofish128 mode:
+     * we always use the 10 byte prefix and not one depending on the blocksize
+     */
+    nprefix = cfx->dek->algo == CIPHER_ALGO_TWOFISH_OLD? blocksize : 8;
+    randomize_buffer( temp, nprefix, 1 );
+    temp[nprefix] = temp[nprefix-2];
+    temp[nprefix+1] = temp[nprefix-1];
     print_cipher_algo_note( cfx->dek->algo );
     cfx->cipher_hd = cipher_open( cfx->dek->algo, CIPHER_MODE_AUTO_CFB, 1 );
+ /*log_hexdump( "thekey", cfx->dek->key, cfx->dek->keylen );*/
     cipher_setkey( cfx->cipher_hd, cfx->dek->key, cfx->dek->keylen );
     cipher_setiv( cfx->cipher_hd, NULL );
-    cipher_encrypt( cfx->cipher_hd, temp, temp, blocksize+2);
+  /* log_hexdump( "prefix", temp, nprefix+2 );*/
+    cipher_encrypt( cfx->cipher_hd, temp, temp, nprefix+2);
     cipher_sync( cfx->cipher_hd );
-    iobuf_write(a, temp, blocksize+2);
+    iobuf_write(a, temp, nprefix+2);
     cfx->header=1;
 }
 
index f59f2a5..3d223ea 100644 (file)
@@ -1,4 +1,4 @@
-/* verify.c - verify signed data
+/* decrypt.c - verify signed data
  *     Copyright (C) 1998 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
index c5967c2..8ae6949 100644 (file)
@@ -52,6 +52,7 @@ decrypt_data( PKT_encrypted *ed, DEK *dek )
     int rc, c, i;
     byte temp[32];
     unsigned blocksize;
+    unsigned nprefix;
 
     if( opt.verbose ) {
        const char *s = cipher_algo_to_string( dek->algo );
@@ -65,10 +66,15 @@ decrypt_data( PKT_encrypted *ed, DEK *dek )
     blocksize = cipher_get_blocksize(dek->algo);
     if( !blocksize || blocksize > 16 )
        log_fatal("unsupported blocksize %u\n", blocksize );
-    if( ed->len && ed->len < (blocksize+2) )
-       log_bug("Nanu\n");   /* oops: found a bug */
+    /* FIXME: remove the kludge for the experimental twofish128 mode:
+     * we always use the 10 byte prefix and not one depending on the blocksize
+     */
+    nprefix = dek->algo == CIPHER_ALGO_TWOFISH_OLD? blocksize : 8;
+    if( ed->len && ed->len < (nprefix+2) )
+       BUG();
 
     dfx.cipher_hd = cipher_open( dek->algo, CIPHER_MODE_AUTO_CFB, 1 );
+ /*log_hexdump( "thekey", dek->key, dek->keylen );*/
     rc = cipher_setkey( dfx.cipher_hd, dek->key, dek->keylen );
     if( rc == G10ERR_WEAK_KEY )
        log_info(_("WARNING: message was encrypted with "
@@ -79,7 +85,7 @@ decrypt_data( PKT_encrypted *ed, DEK *dek )
     cipher_setiv( dfx.cipher_hd, NULL );
 
     if( ed->len ) {
-       for(i=0; i < (blocksize+2) && ed->len; i++, ed->len-- ) {
+       for(i=0; i < (nprefix+2) && ed->len; i++, ed->len-- ) {
            if( (c=iobuf_get(ed->buf)) == -1 )
                break;
            else
@@ -87,16 +93,17 @@ decrypt_data( PKT_encrypted *ed, DEK *dek )
        }
     }
     else {
-       for(i=0; i < (blocksize+2); i++ )
+       for(i=0; i < (nprefix+2); i++ )
            if( (c=iobuf_get(ed->buf)) == -1 )
                break;
            else
                temp[i] = c;
     }
-    cipher_decrypt( dfx.cipher_hd, temp, temp, blocksize+2);
+    cipher_decrypt( dfx.cipher_hd, temp, temp, nprefix+2);
     cipher_sync( dfx.cipher_hd );
     p = temp;
-    if( p[blocksize-2] != p[blocksize] || p[blocksize-1] != p[blocksize+1] ) {
+ /*log_hexdump( "prefix", temp, nprefix+2 );*/
+    if( p[nprefix-2] != p[nprefix] || p[nprefix-1] != p[nprefix+1] ) {
        cipher_close(dfx.cipher_hd);
        return G10ERR_BAD_KEY;
     }
index 5ec1a01..7e98f1e 100644 (file)
--- a/g10/g10.c
+++ b/g10/g10.c
@@ -176,6 +176,7 @@ static ARGPARSE_OPTS opts[] = {
     { aVerify, "verify"   , 256, N_("verify a signature")},
   #endif
     { aListKeys, "list-keys", 256, N_("list keys")},
+    { aListKeys, "list-public-keys", 256, "@" },
     { aListSigs, "list-sigs", 256, N_("list keys and signatures")},
     { aCheckKeys, "check-sigs",256, N_("check key signatures")},
     { oFingerprint, "fingerprint", 256, N_("list keys and fingerprints")},
index deab7f4..5a739b9 100644 (file)
@@ -765,7 +765,10 @@ delete_inv_parts( const char *fname, KBNODE keyblock, u32 *keyid )
                }
                delete_kbnode( node ); /* the user-id */
                /* and all following packets up to the next user-id */
-               while( node->next && node->next->pkt->pkttype != PKT_USER_ID ){
+               while( node->next
+                      && node->next->pkt->pkttype != PKT_USER_ID
+                      && node->next->pkt->pkttype != PKT_PUBLIC_SUBKEY
+                      && node->next->pkt->pkttype != PKT_SECRET_SUBKEY ){
                    delete_kbnode( node->next );
                    node = node->next;
                }
index 7fcd864..6637d95 100644 (file)
@@ -1,5 +1,5 @@
 /* keygen.c - generate a key pair
- *     Copyright (C) 1998 Free Software Foundation, Inc.
+ *     Copyright (C) 1998, 1999 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -454,6 +454,18 @@ ask_keysize( int algo )
            tty_printf(_("DSA only allows keysizes from 512 to 1024\n"));
        else if( nbits < 768 )
            tty_printf(_("keysize too small; 768 is smallest value allowed.\n"));
+       else if( nbits > 4096 ) {
+           /* It is ridiculous and an annoyance to use larger key sizes!
+            * GnuPG can handle much larger sizes; but it takes an eternity
+            * to create such a key (but less than the time the Sirius
+            * Computer Corporation needs to process one of the usual
+            * complaints) and {de,en}cryption although needs some time.
+            * So, before you complain about this limitation, I suggest that
+            * you start a discussion with Marvin about this theme and then
+            * do whatever you want. */
+           tty_printf(_("keysize too large; %d is largest value allowed.\n"),
+                                                                        4096);
+       }
        else if( nbits > 2048 && !cpr_enabled() ) {
            tty_printf(
                _("Keysizes larger than 2048 are not suggested because\n"
@@ -762,8 +774,8 @@ do_create( int algo, unsigned nbits, KBNODE pub_root, KBNODE sec_root,
     tty_printf(_(
 "We need to generate a lot of random bytes. It is a good idea to perform\n"
 "some other action (type on the keyboard, move the mouse, utilize the\n"
-"the disks) during the prime generation; this gives the random\n"
-"number generator a better chance to gain enough entropy.\n") );
+"disks) during the prime generation; this gives the random number\n"
+"generator a better chance to gain enough entropy.\n") );
 
     if( algo == PUBKEY_ALGO_ELGAMAL || algo == PUBKEY_ALGO_ELGAMAL_E )
        rc = gen_elg(algo, nbits, pub_root, sec_root, dek, s2k,
index 09811ae..4742063 100644 (file)
@@ -1,5 +1,5 @@
 /* misc.c -  miscellaneous functions
- *     Copyright (C) 1998 Free Software Foundation, Inc.
+ *     Copyright (C) 1998, 1999 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -225,6 +225,7 @@ print_cipher_algo_note( int algo )
     else if(   algo == CIPHER_ALGO_3DES
             || algo == CIPHER_ALGO_CAST5
             || algo == CIPHER_ALGO_BLOWFISH
+            || algo == CIPHER_ALGO_TWOFISH
           )
        ;
     else {
index 40c737c..bf22f10 100644 (file)
@@ -1318,7 +1318,6 @@ parse_key( IOBUF inp, int pkttype, unsigned long pktlen,
                rc = G10ERR_INVALID_PACKET;
                goto leave;
            }
-           /* fixme: Add support for other blocksizes */
            for(i=0; i < 8 && pktlen; i++, pktlen-- )
                temp[i] = iobuf_get_noeof(inp);
            if( list_mode ) {
index b61aa9b..30e30ce 100644 (file)
@@ -318,8 +318,19 @@ add_keyblock_resource( const char *url, int force, int secret )
                rc = G10ERR_OPEN_FILE;
                goto leave;
            }
-           else
+           else {
+             #ifndef HAVE_DOSISH_SYSTEM
+               if( secret ) {
+                   if( chmod( filename, S_IRUSR | S_IWUSR ) ) {
+                       log_error("%s: chmod failed: %s\n",
+                                               filename, strerror(errno) );
+                       rc = G10ERR_WRITE_FILE;
+                       goto leave;
+                   }
+               }
+             #endif
                log_info(_("%s: keyring created\n"), filename );
+           }
        }
       #if HAVE_DOSISH_SYSTEM || 1
        iobuf_close( iobuf );
@@ -350,6 +361,13 @@ add_keyblock_resource( const char *url, int force, int secret )
        goto leave;
     }
 
+  #ifndef HAVE_DOSISH_SYSTEM
+  #if 0 /* fixme: check directory permissions and print a warning */
+    if( secret ) {
+    }
+  #endif
+  #endif
+
     /* fixme: avoid duplicate resources */
     resource_table[i].used = 1;
     resource_table[i].secret = !!secret;
index 7f0d41e..4ee0485 100644 (file)
@@ -1,5 +1,5 @@
 /* seckey-cert.c -  secret key certificate packet handling
- *     Copyright (C) 1998 Free Software Foundation, Inc.
+ *     Copyright (C) 1998, 1999 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
@@ -52,8 +52,7 @@ do_check( PKT_secret_key *sk )
 
        if( sk->protect.algo == CIPHER_ALGO_NONE )
            BUG();
-       if( check_cipher_algo( sk->protect.algo )
-           || cipher_get_blocksize( sk->protect.algo  ) != 8 ) {
+       if( check_cipher_algo( sk->protect.algo ) ) {
            log_info(_("protection algorithm %d is not supported\n"),
                        sk->protect.algo );
            return G10ERR_CIPHER_ALGO;
@@ -222,8 +221,6 @@ protect_secret_key( PKT_secret_key *sk, DEK *dek )
 
        if( check_cipher_algo( sk->protect.algo ) )
            rc = G10ERR_CIPHER_ALGO; /* unsupport protection algorithm */
-       else if( cipher_get_blocksize( sk->protect.algo ) != 8 )
-           rc = G10ERR_CIPHER_ALGO; /* unsupport protection algorithm */
        else {
            print_cipher_algo_note( sk->protect.algo );
            cipher_hd = cipher_open( sk->protect.algo,
index 71fedb1..c4e214e 100644 (file)
@@ -1,3 +1,7 @@
+Wed Apr  7 20:51:39 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+       * Makefile.am: Explicit rules to invoke cpp on *.S
+
 Mon Mar  8 20:47:17 CET 1999  Werner Koch  <wk@isil.d.shuttle.de>
 
        * config.links: Take advantage of the with_symbol_underscore macro.
index 6fb7add..2f74309 100644 (file)
@@ -4,18 +4,16 @@ INCLUDES =  -I$(top_srcdir)/include
 CFLAGS = @CFLAGS@ @MPI_OPT_FLAGS@
 SFLAGS = @MPI_SFLAGS@
 
-SUFFIXES = .S .s
-
 EXTRA_DIST = config.links
 DISTCLEANFILES = mpih-add1.S mpih-mul1.S mpih-mul2.S mpih-mul3.S  \
                 mpih-lshift.S mpih-rshift.S mpih-sub1.S asm-syntax.h sysdep.h
+CLEANFILES = tmp-*.s
 
 
 noinst_LIBRARIES = libmpi.a
 # noinst_HEADERS   =
 
 
-
 libmpi_a_SOURCES = longlong.h    \
              mpi-add.c      \
              mpi-bit.c      \
@@ -51,3 +49,11 @@ common_asm_objects = mpih-mul1.o    \
 libmpi_a_DEPENDENCIES = $(common_asm_objects) @MPI_EXTRA_ASM_OBJS@
 libmpi_a_LIBADD = $(common_asm_objects) @MPI_EXTRA_ASM_OBJS@
 
+SUFFIXES = .S
+
+.S.o:
+       $(CPP) $(INCLUDES) $(DEFS) $< | grep -v '^#' >tmp-$*.s
+       $(CC) $(CFLAGS) $(SFLAGS) -c tmp-$*.s
+       mv tmp-$*.o $@
+       rm -f tmp-$*.s
+
index 53d9a4f..bdfafca 100644 (file)
@@ -1,3 +1,7 @@
+Wed Apr  7 20:51:39 CEST 1999  Werner Koch  <wk@isil.d.shuttle.de>
+
+       * fr.po: Imported new version.
+
 Wed Feb 24 11:07:27 CET 1999  Werner Koch  <wk@isil.d.shuttle.de>
 
        * de.po: Imported update for 0.9.3
index 225496a..63cb38a 100644 (file)
--- a/po/fr.po
+++ b/po/fr.po
@@ -1,12 +1,12 @@
-# GnuPG french translation
-# Copyright (C) 1998 Free Software Foundation, Inc.
+# GnuPG French translation
+# Copyright (C) 1998, 1999 Free Software Foundation, Inc.
 # Gaël Quéri <gqueri@mail.dotcom.fr>, 1998.
 #
 msgid ""
 msgstr ""
-"Project-Id-Version: gnupg 0.9.0a\n"
-"POT-Creation-Date: 1999-03-20 13:40+0100\n"
-"PO-Revision-Date: 1999-01-09 00:25+01:00\n"
+"Project-Id-Version: gnupg 0.9.4a\n"
+"POT-Creation-Date: 1999-03-20 20:04+0100\n"
+"PO-Revision-Date: 1999-03-20 20:09+01:00\n"
 "Last-Translator: Gaël Quéri <gqueri@mail.dotcom.fr>\n"
 "Language-Team: French <fr@li.org>\n"
 "MIME-Version: 1.0\n"
@@ -20,10 +20,12 @@ msgstr "Attention : utilisation de la m
 #: util/secmem.c:249
 msgid "operation is not possible without initialized secure memory\n"
 msgstr ""
+"l'opération n'est pas possible tant que la mémoire sûre n'est pas\n"
+"initialisée\n"
 
 #: util/secmem.c:250
 msgid "(you may have used the wrong program for this task)\n"
-msgstr ""
+msgstr "(vous avez peut-être utilisé le mauvais programme pour cette tache)\n"
 
 #: util/miscutil.c:143
 msgid "yes"
@@ -203,27 +205,23 @@ msgstr "le fichier existe"
 
 #: util/errors.c:96
 msgid "weak key"
-msgstr "mauvaise clé"
+msgstr "clé faible"
 
 #: util/errors.c:97
-#, fuzzy
 msgid "invalid argument"
-msgstr "armure invalide"
+msgstr "argument invalide"
 
 #: util/errors.c:98
-#, fuzzy
 msgid "bad URI"
-msgstr "mauvais entier en précision multiple (MPI)"
+msgstr "mauvaise adresse (URI)"
 
 #: util/errors.c:99
-#, fuzzy
 msgid "unsupported URI"
-msgstr "non supporté"
+msgstr "URI non supportée"
 
 #: util/errors.c:100
-#, fuzzy
 msgid "network error"
-msgstr "erreur générale"
+msgstr "erreur de réseau"
 
 #: util/logger.c:178
 #, c-format
@@ -251,10 +249,10 @@ msgstr ""
 "Le générateur de nombres aléatoires n'est qu'un artifice visant à exécuter\n"
 "GnuPG - ce n'est en aucune manière un générateur (RNG) fort!\n"
 "\n"
-"N'UTILISEZ PAS LES DONNÉES GÉNÉRÉES PAR CE PROGRAMME!!\n"
+"N'UTILISEZ PAS LES DONNÉES GÉNÉRÉES PAR CE PROGRAMME !!\n"
 "\n"
 
-#: cipher/rndlinux.c:110
+#: cipher/rndlinux.c:114
 #, c-format
 msgid ""
 "\n"
@@ -265,7 +263,7 @@ msgstr ""
 "Il n'y a pas assez d'octets aléatoires disponibles. Faites autre chose\n"
 "pour que l'OS puisse amasser plus d'entropie ! (il faut %d octets de plus)\n"
 
-#: g10/g10.c:166
+#: g10/g10.c:165
 msgid ""
 "@Commands:\n"
 " "
@@ -273,132 +271,128 @@ msgstr ""
 "@Commandes:\n"
 " "
 
-#: g10/g10.c:169
+#: g10/g10.c:168
 msgid "|[file]|make a signature"
 msgstr "|[fichier]|faire une signature"
 
-#: g10/g10.c:170
+#: g10/g10.c:169
 msgid "|[file]|make a clear text signature"
 msgstr "|[fichier]|faire une signature en texte clair"
 
-#: g10/g10.c:171
+#: g10/g10.c:170
 msgid "make a detached signature"
 msgstr "faire une signature détachée"
 
-#: g10/g10.c:172
+#: g10/g10.c:171
 msgid "encrypt data"
 msgstr "chiffrer les données"
 
-#: g10/g10.c:173
+#: g10/g10.c:172
 msgid "encryption only with symmetric cipher"
 msgstr "chiffrement symétrique seulement"
 
-#: g10/g10.c:174
+#: g10/g10.c:173
 msgid "store only"
 msgstr "pas d'action"
 
-#: g10/g10.c:175
+#: g10/g10.c:174
 msgid "decrypt data (default)"
 msgstr "déchiffrer les données (défaut)"
 
-#: g10/g10.c:176
+#: g10/g10.c:175
 msgid "verify a signature"
 msgstr "vérifier une signature"
 
-#: g10/g10.c:178
+#: g10/g10.c:177
 msgid "list keys"
 msgstr "lister les clés"
 
-#: g10/g10.c:179
+#: g10/g10.c:178
 msgid "list keys and signatures"
 msgstr "lister les clés et les signatures"
 
-#: g10/g10.c:180
+#: g10/g10.c:179
 msgid "check key signatures"
 msgstr "vérifier les signatures des clés"
 
-#: g10/g10.c:181
+#: g10/g10.c:180
 msgid "list keys and fingerprints"
 msgstr "lister les clés et les empreintes"
 
-#: g10/g10.c:182
+#: g10/g10.c:181
 msgid "list secret keys"
 msgstr "lister les clés secrètes"
 
-#: g10/g10.c:184
+#: g10/g10.c:183
 msgid "generate a new key pair"
 msgstr "générer une nouvelle paire de clés"
 
-#: g10/g10.c:186
+#: g10/g10.c:185
 msgid "remove key from the public keyring"
 msgstr "enlever la clé du porte-clés public"
 
-#: g10/g10.c:188
+#: g10/g10.c:187
 msgid "sign or edit a key"
 msgstr "signer ou éditer une clé"
 
-#: g10/g10.c:189
+#: g10/g10.c:188
 msgid "generate a revocation certificate"
 msgstr "générer un certificat de révocation"
 
-#: g10/g10.c:191
+#: g10/g10.c:190
 msgid "export keys"
 msgstr "exporter les clés"
 
-#: g10/g10.c:192
+#: g10/g10.c:191
 msgid "export keys to a key server"
-msgstr ""
-
-#: g10/g10.c:193
-msgid "import keys from a key server"
-msgstr ""
+msgstr "exporter les clés vers un serveur de clés"
 
-#: g10/g10.c:196
+#: g10/g10.c:194
 msgid "import/merge keys"
 msgstr "importer/fusionner les clés"
 
-#: g10/g10.c:198
+#: g10/g10.c:196
 msgid "list only the sequence of packets"
 msgstr "ne lister que les paquets"
 
-#: g10/g10.c:201
+#: g10/g10.c:199
 msgid "export the ownertrust values"
 msgstr "exporter les indices de confiance"
 
-#: g10/g10.c:203
+#: g10/g10.c:201
 msgid "import ownertrust values"
 msgstr "importer les indices de confiance"
 
 #
-#: g10/g10.c:205
+#: g10/g10.c:203
 msgid "|[NAMES]|update the trust database"
 msgstr "|[NOMS]|mettre la base de confiance à jour"
 
-#: g10/g10.c:207
+#: g10/g10.c:205
 msgid "|[NAMES]|check the trust database"
 msgstr "|[NOMS]|vérifier la base de confiance"
 
-#: g10/g10.c:208
+#: g10/g10.c:206
 msgid "fix a corrupted trust database"
 msgstr "réparer une base de confiance corrompue"
 
-#: g10/g10.c:209
+#: g10/g10.c:207
 msgid "De-Armor a file or stdin"
 msgstr "Enlever l'armure d'un fichier ou de stdin"
 
-#: g10/g10.c:210
+#: g10/g10.c:208
 msgid "En-Armor a file or stdin"
 msgstr "Mettre une armure à un fichier ou à stdin"
 
-#: g10/g10.c:211
+#: g10/g10.c:209
 msgid "|algo [files]|print message digests"
 msgstr "|alg. [fich.]|indiquer les fonctions de hachage"
 
-#: g10/g10.c:212
+#: g10/g10.c:210
 msgid "print all message digests"
 msgstr "écrire toutes les fonctions de hachage"
 
-#: g10/g10.c:219
+#: g10/g10.c:217
 msgid ""
 "@\n"
 "Options:\n"
@@ -408,146 +402,145 @@ msgstr ""
 "Options:\n"
 " "
 
-#: g10/g10.c:221
+#: g10/g10.c:219
 msgid "create ascii armored output"
 msgstr "créer une sortie ascii armurée"
 
-#: g10/g10.c:222
-#, fuzzy
+#: g10/g10.c:220
 msgid "|NAME|encrypt for NAME"
-msgstr "|NOM|le terminal utilise la table de caractères NOM"
+msgstr "|NOM|chiffrer pour NOM"
 
-#: g10/g10.c:227
+#: g10/g10.c:225
 msgid "use this user-id to sign or decrypt"
 msgstr "utiliser ce nom pour signer ou déchiffrer"
 
-#: g10/g10.c:228
+#: g10/g10.c:226
 msgid "|N|set compress level N (0 disables)"
 msgstr "|N|niveau de compression N (0 désactive)"
 
-#: g10/g10.c:230
+#: g10/g10.c:228
 msgid "use canonical text mode"
 msgstr "utiliser le mode de texte canonique"
 
-#: g10/g10.c:232
+#: g10/g10.c:230
 msgid "use as output file"
 msgstr "utiliser comme fichier de sortie"
 
-#: g10/g10.c:233
+#: g10/g10.c:231
 msgid "verbose"
 msgstr "bavard"
 
-#: g10/g10.c:234
+#: g10/g10.c:232
 msgid "be somewhat more quiet"
 msgstr "devenir beaucoup plus silencieux"
 
 #
-#: g10/g10.c:235
+#: g10/g10.c:233
 msgid "force v3 signatures"
 msgstr "forcer les signatures en v3"
 
-#: g10/g10.c:236
+#: g10/g10.c:234
 msgid "do not make any changes"
-msgstr ""
+msgstr "ne rien changer"
 
-#: g10/g10.c:237
+#: g10/g10.c:235
 msgid "batch mode: never ask"
 msgstr "mode automatique : ne jamais rien demander"
 
-#: g10/g10.c:238
+#: g10/g10.c:236
 msgid "assume yes on most questions"
 msgstr "répondre oui à la plupart des questions"
 
-#: g10/g10.c:239
+#: g10/g10.c:237
 msgid "assume no on most questions"
 msgstr "répondre non à la plupart des questions"
 
-#: g10/g10.c:240
+#: g10/g10.c:238
 msgid "add this keyring to the list of keyrings"
 msgstr "ajouter ce porte-clés à la liste des porte-clés"
 
-#: g10/g10.c:241
+#: g10/g10.c:239
 msgid "add this secret keyring to the list"
 msgstr "ajouter ce porte-clés secret à la liste"
 
-#: g10/g10.c:242
+#: g10/g10.c:240
 msgid "|NAME|use NAME as default secret key"
 msgstr "|NOM|utiliser NOM comme clé secrète par défaut"
 
-#: g10/g10.c:243
+#: g10/g10.c:241
 msgid "|HOST|use this keyserver to lookup keys"
-msgstr ""
+msgstr "|HÔTE|utiliser ce serveur pour chercher des clés"
 
-#: g10/g10.c:244
+#: g10/g10.c:242
 msgid "|NAME|set terminal charset to NAME"
 msgstr "|NOM|le terminal utilise la table de caractères NOM"
 
-#: g10/g10.c:245
+#: g10/g10.c:243
 msgid "read options from file"
 msgstr "lire les options du fichier"
 
-#: g10/g10.c:247
+#: g10/g10.c:245
 msgid "set debugging flags"
 msgstr "choisir les attributs de déboguage"
 
-#: g10/g10.c:248
+#: g10/g10.c:246
 msgid "enable full debugging"
 msgstr "permettre un déboguage complet"
 
-#: g10/g10.c:249
+#: g10/g10.c:247
 msgid "|FD|write status info to this FD"
 msgstr "|FD|écrire l'état sur ce descripteur"
 
-#: g10/g10.c:250
+#: g10/g10.c:248
 msgid "do not write comment packets"
 msgstr "ne pas écrire de paquets de commentaire"
 
-#: g10/g10.c:251
+#: g10/g10.c:249
 msgid "(default is 1)"
 msgstr "(1 par défaut)"
 
-#: g10/g10.c:252
+#: g10/g10.c:250
 msgid "(default is 3)"
 msgstr "(3 par défaut)"
 
-#: g10/g10.c:254
+#: g10/g10.c:252
 msgid "|FILE|load extension module FILE"
 msgstr "|FICH|charger le module d'extension FICH"
 
-#: g10/g10.c:255
+#: g10/g10.c:253
 msgid "emulate the mode described in RFC1991"
 msgstr "imiter le mode décrit dans la RFC1991"
 
 # FIXMOI : faudra trouver mieux ...
-#: g10/g10.c:256
+#: g10/g10.c:254
 msgid "|N|use passphrase mode N"
 msgstr "|N|utiliser le mode de codage des mots de passe N"
 
-#: g10/g10.c:258
+#: g10/g10.c:256
 msgid "|NAME|use message digest algorithm NAME for passphrases"
 msgstr "|NOM|utiliser le hachage NOM pour les mots de passe"
 
-#: g10/g10.c:260
+#: g10/g10.c:258
 msgid "|NAME|use cipher algorithm NAME for passphrases"
 msgstr "|NOM|utiliser le chiffre NOM pour les mots de passe"
 
-#: g10/g10.c:262
+#: g10/g10.c:260
 msgid "|NAME|use cipher algorithm NAME"
 msgstr "|NOM|utiliser l'algorithme de chiffrement NOM"
 
-#: g10/g10.c:263
+#: g10/g10.c:261
 msgid "|NAME|use message digest algorithm NAME"
 msgstr "|NOM|utiliser la fonction de hachage NOM"
 
-#: g10/g10.c:264
+#: g10/g10.c:262
 msgid "|N|use compress algorithm N"
 msgstr "|N|utiliser l'algorithme de compression N"
 
-#: g10/g10.c:265
+#: g10/g10.c:263
 msgid "throw keyid field of encrypted packets"
 msgstr "supprimer l'identification des paquets chiffrés"
 
-#: g10/g10.c:273
+#: g10/g10.c:271
 msgid ""
 "@\n"
 "Examples:\n"
@@ -561,26 +554,26 @@ msgstr ""
 "@\n"
 "Exemples:\n"
 "\n"
-" -se -r Alice [fichier]       signer et crypter pour l'utilisateur Alice\n"
+" -se -r Alice [fichier]       signer et chiffrer pour l'utilisateur Alice\n"
 " --clearsign [fichier]        faire une signature en texte clair\n"
 " --detach-sign [fichier]      faire une signature détachée\n"
 " --list-keys [utilisateur]    montrer les clés\n"
 " --fingerprint [utilisateur]  montrer les empreintes\n"
 
-#: g10/g10.c:353
+#: g10/g10.c:351
 msgid "Please report bugs to <gnupg-bugs@gnu.org>.\n"
 msgstr "Rapporter toutes anomalies à <gnupg-bugs@gnu.org>.\n"
 
-#: g10/g10.c:358
+#: g10/g10.c:356
 msgid "Usage: gpgm [options] [files] (-h for help)"
 msgstr "Utilisation: gpgm [options] [fichiers] (-h pour l'aide)"
 
-#: g10/g10.c:360
+#: g10/g10.c:358
 msgid "Usage: gpg [options] [files] (-h for help)"
 msgstr "Utilisation: gpg [options] [fichiers] (-h pour l'aide)"
 
 #
-#: g10/g10.c:365
+#: g10/g10.c:363
 msgid ""
 "Syntax: gpgm [options] [files]\n"
 "GnuPG maintenance utility\n"
@@ -588,17 +581,17 @@ msgstr ""
 "Syntaxe: gpgm [options] [fichiers]\n"
 "utilitaire de maitenance de GnuPG\n"
 
-#: g10/g10.c:368
+#: g10/g10.c:366
 msgid ""
 "Syntax: gpg [options] [files]\n"
 "sign, check, encrypt or decrypt\n"
 "default operation depends on the input data\n"
 msgstr ""
 "Syntaxe: gpg [options] [fichiers]\n"
-"signer, vérifier, crypter ou décrypter\n"
+"signer, vérifier, chiffer ou déchiffrer\n"
 "l'opération par défaut dépend des données entrées\n"
 
-#: g10/g10.c:374
+#: g10/g10.c:372
 msgid ""
 "\n"
 "Supported algorithms:\n"
@@ -606,149 +599,149 @@ msgstr ""
 "\n"
 "Algorithmes supportés:\n"
 
-#: g10/g10.c:449
+#: g10/g10.c:447
 msgid "usage: gpgm [options] "
 msgstr "utilisation: gpgm [options] "
 
-#: g10/g10.c:451
+#: g10/g10.c:449
 msgid "usage: gpg [options] "
 msgstr "utilisation: gpg [options] "
 
-#: g10/g10.c:492
+#: g10/g10.c:490
 msgid "conflicting commands\n"
 msgstr "commandes en conflit\n"
 
-#: g10/g10.c:631
+#: g10/g10.c:629
 #, c-format
 msgid "NOTE: no default option file `%s'\n"
 msgstr "NOTE : pas de fichier d'options par défaut `%s'\n"
 
-#: g10/g10.c:635
+#: g10/g10.c:633
 #, c-format
 msgid "option file `%s': %s\n"
 msgstr "fichier d'options `%s' : %s\n"
 
-#: g10/g10.c:642
+#: g10/g10.c:640
 #, c-format
 msgid "reading options from `%s'\n"
 msgstr "lire les options de `%s'\n"
 
-#: g10/g10.c:797
+#: g10/g10.c:794
 #, c-format
 msgid "%s is not a valid character set\n"
 msgstr "%s n'est pas une table de caractères valide\n"
 
-#: g10/g10.c:838 g10/g10.c:850
+#: g10/g10.c:835 g10/g10.c:847
 msgid "selected cipher algorithm is invalid\n"
 msgstr "l'algorithme de chiffrement sélectionné est invalide\n"
 
-#: g10/g10.c:844 g10/g10.c:856
+#: g10/g10.c:841 g10/g10.c:853
 msgid "selected digest algorithm is invalid\n"
 msgstr "la fonction de hachage sélectionnée est invalide\n"
 
-#: g10/g10.c:859
+#: g10/g10.c:856
 #, c-format
 msgid "compress algorithm must be in range %d..%d\n"
 msgstr "l'algorithme de compression doit faire partie de l'échelle %d..%d\n"
 
-#: g10/g10.c:861
+#: g10/g10.c:858
 msgid "completes-needed must be greater than 0\n"
 msgstr "« completes-needed » doit être supérieur à 0\n"
 
-#: g10/g10.c:863
+#: g10/g10.c:860
 msgid "marginals-needed must be greater than 1\n"
 msgstr "« marginals-needed » doit être supérieur à 1\n"
 
-#: g10/g10.c:865
+#: g10/g10.c:862
 msgid "max-cert-depth must be in range 1 to 255\n"
 msgstr "« max-cert-depth » doit être compris entre 1 et 255\n"
 
-#: g10/g10.c:868
+#: g10/g10.c:865
 msgid "NOTE: simple S2K mode (0) is strongly discouraged\n"
 msgstr "NOTE : le mode S2K simple (0) est fortement déconseillé\n"
 
-#: g10/g10.c:872
+#: g10/g10.c:869
 msgid "invalid S2K mode; must be 0, 1 or 3\n"
 msgstr "mode S2K invalide ; doit être 0, 1 ou 3\n"
 
-#: g10/g10.c:949
+#: g10/g10.c:946
 #, c-format
 msgid "failed to initialize the TrustDB: %s\n"
 msgstr "n'a pas pu initialiser la base de confiance : %s\n"
 
-#: g10/g10.c:955
+#: g10/g10.c:952
 msgid "--store [filename]"
 msgstr "--store [nom du fichier]"
 
-#: g10/g10.c:963
+#: g10/g10.c:960
 msgid "--symmetric [filename]"
 msgstr "--symmetric [nom du fichier]"
 
-#: g10/g10.c:971
+#: g10/g10.c:968
 msgid "--encrypt [filename]"
 msgstr "--encrypt [nom du fichier]"
 
-#: g10/g10.c:984
+#: g10/g10.c:981
 msgid "--sign [filename]"
 msgstr "--sign [nom du fichier]"
 
-#: g10/g10.c:997
+#: g10/g10.c:994
 msgid "--sign --encrypt [filename]"
 msgstr "--sign --encrypt [nom du fichier]"
 
-#: g10/g10.c:1011
+#: g10/g10.c:1008
 msgid "--clearsign [filename]"
 msgstr "--clearsign [nom du fichier]"
 
-#: g10/g10.c:1023
+#: g10/g10.c:1020
 msgid "--decrypt [filename]"
 msgstr "--decrypt [nom du fichier]"
 
-#: g10/g10.c:1032
+#: g10/g10.c:1029
 msgid "--edit-key username [commands]"
 msgstr "--edit-key utilisateur [commandes]"
 
-#: g10/g10.c:1048
+#: g10/g10.c:1045
 msgid "--delete-secret-key username"
 msgstr "--delete-secret-key utilisateur"
 
-#: g10/g10.c:1051
+#: g10/g10.c:1048
 msgid "--delete-key username"
 msgstr "--delete-key utilisateur"
 
-#: g10/encode.c:229 g10/g10.c:1074 g10/sign.c:311
+#: g10/encode.c:229 g10/g10.c:1071 g10/sign.c:311
 #, c-format
 msgid "can't open %s: %s\n"
 msgstr "ne peut ouvrir %s: %s\n"
 
-#: g10/g10.c:1085
+#: g10/g10.c:1082
 msgid "-k[v][v][v][c] [userid] [keyring]"
 msgstr "-k[v][v][v][c] [utilisateur] [porte-clés]"
 
-#: g10/g10.c:1149
+#: g10/g10.c:1143
 #, c-format
 msgid "dearmoring failed: %s\n"
 msgstr "suppression d'armure non réussie : %s\n"
 
-#: g10/g10.c:1157
+#: g10/g10.c:1151
 #, c-format
 msgid "enarmoring failed: %s\n"
 msgstr "construction d'armure non réussie : %s \n"
 
-#: g10/g10.c:1223
+#: g10/g10.c:1217
 #, c-format
 msgid "invalid hash algorithm `%s'\n"
 msgstr "algorithme de hachage `%s' invalide\n"
 
-#: g10/g10.c:1302
+#: g10/g10.c:1296
 msgid "[filename]"
 msgstr "[nom du fichier]"
 
-#: g10/g10.c:1306
+#: g10/g10.c:1300
 msgid "Go ahead and type your message ...\n"
 msgstr "Continuez et tapez votre message...\n"
 
-#: g10/decrypt.c:59 g10/g10.c:1309 g10/verify.c:66
+#: g10/decrypt.c:59 g10/g10.c:1303 g10/verify.c:66
 #, c-format
 msgid "can't open `%s'\n"
 msgstr "ne peut ouvrir `%s'\n"
@@ -778,53 +771,55 @@ msgstr "signatures en texte clair imbriqu
 msgid "invalid dash escaped line: "
 msgstr "ligne de traits d'échappement invalide : "
 
-#: g10/armor.c:511
+#: g10/armor.c:507
 msgid "unexpected armor:"
 msgstr "armure inattendue :"
 
-#: g10/armor.c:628
+#: g10/armor.c:623
 #, c-format
 msgid "invalid radix64 character %02x skipped\n"
 msgstr "caractère %02x invalide en base 64 ignoré\n"
 
-#: g10/armor.c:671
+#: g10/armor.c:666
 msgid "premature eof (no CRC)\n"
 msgstr "fin de fichier prématurée (pas de CRC)\n"
 
-#: g10/armor.c:705
+#: g10/armor.c:700
 msgid "premature eof (in CRC)\n"
 msgstr "fin de fichier prématurée (dans le CRC)\n"
 
-#: g10/armor.c:709
+#: g10/armor.c:704
 msgid "malformed CRC\n"
 msgstr "CRC malformé\n"
 
-#: g10/armor.c:713
+#: g10/armor.c:708
 #, c-format
 msgid "CRC error; %06lx - %06lx\n"
 msgstr "Erreur de CRC ; %06lx - %06lx\n"
 
-#: g10/armor.c:730
+#: g10/armor.c:725
 msgid "premature eof (in Trailer)\n"
 msgstr "fin de fichier prématurée (dans la remorque)\n"
 
-#: g10/armor.c:734
+#: g10/armor.c:729
 msgid "error in trailer line\n"
 msgstr "erreur dans la ligne de remorque\n"
 
-#: g10/armor.c:998
+#: g10/armor.c:993
 msgid "no valid OpenPGP data found.\n"
 msgstr "aucune de donnée OpenPGP valide n'a été trouvée.\n"
 
-#: g10/armor.c:1002
+#: g10/armor.c:997
 #, c-format
 msgid "invalid armor: line longer than %d characters\n"
 msgstr "armure invalide : ligne plus longue que %d caractères\n"
 
-#: g10/armor.c:1006
+#: g10/armor.c:1001
 msgid ""
 "quoted printable character in armor - probably a buggy MTA has been used\n"
 msgstr ""
+"caractère cité-imprimable (quoted-printable) dans l'armure provenant\n"
+"certainement d'un agent de transfert de messages bogué\n"
 
 #: g10/pkclist.c:137
 #, c-format
@@ -1135,8 +1130,8 @@ msgid ""
 "Okay, but keep in mind that your monitor and keyboard radiation is also very "
 "vulnerable to attacks!\n"
 msgstr ""
-"D'accord, mais n'oubliez pas que votre écran et les radiations du clavier\n"
-"sont aussi très vulnérables aux attaques!\n"
+"D'accord, mais n'oubliez pas que les radiations de votre écran et de votre\n"
+"clavier sont aussi très vulnérables aux attaques !\n"
 
 #: g10/keygen.c:471
 msgid "Do you really need such a large keysize? "
@@ -1218,7 +1213,6 @@ msgstr "Caract
 msgid "Name may not start with a digit\n"
 msgstr "Le nom ne doit pas commencer avec un chiffre\n"
 
-# ??? c'est de la discrimination...
 #: g10/keygen.c:602
 msgid "Name must be at least 5 characters long\n"
 msgstr "Le nom doit faire au moins 5 caractères de long\n"
@@ -1242,7 +1236,7 @@ msgstr "Caract
 #: g10/keygen.c:657
 #, c-format
 msgid "You are using the `%s' character set.\n"
-msgstr ""
+msgstr "Vous utilisez le jeu de caractères '%s'.\n"
 
 #: g10/keygen.c:663
 #, c-format
@@ -1273,7 +1267,7 @@ msgstr ""
 
 #: g10/keyedit.c:421 g10/keygen.c:736
 msgid "passphrase not correctly repeated; try again.\n"
-msgstr "le mot de passe n'a pas été identiquement répété ; recommencez.\n"
+msgstr "le mot de passe n'a pas été répété à l'identique ; recommencez.\n"
 
 #: g10/keygen.c:742
 msgid ""
@@ -1288,18 +1282,16 @@ msgstr ""
 "\n"
 
 #: g10/keygen.c:763
-#, fuzzy
 msgid ""
 "We need to generate a lot of random bytes. It is a good idea to perform\n"
 "some other action (type on the keyboard, move the mouse, utilize the\n"
-"the disks) during the prime generation; this gives the random\n"
-"number generator a better chance to gain enough entropy.\n"
+"disks) during the prime generation; this gives the random number\n"
+"generator a better chance to gain enough entropy.\n"
 msgstr ""
-"Un grand nombre d'octets aléatoires doit être généré. Vous devriez\n"
-"faire autre-chose (travailler dans une autre fenêtre, déplacer la\n"
-"souris, utiliser le réseau et les disques) pendant la génération de nombres\n"
-"premiers ; cela donne au générateur de nombres aléatoires une meilleure\n"
-"chance d'avoir assez d'entropie.\n"
+"Un grand nombre d'octets aléatoires doit être généré. Vous devriez faire\n"
+"autre-chose (taper au clavier, déplacer la souris, utiliser les disques)\n"
+"pendant la génération de nombres premiers ; cela donne au générateur de\n"
+"nombres aléatoires une meilleure chance d'avoir assez d'entropie.\n"
 
 #: g10/keygen.c:833
 msgid "Key generation can only be used in interactive mode\n"
@@ -1328,13 +1320,12 @@ msgid "public and secret key created and signed.\n"
 msgstr "les clés publique et secrète ont été créées et signées.\n"
 
 #: g10/keygen.c:937
-#, fuzzy
 msgid ""
 "Note that this key cannot be used for encryption.  You may want to use\n"
 "the command \"--edit-key\" to generate a secondary key for this purpose.\n"
 msgstr ""
 "Notez que cette clé ne peut être utilisée pour chiffrer. Vous pouvez\n"
-"utiliser la commande « --add-key » pour générer une clé secondaire à\n"
+"utiliser la commande « --edit-key » pour générer une clé secondaire à\n"
 "cette fin.\n"
 
 #: g10/keygen.c:951 g10/keygen.c:1050
@@ -1342,17 +1333,22 @@ msgstr ""
 msgid "Key generation failed: %s\n"
 msgstr "La génération de clé a échoué : %s\n"
 
+# on s'amuse comme on peut...
 #: g10/keygen.c:995 g10/sig-check.c:212 g10/sign.c:52
-#, fuzzy, c-format
+#, c-format
 msgid ""
 "key has been created %lu second in future (time warp or clock problem)\n"
-msgstr "clé publique créée %lu %s dans le futur\n"
+msgstr ""
+"la clé a été créée %lu seconde dans le futur (discontinuité temporelle ou\n"
+"problème d'horloge)\n"
 
 #: g10/keygen.c:997 g10/sig-check.c:214 g10/sign.c:54
-#, fuzzy, c-format
+#, c-format
 msgid ""
 "key has been created %lu seconds in future (time warp or clock problem)\n"
-msgstr "clé publique créée %lu %s dans le futur\n"
+msgstr ""
+"la clé a été créée %lu secondes dans le futur (discontinuité temporelle ou\n"
+"problème d'horloge\n"
 
 #: g10/keygen.c:1028
 msgid "Really create? "
@@ -1655,14 +1651,14 @@ msgid "key %08lX: invalid self-signature\n"
 msgstr "clé %08lX : auto-signature invalide\n"
 
 #: g10/import.c:719
-#, fuzzy, c-format
+#, c-format
 msgid "key %08lX: no subkey for key binding\n"
-msgstr "clé %08lX.%lu : bonne liaison avec la sous-clé\n"
+msgstr "clé %08lX : pas de sous-clé pour relier la clé\n"
 
 #: g10/import.c:728
-#, fuzzy, c-format
+#, c-format
 msgid "key %08lX: invalid subkey binding\n"
-msgstr "clé %08lX.%lu : liaison avec la sous-clé invalide : %s\n"
+msgstr "clé %08lX : liaison avec la sous-clé invalide\n"
 
 #: g10/import.c:760
 #, c-format
@@ -1670,14 +1666,14 @@ msgid "key %08lX: skipped userid '"
 msgstr "clé %08lX : utilisateur non pris en compte '"
 
 #: g10/import.c:780
-#, fuzzy, c-format
+#, c-format
 msgid "key %08lX: skipped subkey\n"
-msgstr "clé %08lX : une nouvelle sous-clé\n"
+msgstr "clé %08lX : sous-clé non prise en compte\n"
 
 #: g10/import.c:800
-#, fuzzy, c-format
+#, c-format
 msgid "key %08lX: non exportable signature (class %02x) - skipped\n"
-msgstr "clé %08lX : certificat de révocation au mauvais endroit - ignorée\n"
+msgstr "clé %08lX : signature non exportable (classe %02x) - ignorée\n"
 
 #: g10/import.c:809
 #, c-format
@@ -1767,6 +1763,8 @@ msgid ""
 "The signature will be marked as non-exportable.\n"
 "\n"
 msgstr ""
+"La signature sera marquée comme non-exportable.\n"
+"\n"
 
 #: g10/keyedit.c:309
 msgid "Really sign? "
@@ -1904,14 +1902,12 @@ msgid "s"
 msgstr "s"
 
 #: g10/keyedit.c:537
-#, fuzzy
 msgid "lsign"
-msgstr "signer"
+msgstr "lsigner"
 
 #: g10/keyedit.c:537
-#, fuzzy
 msgid "sign the key locally"
-msgstr "signer la clé"
+msgstr "signer la clé localement"
 
 #: g10/keyedit.c:538
 msgid "debug"
@@ -2113,9 +2109,9 @@ msgid "No secondary key with index %d\n"
 msgstr "Pas de clé secondaire avec l'index %d\n"
 
 #: g10/mainproc.c:184
-#, fuzzy, c-format
+#, c-format
 msgid "public key is %08lX\n"
-msgstr "clé publique non trouvée"
+msgstr "la clé publique est %08lX\n"
 
 #: g10/mainproc.c:212
 msgid "public key encrypted data: good DEK\n"
@@ -2167,9 +2163,8 @@ msgid "Good signature from \""
 msgstr "Bonne signature de \""
 
 #: g10/mainproc.c:884
-#, fuzzy
 msgid "                aka \""
-msgstr "                      importée : %lu"
+msgstr "              alias \""
 
 #: g10/mainproc.c:930
 #, c-format
@@ -2299,24 +2294,24 @@ msgstr "Mot de passe invalide ; r
 
 #: g10/seckey-cert.c:232
 msgid "WARNING: Weak key detected - please change passphrase again.\n"
-msgstr "ATTENTION : Mauvaise clé détectée - changez encore le mot de passe.\n"
+msgstr "ATTENTION : Clé faible détectée - changez encore le mot de passe.\n"
 
 #: g10/sig-check.c:195
 msgid ""
 "this is a PGP generated ElGamal key which is NOT secure for signatures!\n"
 msgstr ""
 "Ceci est une clé ElGamal générée par PGP qui n'est PAS sûre pour les\n"
-"signatures!\n"
+"signatures !\n"
 
 #: g10/sig-check.c:203
-#, fuzzy, c-format
+#, c-format
 msgid "public key is %lu second newer than the signature\n"
-msgstr "lid %lu : utilisateur sans signature\n"
+msgstr "la clé publique est plus récente de %lu seconde que la signature\n"
 
 #: g10/sig-check.c:204
-#, fuzzy, c-format
+#, c-format
 msgid "public key is %lu seconds newer than the signature\n"
-msgstr "lid %lu : utilisateur sans signature\n"
+msgstr "la clé publique est plus récente de %lu secondes que la signature\n"
 
 #: g10/sig-check.c:220
 #, c-format
@@ -2349,14 +2344,14 @@ msgid "WARNING: `%s' is an empty file\n"
 msgstr "ATTENTION : `%s' est un fichier vide\n"
 
 #: g10/textfilter.c:122
-#, fuzzy, c-format
+#, c-format
 msgid "can't handle text lines longer than %d characters\n"
-msgstr "armure invalide : ligne plus longue que %d caractères\n"
+msgstr "ne peut pas traiter les ligne plus longues que %d caractères\n"
 
 #: g10/textfilter.c:189
-#, fuzzy, c-format
+#, c-format
 msgid "input line longer than %d characters\n"
-msgstr "armure invalide : ligne plus longue que %d caractères\n"
+msgstr "la ligne d'entrée est plus longue que %d caractères\n"
 
 #: g10/tdbio.c:116 g10/tdbio.c:1504
 #, c-format
@@ -2400,9 +2395,9 @@ msgid "%s: can't create: %s\n"
 msgstr "%s : ne peut créer : %s\n"
 
 #: g10/tdbio.c:472 g10/tdbio.c:520
-#, fuzzy, c-format
+#, c-format
 msgid "%s: can't create lock\n"
-msgstr "%s : ne peut créer : %s\n"
+msgstr "%s : ne peut créer de verrouillage\n"
 
 #: g10/tdbio.c:486
 #, c-format
@@ -2725,14 +2720,12 @@ msgstr ""
 "supportés\n"
 
 #: g10/trustdb.c:1654
-#, fuzzy
 msgid "duplicated certificate - deleted"
-msgstr "Certificat dupliqué - enlevé"
+msgstr "certificat dupliqué - supprimé"
 
 #: g10/trustdb.c:1692
-#, fuzzy
 msgid "public key not anymore available"
-msgstr "la clé secrète n'est pas disponible"
+msgstr "la clé secrète n'est plus disponible"
 
 #: g10/trustdb.c:1702 g10/trustdb.c:1791
 msgid "Invalid certificate revocation"
@@ -2945,6 +2938,8 @@ msgstr "R
 #: g10/skclist.c:88 g10/skclist.c:125
 msgid "key is not flagged as insecure - can't use it with the faked RNG!\n"
 msgstr ""
+"la clé n'est pas marquée comme non-sûre ; on ne peut pas l'utiliser avec le\n"
+"pseudo-générateur de nombres aléatiores !\n"
 
 #: g10/skclist.c:113
 #, c-format
@@ -2998,28 +2993,28 @@ msgstr "chiffr
 msgid ""
 "WARNING: message was encrypted with a weak key in the symmetric cipher.\n"
 msgstr ""
-"ATTENTION : Le message a été chiffré avec une mauvaise clé pendant le\n"
+"ATTENTION : Le message a été chiffré avec une clé faible pendant le\n"
 "chiffrement symétrique.\n"
 
 #: g10/seskey.c:52
 msgid "weak key created - retrying\n"
-msgstr "mauvaise clé générée - nouvel essai\n"
+msgstr "clé faible générée - nouvel essai\n"
 
 #: g10/seskey.c:57
 #, c-format
 msgid "cannot avoid weak key for symmetric cipher; tried %d times!\n"
 msgstr ""
-"ne peut éviter une mauvaise clé pour le chiffrement symétrique : \n"
-"%d essais ont eu lieu!\n"
+"ne peut éviter une clé faible pour le chiffrement symétrique :\n"
+"%d essais ont eu lieu !\n"
 
 #. begin of list
 #: g10/helptext.c:48
 msgid "edit_ownertrust.value"
 msgstr ""
 "C'est à vous d'assigner une valeur ici ; cette valeur ne sera jamais\n"
-"einvoyée à une tierce personne. Nous en avons besoin pour créer le\n"
-"réseau de confiance (web-of-trust) ; cela n'a rien à voir avec le\n"
-"réseau des certificats (créé implicitement)"
+"envoyée à une tierce personne. Nous en avons besoin pour créer le réseau de\n"
+"confiance (web-of-trust) ; cela n'a rien à voir avec le réseau des\n"
+"certificats (créé implicitement)"
 
 #: g10/helptext.c:54
 msgid "revoked_key.override"
@@ -3167,97 +3162,3 @@ msgstr "Pas d'aide disponible"
 #, c-format
 msgid "No help available for `%s'"
 msgstr "Pas d'aide disponible pour `%s'"
-
-#~ msgid "|KEYID|ulimately trust this key"
-#~ msgstr "|ID CLE|donner une confiance totale à cette clé"
-
-#~ msgid "chained sigrec %lu has a wrong owner\n"
-#~ msgstr "l'enregistrement de signature %lu a un mauvais propriétaire\n"
-
-#~ msgid "'%s' is not a valid long keyID\n"
-#~ msgstr "'%s' n'est pas une identification longue de clé valide\n"
-
-#~ msgid "key %08lX: no public key for trusted key - skipped\n"
-#~ msgstr "clé %08lX : pas de clé publique pour la clé certifiée - ignorée\n"
-
-#~ msgid "lid %lu: read dir record failed: %s\n"
-#~ msgstr "lid %lu : la lecture d'enregistrement de répertoire a échoué : %s\n"
-
-#~ msgid "lid %lu: read key record failed: %s\n"
-#~ msgstr "lid %lu : la lecture de l''enregistrement de clé a échoué : %s\n"
-
-#~ msgid "lid %lu: read uid record failed: %s\n"
-#~ msgstr "lid %lu : la lecture d'enregistrement d'uid a échoué : %s\n"
-
-#~ msgid "lid %lu: read pref record failed: %s\n"
-#~ msgstr ""
-#~ "lid %lu : la lecture d'enregistrement de préférences a échoué : %s\n"
-
-#~ msgid "lid %lu: read sig record failed: %s\n"
-#~ msgstr "lid %lu : la lecture d'enregistrement de signature a échoué : %s\n"
-
-#~ msgid "user '%s' read problem: %s\n"
-#~ msgstr "problème de lecture de l'utilisateur '%s' : %s\n"
-
-#~ msgid "user '%s' list problem: %s\n"
-#~ msgstr "problème de liste à l'utilisateur '%s' : %s\n"
-
-#~ msgid "user '%s' not in trustdb\n"
-#~ msgstr "l'utilisateur '%s' n'est pas dans la base de confiance\n"
-
-#~ msgid ""
-#~ "# List of assigned trustvalues, created %s\n"
-#~ "# (Use \"gpgm --import-ownertrust\" to restore them)\n"
-#~ msgstr ""
-#~ "# Liste des indices de confiance assignés, créée le %s\n"
-#~ "# (Utiliser « gpgm --import-ownertrust » pour les restaurer)\n"
-
-#~ msgid "directory record w/o primary key\n"
-#~ msgstr "enregistrement de répertoire sans clé principale\n"
-
-#~ msgid "error reading key record: %s\n"
-#~ msgstr "erreur pendant la lecture de l'enregistrement de clé : %s\n"
-
-#~ msgid "line too long\n"
-#~ msgstr "ligne trop longue\n"
-
-#~ msgid "error: missing colon\n"
-#~ msgstr "erreur : deux-points manquant\n"
-
-#~ msgid "error: invalid fingerprint\n"
-#~ msgstr "erreur : empreinte digitale invalide\n"
-
-#~ msgid "error: no ownertrust value\n"
-#~ msgstr "erreur : pas d'indice de confiance\n"
-
-#~ msgid "key not in trustdb, searching ring.\n"
-#~ msgstr ""
-#~ "la clé n'est pas dans la base de confiance, recherche du porte-clés.\n"
-
-#~ msgid "key not in ring: %s\n"
-#~ msgstr "clé absente du porte-clés : %s\n"
-
-#~ msgid "Oops: key is now in trustdb???\n"
-#~ msgstr "Oops : la clé est maintenant dans la base de confiance ???\n"
-
-#~ msgid "insert trust record failed: %s\n"
-#~ msgstr "l'insertion d'enregistrement de confiance a échoué : %s\n"
-
-#~ msgid "error finding dir record: %s\n"
-#~ msgstr ""
-#~ "erreur pendant la recherche de l'enregistrement de répertoire : %s\n"
-
-#~ msgid "Hmmm, public key lost?"
-#~ msgstr "Hmmm, clé publique perdue ?"
-
-#~ msgid "did not use primary key for insert_trust_record()\n"
-#~ msgstr "n'a pas utilisé la clé principale pour « insert_trust_record() »\n"
-
-#~ msgid "use this user-id for encryption"
-#~ msgstr "utiliser ce nom d'utilisateur pour chiffrer"
-
-#~ msgid "second"
-#~ msgstr "seconde"
-
-#~ msgid "seconds"
-#~ msgstr "secondes"