libzypp  17.31.0
PublicKey.cc
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #include <climits>
13 
14 #include <iostream>
15 #include <vector>
16 
17 #include <zypp/base/Gettext.h>
18 #include <zypp/base/String.h>
19 #include <zypp/base/Regex.h>
20 #include <zypp/PublicKey.h>
21 #include <zypp/ExternalProgram.h>
22 #include <zypp/TmpPath.h>
23 #include <zypp/PathInfo.h>
24 #include <zypp/base/Exception.h>
25 #include <zypp/base/LogTools.h>
26 #include <zypp/Date.h>
27 #include <zypp/KeyManager.h>
28 #include <zypp/ZYppFactory.h>
29 
30 #include <gpgme.h>
31 
32 using std::endl;
33 
34 #undef ZYPP_BASE_LOGGER_LOGGROUP
35 #define ZYPP_BASE_LOGGER_LOGGROUP "zypp::gpg"
36 
38 namespace zypp
39 {
41  namespace
42  {
43  inline bool isExpired( const Date & expires_r )
44  { return( expires_r && expires_r < Date::now() ); }
45 
46  inline int hasDaysToLive( const Date & expires_r )
47  {
48  if ( expires_r )
49  {
50  Date exp( expires_r - Date::now() );
51  int ret = exp / Date::day;
52  if ( exp < 0 ) ret -= 1;
53  return ret;
54  }
55  return INT_MAX;
56  }
57 
58  inline std::string expiresDetail( const Date & expires_r )
59  {
60  str::Str str;
61  if ( ! expires_r )
62  {
63  // translators: an annotation to a gpg keys expiry date
64  str << _("does not expire");
65  }
66  else if ( isExpired( expires_r ) )
67  {
68  // translators: an annotation to a gpg keys expiry date: "expired: 1999-04-12"
69  str << ( str::Format(_("expired: %1%") ) % expires_r.printDate() );
70  }
71  else
72  {
73  // translators: an annotation to a gpg keys expiry date: "expires: 2111-04-12"
74  str << ( str::Format(_("expires: %1%") ) % expires_r.printDate() );
75  }
76  return str;
77  }
78 
79  inline std::string expiresDetailVerbose( const Date & expires_r )
80  {
81  if ( !expires_r )
82  { // translators: an annotation to a gpg keys expiry date
83  return _("(does not expire)");
84  }
85  std::string ret( expires_r.asString() );
86  int ttl( hasDaysToLive( expires_r ) );
87  if ( ttl <= 90 )
88  {
89  ret += " ";
90  if ( ttl < 0 )
91  { // translators: an annotation to a gpg keys expiry date
92  ret += _("(EXPIRED)");
93  }
94  else if ( ttl == 0 )
95  { // translators: an annotation to a gpg keys expiry date
96  ret += _("(expires within 24h)");
97  }
98  else
99  { // translators: an annotation to a gpg keys expiry date
100  ret += str::form( PL_("(expires in %d day)", "(expires in %d days)", ttl ), ttl );
101  }
102  }
103  return ret;
104  }
105 
106  inline std::string keyAlgoName( const gpgme_subkey_t & key_r )
107  {
108  std::string ret;
109  if ( const char * n = ::gpgme_pubkey_algo_name( key_r->pubkey_algo ) )
110  ret = str::Str() << n << ' ' << key_r->length;
111  else
112  ret = "?";
113  return ret;
114  }
115 
116  inline bool shorterIsSuffixCI( const std::string & lhs, const std::string & rhs )
117  {
118  if ( lhs.size() >= rhs.size() )
119  return str::endsWithCI( lhs, rhs );
120  return str::endsWithCI( rhs, lhs );
121  }
122  } //namespace
124 
125 
130 
132  {
133  std::string _id;
136 
137  public:
139  static shared_ptr<Impl> nullimpl();
140 
141  private:
142  friend Impl * rwcowClone<Impl>( const Impl * rhs );
144  Impl * clone() const;
145  };
146 
147  shared_ptr<zypp::PublicSubkeyData::Impl> PublicSubkeyData::Impl::nullimpl()
148  {
149  static shared_ptr<Impl> _nullimpl( new Impl );
150  return _nullimpl;
151  }
152 
154  {
155  return new Impl( *this );
156  }
157 
161 
163  : _pimpl( Impl::nullimpl() )
164  {}
165 
166  PublicSubkeyData::PublicSubkeyData(const _gpgme_subkey *rawSubKeyData)
167  : _pimpl (new Impl)
168  {
169  _pimpl->_created = zypp::Date(rawSubKeyData->timestamp);
170  _pimpl->_expires = zypp::Date(rawSubKeyData->expires);
171  _pimpl->_id = str::asString(rawSubKeyData->keyid);
172  }
173 
175  {}
176 
177  PublicSubkeyData::operator bool() const
178  { return !_pimpl->_id.empty(); }
179 
180  std::string PublicSubkeyData::id() const
181  { return _pimpl->_id; }
182 
184  { return _pimpl->_created; }
185 
187  { return _pimpl->_expires; }
188 
190  { return isExpired( _pimpl->_expires ); }
191 
193  { return hasDaysToLive( _pimpl->_expires ); }
194 
195  std::string PublicSubkeyData::asString() const
196  {
197  return str::Str() << id() << " " << created().printDate() << " [" << expiresDetail( expires() ) << "]";
198  }
199 
204 
206  {
207  std::string _keyid;
208  std::string _name;
211 
212  public:
214  static shared_ptr<Impl> nullimpl();
215 
216  private:
217  friend Impl * rwcowClone<Impl>( const Impl * rhs );
219  Impl * clone() const;
220  };
221 
222  shared_ptr<zypp::PublicKeySignatureData::Impl> PublicKeySignatureData::Impl::nullimpl()
223  {
224  static shared_ptr<Impl> _nullimpl( new Impl );
225  return _nullimpl;
226  }
227 
229  {
230  return new Impl( *this );
231  }
232 
236 
238  : _pimpl( Impl::nullimpl() )
239  {}
240 
241  PublicKeySignatureData::PublicKeySignatureData(const _gpgme_key_sig *rawKeySignatureData)
242  : _pimpl (new Impl)
243  {
244  _pimpl->_keyid = str::asString(rawKeySignatureData->keyid);
245  _pimpl->_name = str::asString(rawKeySignatureData->uid);
246  _pimpl->_created = zypp::Date(rawKeySignatureData->timestamp);
247  _pimpl->_expires = zypp::Date(rawKeySignatureData->expires);
248  }
249 
251  {}
252 
253  PublicKeySignatureData::operator bool() const
254  { return !_pimpl->_keyid.empty(); }
255 
256  std::string PublicKeySignatureData::id() const
257  { return _pimpl->_keyid; }
258 
259  std::string PublicKeySignatureData::name() const
260  { return _pimpl->_name; }
261 
263  { return _pimpl->_created; }
264 
266  { return _pimpl->_expires; }
267 
269  { return isExpired( _pimpl->_expires ); }
270 
272  { return hasDaysToLive( _pimpl->_expires ); }
273 
275  {
276  std::string nameStr;
277  if (!name().empty()) {
278  nameStr = str::Str() << name() << " ";
279  }
280  else {
281  nameStr = "[User ID not found] ";
282  }
283  return str::Str() << nameStr
284  << id() << " "
285  << created().printDate()
286  << " [" << expiresDetail( expires() ) << "]";
287  }
288 
290  { return getZYpp()->keyRing()->isKeyTrusted(id()); }
291 
293  { return getZYpp()->keyRing()->isKeyKnown(id()); }
294 
301  {
302  std::string _id;
303  std::string _name;
304  std::string _fingerprint;
305  std::string _algoName;
308 
309  std::vector<PublicSubkeyData> _subkeys;
310  std::vector<PublicKeySignatureData> _signatures;
311 
312  public:
313  bool hasSubkeyId( const std::string & id_r ) const;
314 
315  public:
317  static shared_ptr<Impl> nullimpl();
318  static shared_ptr<Impl> fromGpgmeKey(gpgme_key_t rawData);
319 
320  private:
321  friend Impl * rwcowClone<Impl>( const Impl * rhs );
323  Impl * clone() const;
324  };
325 
326  bool PublicKeyData::Impl::hasSubkeyId( const std::string &id_r) const
327  {
328  bool ret = false;
329  for ( const PublicSubkeyData & sub : _subkeys ) {
330  if ( shorterIsSuffixCI( sub.id(), id_r ) ) {
331  ret = true;
332  break;
333  }
334  }
335  return ret;
336  }
337 
338  shared_ptr<PublicKeyData::Impl> PublicKeyData::Impl::nullimpl()
339  {
340  static shared_ptr<Impl> _nullimpl( new Impl );
341  return _nullimpl;
342  }
343 
344  shared_ptr<PublicKeyData::Impl> PublicKeyData::Impl::fromGpgmeKey(gpgme_key_t rawData)
345  {
346  //gpgme stores almost nothing in the top level key
347  //the information we look for is stored in the subkey, where subkey[0]
348  //is always the primary key
349  gpgme_subkey_t sKey = rawData->subkeys;
350  if (sKey) {
351  shared_ptr<PublicKeyData::Impl> data(new Impl);
352  //libzypp expects the date of the latest signature on the first uid
353  if ( rawData->uids && rawData->uids->signatures ) {
354  data->_created = zypp::Date(rawData->uids->signatures->timestamp);
355  // bsc#1179222: The keyring does not order the signatures when multiple
356  // versions of the same key are imported. We take the last signature here,
357  // the one GPGME_EXPORT_MODE_MINIMAL will later use in export.
358  for ( auto t = rawData->uids->signatures->next; t; t = t->next ) {
359  if (t->keyid != nullptr) {
360  data->_signatures.push_back(PublicKeySignatureData(t));
361  }
362 
363  if ( t->timestamp > data->_created )
364  data->_created = t->timestamp;
365  }
366  }
367  else
368  data->_created = zypp::Date(sKey->timestamp);
369 
370  data->_expires = zypp::Date(sKey->expires);
371  data->_fingerprint = str::asString(sKey->fpr);
372  data->_algoName = keyAlgoName( sKey );
373  data->_id = str::asString(sKey->keyid);
374 
375  //get the primary user ID
376  if (rawData->uids) {
377  data->_name = str::asString(rawData->uids->uid);
378  }
379 
380  //the rest of the keys
381  sKey = sKey->next;
382  while (sKey) {
383  data->_subkeys.push_back( PublicSubkeyData(sKey) );
384  sKey = sKey->next;
385  }
386  return data;
387  }
388  return nullimpl();
389  }
390 
392  {
393  return new Impl( *this );
394  }
395 
399 
401  : _pimpl( Impl::nullimpl() )
402  {}
403 
404  PublicKeyData::PublicKeyData(shared_ptr<Impl> data)
405  : _pimpl( data )
406  {}
407 
409  {}
410 
412  { return PublicKeyData(Impl::fromGpgmeKey(data)); }
413 
414  PublicKeyData::operator bool() const
415  { return !_pimpl->_fingerprint.empty(); }
416 
417  std::string PublicKeyData::id() const
418  { return _pimpl->_id; }
419 
420  std::string PublicKeyData::name() const
421  { return _pimpl->_name; }
422 
423  std::string PublicKeyData::fingerprint() const
424  { return _pimpl->_fingerprint; }
425 
426  std::string PublicKeyData::algoName() const
427  { return _pimpl->_algoName; }
428 
430  { return _pimpl->_created; }
431 
433  { return _pimpl->_expires; }
434 
436  { return isExpired( _pimpl->_expires ); }
437 
439  { return hasDaysToLive( _pimpl->_expires ); }
440 
441  std::string PublicKeyData::expiresAsString() const
442  { return expiresDetailVerbose( _pimpl->_expires ); }
443 
445  { return _pimpl->_id.empty() ? _pimpl->_id : str::toLower( _pimpl->_id.substr(8,8) ); }
446 
448  { return _pimpl->_created ? str::hexstring( _pimpl->_created ).substr(2) : std::string(); }
449 
450  std::string PublicKeyData::rpmName() const
451  { return str::Format( "gpg-pubkey-%1%-%2%" ) % gpgPubkeyVersion() % gpgPubkeyRelease(); }
452 
453  std::string PublicKeyData::asString() const
454  {
455  if ( not *this )
456  return "[NO_KEY]";
457 
458  str::Str str;
459  str << "[" << _pimpl->_id << "-" << gpgPubkeyRelease();
460  for ( auto && sub : _pimpl->_subkeys )
461  str << ", " << sub.id();
462  return str << "] [" << _pimpl->_name.c_str() << "] [" << expiresDetail( _pimpl->_expires ) << "]";
463  }
464 
466  { return !_pimpl->_subkeys.empty(); }
467 
469  { return makeIterable( &(*_pimpl->_subkeys.begin()), &(*_pimpl->_subkeys.end()) ); }
470 
472  { return makeIterable( &(*_pimpl->_signatures.begin()), &(*_pimpl->_signatures.end()) ); }
473 
474  bool PublicKeyData::providesKey( const std::string & id_r ) const
475  {
476  if ( not isSafeKeyId( id_r ) )
477  return( id_r.size() == 8 && str::endsWithCI( _pimpl->_id, id_r ) );
478 
479  if ( str::endsWithCI( _pimpl->_fingerprint, id_r ) )
480  return true;
481 
482  return _pimpl->hasSubkeyId( id_r );
483  }
484 
486  { return AsciiArt( fingerprint(), algoName() ); }
487 
488  std::ostream & dumpOn( std::ostream & str, const PublicKeyData & obj )
489  {
490  str << "[" << obj.name() << "]" << endl;
491  str << " fpr " << obj.fingerprint() << endl;
492  str << " id " << obj.id() << endl;
493  str << " alg " << obj.algoName() << endl;
494  str << " cre " << Date::ValueType(obj.created()) << ' ' << obj.created() << endl;
495  str << " exp " << Date::ValueType(obj.expires()) << ' ' << obj.expiresAsString() << endl;
496  str << " ttl " << obj.daysToLive() << endl;
497  for ( auto && sub : obj._pimpl->_subkeys )
498  str << " sub " << sub << endl;
499  str << " rpm " << obj.gpgPubkeyVersion() << "-" << obj.gpgPubkeyRelease() << endl;
500  return str;
501  }
502 
503  bool operator==( const PublicKeyData & lhs, const PublicKeyData & rhs )
504  { return ( lhs.fingerprint() == rhs.fingerprint() && lhs.created() == rhs.created() ); }
505 
506 
512  {
514  {}
515 
516  Impl( const Pathname & keyFile_r )
517  : _dontUseThisPtrDirectly( new filesystem::TmpFile )
518  {
519  PathInfo info( keyFile_r );
520  MIL << "Taking pubkey from " << keyFile_r << " of size " << info.size() << " and sha1 " << filesystem::checksum(keyFile_r, "sha1") << endl;
521 
522  if ( !info.isExist() )
523  ZYPP_THROW(Exception("Can't read public key from " + keyFile_r.asString() + ", file not found"));
524 
525  if ( filesystem::hardlinkCopy( keyFile_r, path() ) != 0 )
526  ZYPP_THROW(Exception("Can't copy public key data from " + keyFile_r.asString() + " to " + path().asString() ));
527 
528  readFromFile();
529  }
530 
531  Impl( const filesystem::TmpFile & sharedFile_r )
532  : _dontUseThisPtrDirectly( new filesystem::TmpFile( sharedFile_r ) )
533  { readFromFile(); }
534 
535  // private from keyring
536  Impl( const filesystem::TmpFile & sharedFile_r, const PublicKeyData & keyData_r )
537  : _dontUseThisPtrDirectly( new filesystem::TmpFile( sharedFile_r ) )
538  , _keyData( keyData_r )
539  {
540  if ( ! keyData_r )
541  {
542  WAR << "Invalid PublicKeyData supplied: scanning from file" << endl;
543  readFromFile();
544  }
545  }
546 
547  // private from keyring
548  Impl( const PublicKeyData & keyData_r )
549  : _keyData( keyData_r )
550  {}
551 
552  public:
553  const PublicKeyData & keyData() const
554  { return _keyData; }
555 
556  Pathname path() const
557  { return( /*the one and only intended use*/_dontUseThisPtrDirectly ? _dontUseThisPtrDirectly->path() : Pathname() ); }
558 
559  const std::list<PublicKeyData> & hiddenKeys() const
560  { return _hiddenKeys; }
561 
562  protected:
564  {
565  PathInfo info( path() );
566  MIL << "Reading pubkey from " << info.path() << " of size " << info.size() << " and sha1 " << filesystem::checksum(info.path(), "sha1") << endl;
567 
568  std::list<PublicKeyData> keys = KeyManagerCtx::createForOpenPGP().readKeyFromFile( path() );
569  switch ( keys.size() )
570  {
571  case 0:
572  ZYPP_THROW( BadKeyException( "File " + path().asString() + " doesn't contain public key data" , path() ) );
573  break;
574 
575  case 1:
576  // ok.
577  _keyData = keys.back();
578  _hiddenKeys.clear();
579  break;
580 
581  default:
582  WAR << "File " << path().asString() << " contains multiple keys: " << keys << endl;
583  _keyData = keys.back();
584  keys.pop_back();
585  _hiddenKeys.swap( keys );
586  break;
587  }
588 
589  MIL << "Read pubkey from " << info.path() << ": " << _keyData << endl;
590  }
591 
592  private:
593  shared_ptr<filesystem::TmpFile> _dontUseThisPtrDirectly; // shared_ptr ok because TmpFile itself is a refernce type (no COW)
595  std::list<PublicKeyData> _hiddenKeys;
596 
597  public:
599  static shared_ptr<Impl> nullimpl()
600  {
601  static shared_ptr<Impl> _nullimpl( new Impl );
602  return _nullimpl;
603  }
604 
605  private:
606  friend Impl * rwcowClone<Impl>( const Impl * rhs );
608  Impl * clone() const
609  { return new Impl( *this ); }
610  };
612 
614  // class PublicKey
617  : _pimpl( Impl::nullimpl() )
618  {}
619 
621  : _pimpl( new Impl( file ) )
622  {}
623 
625  : _pimpl( new Impl( sharedfile ) )
626  {}
627 
628  PublicKey::PublicKey( const filesystem::TmpFile & sharedfile, const PublicKeyData & keyData_r )
629  : _pimpl( new Impl( sharedfile, keyData_r ) )
630  {}
631 
632  PublicKey::PublicKey( const PublicKeyData & keyData_r )
633  : _pimpl( new Impl( keyData_r ) )
634  {}
635 
637  {}
638 
639  PublicKey PublicKey::noThrow( const Pathname & keyFile_r )
640  try { return PublicKey( keyFile_r ); } catch(...) { return PublicKey(); }
641 
643  { return _pimpl->keyData(); }
644 
646  { return _pimpl->path(); }
647 
648  const std::list<PublicKeyData> & PublicKey::hiddenKeys() const
649  { return _pimpl->hiddenKeys(); }
650 
651  bool PublicKey::fileProvidesKey( const std::string & id_r ) const
652  {
653  if ( providesKey( id_r ) )
654  return true;
655  for ( const auto & keydata : hiddenKeys() ) {
656  if ( keydata.providesKey( id_r ) )
657  return true;
658  }
659  return false;
660  }
661 
662  std::string PublicKey::id() const
663  { return keyData().id(); }
664 
665  std::string PublicKey::name() const
666  { return keyData().name(); }
667 
668  std::string PublicKey::fingerprint() const
669  { return keyData().fingerprint(); }
670 
671  std::string PublicKey::algoName() const
672  { return keyData().algoName(); }
673 
675  { return keyData().created(); }
676 
678  { return keyData().expires(); }
679 
680  bool PublicKey::expired() const
681  { return keyData().expired(); }
682 
684  { return keyData().daysToLive(); }
685 
686  std::string PublicKey::expiresAsString() const
687  { return keyData().expiresAsString(); }
688 
689  std::string PublicKey::gpgPubkeyVersion() const
690  { return keyData().gpgPubkeyVersion(); }
691 
692  std::string PublicKey::gpgPubkeyRelease() const
693  { return keyData().gpgPubkeyRelease(); }
694 
695  std::string PublicKey::asString() const
696  { return keyData().asString(); }
697 
698  std::string PublicKey::rpmName() const
699  { return keyData().rpmName(); }
700 
701  bool PublicKey::operator==( const PublicKey & rhs ) const
702  { return rhs.keyData() == keyData(); }
703 
704  bool PublicKey::operator==( const std::string & sid ) const
705  { return ( isSafeKeyId( sid ) || sid.size() == 8 ) && str::endsWithCI( fingerprint(), sid ); }
706 
707  std::ostream & dumpOn( std::ostream & str, const PublicKey & obj )
708  { return dumpOn( str, obj.keyData() ); }
709 
710 
711 
712 
714 } // namespace zypp
std::string asString() const
Simple string representation.
Definition: PublicKey.cc:195
static const ValueType day
Definition: Date.h:44
PublicKeySignatureData()
Default constructed: empty data.
Definition: PublicKey.cc:237
static shared_ptr< Impl > nullimpl()
Offer default Impl.
Definition: PublicKey.cc:147
#define MIL
Definition: Logger.h:96
Impl(const filesystem::TmpFile &sharedFile_r, const PublicKeyData &keyData_r)
Definition: PublicKey.cc:536
static bool isSafeKeyId(const std::string &id_r)
Whether this is a long id (64bit/16byte) or even better a fingerprint.
Definition: PublicKey.h:302
int daysToLive() const
Number of days (24h) until the key expires (or since it exired).
Definition: PublicKey.cc:192
std::list< PublicKeyData > readKeyFromFile(const Pathname &file)
Returns a list of all PublicKeyData found in file.
Definition: KeyManager.cc:350
#define _(MSG)
Definition: Gettext.h:37
Pathname path() const
Definition: PublicKey.cc:556
const Pathname & path() const
Return current Pathname.
Definition: PathInfo.h:246
const std::list< PublicKeyData > & hiddenKeys() const
Additional keys data in case the ASCII armored blob contains multiple keys.
Definition: PublicKey.cc:648
std::list< PublicKeyData > _hiddenKeys
Definition: PublicKey.cc:595
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
Definition: Exception.h:428
const PublicKeyData & keyData() const
The public keys data (.
Definition: PublicKey.cc:642
std::string name() const
Definition: PublicKey.cc:665
static shared_ptr< Impl > nullimpl()
Offer default Impl.
Definition: PublicKey.cc:338
Iterable< KeySignatureIterator > signatures() const
Iterate all key signatures.
Definition: PublicKey.cc:471
RWCOW_pointer< Impl > _pimpl
Definition: PublicKey.h:119
std::string gpgPubkeyRelease() const
Gpg-pubkey release as computed by rpm (hexencoded created)
Definition: PublicKey.cc:447
PublicSubkeyData implementation.
Definition: PublicKey.cc:131
bool fileProvidesKey(const std::string &id_r) const
Extends providesKey to look at the hidden keys too.
Definition: PublicKey.cc:651
Class representing one GPG Public Keys data.
Definition: PublicKey.h:206
bool expired() const
Whether the key has expired.
Definition: PublicKey.cc:189
std::string asString() const
Simple string representation.
Definition: PublicKey.cc:453
const PublicKeyData & keyData() const
Definition: PublicKey.cc:553
Exception thrown when the supplied key is not a valid gpg key.
Definition: PublicKey.h:48
std::string algoName() const
Key algorithm string like RSA 2048
Definition: PublicKey.cc:426
PublicSubkeyData()
Default constructed: empty data.
Definition: PublicKey.cc:162
std::string id() const
Definition: PublicKey.cc:662
std::string name() const
Key name.
Definition: PublicKey.cc:420
String related utilities and Regular expression matching.
RWCOW_pointer< Impl > _pimpl
Definition: PublicKey.h:185
const std::string & asString(const std::string &t)
Global asString() that works with std::string too.
Definition: String.h:139
std::string asString() const
Simple string representation.
Definition: PublicKey.cc:274
Date created() const
Creation date.
Definition: PublicKey.cc:183
static shared_ptr< Impl > nullimpl()
Offer default Impl.
Definition: PublicKey.cc:222
int daysToLive() const
Definition: PublicKey.cc:683
Convenient building of std::string with boost::format.
Definition: String.h:252
static KeyManagerCtx createForOpenPGP()
Creates a new KeyManagerCtx for PGP using a volatile temp.
Definition: KeyManager.cc:270
bool operator==(const SetRelation::Enum &lhs, const SetCompare &rhs)
Provide a new empty temporary file and delete it when no longer needed.
Definition: TmpPath.h:127
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
Iterable< SubkeyIterator > subkeys() const
Iterate any subkeys.
Definition: PublicKey.cc:468
Date expires() const
Expiry date, or Date() if the key never expires.
Definition: PublicKey.cc:265
PublicKeyData()
Default constructed: empty data.
Definition: PublicKey.cc:400
PublicKeySignatureData implementation.
Definition: PublicKey.cc:205
bool inTrustedRing() const
Whether the signature is trusted in rpmdb.
Definition: PublicKey.cc:289
bool endsWithCI(const C_Str &str_r, const C_Str &prefix_r)
Definition: String.h:1095
std::string expiresAsString() const
Definition: PublicKey.cc:686
std::string gpgPubkeyVersion() const
Gpg-pubkey version as computed by rpm (trailing 8 byte id)
Definition: PublicKey.cc:444
const std::list< PublicKeyData > & hiddenKeys() const
Definition: PublicKey.cc:559
std::string id() const
Subkey ID.
Definition: PublicKey.cc:180
Date expires() const
Definition: PublicKey.cc:677
bool operator==(const PublicKey &rhs) const
Definition: PublicKey.cc:701
std::string expiresAsString() const
Definition: PublicKey.cc:441
int daysToLive() const
Number of days (24h) until the key expires (or since it exired).
Definition: PublicKey.cc:438
RWCOW_pointer< Impl > _pimpl
Pointer to implementation.
Definition: PublicKey.h:464
std::string rpmName() const
Gpg-pubkey name as computed by rpm.
Definition: PublicKey.cc:450
Store and operate on date (time_t).
Definition: Date.h:32
Date created() const
Creation / last modification date (latest selfsig).
Definition: PublicKey.cc:429
bool expired() const
Whether the key has expired.
Definition: PublicKey.cc:268
base::DrunkenBishop AsciiArt
Random art fingerprint visualization type (base::DrunkenBishop).
Definition: PublicKey.h:311
PublicKeyData _keyData
Definition: PublicKey.cc:594
std::string name() const
The user ID associated with this key, if present.
Definition: PublicKey.cc:259
Convenient building of std::string via std::ostringstream Basically a std::ostringstream autoconverti...
Definition: String.h:211
Impl(const Pathname &keyFile_r)
Definition: PublicKey.cc:516
std::string gpgPubkeyVersion() const
Definition: PublicKey.cc:689
std::string rpmName() const
Definition: PublicKey.cc:698
const std::string & asString() const
String representation.
Definition: Pathname.h:91
bool isExist() const
Return whether valid stat info exists.
Definition: PathInfo.h:281
Impl * clone() const
clone for RWCOW_pointer
Definition: PublicKey.cc:391
#define WAR
Definition: Logger.h:97
bool providesKey(const std::string &id_r) const
!<
Definition: PublicKey.h:423
int hardlinkCopy(const Pathname &oldpath, const Pathname &newpath)
Create newpath as hardlink or copy of oldpath.
Definition: PathInfo.cc:883
bool inKnownRing() const
Whether the key has been seen before.
Definition: PublicKey.cc:292
shared_ptr< filesystem::TmpFile > _dontUseThisPtrDirectly
Definition: PublicKey.cc:593
static shared_ptr< Impl > nullimpl()
Offer default Impl.
Definition: PublicKey.cc:599
std::ostream & dumpOn(std::ostream &str, const Capability &obj)
Definition: Capability.cc:567
int daysToLive() const
Number of days (24h) until the key expires (or since it expired).
Definition: PublicKey.cc:271
Impl * clone() const
clone for RWCOW_pointer
Definition: PublicKey.cc:228
std::string toLower(const std::string &s)
Return lowercase version of s.
Definition: String.cc:177
Impl(const PublicKeyData &keyData_r)
Definition: PublicKey.cc:548
PublicKey()
Default ctor.
Definition: PublicKey.cc:616
Date created() const
Creation date.
Definition: PublicKey.cc:262
Impl * clone() const
clone for RWCOW_pointer
Definition: PublicKey.cc:153
PublicKey implementation.
Definition: PublicKey.cc:511
std::string fingerprint() const
Key fingerprint.
Definition: PublicKey.cc:423
bool expired() const
Whether the key has expired.
Definition: PublicKey.cc:435
std::string gpgPubkeyRelease() const
Definition: PublicKey.cc:692
Class representing a GPG Public Keys subkeys.
Definition: PublicKey.h:79
Class representing one GPG Public Key (PublicKeyData + ASCII armored in a tempfile).
Definition: PublicKey.h:358
Date expires() const
Expiry date, or Date() if the key never expires.
Definition: PublicKey.cc:186
AsciiArt asciiArt() const
Random art fingerprint visualization (base::DrunkenBishop).
Definition: PublicKey.cc:485
Date created() const
Definition: PublicKey.cc:674
Base class for Exception.
Definition: Exception.h:145
static bool isSafeKeyId(const std::string &id_r)
!<
Definition: PublicKey.h:426
Pathname path() const
File containing the ASCII armored key.
Definition: PublicKey.cc:645
std::string id() const
Key ID.
Definition: PublicKey.cc:417
Impl(const filesystem::TmpFile &sharedFile_r)
Definition: PublicKey.cc:531
static Date now()
Return the current time.
Definition: Date.h:78
std::string checksum(const Pathname &file, const std::string &algorithm)
Compute a files checksum.
Definition: PathInfo.cc:1051
RWCOW_pointer< Impl > _pimpl
Definition: PublicKey.h:322
#define PL_(MSG1, MSG2, N)
Definition: Gettext.h:40
std::string fingerprint() const
Definition: PublicKey.cc:668
std::string asString() const
Definition: PublicKey.cc:695
bool expired() const
Definition: PublicKey.cc:680
time_t ValueType
Definition: Date.h:38
PublicKeyData implementation.
Definition: PublicKey.cc:300
Wrapper class for ::stat/::lstat.
Definition: PathInfo.h:220
std::string printDate(DateFormat dateFormat_r=DateFormat::calendar, TimeBase base_r=TB_LOCALTIME) const
Convenience for printing the date only [&#39;2014-02-07&#39;] The default is DateFormat::calendar and TB_LOCA...
Definition: Date.h:192
static shared_ptr< Impl > fromGpgmeKey(gpgme_key_t rawData)
Definition: PublicKey.cc:344
bool hasSubkeyId(const std::string &id_r) const
Definition: PublicKey.cc:326
static PublicKey noThrow(const Pathname &keyFile_r)
Static ctor returning an empty PublicKey rather than throwing.
Definition: PublicKey.cc:639
std::vector< PublicKeySignatureData > _signatures
Definition: PublicKey.cc:310
static PublicKeyData fromGpgmeKey(_gpgme_key *data)
Definition: PublicKey.cc:411
std::vector< PublicSubkeyData > _subkeys
Definition: PublicKey.cc:309
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
bool providesKey(const std::string &id_r) const
Whether id_r is the id or fingerprint of the primary key or of a subkey.
Definition: PublicKey.cc:474
Class representing a signature on a GPG Public Key.
Definition: PublicKey.h:136
Date expires() const
Expiry date, or Date() if the key never expires.
Definition: PublicKey.cc:432
std::string hexstring(char n, int w=4)
Definition: String.h:324
std::string algoName() const
Definition: PublicKey.cc:671
std::string id() const
The key ID of key used to create the signature.
Definition: PublicKey.cc:256
bool hasSubkeys() const
Whether subkeys is not empty.
Definition: PublicKey.cc:465
Impl * clone() const
clone for RWCOW_pointer
Definition: PublicKey.cc:608
Random art fingerprint visualization Visualize fingerprint data on a [17x9] (SSH) or [19x11] (GPG) or...
Definition: DrunkenBishop.h:61