From 9f40263e56cc9ebe28016bb4588da3846342ba79 Mon Sep 17 00:00:00 2001 From: Werner Koch Date: Wed, 7 Apr 1999 18:58:34 +0000 Subject: [PATCH] See ChangeLog: Wed Apr 7 20:51:39 CEST 1999 Werner Koch --- ChangeLog | 5 + Makefile.am | 22 +- NEWS | 4 + TODO | 8 +- VERSION | 2 +- checks/conventional.test | 19 +- cipher/ChangeLog | 9 + cipher/Makefile.am | 11 +- cipher/blowfish.h | 10 + cipher/cipher.c | 22 ++ cipher/twofish.c | 486 ++++++++++++++++++++++++++------------ configure.in | 40 +++- debian/changelog | 15 +- debian/control | 2 +- doc/gpg.1pod | 9 +- g10/ChangeLog | 15 ++ g10/cipher.c | 19 +- g10/decrypt.c | 2 +- g10/encr-data.c | 19 +- g10/g10.c | 1 + g10/import.c | 5 +- g10/keygen.c | 18 +- g10/misc.c | 3 +- g10/parse-packet.c | 1 - g10/ringedit.c | 20 +- g10/seckey-cert.c | 7 +- mpi/ChangeLog | 4 + mpi/Makefile.am | 12 +- po/ChangeLog | 4 + po/fr.po | 497 ++++++++++++++++----------------------- 30 files changed, 771 insertions(+), 520 deletions(-) diff --git a/ChangeLog b/ChangeLog index d1f3ec144..4fb2beea0 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,8 @@ +Wed Apr 7 20:51:39 CEST 1999 Werner Koch + + * Makefile.am (g10defs.h): Removed. + * configure.in (AC_OUTPUT_COMMANDS): Create g10defs.h + Sat Mar 20 12:55:33 CET 1999 Werner Koch * VERSION: Now 0.9.5 diff --git a/Makefile.am b/Makefile.am index b06903ca1..1651d0a49 100644 --- a/Makefile.am +++ b/Makefile.am @@ -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 c6c57708a..03e41cd55 100644 --- 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 63df5accd..356b2893f 100644 --- 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. @@ -26,9 +24,15 @@ * 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 c726cf3a8..278046e3f 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.9.5a +0.9.5b diff --git a/checks/conventional.test b/checks/conventional.test index 5492ac988..6f78b0191 100755 --- a/checks/conventional.test +++ b/checks/conventional.test @@ -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 diff --git a/cipher/ChangeLog b/cipher/ChangeLog index b1000c8f7..4ecdbc488 100644 --- a/cipher/ChangeLog +++ b/cipher/ChangeLog @@ -1,3 +1,12 @@ +Wed Apr 7 20:51:39 CEST 1999 Werner Koch + + * 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 * random.c (get_random_bits): Can now handle requests > POOLSIZE diff --git a/cipher/Makefile.am b/cipher/Makefile.am index ba237bf6d..f42d682ac 100644 --- a/cipher/Makefile.am +++ b/cipher/Makefile.am @@ -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 diff --git a/cipher/blowfish.h b/cipher/blowfish.h index 827baa141..7c34bab3c 100644 --- a/cipher/blowfish.h +++ b/cipher/blowfish.h @@ -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*/ diff --git a/cipher/cipher.c b/cipher/cipher.c index 338b2b9d2..0306c378d 100644 --- a/cipher/cipher.c +++ b/cipher/cipher.c @@ -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; diff --git a/cipher/twofish.c b/cipher/twofish.c index d1e171bad..94a31de71 100644 --- a/cipher/twofish.c +++ b/cipher/twofish.c @@ -1,5 +1,6 @@ /* Twofish for GPG * By Matthew Skala , 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) + 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) -/* 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); + if (keylen == 32) { /* 256-bit key */ - /* 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); + /* 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); } -/* 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; } -/* 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 */ -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. diff --git a/configure.in b/configure.in index e4760fbd5..a792ec00c 100644 --- a/configure.in +++ b/configure.in @@ -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 <cipher/construct.c +cat <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 <>cipher/construct.c +cat <>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 </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 diff --git a/debian/changelog b/debian/changelog index 6d71f15cf..ad0164818 100644 --- a/debian/changelog +++ b/debian/changelog @@ -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 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 Mon, 8 Mar 1999 19:58:28 +0100 +gnupg (0.9.3-1) unstable; urgency=low + + * New upstream version. + + -- James Troup Mon, 22 Feb 1999 22:55:04 +0000 + gnupg (0.9.2-1) unstable; urgency=low * New version. diff --git a/debian/control b/debian/control index dfb4546c1..9e900f8d4 100644 --- a/debian/control +++ b/debian/control @@ -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. . diff --git a/doc/gpg.1pod b/doc/gpg.1pod index 644f4c8b7..fee6d588d 100644 --- a/doc/gpg.1pod +++ b/doc/gpg.1pod @@ -13,7 +13,7 @@ B [--homedir name] [--options file] [options] command [args] B is the main program for the GnuPG system. B is a maintenance tool which has some commands B 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] Decrypt file (or stdin if no file is specified) and @@ -50,7 +50,7 @@ B<--decrypt> [I] message. B<--verify> [[I] {I}] - Assume that I is a signature and verify it + Assume that I 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] [I] B<-kvc> List fingerprints B<-kvvc> List fingerprints and signatures + B + B<--list-keys> [I] +B<--list-public-keys> [I] List all keys from the public keyrings, or just the ones given on the command line. diff --git a/g10/ChangeLog b/g10/ChangeLog index 91a45a931..c2885b4e1 100644 --- a/g10/ChangeLog +++ b/g10/ChangeLog @@ -1,3 +1,18 @@ +Wed Apr 7 20:51:39 CEST 1999 Werner Koch + + * 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 * armor.c: Removed duped include (John Bley) diff --git a/g10/cipher.c b/g10/cipher.c index 0d6e54ff2..98c5e8403 100644 --- a/g10/cipher.c +++ b/g10/cipher.c @@ -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; } diff --git a/g10/decrypt.c b/g10/decrypt.c index f59f2a546..3d223eadd 100644 --- a/g10/decrypt.c +++ b/g10/decrypt.c @@ -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. diff --git a/g10/encr-data.c b/g10/encr-data.c index c5967c23b..8ae6949d8 100644 --- a/g10/encr-data.c +++ b/g10/encr-data.c @@ -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; } diff --git a/g10/g10.c b/g10/g10.c index 5ec1a013c..7e98f1e29 100644 --- 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")}, diff --git a/g10/import.c b/g10/import.c index deab7f4bd..5a739b922 100644 --- a/g10/import.c +++ b/g10/import.c @@ -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; } diff --git a/g10/keygen.c b/g10/keygen.c index 7fcd86453..6637d95e4 100644 --- a/g10/keygen.c +++ b/g10/keygen.c @@ -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, diff --git a/g10/misc.c b/g10/misc.c index 09811ae4e..47420638d 100644 --- a/g10/misc.c +++ b/g10/misc.c @@ -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 { diff --git a/g10/parse-packet.c b/g10/parse-packet.c index 40c737c39..bf22f10dc 100644 --- a/g10/parse-packet.c +++ b/g10/parse-packet.c @@ -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 ) { diff --git a/g10/ringedit.c b/g10/ringedit.c index b61aa9b94..30e30cefe 100644 --- a/g10/ringedit.c +++ b/g10/ringedit.c @@ -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; diff --git a/g10/seckey-cert.c b/g10/seckey-cert.c index 7f0d41e33..4ee0485ca 100644 --- a/g10/seckey-cert.c +++ b/g10/seckey-cert.c @@ -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, diff --git a/mpi/ChangeLog b/mpi/ChangeLog index 71fedb1ab..c4e214e08 100644 --- a/mpi/ChangeLog +++ b/mpi/ChangeLog @@ -1,3 +1,7 @@ +Wed Apr 7 20:51:39 CEST 1999 Werner Koch + + * Makefile.am: Explicit rules to invoke cpp on *.S + Mon Mar 8 20:47:17 CET 1999 Werner Koch * config.links: Take advantage of the with_symbol_underscore macro. diff --git a/mpi/Makefile.am b/mpi/Makefile.am index 6fb7adda0..2f743093e 100644 --- a/mpi/Makefile.am +++ b/mpi/Makefile.am @@ -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 + diff --git a/po/ChangeLog b/po/ChangeLog index 53d9a4f33..bdfafcab2 100644 --- a/po/ChangeLog +++ b/po/ChangeLog @@ -1,3 +1,7 @@ +Wed Apr 7 20:51:39 CEST 1999 Werner Koch + + * fr.po: Imported new version. + Wed Feb 24 11:07:27 CET 1999 Werner Koch * de.po: Imported update for 0.9.3 diff --git a/po/fr.po b/po/fr.po index 225496a34..63cb38a8b 100644 --- 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 , 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 \n" "Language-Team: French \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 "" +msgstr "exporter les clés vers un serveur de clés" -#: g10/g10.c:193 -msgid "import keys from a key server" -msgstr "" - -#: 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 .\n" msgstr "Rapporter toutes anomalies à .\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"