And finally, make pgpDig struct fully opaque

- As long as this was exposed and relied on, we couldn't really
  make any changes to how this stuff is stored. Now we have a chance...

Eliminate direct pgpDig accesses from signing code

Eliminate direct pgpDig accesses from pubkey importing

Eliminate direct pgpDig access from package reading code

Eliminate direct pgpDig accesses from lowlevel signature code

Eliminate direct pgpDig accesses from keyring

Add a dumb API to retrieve pubkey / signature params from pgpDig

Take advantage of parsePGPSig() in pgpsigFormat() too

- Doesn't make for less lines in this case but unifying the accesses
  is good anyway.

Unify the parsePGP() variants from package.c and rpmchecksig.c

- Hide allocation inside the helper, automatically free on failure
- Return pointer to the signature parameters on success to simplify
  life for callers
- Don't bother checking or reporting the signature version: the
  pgp parser errors out if it encounters unsupported version and
  does not scrible anything to the version field in that case,
  mumbling about "V0 signatures" is not particularly helpful.
- Log the bad package names from rpmpkgReadHeader() too

Hide pgpDig alloc etc details in the parsePGP helper

- Return a pointer to the signature part on success, hide allocation
  (and free on failure) in the helper. Makes life a little bit
  saner for the callers and limits the places where we access
  the full pgpDig further.

Process all keys and signatures we find

- We still can't store more than one signature / key at a time, but
  since we can easily *process* them without trashing already stored
  values, lets do so to avoid returning errors from legal packets.
  Also pay attention to only store data matching our expected type,
  ie dont store signature data into pubkey parameters and vice versa.
- This mostly affects pubkey packets which can have more than one
  key present and which (can) also carry certification signature
  which we currently do not handle properly at all.

Make pgpPrtPubkeyParams() return an int like all the others do too

- No functional changes, just making the interfaces consistent

Add another pgpVerify variant which takes key and sig as separate args

- pgpVerifySig() is now just a dumb wrapper around pgpVerifySignature()
  which does the real work.
- Update the sole caller to use the new interface instead, deprecate
  the old dig interface.
- First steps towards getting rig of pgpDig which always was a
  strange creature and now is nothing but a nuisance and obfuscation.
  Yes keys and signatures walk hand in hand much of the time, but
  they come from different sources and want to be handled as
  separate data really.

Eliminate couple of unnecessary pgpDig usages

- stashKeyid() only wants the signature, not the whole dig
- dig argument to readFile() was simply unused

Clean up pgpPrtPkts() and friends a bit

- Use decodePkt() for added initial sanity check + grabbing the "main" tag
  instead of duplicating the tag decoding here.
- Call decodePkt() from the main parse loop instead of pgpPrtPkt(),
  and return simple ok/error codes from pgpPrtPkt() and do the
  length calculation in the main loop.
- Besides making the code simpler and more obvious this fixes some
  fishy cases where we previously would've returned 0 for success
  despite there being an error.

Bury all NSS specifics into a separate source

- Not everybody needs/wants the certified monster that NSS is
  (along with all its quirks), this leaves room for alternative
  compile-time selectable crypto backends. Besides that, we get
  a clean functionality separation for the PGP parser and the
  cryptography parts.
- The whole crypto abstraction works inspired + somewhat based on
  Michael Schroeder's similar patch in Suse, kudos.
- TODO: port beecrypt support from Suse to the new interface.

Add a couple of missing includes, masked by NSS headers

Implement PGP key & sig algorithm specific part OO-style

- Collect the crypto algorithm specific bits into new struct
  with function pointers for the necessary set/verify/free methods,
  adjust callers to operate on these. This will allow nice and
  clean switching for different underlying crypto implementations
  with differing supported algorithms etc with minimal internals exposure.
- pgpSignatureNew() and pgpPubkeyNew() never fail to avoid having
  to check for NULL's over and over, they just return a "null object"
  object for which all operations return failure instead.
- This shreds out some of the output --prtpkts used to give. Wouldn't
  be hard to preserve but the stderr fprintf() spew is not very
  useful nor library-like behavior.

Lift RSA/DSA specific signature verification to helper functions

- Use function pointers to call appropriate helper, cleaning up
  pgpVerifySig() a bit. Supposedly no functional changes, just
  further isolation of NSS specifics.
- Pass down pubkey and signature as separate pointers, we'll
  want to get rid of pgpDig eventually as it only obfuscates things.

Lift RSA/DSA key MPI calculations to helper functions

- Same as commit 8473a5b6ce2050a8e899b0be4a012f5724eb0b6d, only for keys
- Use function pointers to call appropriate helper etc, cleaning up
  pgpPrtPubkeyParams() considerably. Supposedly no functional changes,
  just further isolating NSS specifics behind generic interfaces.

Lift RSA/DSA signature MPI calculations to helper functions

- Use function pointers to call appropriate helper, cleaning up
  pgpPrtSigParams() considerably. Supposedly no functional changes.
- Also serves as first step towards isolating NSS-specific bits
  and pieces behind more generic interfaces to enable using
  alternative crypto "engines" later on.

Remove now redundant NULL digparam checks within the PGP parser

- Since the only entry to these is pgpPrtPkts() and that ensures
  the internals are never called with non-NULL digp... Cleans up
  and simplifies the internals.

Arrange temporary storage for parsing if called with NULL dig

- The only known caller with NULL dig is in the rather useless
  wrapping of prtPrtPkts() in the python bindings, but since in
  theory some other callers could use this just for validating
  a PGP packet .. preserve the behavior since it's easy. The
  actual benefit here is that this frees the parser internals
  of having to check for NULL pointers everywhere.

Added sanity checks on pgpPrtPkts() entry

- Error out cleanly on NULL pkts pointer (caller error but not worth
  dying for)
- Error out early if packet is clearly not valid

Eliminate bunch of unused/useless debug cruft from pgp parser

Split digest parameter freeing into a separate helper function

- The data is all the same except for rsa/dsa specific bits,
  to me this calls for a function. We might want to export
  pgpCleanDigParams() or such later on but for now keep it static.
  No functional changes.

Store the rsa/dsa parameters in pgpDigParamers struct directly

- Avoids having to pass around pgpDig pointers in addition to
  pgpDigParamrs pointers. The type (key vs sig) is determined
  early on in pgpPrtPkts() and doesn't change, and the rsa/dsa
  data is associated with that always. No functional changes,
  just makes the whole thing just a little bit cleaner.

Verify PGP signature packet sizes and number of MPIs match expectations

- Similar to commit 807b402d95702f3f91e9e2bfbd2b5ca8c9964ed9 but
  for signature packets: packet must be larger than the "intro"
  structure, and verify the calculated sizes match our expectations.

Eliminate buggy pgpPrtComment()

- Removes another source of stupid bugs: for rpm's purposes we're not
  interested in PGP comment tag contents, and the implementation
  here was unsafe as it assumes there always is a terminating \0
  somewhere in the packet which might not be true for a malformed packet.

Verify PGP key packet sizes and number of MPIs match expectations, part II

- Same as commit 807b402d95702f3f91e9e2bfbd2b5ca8c9964ed9 but for
  retrieving the actual key data instead of its fingerprint.
- Only look inside keys whose pubkey algo we actually support:
  DSA and RSA. Anything else is better left untouched and treated
  as an error to avoid nasty surprises.

Verify PGP key packet sizes and number of MPIs match expectations

- A key packet must be larger than the "intro" structure to have
  room for the trailing MPIs, ie in order to be valid. This also
  ensures we can safely access the pubkey algorithm data.
- Verify the number of trailing MPI's and their total size matches
  the expectations and packet size exactly before bothering with
  digest calculations.
- Also use sizeof(keyid) instead of "magic eight" and memcpy()
  instead of memmove(), the argument keyid and memory returned
  from rpmDigestFinal() cannot overlap.

Verify MPI size is within packet boundary in pgpMpiItem()

- Malformed data can claim the MPI size to be "arbitrarily" large,
  pass packet end pointer to pgpMpiItem() and validate we have enough
  bytes in the packet to contain the MPI before copying.

Remove support for V3 public keys

- V3 keys have been long since deprecated and extinct for all practical
  purposes for more than a decade by now (for example, Red Hat Linux 6.0
  from 1999 was the last RHL to use a V3 key for signing). RFC-4880
  says V3 keys MUST NOT be generated (they have a number of weaknesses),
  but implementations MAY accept them. We choose not to accept them
  anymore, eliminating a code path that would essentially only get
  triggered by malformed packages. The said code path also contained
  a few buffer overflows and other bugs, so its more than just
  "good riddance."
- Worth nothing is that only support for V3 *keys* is removed, V3
  signatures are still supported along with V4 ones.

We dont deal with secret keys, leave them alone

- As we only do OpenPGP signature verification and never signing /
  encrypting content ourselves, we have no need to know anything
  about secret keys. One less place to worry about, tripping up
  on bad data that we dont even try to use would be pretty dumb.

Centralize PGP packet decoding and sanity checking into helper function

- Stricter sanity checking on both old and new packet types - whereas
  new format packets were mostly covered by pgpLen() changes already,
  old format has similar case where malformed packet could cause us
  to read beyond packet (buffer) end.
- Collect the necessary packet data into a struct that's nicer to
  pass around (taking advantage of this mostly left for next steps)

Verify there are sufficient number of bytes to calculate packet length

- The number of bytes used to store a PGP packet body length is not
  known until we decode the first byte, pass remaining packet length
  to pgpLen() and verify there are sufficient bytes for the
  used encoding before reading them.
- Clarify the function description while at it.

Avoid redundant calculations on pubkey fingerprint retrieval

- In pgpPrtPkt() we just calculated the packet body and length,
  avoid redoing it for the fingerprint by splitting the actual
  fingerprint calculation out of pgpPubkeyFingerprint() into a helper
  function and calling that instead.

pgpPubkeyFingerprint() can fail, propagate errors part II

- rpmPubkeyNew() needs to return NULL if we fail to grab the
  keyid, make it so...

pgpPubkeyFingerprint() can fail, propagate errors

- Rpm itself doesn't even use pgpExtractPubkeyFingerprint() anymore
  but there appear to be other users so leaving it alone for now,
  just behave sanely on errors.

Eliminate useless pgpIsPkt() helper function

- While I can imagine uses for such a function, our only caller is
  using it in a bogus way: decodePkts() is trying to avoid looking into
  binary-only data by calling it, but then pgpIsPkt() returns
  "not pgp tag" for various things that *are* pgp tags, making the
  whole thing just moot. If such checks are actually needed, we'd be better
  of checking for printable characters or such.

Eliminate broken pgpLen() from the API

- pgpLen() only works for new format packets, and even for those
  its unsafe and cannot be fixed without breaking the API. Start
  by taking it behind the barn for further, err, operations. Rpm has
  no users outside rpmpgp.c now and anybody else using it will be
  better off not doing so.

Sanitize pgpsigFormat()

- Eliminate bogus size calculations: we have a buffer of td->count size
  that may or may not contain legal OpenPGP signature. Leave it up to
  pgpPrtPkts() to validate & figure it out and check its return code instead,
  eliminating need to repeat a bunch of tedious calculations here.
- Use non-zero signature version is used as a hint for valid signature,
  should be "close enough" for the rest of the code.

Valid PGP packets are always at least two bytes long

- Old format tags encode the number of body length bytes in the packet
  header, new format encodes it in the first body length byte. In
  both cases there must be at least two bytes worth of data for it
  to be a valid header. Sanity check before accessing.

Fix unterminated buffer after readlink() call

readlink() never terminates the buffer.

Detected by "cppcheck" (git HEAD)

Signed-off-by: Thomas Jarosch <thomas.jarosch@intra2net.com>
Signed-off-by: Panu Matilainen <pmatilai@redhat.com>

Log an error on signing if we can't even parse the gpg-generated signature

- The error message is not very helpful but if pgpPrtPkts() fails
  we dont have a whole lot clue in the caller why it failed, spitting
  out at least *some* error is better than silently failing
  (RhBug:748116, RhBug:719154)

Warn but don't fail the build on missing excluded files (RhBug:745629)

- If a file/directory is not to be packaged, there's not a whole lot
  point making the build fail if its missing. In case exclude is
  used to leave certain files to sub-packages, the sub-package file
  lists will catch out missing files that are really missing as a
  result of actual build failure or such (except perhaps for some
  glob cases but missing files can go unnoticed in those cases anyway)

Eliminate bunch of exit points in addFile()

- Assume failure, handle setting fl->processingFailed centrally at exit
  (file too large wasn't resulting in processingFailed getting set)

Fix ancient off-by-one at end boundary in string array size calculation

- String array size calculation could read one byte past data end
  pointer when expected count and number of \0's disagree (ie invalid data)
  due to while condition side-effects + bounds checking being in
  the inner loop.
- Lift the string length calculation to inline helper function, used for
  both string and string array types.
- Streamline the calculations:
  - Eliminate unnecessary length increments, calculate the length
    from pointer distance
  - Eliminate end pointer NULL checking within the loop: when caller
    doesn't supply end pointer, cap to HEADER_MAX_DATA (ie 16MB),
    anything larger would trip up in later hdrchkData() checks anyway.
  - Avoid the off-by-one by eliminating the problematic inner loop.

Verify the entire region trailer, not just its offset, is within data area

- Offset being within the data area doesn't help if the actual data doesn't
  fit. Since the trailer size is well known, we can just as easily
  make the check accurate to prevent reading beyond end of data in case
  the offset is subtly wrong.
- In headerLoad(), region offset of zero doesn't need sanity checking,
  only validate if its something else and do so accurately there too.

Update man page(s) verify output description to match current behavior

- Since addition of file capability verification in rpm 4.7.x,
  the verify output has nine characters, not eight (RhBug:746525)

Fix pretrans dependency calculation when provider is upgraded

- Pretrans-dependencies are twisty little beasts unlike anything else...
  When a pretrans-dependency provider is updated, the currently installed
  version is the provider for that transaction, unlike others where
  the packages from installing set act as providers for updates. So
  when looking up pretrans deps, we must not prune the to-be-erased
  packages from the db match iterators. As an added twist, we also
  must not cache these non-pruned cases as it would mess up the
  cache for "regular" dependencies.
- Fixes this case reported on fedora-devel:
  http://lists.fedoraproject.org/pipermail/devel/2011-October/158058.html

rpmio: Set a umask before using mkstemp()

This commit sets a restrictive umask before calling mkstemp().
This is because the permissions of files created by mkstemp() are
not defined in POSIX. Old versions of glibc created files with
mode 0666 which can be a security hole. Because the behavior is
implementation-dependent, we set a umask.

rpmio: Don't de-ref lzfile which was freed in lzclose()

build: Update .gitignore rules

Let headerLoad() failure message come through

- headerVerify() always returns with a message even for OK results,
  which was masking the error message from headerLoad(), sometimes
  giving not very helpful "headerRead failed: Header sanity check OK"
  style messages.

Eliminate headerCheckPayloadFormat() from the API

- While we're on API killing spree... Exporting this was needless and
  dumb to begin with (greetings to self in 2007...), bury it inside
  depends.c as static and let rot there.
- Might be a better idea to kill it completely with some other
  mechanism such as turning payload format into rpmlib() dependency
  internally but just get it out of public sight for now.

Eliminate headerMergeLegacySigs() from the API

- No need to export this in the API - if you want merged signature
  tags you use rpm's package reading functions.

Eliminate leftover headerRegenSigHeader() function

- This was only ever used by repackage support inside rpm and has been
  orphan since 2008, likely more than just a little broken too as it
  doesn't know about 64bit types and all. RIP.

Only bother allocating a pgpDig when needed

- Now that rpmVerifySignature() doesn't require a non-null dig
  for digests, don't bother allocating one unless necessary.
- pgpNewDig() cannot fail so dont bother checking.

Eliminate redundant NULL-checks in lower level sigchecking functions

- sigtd->data and dig checking (where needed) is done at
  rpmVerifySignature() level, dont bother double-checking
- Hash context is dup'ed, which CAN fail, so while we dont need
  to check the argument for non-null, the dup result needs to
  be checked for digests. For actual signatures the dup happens
  elsewhere, we dont need to check the argument for non-null here.

Sanitize rpmVerifySignature() a bit

- Hash context is required for everything, require non-NULL ctx
  in rpmVerifySignature() already
- pgpDig is only relevant for true signature, digest checking doesn't
  need it - dont require dummy dig to be passed for digests.
- Treat unknown signatures as a case of bad parameters: we're the
  only caller of rpmVerifySignature() so it'd be us screwing up if
  we ask for unknown signature to be verified.
- Treat bad parameters as a hard failure instead of "not found",
  bad parameters mean we cannot verify the signature which really
  equals FAIL.

Also add RPMTAG_OPTFLAGS during spec parse since we easily can...

Add implicit self-provides during spec parse already

- Makes the self-provides accessible on spec parse queries, shouldn't
  affect anything else.

Split signature/digest verification out of headerVerify()

- headerVerify() is big enough without having all the signature
  goo inline, just lift the whole signature/digest business into
  separate function. Supposedly no functional changes...

Unobfuscate header digest calculation in headerVerify()

- Assigning goo to temporary variables for calling rpmDigestUpdate()
  doesn't make it any more readable, more the contrary. Also
  don't bother with htonl() (calls that should've been ntohl()
  for "correctness") when we have the data elsewhere in host order already.

Unobfuscate headerVerify() exit logic

- Jumping forwards is one thing, jumping backwards and forwards to an
  exit label residing in the middle of a function is something else...
  Refactor to single point of exit, at the end of the function.
- Handle the no header-only signature/digest case (whether disabled
  or v3 package) and cleanup centrally at the exit label, everything
  falls through there now.

Eliminate pointless exit label from headerVerify()

- pgpNewDig() like most rpm "constructor" functions cannot fail,
  no point checking the result. Allows an icky backwards goto + label
  to be eliminated.

Push couple of variables to more local scope

- No functional changes, just preparing to tidy up the headerVerify()
  monster a bit.

Eliminate redundant local variable in headerLoad()

Sanity check region length on header load

- Region size can't obviously be larger than the containing header,
  sanity check to avoid crashes from malformed packages.
- We should really test for length equality here, but with dribbles
  the size is sometimes off by three, whatever the reason (bug likely),
  leaving that investigation for some sunnier day...

Sanity check OpenPGP packet lengths in pgpPrtSubType()

- Sub-packet prefix length + packet length can't very well be larger
  than the remaining packet length. In addition to sanity checking,
  return an error code and have callers actually check for it.
- Fixes (yet another) segfault on malformed package (RhBug:742499)

Sanity check region offset range on headerLoad()

- Fixes the  first case crash of RhBug:741606 / CVE-2011-3378 where
  immutable region offset is way out of bounds.

Sanity check region offset in regionSwab()

- Region offsets are supposed to be negative when when an entry
  is involved, otherwise zero. Fixes some cases of crash'n'burn on
  malformed headers having bogus offsets (CVE-2011-3378)

Whoops, ftell() and rpmio equivalents should return long not off_t

Fix up a few strict-prototype warnings on x86

Kick out ppc arch detection leftovers

- This should've been in commit 6e2f56fe25a9ee62af51e0408861a8a43c97a709
  all the way back then, unused ever since...

Eliminate hysterical copy-paste comments from rpmrc

Bit of rpmrc spring-cleaning: nuke detection for some extinct creatures

Add Transifex config + adjust .gitignore to track it

Nuke ancient ChangeLog in po/

Use POPT_BIT_SET for setting the scriptlet flags

- No functional changes, just avoid doing extra work for what popt
  can already do for us.

Actually remember scriptlet flags in the rpmScript struct

- Currently doesn't make any difference but since we actually
  have a flags member in the struct, might as well use it. Also
  we'll shortly be needing these during the actual execution too.

Rename scriptlet flags from RPMSCRIPT_FOO to RPMSCRIPT_FLAG_FOO

- No functional changes (and this is still internal-only API),
  just making more obvious what they are and clearing the
  RPMSCRIPT_FOO namespace for possible future use for the scriptlet
  types themselves.

Show all interpreter arguments on --scripts query (ticket #847)

- Previously any arguments to interpreter were invisible unless
  you happened to know that RPMTAG_FOOPROG are actually string
  arrays despite their type showing plain string, and queried
  as arrays. This makes all the arguments for all scriptlets
  supporting interpreter arguments visible on --scripts query
  and also serves as an example on how to properly query them.i
- Perhaps worth noting is the exact formatting of the query:
  "(using[ %{PRETRANSPROG}]" instead of the more typical style of
  "(using [%{PRETRANSPROG} ]" to avoid extra trailing blanks.

Show possible %verifyscript interpreter similarly to other scriptlets

Scriptlet argument tags are really arrays

- While the vast majority of scriptlet interpreters only consist
  of the interpreter name itself, they all can consist of arbitrary
  number of extra arguments. Rpm itself doesn't really care whether
  the tags are strings or string arrays but the scalar definition
  causes the rest of arguments to be invisible from eg python.
  Also having the type shown as string array hints at the proper
  query format when accessing these (and rpm itself is doing it
  wrong too in --scripts alias). Related to ticket #847.

Sanity check trigger scriptlet arguments on build

- Trigger scriptlets differ from other types in that additional
  arguments to scriptlet interpreter are not supported due to the
  way trigger data is stored in the header. Until now any extra
  arguments have just been quietly discarded, make it an hard
  error to avoid surprises.

Fix brp-python-bytecompile breakage from the recent whitespace patch

Use the new FOO_NEVRS extensions for --requires etc popt aliases

- Makes the popt foobar somewhat saner and fixes RhBug:717534 and
  RhBug:735801 while at it.

Add four new extension tags for pretty-formatting dependencies

- The current method that --requires and friends use is kinda
  cumbersome and outputs extra whitespace for dependencies which
  dont have flags+version attached. Adding extensions for this
  is likely to be easier than teaching query formatting to
  permit conditionalizing on current value instead of just tag existence.

$RPM_BUILD_ROOT breaks brp-* scripts if it contains spaces (ticket #843)

- This patch adds quotes around $RPM_BUILD_ROOT in places that I noticed
  they were missing, and attempts to handle some of the problems that can
  occur when looping over the output of find.

Signed-off-by: Panu Matilainen <pmatilai@redhat.com>

Manual typo fix.

Signed-off-by: Panu Matilainen <pmatilai@redhat.com>

Sync autoconf macro defaults in manual with the macros file.

Signed-off-by: Panu Matilainen <pmatilai@redhat.com>

Make --pipe command failures reflect our exit codes (RhBug:735481)

Make rpmScript opaque

- Add accessor for fetching the script tag, the final piece that
  psm needs (and will continue to do so) from script internals.
  This allows the script type to become opaque for real.

Add an API for creating real rpmScript items out of triggers, use it

- Bury rpmScriptNew() into being internal helper in rpmscript -
  triggers and other scripts differ quite a bit in how their data
  is laid out in the header, especially args need "special attention".
- Besides cleaning up things in the psm side, this technically makes
  trigger scripts runnable without having a header at hand. Of course
  currently trigger scripts are currently created and destroyed
  on the spot from headers so this is of academic interest...

First step towards unifying triggers into rpmScript API

- Add a lower level script creation function to deal with the
  body expansions and such, use it for triggers as well.
- This is still fairly ugly but its something that can be reasonably
  backported to 4.9.x which needs this too, as currently triggers
  are forgetting to set script->descr, causing "(null) failure" messages
  on glibc and on others, in would just crash on trigger failure
  and/or in debug verbosity level.

Fix up one strict-prototype warning that has crept in meantime

GCC warning option tweaks

- WTH are we compiling with -Wno-char-subscripts? This appears to have
  been there since the dawn of times, and at least nowadays removing
  it causes no new warnings.
- Re-enable -Wstrict-prototypes, either NSS headers have gotten fixed
  or GCC has gotten smarter and no longer whines about broken
  system headers.

Oops, RPMSENSE_PRETRANS and _POSTTRANS missing from python bindings