keyring_p.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_PRIVATE_KEYRINGIMPL_H
#define ZYPP_PRIVATE_KEYRINGIMPL_H
 
#include <zypp-core/ng/base/signals.h>
#include <zypp-core/fs/TmpPath.h>
#include <zypp-core/fs/WatchFile>
#include <zypp-common/KeyManager.h>
#include <zypp-core/ng/pipelines/expected.h>
#include <functional>
#include <optional>
 
namespace zypp {
 

  struct CachedPublicKeyData : private base::NonCopyable
  {
    const std::list<PublicKeyData> & operator()( const Pathname & keyring_r ) const;
 
    void setDirty( const Pathname & keyring_r );

    struct Manip {
      NON_COPYABLE_BUT_MOVE( Manip );
      Manip( CachedPublicKeyData & cache_r, Pathname keyring_r );
 
      KeyManagerCtx & keyManagerCtx();
    private:
      CachedPublicKeyData & _cache;
      Pathname _keyring;
      std::optional<KeyManagerCtx> _context;
    };


    Manip manip( Pathname keyring_r );
 
  private:
    struct Cache
    {
      Cache();
 
      void setDirty();
 
      void assertCache( const Pathname & keyring_r );
 
      bool hasChanged() const;
 
      std::list<PublicKeyData> _data;
 
    private:
 
      scoped_ptr<WatchFile> _keyringK;
      scoped_ptr<WatchFile> _keyringP;
    };
 
    using CacheMap = std::map<Pathname, Cache>;
 
    const std::list<PublicKeyData> & getData( const Pathname & keyring_r ) const;
 
    const std::list<PublicKeyData> & getData( const Pathname & keyring_r, Cache & cache_r ) const;
 
    mutable CacheMap _cacheMap;
  };

  class KeyRingImpl
  {
    public:
      enum class Ring : bool {
        General = false,
        Trusted = true,
      };
 
      zyppng::SignalProxy<void ( const PublicKey &/*key*/ )> sigTrustedKeyAdded()
      { return _sigTrustedKeyAdded; }
 
      zyppng::SignalProxy<void ( const PublicKey &/*key*/ )> sigTrustedKeyRemoved()
      { return _sigTrustedKeyRemoved; }
 
    public:
      KeyRingImpl( const Pathname & baseTmpDir );
 
    public:
      void allowPreload( bool yesno_r ) //< General keyring may be preloaded with keys cached on the system.
      { _allowPreload = yesno_r; }
 
      void setTrustedKeyRingInit( std::function<void()> init_r ) //< Executed on first use of the trusted keyring.
      { _trustedRingInit = std::move(init_r); }

      void importKey ( const PublicKey & key, const Ring ring );
      void importKeys( const std::list<PublicKey> & keys, const Ring ring );
 
      PublicKey exportKey( const std::string & id, const Ring ring ) const
      { return exportKey( id, keyRingPath( ring ) ); }
      PublicKey exportKey( const PublicKeyData & keyData, const Ring ring ) const
      { return exportKey( keyData, keyRingPath( ring ) ); }
      PublicKey exportKey( const PublicKey & key, const Ring ring ) const
      { return exportKey( key.keyData(), ring ); }
 
      void deleteKey( const std::string & id, const Ring ring );
 
      void dumpPublicKey( const std::string & id, const Ring ring, std::ostream & stream )
      { dumpPublicKey( id, keyRingPath( ring ), stream ); }
 
      bool verifyFile( const Pathname & file, const Pathname & signature, const Ring ring )
      { return verifyFile( file, signature, keyRingPath( ring ) ); }
 
      std::string readSignatureKeyId( const Pathname & signature );

      void multiKeyImport( const Pathname & keyfile_r, const Ring ring );
 
    public:
      enum class MustUpdate {
        Present = 0,  
        Missing = 1,  
        Update  = 2,  
      };

      MustUpdate mustUpdateData( const PublicKeyData & keyData, const Ring ring ) const
      {
        PublicKeyData ringKeyData { publicKeyData( keyData, ring ) };
        if ( not ringKeyData ) {
          return MustUpdate::Missing;
        }
        if ( keyData.isUpdateFor( ringKeyData ) ) {
          return MustUpdate::Update;
        }
        return MustUpdate::Present;
      }
 
      bool isKeyTrusted( const std::string & id ) const
      { return bool(publicKeyData( id, Ring::Trusted )); }
 
      bool isKeyKnown( const std::string & id ) const
      { return publicKeyData( id, Ring::Trusted ) || publicKeyData( id, Ring::General ); }
 
      PublicKeyData publicKeyData( const std::string & id, const Ring ring ) const
      { return publicKeyData( id, keyRingPath( ring ) ); }
      PublicKeyData publicKeyData( const PublicKeyData & keyData, const Ring ring ) const
      { return publicKeyData( keyData.id(), ring ); }
      PublicKeyData publicKeyData( const PublicKey & key, const Ring ring ) const
      { return publicKeyData( key.keyData().id(), ring ); }
 
      const std::list<PublicKeyData> & publicKeyData( const Ring ring ) const
      { return publicKeyData( keyRingPath( ring ) ); }
 
      std::list<PublicKey> publicKeys( const Ring ring ) const
      { return publicKeys( keyRingPath( ring ) ); }
 
 
    private:
      class SendKeys
      {
      public:
        SendKeys( KeyRingImpl & keyRing, const Pathname & source, const Pathname & target );
        SendKeys( KeyRingImpl & keyRing, const Ring source, const Ring target );
        SendKeys( const SendKeys & ) = delete;
        SendKeys( SendKeys && ) = delete;
        SendKeys & operator=( const SendKeys & ) = delete;
        SendKeys & operator=( SendKeys && ) = delete;

        void operator()( const std::string & id );
 
      private:
        KeyManagerCtx _source;
        CachedPublicKeyData::Manip _target;
      };
 
    private:
      const Pathname keyRingPath( const Ring ring ) const
      {
        if ( ring == Ring::General )
          return _general_tmp_dir.path();
        if ( _trustedRingInit ) {
          // Reset before executing: the initializer populates the ring and
          // will ask for this path again.
          KeyRingImpl * lazyinit = const_cast<KeyRingImpl*>(this);
          std::function<void()> init;
          init.swap( lazyinit->_trustedRingInit );
          init();
        }
        return _trusted_tmp_dir.path();
      }
 
      void importKey( const Pathname & keyfile, const Pathname & keyring );
 
      PublicKey exportKey( const std::string & id, const Pathname & keyring ) const;
      PublicKey exportKey( const PublicKeyData & keyData, const Pathname & keyring ) const;
 
      void deleteKey( const std::string & id, const Pathname & keyring );
 
      PublicKeyData publicKeyData( const std::string & id, const Pathname & keyring ) const;
 
      const std::list<PublicKeyData> & publicKeyData( const Pathname & keyring ) const
      {
        if ( _allowPreload && keyring == keyRingPath( Ring::General ) ) {
          KeyRingImpl * lazyinit = const_cast<KeyRingImpl*>(this);
          lazyinit->_allowPreload = false;
          lazyinit->preloadCachedKeys();
        }
        return cachedPublicKeyData( keyring );
      }
 
      std::list<PublicKey> publicKeys( const Pathname & keyring ) const;
 
      void dumpPublicKey( const std::string & id, const Pathname & keyring, std::ostream & stream ) const;
      filesystem::TmpFile dumpPublicKeyToTmp( const std::string & id, const Pathname & keyring ) const;
 
      bool verifyFile( const Pathname & file, const Pathname & signature, const Pathname & keyring );
 
    private:
      void preloadCachedKeys();

      CachedPublicKeyData::Manip keyRingManip( const Pathname & keyring )
      { return cachedPublicKeyData.manip( keyring ); }
 
    private:
      // Used for trusted and untrusted keyrings
      filesystem::TmpDir _trusted_tmp_dir;
      filesystem::TmpDir _general_tmp_dir;
      Pathname _base_dir;
      bool _allowPreload = false;  //< General keyring may be preloaded with keys cached on the system.
      std::function<void()> _trustedRingInit;       //< Executed on first use of the trusted keyring.

      CachedPublicKeyData cachedPublicKeyData;
 
      zyppng::Signal<void ( const PublicKey &/*key*/ )> _sigTrustedKeyAdded;
      zyppng::Signal<void ( const PublicKey &/*key*/ )> _sigTrustedKeyRemoved;
  };
 
  inline std::ostream & operator<<( std::ostream & str, KeyRingImpl::Ring ring )
  { return str << ( ring == KeyRingImpl::Ring::General ? "generalKeyRing" : "trustedKeyRing" ); }
 
  inline std::ostream & operator<<( std::ostream & str, KeyRingImpl::MustUpdate flag )
  { return str << ( flag == KeyRingImpl::MustUpdate::Present ? "=" : flag == KeyRingImpl::MustUpdate::Missing ? "+" : ">" ); }
}
 
 
#endif