PublicKey.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_PUBLICKEY_H
#define ZYPP_PUBLICKEY_H
 
#include <iosfwd>
#include <list>
#include <string>
#include <utility>
 
#include <zypp-common/base/DrunkenBishop.h>
 
#include <zypp-core/base/Iterable.h>
#include <zypp-core/base/PtrTypes.h>
#include <zypp-core/base/Exception.h>
#include <zypp-core/Pathname.h>
#include <zypp/Edition.h>
#include <zypp-core/Date.h>
 
struct _gpgme_key;
struct _gpgme_subkey;
struct _gpgme_key_sig;

namespace zypp
{ 
 
  namespace filesystem
  {
    class TmpFile;
  }
  class PublicKeyData;
  class KeyManagerCtx;

  class ZYPP_API BadKeyException : public Exception
  {
    public:
      BadKeyException()
      : Exception( "Bad Key Exception" )
      {}
 
      Pathname keyFile() const
      { return _keyfile; }

      BadKeyException( const std::string & msg_r, Pathname keyfile = Pathname() )
      : Exception( msg_r ), _keyfile(std::move(keyfile))
      {}

      ~BadKeyException() throw() override {};
    private:
      Pathname _keyfile;
  };


  class ZYPP_API PublicSubkeyData
  {
  public:
    PublicSubkeyData();
 
    ~PublicSubkeyData();

    explicit operator bool() const;
 
  public:
    std::string id() const;

    Date created() const;

    Date expires() const;

    bool expired() const;

    int daysToLive() const;

    std::string asString() const;
 
  private:
    struct Impl;
    RWCOW_pointer<Impl> _pimpl;
    friend class PublicKeyData;
    friend std::ostream & dumpOn( std::ostream & str, const PublicKeyData & obj );
    PublicSubkeyData(const _gpgme_subkey *rawSubKeyData);
  };


  inline std::ostream & operator<<( std::ostream & str, const PublicSubkeyData & obj )
  { return str << obj.asString(); }

  class ZYPP_API PublicKeySignatureData
  {
  public:
    PublicKeySignatureData();
 
    ~PublicKeySignatureData();

    explicit operator bool() const;
 
  public:
    std::string id() const;

    std::string name() const;

    Date created() const;

    Date expires() const;

    bool expired() const;

    int daysToLive() const;

    std::string asString() const;
 
  private:
    struct Impl;
    RWCOW_pointer<Impl> _pimpl;
    friend class PublicKeyData;
    friend std::ostream & dumpOn( std::ostream & str, const PublicKeyData & obj );
    PublicKeySignatureData(const _gpgme_key_sig *rawKeySignatureData);
  };


  inline std::ostream & operator<<( std::ostream & str, const PublicKeySignatureData & obj )
  { return str << obj.asString(); }

  class ZYPP_API PublicKeyData
  {
  public:
    PublicKeyData();
 
    ~PublicKeyData();
 
    PublicKeyData(const PublicKeyData &) = default;
    PublicKeyData(PublicKeyData &&) noexcept = default;
    PublicKeyData &operator=(const PublicKeyData &) = default;
    PublicKeyData &operator=(PublicKeyData &&) noexcept = default;

    explicit operator bool() const;
 
  public:
    std::string id() const;

    std::string name() const;

    std::string fingerprint() const;

    std::string algoName() const;

    Date created() const;

    Date expires() const;

    bool expired() const;

    int daysToLive() const;

    std::string expiresAsString() const;

    std::string gpgPubkeyVersion() const;

    std::string gpgPubkeyRelease() const;

    static std::string date2release( const Date & date_r );

    std::string rpmName () const;

    Edition gpgPubkeyEdition() const
    { return Edition( gpgPubkeyVersion(), gpgPubkeyRelease() ); }

    std::string asString() const;

    bool isUpdateFor( const PublicKeyData & rhs ) const
    {
      // bnc #393160: Comment #30: Compare at least the fingerprint
      // in case an attacker created a key the the same id.
      //
      // bsc#1008325: For keys using subkeys, we'd actually need to compare
      // the subkey sets, to tell whether a key was updated. because created()
      // remains unchanged if the primary key is not touched.
      // For now we wait until a new subkey signs any metadata and treat it as
      // a new key then (see VerifyFileSignatureLogic)
      return not rhs || ( fingerprint() == rhs.fingerprint() && created() > rhs.created() );
    }
 
  public:
    using SubkeyIterator = const PublicSubkeyData *;
    using KeySignatureIterator = const PublicKeySignatureData *;

    bool hasSubkeys() const;

    Iterable<SubkeyIterator> subkeys() const;

    Iterable<KeySignatureIterator> signatures() const;

    bool providesKey( const std::string & id_r ) const;

    static bool isSafeKeyId( const std::string & id_r )
    { return id_r.size() >= 16; }
 
  public:
    bool hasSignatures() const;
 
  public:
    using AsciiArt = base::DrunkenBishop;

    AsciiArt asciiArt() const;
 
  private:
    struct Impl;
    RWCOW_pointer<Impl> _pimpl;
 
    friend class KeyManagerCtx;
    static PublicKeyData fromGpgmeKey(_gpgme_key *data);
 
    PublicKeyData(shared_ptr<Impl> data);
    friend std::ostream & dumpOn( std::ostream & str, const PublicKeyData & obj );
  };


  inline std::ostream & operator<<( std::ostream & str, const PublicKeyData & obj )
  { return str << obj.asString(); }

  std::ostream & dumpOn( std::ostream & str, const PublicKeyData & obj ) ZYPP_API;

  bool operator==( const PublicKeyData & lhs, const PublicKeyData & rhs ) ZYPP_API;

  inline bool operator!=( const PublicKeyData & lhs, const PublicKeyData & rhs )
  { return !( lhs == rhs ); }

  class ZYPP_API PublicKey
  {
  public:
    struct Impl;
 
  public:
    PublicKey();

    explicit PublicKey( const Pathname & keyFile_r );

    explicit PublicKey( const filesystem::TmpFile & sharedFile_r );
 
    ~PublicKey();

    static PublicKey noThrow( const Pathname & keyFile_r );
 
  public:
    const PublicKeyData & keyData() const;
 
    using SubkeyIterator = PublicKeyData::SubkeyIterator;
 
    bool isValid() const
    { return ! ( id().empty() || fingerprint().empty() ); }
 
    std::string id() const;                     
    std::string name() const;                   
    std::string fingerprint() const;            
    std::string algoName() const;               
    Date created() const;                       
    Date expires() const;                       
    std::string expiresAsString() const;        
    bool expired() const;                       
    int daysToLive() const;                     
    std::string gpgPubkeyVersion() const;       
    std::string gpgPubkeyRelease() const;       
    std::string asString() const;               
    std::string rpmName () const;
 
    Edition gpgPubkeyEdition() const            
    { return keyData().gpgPubkeyEdition(); }
 
    bool hasSubkeys() const                     
    { return keyData().hasSubkeys(); }
 
    Iterable<SubkeyIterator> subkeys() const    
    { return keyData().subkeys(); }
 
    bool providesKey( const std::string & id_r ) const  
    { return keyData().providesKey( id_r ); }
 
    static bool isSafeKeyId( const std::string & id_r ) 
    { return PublicKeyData::isSafeKeyId(id_r); }
 
  public:
    using AsciiArt = PublicKeyData::AsciiArt;   
 
    AsciiArt asciiArt() const                   
    { return keyData().asciiArt(); }
 
  public:
    Pathname path() const;
 
    bool hasHiddenKeys() const
    { return not hiddenKeys().empty(); }

    const std::list<PublicKeyData> & hiddenKeys() const;

    bool fileProvidesKey( const std::string & id_r ) const;
 
  public:
    bool operator==( const PublicKey & rhs ) const;
    bool operator!=( const PublicKey & rhs ) const
    { return not operator==( rhs ); }
    bool operator==( const std::string & sid ) const;
    bool operator!=( const std::string & sid ) const
    { return not operator==( sid ); }
 
  private:
    friend class KeyRingImpl;
    PublicKey( const filesystem::TmpFile & sharedFile_r, const PublicKeyData & keyData_r );
    explicit PublicKey( const PublicKeyData & keyData_r );
 
  private:
    RWCOW_pointer<Impl> _pimpl;
  };


  inline std::ostream & operator<<( std::ostream & str, const PublicKey & obj )
  { return str << obj.asString(); }

  std::ostream & dumpOn( std::ostream & str, const PublicKey & obj ) ZYPP_API;

} // namespace zypp
#endif // ZYPP_PUBLICKEY_H