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/PublicKey.h>
#include <zypp/KeyContext.h>
 
namespace zypp
{ 
 
  DEFINE_PTR_TYPE(KeyRing);
 
  struct 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";
 
  };
 
  struct KeyRingSignals : public callback::ReportBase
  {
    virtual void trustedKeyAdded( const PublicKey &/*key*/ )
    {}
    virtual void trustedKeyRemoved( const PublicKey &/*key*/ )
    {}
  };
 
  class KeyRingException : public Exception
   {
     public:
       KeyRingException()
       : Exception( "Bad Key Exception" )
       {}
       KeyRingException( const std::string & msg_r )
       : Exception( msg_r )
       {}
       virtual ~KeyRingException() throw() {};
   };
 
  //
  //    CLASS NAME : KeyRing
  //
  class 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 trustedPublicKeyData( const std::string &id );
 
    bool verifyFileSignatureWorkflow( const Pathname &file, const std::string &filedesc, const Pathname &signature, bool & sigValid_r, const KeyContext &keycontext = KeyContext());
    bool verifyFileSignatureWorkflow( const Pathname &file, const std::string filedesc, const Pathname &signature, const KeyContext &keycontext = KeyContext());
 
    bool verifyFileSignature( const Pathname &file, const Pathname &signature );
 
    bool verifyFileTrustedSignature( const Pathname &file, const Pathname &signature );
 
    bool provideAndImportKeyFromRepositoryWorkflow ( const std::string &id , const RepoInfo &info );
 
    ~KeyRing();
 
  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