28#include <zypp-core/fs/WatchFile> 
   33#include <zypp-common/KeyManager.h> 
   39#undef  ZYPP_BASE_LOGGER_LOGGROUP 
   40#define ZYPP_BASE_LOGGER_LOGGROUP "zypp::KeyRing" 
   54  { 
return _keyRingDefaultAccept; }
 
 
   58    MIL << 
"Set new KeyRing::DefaultAccept: " << value_r << endl;
 
   59    _keyRingDefaultAccept = value_r;
 
 
   87    data.
set(
"PublicKey", key_r);
 
   88    data.
set(
"KeyContext", keycontext_r);
 
   92      return data.
get<
bool>(
"TrustKey");
 
 
   99    data.
set(
"Keys", keys_r);
 
 
  104                                           const PublicKeyData & keySigning_r,
 
  108    data.set( 
"KeyDataList", keyDataList_r );
 
  109    data.set( 
"KeySigning",  keySigning_r );
 
  110    data.set( 
"KeyContext",  keyContext_r );
 
 
  117    struct ImportKeyCBHelper
 
  122          _rpmdbEmitSignal->trustedKeyAdded( key_r );
 
  123          _emitSignal->trustedKeyAdded( key_r );
 
  125        catch ( 
const Exception & excp )
 
  127          ERR << 
"Could not import key into rpmdb: " << excp << endl;
 
  134      callback::SendReport<target::rpm::KeyRingSignals> _rpmdbEmitSignal;
 
  135      callback::SendReport<KeyRingSignals>              _emitSignal;
 
  142    MIL << 
"Current KeyRing::DefaultAccept: " << _keyRingDefaultAccept << std::endl;
 
  144    sigTrustedKeyAdded ().connect ([]( 
const PublicKey &key ){
 
  145      ImportKeyCBHelper emit;
 
  149    sigTrustedKeyRemoved ().connect ([]( 
const PublicKey &key ){
 
  152        rpmdbEmitSignal->trustedKeyRemoved( key );
 
  155        emitSignal->trustedKeyRemoved( key );
 
  159        ERR << 
"Could not delete key from rpmmdb: " << excp << endl;
 
 
  186  { 
_pimpl->allowPreload( yesno_r ); }
 
 
  190  { 
_pimpl->importKey( key, trusted ); }
 
 
  193  { 
_pimpl->multiKeyImport( keyfile_r, trusted_r ); }
 
 
  196  { 
return _pimpl->readSignatureKeyId( signature ); }
 
 
  199  { 
_pimpl->deleteKey( 
id, trusted ); }
 
 
  202  { 
return _pimpl->publicKeys(); }
 
 
  205  { 
return _pimpl->trustedPublicKeys(); }
 
 
  208  { 
return _pimpl->publicKeyData(); }
 
 
  211  { 
return _pimpl->trustedPublicKeyData(); }
 
 
  214  { 
return _pimpl->publicKeyExists( id_r ); }
 
 
  217  { 
return _pimpl->trustedPublicKeyExists( id_r ); }
 
 
  220  { 
return _pimpl->verifyFileSignature( file, signature ); }
 
 
  223  { 
return _pimpl->verifyFileTrustedSignature( file, signature ); }
 
 
  225  { 
_pimpl->dumpPublicKey( 
id, trusted, stream ); }
 
 
  228  { 
return _pimpl->exportPublicKey( keyData ); }
 
 
  231  { 
return _pimpl->exportTrustedPublicKey( keyData ); }
 
 
  234  { 
return _pimpl->isKeyTrusted( 
id ); }
 
 
  237  { 
return _pimpl->isKeyKnown( 
id ); }
 
 
bool operator()(const zypp::Arch &lhs, const zypp::Arch &rhs) const
Default order for std::container based Arch::compare.
Base class for Exception.
std::string asUserHistory() const
A single (multiline) string composed of asUserString and historyAsString.
KeyRing::Impl & pimpl()
Access to private functions for the KeyRingWorkflow implementations.
bool verifyFileTrustedSignature(const Pathname &file, const Pathname &signature) ZYPP_API
bool isKeyKnown(const std::string &id)
true if the key id is knows, that means at least exist on the untrusted keyring
std::list< PublicKey > publicKeys()
Get a list of public keys in the keyring (incl.
std::list< PublicKey > trustedPublicKeys()
Get a list of trusted public keys in the keyring (incl.
static DefaultAccept defaultAccept()
Get the active accept bits.
void dumpPublicKey(const std::string &id, bool trusted, std::ostream &stream)
void multiKeyImport(const Pathname &keyfile_r, bool trusted_r=false)
Initial import from RpmDb.
KeyRing(const Pathname &baseTmpDir)
Default ctor.
PublicKey exportPublicKey(const PublicKeyData &keyData)
Export a public key identified by its key data.
std::string readSignatureKeyId(const Pathname &signature)
reads the public key id from a signature
void allowPreload(bool yesno_r)
The general keyring may be populated with known keys stored on the system.
void importKey(const PublicKey &key, bool trusted=false)
imports a key from a file.
RW_pointer< Impl > _pimpl
Pointer to implementation.
bool verifyFileSignature(const Pathname &file, const Pathname &signature) ZYPP_API
Verifies a file against a signature, with no user interaction.
void deleteKey(const std::string &id, bool trusted=false)
removes a key from the keyring.
std::list< PublicKeyData > trustedPublicKeyData()
Get a list of trusted public key data in the keyring (key data only)
static void setDefaultAccept(DefaultAccept value_r)
Set the active accept bits.
std::list< PublicKeyData > publicKeyData()
Get a list of public key data in the keyring (key data only)
@ ACCEPT_VERIFICATION_FAILED
PublicKey exportTrustedPublicKey(const PublicKeyData &keyData)
Export a trusted public key identified by its key data.
bool isKeyTrusted(const std::string &id)
true if the key id is trusted
const Tp & get(const std::string &key_r) const
Pass back a const Tp & reference to key_r value.
bool hasvalue(const std::string &key_r) const
Whether key_r is in data and value is not empty.
bool set(const std::string &key_r, AnyType val_r)
Set the value for key (nonconst version always returns true).
Easy-to use interface to the ZYPP dependency resolver.
static bool error(const std::string &msg_r, const UserData &userData_r=UserData())
send error text
virtual void infoVerify(const std::string &file_r, const PublicKeyData &keyData_r, const KeyContext &keycontext=KeyContext())
Informal callback showing the trusted key that will be used for verification.
void reportNonImportedKeys(const std::set< Edition > &keys_r)
Notify the user about keys that were not imported from the rpm key database into zypp keyring.
KeyTrust
User reply options for the askUserToTrustKey callback.
@ KEY_TRUST_AND_IMPORT
Import the key.
@ KEY_DONT_TRUST
User has chosen not to trust the key.
@ KEY_TRUST_TEMPORARILY
This basically means, we knew the key, but it was not trusted.
static constexpr const char * REPORT_AUTO_IMPORT_KEY
generic reports UserData::type
virtual bool askUserToAcceptUnsignedFile(const std::string &file, const KeyContext &keycontext=KeyContext())
bool askUserToAcceptPackageKey(const PublicKey &key_r, const KeyContext &keycontext_r=KeyContext())
Ask user to trust and/or import the package key to trusted keyring, using ReportBase::report.
static constexpr const char * ACCEPT_PACKAGE_KEY_REQUEST
generic reports UserData::type
static constexpr const char * KEYS_NOT_IMPORTED_REPORT
generic reports UserData::type
void reportAutoImportKey(const std::list< PublicKeyData > &keyDataList_r, const PublicKeyData &keySigning_r, const KeyContext &keyContext_r)
Notify that a repository auto imported new package signing keys.
virtual KeyTrust askUserToAcceptKey(const PublicKey &key, const KeyContext &keycontext=KeyContext())
Ask user to trust and/or import the key to trusted keyring.
virtual bool askUserToAcceptUnknownKey(const std::string &file, const std::string &id, const KeyContext &keycontext=KeyContext())
we DONT know the key, only its id, but we have never seen it, the difference with trust key is that i...
virtual bool askUserToAcceptVerificationFailed(const std::string &file, const PublicKey &key, const KeyContext &keycontext=KeyContext())
The file filedesc is signed but the verification failed.
Impl(const filesystem::Pathname &baseTmpDir)
virtual void report(const UserData &userData_r=UserData())
The most generic way of sending/receiving data.
callback::UserData UserData
#define IMPL_PTR_TYPE(NAME)