easier revocation checks

[anarcat]

There is a neat is_expired property in the PGPKey class. We should also have a is_revoked property to easily check if a key is revoked. That property should:

• look for revocation signatures on the key (done in Add revocation_signatures property to PGPKey. #207)
• verify the signatures against the keys allowed to revoke it (needs Support Revocation Key signature subpackets and honor them in PGPKey.revoke(). #198 to check against revokers and Support IssuerFingerprint subpacket. #205 for full fingerprint comparison)

The latter may require this to be a real function, not a property, because we may have to pass public key material to verify the revocation signature, in case of third-party revocations. With RFCbis, the full fingerprint is attached to signatures, so we may be able to check against that, but that seems flaky as well: that field is just indicative...

So I'm not sure this can be a property. Maybe this could be an indicative is_revoked property that needs to be checked with an actual verify using actual public key material.

[anarcat]

so this can partly be done right now, provided that you have the key material of the delegated revokers.

for keyclass, algo, fingerprint in somekey.revocation_keys():
  if fingerprint == somekey.fingerprint:
    revoker = somekey
  else:
    revoker = PGPkey.from_thin_air(fingerprint) # obviously that part is missing
  revoker.verify(somekey, somekey.revocation_signatures())

the challenge here, obviously is to verify revocation on somekey when the revoker key isn't the key itself. we then need to fetch the key elsewhere, something that cannot be done at all in PGPy right now.

[anarcat]

looking at this comment it seems the above code misses some key part of the RFC, namely that the keyclass and algo fields match the signature as well, something that verify doesn't support right now. so maybe there's room for a dedicated revoker.revoked(somekey) interface that would cover for those situations.

[anarcat]

and obviously, this doesn't actually work:

for keyclass, algo, fingerprint in somekey.revocation_keys():

so I made #227 to fix that.

[anarcat]

so here's how i implemented this so far:

https://0xacab.org/monkeysphere/monkeypy/commit/0bf0d9f30b419bdccbb1d4942665124294730a88#6768269555ca74f15c1cdba28cf1d4a0b31feb67_43_69

instead of relying on a blind is_revoked property (from #223 - obviously too naive), we expand the check as discussed to cover revoker delegations and so on. in short, this would look like:

def is_revoked(subkey, primary=None):
  revoker = primary or subkey
  for sig in key.revocation_signatures(): # needs #227
    if sig.signer != revoker.fingerprint.keyid:
      continue
    verified = revoker.verify(key, sig)
    if verified:
      return verified
  return False

... and that's just for self-signatures. for revoker delegation, we'll probably need to turn that into a set of revokers and dynamically load the public key material for those folks in my program.

[anarcat]

and yes, this could be part of the PGPKey API, which would be, as @Commod0re suggested, "did key A revoke key B" semantics:

def revoked(self, key):
    for sig in revocation_signatures(key):  # needs #227
        if sig.signer not in {self.fingerprint.keyid} | set(self.subkeys):
            continue
        logging.debug('checking revocation signature %r', sig)
        verified = self.verify(key, sig)
        if verified:
            return verified
    return False

(Maybe SignatureVerification elements could be aggregated here somhow and be returned in one shot.)

Then this would be used like this:

revoker = primary or subkey
if revoker.revoked(subkey):
  return True
revokers = list(subkey.revocation_keys())
for revoker in [PGPKey.from_keyserver(x) for x in revokers]:
  if revoker.revoked(subkey):
    return True

logic like this is now defined in openpgp2ssh here:

https://0xacab.org/monkeysphere/monkeypy/blob/dcd2fd4b34404b5be43716927cf3b075df5274f9/openpgp2ssh.py#L80

how does that look?