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
    };

    constexpr static const char * ACCEPT_PACKAGE_KEY_REQUEST = "KeyRingReport/AcceptPackageKey";

    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() );

  };

  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:
    class 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 );

    ~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