8 #define _RPMIOB_INTERNAL
14 #define _RPMPGP_INTERNAL
16 #if defined(WITH_GCRYPT)
22 #if defined(WITH_OPENSSL)
25 #if defined(WITH_CDSA)
28 #if defined(WITH_TOMCRYPT)
53 #if defined(USE_CRYPTO_BEECRYPT) && defined(WITH_BEECRYPT)
55 #elif defined(USE_CRYPTO_GCRYPT) && defined(WITH_GCRYPT)
57 #elif defined(USE_CRYPTO_NSS) && defined(WITH_NSS)
59 #elif defined(USE_CRYPTO_OPENSSL) && defined(WITH_SSL)
61 #elif defined(USE_CRYPTO_TOMCRYPT) && defined(WITH_TOMCRYPT)
63 #elif defined(USE_CRYPTO_CDSA) && defined(WITH_CDSA)
66 #elif defined(WITH_BEECRYPT)
68 #elif defined(WITH_GCRYPT)
70 #elif defined(WITH_NSS)
72 #elif defined(WITH_SSL)
74 #elif defined(WITH_TOMCRYPT)
76 #elif defined(WITH_CDSA)
79 #error INTERNAL ERROR: no suitable Cryptography library available
113 { -1,
"SIG_UNKNOWN" },
126 { -1,
"KEY_UNKNOWN" },
145 { -1,
"SYM_UNKNOWN" },
153 { -1,
"Unknown compression algorithm" },
167 { -1,
"MD_UNKNOWN" },
173 { 0x80,
"No-modify" },
174 { -1,
"Unknown key server preference" },
215 { -1,
"Unknown signature subkey type" },
236 {
PGPTAG_MDC,
"Manipulaion detection code packet" },
241 { -1,
"TAG_UNKNOWN" },
252 { -1,
"Unknown armor block" }
261 { -1,
"Unknown armor key" }
268 if (!_pgp_print)
return;
269 fprintf(stderr,
"\n");
276 if (!_pgp_print)
return;
278 fprintf(stderr,
"%s", pre);
279 fprintf(stderr,
" %d", i);
286 if (!_pgp_print)
return;
288 fprintf(stderr,
"%s", pre);
289 fprintf(stderr,
" %s", s);
296 if (!_pgp_print)
return;
298 fprintf(stderr,
"%s", pre);
299 fprintf(stderr,
" %s",
pgpHexStr(p, plen));
306 if (!_pgp_print)
return;
308 fprintf(stderr,
"%s", pre);
309 fprintf(stderr,
"%s(%u)",
pgpValStr(vs, val), (
unsigned)val);
326 fprintf(stderr,
" *CRITICAL*");
329 for (i = 1; i < plen; i++)
333 for (i = 1; i < plen; i++)
337 for (i = 1; i < plen; i++)
341 for (i = 1; i < plen; i++)
342 pgpPrtVal(
" ", pgpKeyServerPrefsTbl, p[i]);
346 if (_digp && !(_digp->saved & PGPDIG_SAVED_TIME) &&
349 _digp->saved |= PGPDIG_SAVED_TIME;
350 memcpy(_digp->time, p+1,
sizeof(_digp->time));
353 if ((plen - 1) == 4) {
354 time_t t =
pgpGrab(p+1, plen-1);
356 fprintf(stderr,
" %-24.24s(0x%08x)", ctime(&t), (
unsigned)t);
362 if ((plen - 1) == 4) {
363 time_t t =
pgpGrab(p+1, plen-1);
366 fprintf(stderr,
" never(0x%08x)", (
unsigned)t);
367 }
else if (_digp && _digp->saved & PGPDIG_SAVED_TIME) {
368 t +=
pgpGrab(_digp->time,
sizeof(_digp->time));
370 fprintf(stderr,
" %-24.24s(0x%08x)", ctime(&t), (
unsigned)t);
373 fprintf(stderr,
" creation+secs(0x%08x)", (
unsigned)t);
381 if (_digp && !(_digp->saved & PGPDIG_SAVED_ID) &&
384 _digp->saved |= PGPDIG_SAVED_ID;
385 memcpy(_digp->signid, p+1,
sizeof(_digp->signid));
456 for (i = 0; p < pend; i++, p +=
pgpMpiLen(p)) {
516 fprintf(stderr,
"%7d", i);
549 fprintf(stderr,
" %-24.24s(0x%08x)", ctime(&t), (
unsigned)t);
556 if (_digp && _digp->pubkey_algo == (
rpmuint8_t)0) {
558 _digp->hashlen = (size_t) v->
hashlen;
561 memcpy(_digp->time, v->
time,
sizeof(_digp->time));
562 memcpy(_digp->signid, v->
signid,
sizeof(_digp->signid));
565 memcpy(_digp->signhash16, v->
signhash16,
sizeof(_digp->signhash16));
585 if ((p + plen) > (pp->u.h + pp->hlen))
588 if (_pgp_debug && _pgp_print)
589 fprintf(stderr,
" hash[%u] -- %s\n", plen,
pgpHexStr(p, plen));
590 if (_digp && _digp->pubkey_algo == (
rpmuint8_t)0) {
591 _digp->hashlen =
sizeof(*v) + plen;
592 _digp->hash = pp->u.h;
600 if ((p + plen) > (pp->u.h + pp->hlen))
603 if (_pgp_debug && _pgp_print)
604 fprintf(stderr,
" unhash[%u] -- %s\n", plen,
pgpHexStr(p, plen));
612 if (_digp && _digp->pubkey_algo == (
rpmuint8_t)0) {
617 memcpy(_digp->signhash16, p,
sizeof(_digp->signhash16));
621 if (p > (pp->u.h + pp->hlen))
644 static const char * pgpSecretRSA[] = {
664 static const char * pgpSecretDSA[] = {
678 static const char * pgpSecretECDSA[] = {
692 static const char * pgpSecretECDH[] = {
708 static const char * pgpSecretELGAMAL[] = {
721 for (i = 0; p < pend; i++, p +=
pgpMpiLen(p)) {
807 fprintf(stderr,
"%7d", i);
842 pgpPrtVal(
" iterated/salted ", pgpHashTbl, p[2]);
843 i = (16 + ((unsigned)p[11] & 0xf)) << (((
unsigned)p[11] >> 4U) + 6);
861 for (i = 0; p < &pp->u.h[pp->hlen]; i++, p +=
pgpMpiLen(p)) {
863 if (pgpSecretRSA[i] == NULL)
break;
866 if (pgpSecretDSA[i] == NULL)
break;
869 if (pgpSecretECDSA[i] == NULL)
break;
872 if (pgpSecretELGAMAL[i] == NULL)
break;
876 fprintf(stderr,
"%7d", i);
882 pgpPrtHex(
" secret", p, (pp->hlen - (p - pp->u.h) - 2));
884 p += (pp->hlen - (p - pp->u.h) - 2);
909 fprintf(stderr,
" %-24.24s(0x%08x)", ctime(&t), (
unsigned)t);
912 fprintf(stderr,
" valid %u days", plen);
915 if (_digp && _digp->tag == (
rpmuint8_t)pp->tag) {
917 memcpy(_digp->time, v->
time,
sizeof(_digp->time));
931 fprintf(stderr,
" %-24.24s(0x%08x)", ctime(&t), (
unsigned)t);
934 if (_digp && _digp->tag == (
rpmuint8_t)pp->tag) {
936 memcpy(_digp->time, v->
time,
sizeof(_digp->time));
959 fprintf(stderr,
" \"%.*s\"", (
int)pp->hlen, (
const char *)pp->u.h);
962 char * t = (
char *) memcpy(
xmalloc(pp->hlen+1), pp->u.h, pp->hlen);
964 _digp->userid =
_free(_digp->userid);
977 fprintf(stderr,
" ");
987 fprintf(stderr,
"%.*s", (
int)strlen((
const char *)h), (
const char *)h);
1001 unsigned int val = (
unsigned int)*pkt;
1004 memset(pp, 0,
sizeof(*pp));
1010 pp->tag = (
pgpTag) (val & 0x3f);
1011 plen =
pgpLen(pkt+1, &pp->hlen);
1013 pp->tag = (
pgpTag) ((val >> 2) & 0xf);
1014 plen = (1 << (val & 0x3));
1015 pp->hlen =
pgpGrab(pkt+1, plen);
1018 pp->pktlen = 1 + plen + pp->hlen;
1019 if (pleft > 0 && pp->pktlen > (
unsigned)pleft)
1023 pp->u.h = pkt + 1 + plen;
1038 switch (pp->u.h[0]) {
1047 memmove(keyid, (se-8), 8);
1057 case 0x99:
case 0x98:
case 0xb9:
case 0xb8:
break;
1063 goop[1] = (pp->hlen >> 8) & 0xff;
1064 goop[2] = (pp->hlen ) & 0xff;
1069 memmove(keyid, (d + (dlen-8)), 8);
1082 if (b64decode(b64pkt, (
void **)&pkt, &pktlen))
1106 _digp->saved |= PGPDIG_SAVED_ID;
1108 memset(_digp->signid, 0,
sizeof(_digp->signid));
1149 return (rc ? -1 : (
int)pp->pktlen);
1158 dig->signature.userid =
_free(dig->signature.userid);
1159 dig->pubkey.userid =
_free(dig->pubkey.userid);
1160 dig->build_sign =
_free(dig->build_sign);
1161 dig->pubkey_algoN = NULL;
1162 dig->hash_algoN = NULL;
1163 memset(&dig->dops, 0,
sizeof(dig->dops));
1164 memset(&dig->sops, 0,
sizeof(dig->sops));
1165 dig->ppkts =
_free(dig->ppkts);
1167 dig->signature.hash = NULL;
1168 dig->signature.hashlen = 0;
1169 dig->pubkey.hash = NULL;
1170 dig->pubkey.hashlen = 0;
1172 memset(&dig->signature, 0,
sizeof(dig->signature));
1173 memset(&dig->pubkey, 0,
sizeof(dig->pubkey));
1175 dig->md5 =
_free(dig->md5);
1177 dig->sha1 =
_free(dig->sha1);
1220 dig->build_sign = t;
1222 if ((te = strrchr(t,
'/')) != NULL)
1225 te = (!strcasecmp(t,
"ECDSA") ?
"SHA256" :
"SHA1");
1227 dig->pubkey_algoN = t;
1228 dig->hash_algoN = te;
1237 sigp->pubkey_algo = pubp->pubkey_algo;
1238 pubp->hash_algo = sigp->hash_algo;
1249 dig->sig =
_free(dig->sig);
1251 dig->pub =
_free(dig->pub);
1264 if (dig->hrsa != NULL)
1268 if (dig->hdsa != NULL)
1272 if (dig->hecdsa != NULL)
1276 if (dig->hsha != NULL)
1281 if (dig->hdrmd5ctx != NULL)
1283 dig->hdrmd5ctx = NULL;
1286 if (dig->md5ctx != NULL)
1303 if (_digPool == NULL) {
1304 _digPool =
rpmioNewPool(
"dig",
sizeof(*dig), -1, _pgp_debug,
1310 memset(((
char *)dig)+
sizeof(dig->_item), 0,
sizeof(*dig)-
sizeof(dig->_item));
1326 pubp->pubkey_algo = pubkey_algo;
1327 sigp->pubkey_algo = pubkey_algo;
1329 if (pubp->pubkey_algo) {
1342 #if defined(WITH_BEECRYPT)
1346 #if defined(WITH_SSL)
1350 #if defined(WITH_NSS)
1354 #if defined(WITH_GCRYPT)
1358 #if defined(WITH_TOMCRYPT)
1369 #if defined(WITH_BEECRYPT)
1373 #if defined(WITH_SSL)
1377 #if defined(WITH_NSS)
1381 #if defined(WITH_GCRYPT)
1385 #if defined(WITH_TOMCRYPT)
1394 return (dig ? &dig->signature : NULL);
1399 return (dig ? &dig->pubkey : NULL);
1404 return (dig ? dig->sigtag : 0);
1409 return (dig ? dig->sigtype : 0);
1414 return (dig ? dig->sig : NULL);
1419 return (dig ? dig->siglen : 0);
1426 dig->sigtag = sigtag;
1427 dig->sigtype = (sig ? sigtype : 0);
1431 dig->siglen = siglen;
1451 int (*findPubkey) (
void *
ts,
void *dig),
void * _ts)
1455 dig->findPubkey = findPubkey;
1467 if (dig && dig->findPubkey && dig->_ts)
1468 rc = (*dig->findPubkey) (dig->_ts, dig);
1483 for (p = pkts, pleft = pktlen; p < (pkts + pktlen); p +=
len, pleft -=
len) {
1495 for (p = pkts, pleft = pktlen; p < (pkts + pktlen); p +=
len, pleft -=
len) {
1498 if (ppkts) ppkts =
_free(ppkts);
1504 ppkts[npkts] = NULL;
1509 ppkts =
_free(ppkts);
1523 unsigned int val = (
unsigned int)*pkts;
1530 _pgp_print = printing;
1532 if (dig != NULL && (val & 0x80)) {
1533 pgpTag tag = (
pgpTag)((val & 0x40) ? (val & 0x3f) : ((val >> 2) & 0xf));
1539 if (
pgpGrabPkts(pkts, pktlen, &ppkts, &npkts) || ppkts == NULL) {
1545 for (i = 0, pleft = pktlen; i < npkts; i++, pleft -=
len) {
1551 dig->ppkts =
_free(dig->ppkts);
1555 ppkts =
_free(ppkts);
1566 const char * enc = NULL;
1567 const char * crcenc = NULL;
1573 const char * armortype = NULL;
1601 iob->blen =
pgpPktLen(iob->b, iob->blen, pp);
1603 (void)
pgpPktLen(iob->b, iob->blen, pp);
1609 #define TOKEQ(_s, _tok) (!strncmp((_s), (_tok), sizeof(_tok)-1))
1612 for (t = (
char *)iob->b; t && *t; t = te) {
1613 if ((te = strchr(t,
'\n')) == NULL)
1621 if (!
TOKEQ(t,
"-----BEGIN PGP "))
1623 t +=
sizeof(
"-----BEGIN PGP ")-1;
1636 t = strchr(t,
'\n');
1641 t -= (
sizeof(
"-----")-1);
1642 if (!
TOKEQ(t,
"-----"))
1652 if (!(*t ==
'\n' || *t ==
'\r')) {
1669 if (!
TOKEQ(t,
"-----END PGP ")) {
1674 t +=
sizeof(
"-----END PGP ")-1;
1675 if (t >= te)
continue;
1677 if (armortype == NULL)
1679 rc = strncmp(t, armortype, strlen(armortype));
1683 t += strlen(armortype);
1684 if (t >= te)
continue;
1686 if (!
TOKEQ(t,
"-----")) {
1690 t += (
sizeof(
"-----")-1);
1691 if (t >= te)
continue;
1693 if (!(*t ==
'\n' || *t ==
'\r'))
continue;
1697 if (b64decode(crcenc, (
void **)&crcdec, &crclen) != 0) {
1701 crcpkt =
pgpGrab(crcdec, crclen);
1702 crcdec =
_free(crcdec);
1705 if (b64decode(enc, (
void **)&dec, &declen) != 0) {
1709 crc =
pgpCRC(dec, declen);
1710 if (crcpkt != crc) {
1716 iob->b =
_free(iob->b);
1729 if (pkt) *pkt = iob->b;
1730 if (pktlen) *pktlen = iob->blen;
1733 if (pkt) *pkt = NULL;
1734 if (pktlen) *pktlen = 0;
1757 nt = ((ns + 2) / 3) * 4;
1760 if (b64encode_chars_per_line > 0 && b64encode_eolstr != NULL) {
1761 lc = (nt + b64encode_chars_per_line - 1) / b64encode_chars_per_line;
1762 if (((nt + b64encode_chars_per_line - 1) % b64encode_chars_per_line) != 0)
1764 nt += lc * strlen(b64encode_eolstr);
1770 val = t = (
char *)
xmalloc(nt + 1);
1772 t =
stpcpy(t,
"-----BEGIN PGP ");
1786 if ((enc = b64encode(s, ns)) != NULL) {
1789 if ((enc = b64crc(s, ns)) != NULL) {
1796 t =
stpcpy(t,
"-----END PGP ");
1798 t =
stpcpy(t,
"-----\n");
1812 name_len = strlen(name);
1813 for (i = 0; i <
sizeof(
pgpHashTbl)/
sizeof(pgpHashTbl[0]); i++)
static const char * pgpSigDSA[]
const char const double d
static int pgpValTok(pgpValTbl vs, const char *s, const char *se)
Return value of an OpenPGP string.
static void pgpPrtInt(const char *pre, int i)
pgpDigParams pgpGetPubkey(pgpDig dig)
Return OpenPGP pubkey parameters.
const rpmuint8_t * pgpPrtPubkeyParams(pgpDig dig, const pgpPkt pp, pgpPubkeyAlgo pubkey_algo, const rpmuint8_t *p)
pgpImplVecs_t * pgpImplVecs
struct pgpImplVecs_s rpmbcImplVecs
int pgpSetFindPubkey(pgpDig dig, int(*findPubkey)(void *ts, void *dig), void *_ts)
Set find pubkey vector.
static const char * pgpValStr(pgpValTbl vs, rpmuint8_t val)
Return string representation of an OpenPGP value.
static const rpmuint8_t * pgpPrtSeckeyParams(const pgpPkt pp, rpmuint8_t pubkey_algo, const rpmuint8_t *p)
pgpDig pgpDigFree(pgpDig dig)
Destroy a container for parsed OpenPGP packates.
static unsigned int pgpCRC(const rpmuint8_t *octets, size_t len)
Return CRC of a buffer.
const char const char size_t len
const char bson_timestamp_t * ts
rpmuint32_t pgpGetSiglen(pgpDig dig)
Get signature tag data length, i.e.
int pgpPktLen(const rpmuint8_t *pkt, size_t pleft, pgpPkt pp)
void yarnPossess(yarnLock bolt)
const void * pgpGetSig(pgpDig dig)
Get signature tag data, i.e.
char * xstrdup(const char *str)
struct pgpValTbl_s pgpCompressionTbl[]
Compression (string, value) pairs.
struct pgpDigParams_s * pgpDigParams
static unsigned int pgpLen(const rpmuint8_t *s, unsigned int *lenp)
Return length of an OpenPGP packet.
DIGEST_CTX rpmDigestInit(pgpHashAlgo hashalgo, rpmDigestFlags flags)
Initialize digest context.
int rpmgcExportSignature(pgpDig dig, DIGEST_CTX ctx)
int pgpExtractPubkeyFingerprint(const char *b64pkt, rpmuint8_t *keyid)
Extract OpenPGP public key fingerprint from base64 encoded packet.
struct pgpValTbl_s pgpHashTbl[]
Hash (string, value) pairs.
struct pgpValTbl_s pgpArmorKeyTbl[]
Armor key (string, value) pairs.
int xstrncasecmp(const char *s1, const char *s2, size_t n)
Locale insensitive strncasecmp(3).
static unsigned int pgpGrab(const rpmuint8_t *s, size_t nbytes)
Return (native-endian) integer from big-endian representation.
enum pgpHashAlgo_e pgpHashAlgo
9.4.
pgpImplVecs_t rpmltcImplVecs
Implementation specific parameter storage.
int pgpDigSetAlgos(pgpDig dig)
static const char * pgpPublicELGAMAL[]
static rpmVSFlags vsflags
char * pgpArmorWrap(rpmuint8_t atype, const unsigned char *s, size_t ns)
Wrap a OpenPGP packets in ascii armor for transport.
int pgpSetSig(pgpDig dig, rpmuint32_t sigtag, rpmuint32_t sigtype, const void *sig, rpmuint32_t siglen)
Set signature tag info, i.e.
rpmiob rpmiobFree(rpmiob iob)
Destroy a I/O buffer instance.
rpmuint8_t pgpPubkeyName2Algo(const char *name)
enum pgpSigType_e pgpSigType
5.2.1.
pgpDig pgpDigLink(pgpDig dig)
Reference a signature parameters instance.
static int pgpImplGenerate(pgpDig dig)
pgpImplVecs_t rpmnssImplVecs
struct pgpValTbl_s pgpTagTbl[]
static const char * pgpPublicECDH[]
const char * pgpPubkeyAlgo2Name(uint32_t algo)
pgpArmor pgpArmorUnwrap(rpmiob iob, rpmuint8_t **pkt, size_t *pktlen)
Parse armored OpenPGP packets from an iob.
int pgpExportPubkey(pgpDig dig)
int rpmltcExportPubkey(pgpDig dig)
int rpmiobSlurp(const char *fn, rpmiob *iobp)
static void pgpDigFini(void *__dig)
static const char * pgpPublicRSA[]
static int pgpIsPkt(const rpmuint8_t *p, pgpTag *tagp)
Is buffer at beginning of an OpenPGP packet?
rpmuint32_t pgpGetSigtype(pgpDig dig)
Get signature tag type.
pgpArmor pgpReadPkts(const char *fn, rpmuint8_t **pkt, size_t *pktlen)
Parse armored OpenPGP packets from a file.
static void * pgpImplFree(void *impl)
static void * pgpImplInit(void)
pgpVSFlags pgpDigVSFlags
Disabler bits(s) for signature/digest checking.
static int crc(FD_t fd, uint32_t *cval, uint32_t *clen)
void * xcalloc(size_t nmemb, size_t size)
int pgpPrtPkt(const rpmuint8_t *pkt, size_t pleft)
Return lenth of a OpenPGP packet.
const char const bson_bool_t v
struct pgpPktSigV4_s * pgpPktSigV4
5.2.3.
int rpmDigestUpdate(DIGEST_CTX ctx, const void *data, size_t len)
Update context with next plain text buffer.
int pgpFindPubkey(pgpDig dig)
Call find pubkey vector.
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
Get unused item from pool, or alloc a new item.
struct pgpValTbl_s pgpSymkeyTbl[]
Symmetric key (string, value) pairs.
int pgpPrtSigParams(pgpDig dig, const pgpPkt pp, pgpPubkeyAlgo pubkey_algo, pgpSigType sigtype, const rpmuint8_t *p)
unsigned char rpmuint8_t
Private int typedefs to avoid C99 portability issues.
static const char * pgpMpiStr(const rpmuint8_t *p)
Return hex formatted representation of a multiprecision integer.
enum pgpVSFlags_e pgpVSFlags
Bit(s) to control digest and signature verification.
pgpDigParams pgpGetSignature(pgpDig dig)
Return OpenPGP signature parameters.
int rpmsslExportSignature(pgpDig dig, DIGEST_CTX ctx)
struct pgpValTbl_s pgpArmorTbl[]
Armor (string, value) pairs.
rpmuint32_t pgpGetSigtag(pgpDig dig)
Get signature tag.
pgpImplVecs_t rpmsslImplVecs
Implementation specific parameter storage.
struct pgpValTbl_s pgpSubTypeTbl[]
Subtype (string, value) pairs.
int rpmgcExportPubkey(pgpDig dig)
static rpmuint8_t pgpStrVal(pgpValTbl vs, const char *str)
Return byte value of an OpenPGP string.
static void pgpPrtHex(const char *pre, const rpmuint8_t *p, size_t plen)
char * rpmExpand(const char *arg,...)
Return (malloc'ed) concatenated macro expansion(s).
pgpHashAlgo pgpHashAlgoStringToNumber(const char *name, size_t name_len)
Convert a hash algorithm "foo" to the internal PGPHASHALGO_FOO number.
void pgpDigClean(pgpDig dig)
Release (malloc'd) data from container.
struct pgpPktKeyV4_s * pgpPktKeyV4
The version 4 format is similar to the version 3 format except for the absence of a validity period...
static void pgpPrtStr(const char *pre, const char *s)
static const char * pgpPublicECDSA[]
void yarnRelease(yarnLock bolt)
int rpmbcExportSignature(pgpDig dig, DIGEST_CTX ctx)
struct pgpValTbl_s pgpSigTypeTbl[]
int pgpGrabPkts(const rpmuint8_t *pkts, size_t pktlen, rpmuint8_t ***pppkts, int *pnpkts)
Return array of packet pointers.
struct pgpValTbl_s pgpPubkeyTbl[]
enum pgpPubkeyAlgo_e pgpPubkeyAlgo
9.1.
pgpDig pgpDigNew(pgpVSFlags vsflags, pgpPubkeyAlgo pubkey_algo)
Create a container for parsed OpenPGP packates.
static unsigned int pgpMpiLen(const rpmuint8_t *p)
Return no.
int pgpPrtSubType(const rpmuint8_t *h, size_t hlen, pgpSigType sigtype)
int pgpPrtComment(const pgpPkt pp)
static void pgpImplClean(void *impl)
rpmioPool rpmioNewPool(const char *name, size_t size, int limit, int flags, char *(*dbg)(void *item), void(*init)(void *item), void(*fini)(void *item))
Create a memory pool.
static pgpDig digGetPool(rpmioPool pool)
int pgpPubkeyFingerprint(const rpmuint8_t *pkt, size_t pktlen, rpmuint8_t *keyid)
Print/parse an OpenPGP subtype packet.
char * stpcpy(char *dest, const char *src)
struct pgpPktSigV3_s * pgpPktSigV3
5.2.2.
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
int pgpPrtUserID(const pgpPkt pp)
static const char * pgpPublicDSA[]
int rpmsslExportPubkey(pgpDig dig)
pgpImplVecs_t rpmgcImplVecs
Implementation specific parameter storage.
struct pgpValTbl_s pgpKeyServerPrefsTbl[]
const char * pgpHashAlgo2Name(uint32_t algo)
int pgpPrtPkts(const rpmuint8_t *pkts, size_t pktlen, pgpDig dig, int printing)
Print/parse a OpenPGP packet(s).
int rpmDigestFinal(DIGEST_CTX ctx, void *datap, size_t *lenp, int asAscii)
Return digest and destroy context.
int rpmnssExportSignature(pgpDig dig, DIGEST_CTX ctx)
static int pgpImplMpiItem(const char *pre, pgpDig dig, int itemno, const rpmuint8_t *p, const rpmuint8_t *pend)
int rpmltcExportSignature(pgpDig dig, DIGEST_CTX ctx)
int rpmbcExportPubkey(pgpDig dig)
static char * pgpHexStr(const rpmuint8_t *p, size_t plen)
Return hex formatted representation of bytes.
static const char * pgpSigRSA[]
void * pgpStatsAccumulator(pgpDig dig, int opx)
Return pgpDig container accumulator structure.
struct pgpPktKeyV3_s * pgpPktKeyV3
5.5.1.
static const char * pgpSigECDSA[]
The version 4 format is similar to the version 3 format except for the absence of a validity period...
int pgpPrtSig(const pgpPkt pp)
static void pgpPrtNL(void)
rpmuint8_t pgpHashName2Algo(const char *name)
int pgpPrtKey(const pgpPkt pp)
int rpmnssExportPubkey(pgpDig dig)
int pgpExportSignature(pgpDig dig, DIGEST_CTX ctx)
void pgpPrtVal(const char *pre, pgpValTbl vs, rpmuint8_t val)
Print an OpenPGP value.
static pgpDigParams _digp