RPM Package Manager, CVS Repository http://rpm5.org/cvs/ ____________________________________________________________________________
Server: rpm5.org Name: Jeff Johnson Root: /v/rpm/cvs Email: [email protected] Module: rpm Date: 12-Jun-2010 16:32:08 Branch: HEAD Handle: 2010061214320701 Modified files: rpm CHANGES rpm/rpmio rpmltc.c rpmltc.h rpmpgp.h rpm/tests tpgp.c Log: - ltc: implement RSA/DSA/ECDSA methods (RSA still has issues). Summary: Revision Changes Path 1.3388 +5 -2 rpm/CHANGES 1.2 +483 -35 rpm/rpmio/rpmltc.c 1.2 +5 -2 rpm/rpmio/rpmltc.h 2.103 +1 -1 rpm/rpmio/rpmpgp.h 1.5 +6 -1 rpm/tests/tpgp.c ____________________________________________________________________________ patch -p0 <<'@@ .' Index: rpm/CHANGES ============================================================================ $ cvs diff -u -r1.3387 -r1.3388 CHANGES --- rpm/CHANGES 10 Jun 2010 19:46:56 -0000 1.3387 +++ rpm/CHANGES 12 Jun 2010 14:32:07 -0000 1.3388 @@ -1,7 +1,8 @@ -5.3.0 -> 5.4a1: +5.3.1 -> 5.4a1: + - jbj: ltc: implement RSA/DSA/ECDSA methods (RSA still has issues). - jbj: crypto: add --usecrypto options for libtomcrypt/cdsa. - jbj: crypto: stub in wrappers for libtomcrypt & Apple CDSA. - - jbj: autofu: detect libtomcrypt (with custom tomcrypt.pc). + - jbj: autofu: detect libtomcrypt (needs custom-crafted tomcrypt.pc). - jbj: pgp: add ECDSA generate/sign/verify tests using gcrypt/openssl. - jbj: pgp: buff the chrome. - jbj: nss: add a strerror to decode errors to something meaningful. @@ -24,6 +25,8 @@ - jbj: hmac: fix: permit HMAC's to be clone'd (salt size was incorrect). - jbj: ssl: populate set/verify/sign/generate methods for ECDSA. - jbj: ecdsa: stub-in sign/generate methods for {ECDSA,RSA,DSA}. + +5.3.0 -> 5.3.1: - jbj: hkp: only verify the signhash, not the signature, with V3 signatures. - jbj: hkp: fix: avoid encoding issues in user id: truncate to 256b. - jbj: hkp: fix: validate rpmdb pubkeys too. @@ . patch -p0 <<'@@ .' Index: rpm/rpmio/rpmltc.c ============================================================================ $ cvs diff -u -r1.1 -r1.2 rpmltc.c --- rpm/rpmio/rpmltc.c 10 Jun 2010 19:22:30 -0000 1.1 +++ rpm/rpmio/rpmltc.c 12 Jun 2010 14:32:07 -0000 1.2 @@ -9,6 +9,7 @@ #define _RPMPGP_INTERNAL #if defined(WITH_TOMCRYPT) +#define LTM_DESC #define _RPMLTC_INTERNAL #include <rpmltc.h> #endif @@ -29,7 +30,10 @@ /*...@=redecl@*/ /*...@unchecked@*/ -static int _rpmltc_debug = 1; +static int _rpmltc_debug; + +/*...@unchecked@*/ +static prng_state yarrow_prng; #define SPEW(_t, _rc, _dig) \ { if ((_t) || _rpmltc_debug || _pgp_debug < 0) \ @@ -48,6 +52,103 @@ } static +int rpmltcErr(rpmltc ltc, const char * msg, int rc) + /*...@*/ +{ + /* XXX FIXME: Don't spew on expected failures ... */ + if (rc != CRYPT_OK) { + fprintf (stderr, "rpmltc: %s rc(%d) %s\n", + msg, rc, error_to_string(rc)); + } + return rc; +} + +#define _spewBN(_N, _BN) \ + { mp_int * bn = _BN; \ + int nt = 0; \ + int err = (bn ? mp_radix_size(bn, 16, &nt) : 0); \ + char * t = (nt ? xmalloc(nt) : ""); \ + if (nt) \ + err = mp_toradix(bn, t, 16); \ + fprintf(stderr, "\t" _N ": %s\n", t); \ + if (nt) \ + t = _free(t); \ + } + +static void rpmltcDumpRSA(const char * msg, rpmltc ltc) +{ + if (msg) fprintf(stderr, "========== %s\n", msg); + + { + _spewBN(" n", ltc->rsa.N); + _spewBN(" e", ltc->rsa.e); + _spewBN(" d", ltc->rsa.d); + _spewBN(" p", ltc->rsa.p); + _spewBN(" q", ltc->rsa.q); + _spewBN("dp", ltc->rsa.dP); + _spewBN("dq", ltc->rsa.dQ); + _spewBN("qi", ltc->rsa.qP); + } + + _spewBN(" c", ltc->c); +} + +static void rpmltcDumpDSA(const char * msg, rpmltc ltc) +{ + if (msg) fprintf(stderr, "========== %s\n", msg); + + { + _spewBN(" p", ltc->dsa.p); + _spewBN(" q", ltc->dsa.q); + _spewBN(" g", ltc->dsa.g); + _spewBN(" x", ltc->dsa.x); + _spewBN(" y", ltc->dsa.y); + } + + _spewBN(" r", ltc->r); + _spewBN(" s", ltc->s); + +} + +static void rpmltcDumpECDSA(const char * msg, rpmltc ltc) +{ + if (msg) fprintf(stderr, "========== %s\n", msg); + + { + const ltc_ecc_set_type * dp = ltc->ecdsa.idx >= 0 + ? ltc_ecc_sets + ltc->ecdsa.idx : NULL; + if (dp == NULL) + dp = ltc->ecdsa.dp; + + if (dp) { + fprintf(stderr, "\tsize: %d\n", dp->size); + fprintf(stderr, "\tname: %s\n", dp->name); + fprintf(stderr, "\t p: %s\n", dp->prime); + fprintf(stderr, "\t n: %s\n", dp->order); + fprintf(stderr, "\t b: %s\n", dp->B); + fprintf(stderr, "\tGx: %s\n", dp->Gx); + fprintf(stderr, "\tGy: %s\n", dp->Gy); + } + + _spewBN("Qx", ltc->ecdsa.pubkey.x); + _spewBN("Qy", ltc->ecdsa.pubkey.y); + + _spewBN(" d", ltc->ecdsa.k); + + } + + _spewBN(" r", ltc->r); + _spewBN(" s", ltc->s); +} + +#undef _spewBN + +#define _initBN(_t) \ + { if (_t == NULL) _t = xmalloc(sizeof(mp_int)); \ + xx = mp_init(_t); \ + } + +static int rpmltcSetRSA(/*...@only@*/ DIGEST_CTX ctx, pgpDig dig, pgpDigParams sigp) /*...@modifies dig @*/ { @@ -65,10 +166,8 @@ ltc->digestlen = 0; xx = rpmDigestFinal(ctx, (void **)<c->digest, <c->digestlen, 0); - /* Add PKCS1 padding. */ - /* Compare leading 16 bits of digest for quick check. */ -rc = 0; + rc = memcmp(ltc->digest, sigp->signhash16, sizeof(sigp->signhash16)); SPEW(0, !rc, dig); return rc; @@ -80,8 +179,35 @@ { rpmltc ltc = dig->impl; int rc = 0; /* assume failure. */ -ltc = ltc; +int _padding = LTC_LTC_PKCS_1_V1_5; +int hash_idx = find_hash("sha1"); +unsigned long saltlen = 0; +unsigned char sig[2048]; +unsigned long siglen = sizeof(sig); +unsigned char digest[2048]; +unsigned long digestlen = sizeof(digest); +int xx; + +#ifdef DYING +rpmltcDumpRSA(__FUNCTION__, ltc); +#endif +if (ltc->digest == NULL || ltc->digestlen == 0) goto exit; + +xx = mp_to_unsigned_bin_n(ltc->c, sig, &siglen); +memcpy(digest, ltc->digest, ltc->digestlen); + +#ifndef NOTYET + rc = rpmltcErr(ltc, "rsa_verify_hash_ex", + rsa_verify_hash_ex(sig, siglen, + ltc->digest, ltc->digestlen, + _padding, hash_idx, saltlen, &rc, <c->rsa)); +#else + rc = rpmltcErr(ltc, "rsa_decrypt_key_ex", + rsa_decrypt_key_ex(sig, siglen, digest, &digestlen, + NULL, 0, hash_idx, _padding, &rc, <c->rsa)); +#endif +exit: SPEW(!rc, rc, dig); return rc; } @@ -92,8 +218,38 @@ { rpmltc ltc = dig->impl; int rc = 0; /* assume failure. */ -ltc = ltc; +int _padding = LTC_LTC_PKCS_1_V1_5; +int hash_idx = find_hash("sha1"); +unsigned long saltlen = 0; +unsigned char sig[2048]; +unsigned long siglen = sizeof(sig); + +if (ltc->digest == NULL || ltc->digestlen == 0) goto exit; + +#ifdef NOTYET + rc = rpmltcErr(ltc, "rsa_sign_hash_ex", + rsa_sign_hash_ex(ltc->digest, ltc->digestlen, sig, &siglen, + _padding, &yarrow_prng, find_prng("yarrow"), + hash_idx, saltlen, <c->rsa)); +#else + rc = rpmltcErr(ltc, "rsa_encrypt_key_ex", + rsa_encrypt_key_ex(ltc->digest, ltc->digestlen, sig, &siglen, + NULL, 0, &yarrow_prng, find_prng("yarrow"), + hash_idx, _padding, <c->rsa)); +#endif + if (rc == CRYPT_OK) { + int xx; + _initBN(ltc->c); + xx = mp_read_unsigned_bin(ltc->c, sig, siglen); + } + +#ifdef DYING +rpmltcDumpRSA(__FUNCTION__, ltc); +#endif + rc = (rc == CRYPT_OK); + +exit: SPEW(!rc, rc, dig); return rc; @@ -105,7 +261,18 @@ { rpmltc ltc = dig->impl; int rc = 0; /* assume failure. */ -ltc = ltc; +static long _e = 0x10001; /* XXX FIXME */ + +if (ltc->nbits == 0) ltc->nbits = 1024; /* XXX FIXME */ + + rc = rpmltcErr(ltc, "rsa_make_key", + rsa_make_key(&yarrow_prng, find_prng("yarrow"), + ltc->nbits/8, _e, <c->rsa)); + rc = (rc == CRYPT_OK); + +#ifdef DYING +rpmltcDumpRSA(__FUNCTION__, ltc); +#endif SPEW(!rc, rc, dig); @@ -124,6 +291,7 @@ dig->hash_algoN = rpmltcHashAlgo2Name(sigp->hash_algo); assert(sigp->hash_algo == rpmDigestAlgo(ctx)); + /* Set DSA hash. */ /* XXX FIXME: should this lazy free be done elsewhere? */ ltc->digest = _free(ltc->digest); @@ -142,9 +310,20 @@ /*...@*/ { rpmltc ltc = dig->impl; - int rc; -ltc = ltc; + int rc = 0; /* assume failure. */ +int xx; + +if (ltc->digest == NULL || ltc->digestlen == 0) goto exit; +if (ltc->r == NULL || ltc->s == NULL) goto exit; +#ifdef DYING +rpmltcDumpDSA(__FUNCTION__, ltc); +#endif + xx = rpmltcErr(ltc, "dsa_verify_hash_raw", + dsa_verify_hash_raw(ltc->r, ltc->s, + ltc->digest, ltc->digestlen, &rc, <c->dsa)); + +exit: SPEW(!rc, rc, dig); return rc; } @@ -155,8 +334,23 @@ { rpmltc ltc = dig->impl; int rc = 0; /* assume failure */ -ltc = ltc; +int xx; + +if (ltc->digest == NULL || ltc->digestlen == 0) goto exit; + _initBN(ltc->r); + _initBN(ltc->s); + rc = rpmltcErr(ltc, "dsa_sign_hash_raw", + dsa_sign_hash_raw(ltc->digest, ltc->digestlen, ltc->r, ltc->s, + &yarrow_prng, find_prng("yarrow"), <c->dsa)); + +#ifdef DYING +rpmltcDumpDSA(__FUNCTION__, ltc); +#endif + + rc = (rc == CRYPT_OK); + +exit: SPEW(!rc, rc, dig); return rc; @@ -168,7 +362,28 @@ { rpmltc ltc = dig->impl; int rc = 0; /* assume failure. */ -ltc = ltc; +int xx; +int _group_size; +int _modulus_size; + +if (ltc->qbits == 0) ltc->qbits = 160; /* XXX FIXME */ +if (ltc->nbits == 0) ltc->nbits = 1024; /* XXX FIXME */ + +_group_size = ltc->qbits/8; +_modulus_size = ltc->nbits/8; + + xx = rpmltcErr(ltc, "dsa_make_key", + dsa_make_key(&yarrow_prng, find_prng("yarrow"), + _group_size, _modulus_size, <c->dsa)); +#ifdef NOTYET + xx = rpmltcErr(ltc, "dsa_verify_key", + dsa_verify_key(<c->dsa, &rc)); +#else + rc = (xx == CRYPT_OK); +#endif +#ifdef DYING +rpmltcDumpDSA(__FUNCTION__, ltc); +#endif SPEW(!rc, rc, dig); @@ -225,8 +440,27 @@ { rpmltc ltc = dig->impl; int rc = 0; /* assume failure. */ -ltc = ltc; +unsigned char sig[2048]; +unsigned long siglen = sizeof(sig); +int xx; +if (ltc->digest == NULL || ltc->digestlen == 0) goto exit; +if (ltc->r == NULL || ltc->s == NULL) goto exit; + +#ifdef DYING +rpmltcDumpECDSA(__FUNCTION__, ltc); +#endif + + xx = der_encode_sequence_multi(sig, &siglen, + LTC_ASN1_INTEGER, 1UL, ltc->r, + LTC_ASN1_INTEGER, 1UL, ltc->s, + LTC_ASN1_EOL, 0UL, NULL); + + xx = rpmltcErr(ltc, "ecc_verify_hash", + ecc_verify_hash(sig, siglen, + ltc->digest, ltc->digestlen, &rc, <c->ecdsa)); + +exit: SPEW(!rc, rc, dig); return rc; } @@ -237,8 +471,30 @@ { rpmltc ltc = dig->impl; int rc = 0; /* assume failure. */ -ltc = ltc; +unsigned char sig[2048]; +unsigned long siglen = sizeof(sig); +if (ltc->digest == NULL || ltc->digestlen == 0) goto exit; + + rc = rpmltcErr(ltc, "ecc_sign_hash", + ecc_sign_hash(ltc->digest, ltc->digestlen, sig, &siglen, + &yarrow_prng, find_prng ("yarrow"), <c->ecdsa)); + if (rc == CRYPT_OK) { + int xx; + _initBN(ltc->r); + _initBN(ltc->s); + xx = der_decode_sequence_multi(sig, siglen, + LTC_ASN1_INTEGER, 1UL, ltc->r, + LTC_ASN1_INTEGER, 1UL, ltc->s, + LTC_ASN1_EOL, 0UL, NULL); + } + rc = (rc == CRYPT_OK); + +#ifdef DYING +rpmltcDumpECDSA(__FUNCTION__, ltc); +#endif + +exit: SPEW(!rc, rc, dig); return rc; } @@ -248,8 +504,18 @@ /*...@*/ { rpmltc ltc = dig->impl; - int rc = 0; /* assume failure. */ -ltc = ltc; + int rc; + +if (ltc->nbits == 0) ltc->nbits = 256; /* XXX FIXME */ + + rc = rpmltcErr(ltc, "ecc_make_key", + ecc_make_key(&yarrow_prng, find_prng ("yarrow"), + ltc->nbits/8, <c->ecdsa)); + rc = (rc == CRYPT_OK); + +#ifdef DYING +rpmltcDumpECDSA(__FUNCTION__, ltc); +#endif SPEW(!rc, rc, dig); return rc; @@ -385,6 +651,12 @@ return rc; } +#define _loadBN(_t, _s, _ns) \ + { int xx; \ + _initBN(_t); \ + xx = mp_read_unsigned_bin(_t, _s, _ns); \ + } + static int rpmltcMpiItem(/*...@unused@*/ const char * pre, pgpDig dig, int itemno, const rpmuint8_t * p, @@ -398,33 +670,43 @@ switch (itemno) { default: assert(0); - case 50: /* ECDSA r */ - case 51: /* ECDSA s */ + break; + case 10: _loadBN(ltc->c, p+2, nb); break; /* RSA m**d */ + case 20: _loadBN(ltc->r, p+2, nb); break; /* DSA r */ + case 21: _loadBN(ltc->s, p+2, nb); break; /* DSA s */ + case 30: _loadBN(ltc->rsa.N, p+2, nb); break; /* RSA n */ + case 31: _loadBN(ltc->rsa.e, p+2, nb); break; /* RSA e */ + case 40: _loadBN(ltc->dsa.p, p+2, nb); break; /* DSA p */ + case 41: _loadBN(ltc->dsa.q, p+2, nb); break; /* DSA q */ + case 42: _loadBN(ltc->dsa.g, p+2, nb); break; /* DSA g */ + case 43: _loadBN(ltc->dsa.y, p+2, nb); break; /* DSA y */ + case 50: _loadBN(ltc->r, p+2, nb); break; /* ECDSA r */ + case 51: _loadBN(ltc->s, p+2, nb); break; /* ECDSA s */ case 60: /* ECDSA curve OID */ case 61: /* ECDSA Q */ break; - case 10: /* RSA m**d */ - break; - case 20: /* DSA r */ - break; - case 21: /* DSA s */ - break; - case 30: /* RSA n */ - break; - case 31: /* RSA e */ - break; - case 40: /* DSA p */ - break; - case 41: /* DSA q */ - break; - case 42: /* DSA g */ - break; - case 43: /* DSA y */ - break; } + +#ifdef DYING +{ +const char * pubkey_algoN = dig->pubkey_algoN; +dig->pubkey_algoN = pre; +SPEW(0, !rc, dig); +dig->pubkey_algoN = pubkey_algoN; +} +#endif + return rc; } +#undef _loadBN + +#define _freeBN(_t) \ + if (_t) { \ + (void) mp_clear(_t); \ + _t = _free(_t); \ + } + static void rpmltcClean(void * impl) /*...@modifies impl @*/ @@ -432,14 +714,42 @@ rpmltc ltc = impl; if (ltc != NULL) { ltc->nbits = 0; + ltc->qbits = 0; ltc->err = 0; ltc->badok = 0; ltc->digest = _free(ltc->digest); ltc->digestlen = 0; + _freeBN(ltc->rsa.N); + _freeBN(ltc->rsa.e); + _freeBN(ltc->rsa.d); + _freeBN(ltc->rsa.p); + _freeBN(ltc->rsa.q); + _freeBN(ltc->rsa.dP); + _freeBN(ltc->rsa.dQ); + _freeBN(ltc->rsa.qP); + memset(<c->rsa, 0, sizeof(ltc->rsa)); + + _freeBN(ltc->c); + + _freeBN(ltc->dsa.p); + _freeBN(ltc->dsa.q); + _freeBN(ltc->dsa.g); + _freeBN(ltc->dsa.x); + _freeBN(ltc->dsa.y); + memset(<c->dsa, 0, sizeof(ltc->dsa)); + + _freeBN(ltc->r); + _freeBN(ltc->s); + + ecc_free(<c->ecdsa); + memset(<c->ecdsa, 0, sizeof(ltc->ecdsa)); + } } +#undef _freeBN + static /*...@null@*/ void * rpmltcFree(/*...@only@*/ void * impl) /*...@modifies impl @*/ @@ -449,11 +759,149 @@ return NULL; } +static void reg_algs(void) +{ + int err; +#ifdef LTC_RIJNDAEL + register_cipher (&aes_desc); +#endif +#ifdef LTC_BLOWFISH + register_cipher (&blowfish_desc); +#endif +#ifdef LTC_XTEA + register_cipher (&xtea_desc); +#endif +#ifdef LTC_RC5 + register_cipher (&rc5_desc); +#endif +#ifdef LTC_RC6 + register_cipher (&rc6_desc); +#endif +#ifdef LTC_SAFERP + register_cipher (&saferp_desc); +#endif +#ifdef LTC_TWOFISH + register_cipher (&twofish_desc); +#endif +#ifdef LTC_SAFER + register_cipher (&safer_k64_desc); + register_cipher (&safer_sk64_desc); + register_cipher (&safer_k128_desc); + register_cipher (&safer_sk128_desc); +#endif +#ifdef LTC_RC2 + register_cipher (&rc2_desc); +#endif +#ifdef LTC_DES + register_cipher (&des_desc); + register_cipher (&des3_desc); +#endif +#ifdef LTC_CAST5 + register_cipher (&cast5_desc); +#endif +#ifdef LTC_NOEKEON + register_cipher (&noekeon_desc); +#endif +#ifdef LTC_SKIPJACK + register_cipher (&skipjack_desc); +#endif +#ifdef LTC_KHAZAD + register_cipher (&khazad_desc); +#endif +#ifdef LTC_ANUBIS + register_cipher (&anubis_desc); +#endif +#ifdef LTC_KSEED + register_cipher (&kseed_desc); +#endif +#ifdef LTC_KASUMI + register_cipher (&kasumi_desc); +#endif +#ifdef LTC_MULTI2 + register_cipher (&multi2_desc); +#endif + +#ifdef LTC_TIGER + register_hash (&tiger_desc); +#endif +#ifdef LTC_MD2 + register_hash (&md2_desc); +#endif +#ifdef LTC_MD4 + register_hash (&md4_desc); +#endif +#ifdef LTC_MD5 + register_hash (&md5_desc); +#endif +#ifdef LTC_SHA1 + register_hash (&sha1_desc); +#endif +#ifdef LTC_SHA224 + register_hash (&sha224_desc); +#endif +#ifdef LTC_SHA256 + register_hash (&sha256_desc); +#endif +#ifdef LTC_SHA384 + register_hash (&sha384_desc); +#endif +#ifdef LTC_SHA512 + register_hash (&sha512_desc); +#endif +#ifdef LTC_RIPEMD128 + register_hash (&rmd128_desc); +#endif +#ifdef LTC_RIPEMD160 + register_hash (&rmd160_desc); +#endif +#ifdef LTC_RIPEMD256 + register_hash (&rmd256_desc); +#endif +#ifdef LTC_RIPEMD320 + register_hash (&rmd320_desc); +#endif +#ifdef LTC_WHIRLPOOL + register_hash (&whirlpool_desc); +#endif +#ifdef LTC_CHC_HASH + register_hash(&chc_desc); + if ((err = chc_register(register_cipher(&aes_desc))) != CRYPT_OK) { + fprintf(stderr, "chc_register error: %s\n", error_to_string(err)); + exit(EXIT_FAILURE); + } +#endif + +#ifndef LTC_YARROW + #error This demo requires Yarrow. +#endif +register_prng(&yarrow_desc); +#ifdef LTC_FORTUNA +register_prng(&fortuna_desc); +#endif +#ifdef LTC_RC4 +register_prng(&rc4_desc); +#endif +#ifdef LTC_SOBER128 +register_prng(&sober128_desc); +#endif + + if ((err = rng_make_prng(128, find_prng("yarrow"), &yarrow_prng, NULL)) != CRYPT_OK) { + fprintf(stderr, "rng_make_prng failed: %s\n", error_to_string(err)); + exit(EXIT_FAILURE); + } + +} static void * rpmltcInit(void) /*...@*/ { + static int oneshot; rpmltc ltc = xcalloc(1, sizeof(*ltc)); + if (!oneshot) { + reg_algs(); + ltc_mp = ltm_desc; /* XXX tfm_desc */ + oneshot++; + } return (void *) ltc; } @@ . patch -p0 <<'@@ .' Index: rpm/rpmio/rpmltc.h ============================================================================ $ cvs diff -u -r1.1 -r1.2 rpmltc.h --- rpm/rpmio/rpmltc.h 10 Jun 2010 19:22:30 -0000 1.1 +++ rpm/rpmio/rpmltc.h 12 Jun 2010 14:32:07 -0000 1.2 @@ -12,6 +12,7 @@ /* Implementation specific includes. */ #if defined(_RPMLTC_INTERNAL) #include <tomcrypt.h> +#include <tommath.h> #endif /** @@ -34,13 +35,15 @@ /* DSA parameters. */ dsa_key dsa; + mp_int * r; + mp_int * s; /* RSA parameters. */ rsa_key rsa; + mp_int * c; /* ECDSA parameters. */ - ecc_key pub_key; - ecc_key sec_key; + ecc_key ecdsa; }; #endif @@ . patch -p0 <<'@@ .' Index: rpm/rpmio/rpmpgp.h ============================================================================ $ cvs diff -u -r2.102 -r2.103 rpmpgp.h --- rpm/rpmio/rpmpgp.h 9 Jun 2010 02:29:05 -0000 2.102 +++ rpm/rpmio/rpmpgp.h 12 Jun 2010 14:32:07 -0000 2.103 @@ -1140,7 +1140,7 @@ char * pgpHexCvt(/*...@returned@*/ char * t, const rpmuint8_t * s, size_t nbytes) /*...@modifies *t @*/ { - static char hex[] = "0123456789abcdef"; + static char hex[] = "0123456789ABCDEF"; while (nbytes-- > 0) { unsigned int i; i = (unsigned int) *s++; @@ . patch -p0 <<'@@ .' Index: rpm/tests/tpgp.c ============================================================================ $ cvs diff -u -r1.4 -r1.5 tpgp.c --- rpm/tests/tpgp.c 9 Jun 2010 19:19:45 -0000 1.4 +++ rpm/tests/tpgp.c 12 Jun 2010 14:32:08 -0000 1.5 @@ -11,7 +11,9 @@ #define _RPMPGP_INTERNAL #include <rpmio.h> #include <rpmbc.h> +#include <rpmcdsa.h> #include <rpmgc.h> +#include <rpmltc.h> #include <rpmnss.h> #include <rpmssl.h> @@ -159,7 +161,10 @@ } #endif - if (pgpImplVecs == &rpmgcImplVecs || pgpImplVecs == &rpmsslImplVecs) { + if (pgpImplVecs == &rpmgcImplVecs + || pgpImplVecs == &rpmltcImplVecs + || pgpImplVecs == &rpmsslImplVecs) + { fprintf(stderr, " ECDSA"); rc = generateTest(ts, "abc", PGPPUBKEYALGO_ECDSA, PGPHASHALGO_SHA256); if (rc != RPMRC_OK) ec++; @@ . ______________________________________________________________________ RPM Package Manager http://rpm5.org CVS Sources Repository [email protected]
