KeyRing.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_KEYRING_H
#define ZYPP_KEYRING_H
 
#include <iosfwd>
#include <map>
#include <list>
#include <set>
#include <string>
 
#include <zypp/base/ReferenceCounted.h>
#include <zypp/base/Flags.h>
#include <zypp/Callback.h>
#include <zypp/base/PtrTypes.h>
#include <zypp/Locale.h>
#include <zypp/KeyRingContexts.h>
 
#include <zypp-common/PublicKey.h>
#include <zypp-common/KeyRingException.h>

namespace zypp
{ 
 
  DEFINE_PTR_TYPE(KeyRing);

  struct ZYPP_API KeyRingReport : public callback::ReportBase
  {
    enum KeyTrust
    {
      KEY_DONT_TRUST = 0,
      KEY_TRUST_TEMPORARILY,
      KEY_TRUST_AND_IMPORT
    };

    virtual KeyTrust askUserToAcceptKey( const PublicKey &key, const KeyContext &keycontext = KeyContext() );

    virtual void infoVerify( const std::string & file_r, const PublicKeyData & keyData_r, const KeyContext &keycontext = KeyContext() );
 
    virtual bool askUserToAcceptUnsignedFile( const std::string &file, const KeyContext &keycontext = KeyContext() );

    virtual bool askUserToAcceptUnknownKey( const std::string &file, const std::string &id, const KeyContext &keycontext = KeyContext() );

    virtual bool askUserToAcceptVerificationFailed( const std::string &file, const PublicKey &key, const KeyContext &keycontext = KeyContext() );

    bool askUserToAcceptPackageKey( const PublicKey &key_r, const KeyContext &keycontext_r = KeyContext() );
    constexpr static const char * ACCEPT_PACKAGE_KEY_REQUEST = "KeyRingReport/AcceptPackageKey";

     void reportNonImportedKeys( const std::set<Edition> &keys_r );
     constexpr static const char *KEYS_NOT_IMPORTED_REPORT = "KeyRingReport/KeysNotImported";
 

     void reportAutoImportKey( const std::list<PublicKeyData> & keyDataList_r,
                               const PublicKeyData & keySigning_r,
                               const KeyContext &keyContext_r );
     constexpr static const char *REPORT_AUTO_IMPORT_KEY = "KeyRingReport/reportAutoImportKey";
  };
 
  struct ZYPP_API KeyRingSignals : public callback::ReportBase
  {
    virtual void trustedKeyAdded( const PublicKey &/*key*/ )
    {}
    virtual void trustedKeyRemoved( const PublicKey &/*key*/ )
    {}
  };

  //
  //    CLASS NAME : KeyRing
  //
  class ZYPP_API KeyRing : public base::ReferenceCounted, private base::NonCopyable
  {
    friend std::ostream & operator<<( std::ostream & str, const KeyRing & obj );
 
    public:

      enum DefaultAcceptBits
      {
        ACCEPT_NOTHING             = 0x0000,
        ACCEPT_UNSIGNED_FILE       = 0x0001,
        ACCEPT_UNKNOWNKEY          = 0x0002,
        TRUST_KEY_TEMPORARILY      = 0x0004,
        TRUST_AND_IMPORT_KEY       = 0x0008,
        ACCEPT_VERIFICATION_FAILED = 0x0010,
      };
      ZYPP_DECLARE_FLAGS( DefaultAccept, DefaultAcceptBits );

      static DefaultAccept defaultAccept();

      static void setDefaultAccept( DefaultAccept value_r );
 
  public:
    struct Impl;
 
  public:
    KeyRing(const Pathname &baseTmpDir);

    void importKey( const PublicKey &key, bool trusted = false);

    void multiKeyImport( const Pathname & keyfile_r, bool trusted_r = false );
 
    void dumpTrustedPublicKey( const std::string &id, std::ostream &stream )
    { dumpPublicKey(id, true, stream); }
 
    void dumpUntrustedPublicKey( const std::string &id, std::ostream &stream )
    { dumpPublicKey(id, false, stream); }
 
    void dumpPublicKey( const std::string &id, bool trusted, std::ostream &stream );

    PublicKey exportPublicKey( const PublicKeyData & keyData );

    PublicKey exportTrustedPublicKey( const PublicKeyData & keyData );

    std::string readSignatureKeyId( const Pathname &signature );

    bool isKeyTrusted( const std::string &id );

    bool isKeyKnown( const std::string &id );

    void deleteKey( const std::string &id, bool trusted =  false );

    std::list<PublicKey> publicKeys();

    std::list<PublicKey> trustedPublicKeys();

    std::list<PublicKeyData> publicKeyData();

    std::list<PublicKeyData> trustedPublicKeyData();

    PublicKeyData publicKeyData( const std::string &id );

    PublicKeyData trustedPublicKeyData( const std::string &id );

    bool verifyFileSignature( const Pathname &file, const Pathname &signature ) ZYPP_API;
 
    bool verifyFileTrustedSignature( const Pathname &file, const Pathname &signature ) ZYPP_API;

    ~KeyRing() override;

    KeyRing::Impl &pimpl();
 
  public:
    void allowPreload( bool yesno_r );
 
  private:
    RW_pointer<Impl> _pimpl;
  };


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

  ZYPP_DECLARE_OPERATORS_FOR_FLAGS( KeyRing::DefaultAccept );

 
  namespace target
  {
    namespace rpm
    {
      struct KeyRingSignals : public ::zypp::KeyRingSignals
      {};
    }
  }

} // namespace zypp
#endif // ZYPP_KEYRING_H