You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
261 lines
5.4 KiB
261 lines
5.4 KiB
/*
|
|
kpgpkey.cpp
|
|
|
|
Copyright (C) 2001,2002 the KPGP authors
|
|
See file AUTHORS.kpgp for details
|
|
|
|
This file is part of KPGP, the KDE PGP/GnuPG support library.
|
|
|
|
KPGP is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software Foundation,
|
|
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "kpgpkey.h"
|
|
#include "kdebug.h"
|
|
|
|
namespace Kpgp {
|
|
|
|
/* member functions of Kpgp::KeyIDList --------------------------------- */
|
|
|
|
/** Converts from a KeyIDList to a TQStringList.
|
|
*/
|
|
TQStringList KeyIDList::toStringList() const
|
|
{
|
|
TQStringList res;
|
|
for( KeyIDList::ConstIterator it = begin(); it != end(); ++it ) {
|
|
res << (*it).data();
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/** Converts from a TQStringList to a KeyIDList.
|
|
*/
|
|
KeyIDList KeyIDList::fromStringList( const TQStringList& l )
|
|
{
|
|
KeyIDList res;
|
|
for( TQStringList::ConstIterator it = l.begin(); it != l.end(); ++it ) {
|
|
res << (*it).local8Bit();
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/* member functions of Kpgp::UserID ------------------------------------ */
|
|
|
|
UserID::UserID(const TQString& str, const Validity validity,
|
|
const bool revoked, const bool invalid)
|
|
{
|
|
mText = str;
|
|
mValidity = validity;
|
|
mRevoked = revoked;
|
|
mInvalid = invalid;
|
|
}
|
|
|
|
|
|
/* member functions of Kpgp::Subkey ------------------------------------ */
|
|
|
|
Subkey::Subkey(const KeyID& keyID, const bool secret)
|
|
{
|
|
mSecret = secret;
|
|
mKeyID = keyID;
|
|
|
|
mRevoked = false;
|
|
mExpired = false;
|
|
mDisabled = false;
|
|
mInvalid = false;
|
|
mCanEncrypt = false;
|
|
mCanSign = false;
|
|
mCanCertify = false;
|
|
mKeyAlgo = 0;
|
|
mKeyLen = 0;
|
|
mFingerprint = 0;
|
|
mTimestamp = 0;
|
|
mExpiration = 0;
|
|
}
|
|
|
|
|
|
/* member functions of Kpgp::Key --------------------------------------- */
|
|
|
|
Key::Key(const KeyID& keyid, const TQString& uid, const bool secret) :
|
|
mSubkeys(), mUserIDs()
|
|
{
|
|
mSecret = secret;
|
|
if (!keyid.isEmpty())
|
|
addSubkey(keyid, secret);
|
|
if (!uid.isEmpty())
|
|
addUserID(uid);
|
|
|
|
mRevoked = false;
|
|
mExpired = false;
|
|
mDisabled = false;
|
|
mInvalid = false;
|
|
mCanEncrypt = false;
|
|
mCanSign = false;
|
|
mCanCertify = false;
|
|
|
|
mEncryptPref = UnknownEncryptPref;
|
|
}
|
|
|
|
Key::~Key()
|
|
{
|
|
//kdDebug(5100) << "Kpgp::Key: Deleting key " << primaryUserID() << endl;
|
|
mUserIDs.setAutoDelete(true);
|
|
mUserIDs.clear();
|
|
mSubkeys.setAutoDelete(true);
|
|
mSubkeys.clear();
|
|
}
|
|
|
|
void
|
|
Key::clear()
|
|
{
|
|
mSecret = false;
|
|
mRevoked = false;
|
|
mExpired = false;
|
|
mDisabled = false;
|
|
mInvalid = false;
|
|
mCanEncrypt = false;
|
|
mCanSign = false;
|
|
mCanCertify = false;
|
|
|
|
mEncryptPref = UnknownEncryptPref;
|
|
|
|
mSubkeys.setAutoDelete(true);
|
|
mSubkeys.clear();
|
|
mUserIDs.setAutoDelete(true);
|
|
mUserIDs.clear();
|
|
}
|
|
|
|
Validity
|
|
Key::keyTrust() const
|
|
{
|
|
Validity trust = KPGP_VALIDITY_UNKNOWN;
|
|
|
|
for( UserIDListIterator it(mUserIDs); it.current(); ++it )
|
|
{
|
|
if( (*it)->validity() > trust )
|
|
trust = (*it)->validity();
|
|
}
|
|
|
|
return trust;
|
|
}
|
|
|
|
Validity
|
|
Key::keyTrust( const TQString& uid ) const
|
|
{
|
|
Validity trust = KPGP_VALIDITY_UNKNOWN;
|
|
|
|
if( uid.isEmpty() )
|
|
return trust;
|
|
|
|
for( UserIDListIterator it(mUserIDs); it.current(); ++it )
|
|
{
|
|
if( (*it)->text() == uid )
|
|
trust = (*it)->validity();
|
|
}
|
|
|
|
return trust;
|
|
}
|
|
|
|
void
|
|
Key::cloneKeyTrust( const Key* key )
|
|
{
|
|
if( !key )
|
|
return;
|
|
|
|
for( UserIDListIterator it(mUserIDs); it.current(); ++it )
|
|
{
|
|
(*it)->setValidity( key->keyTrust( (*it)->text() ) );
|
|
}
|
|
}
|
|
|
|
bool
|
|
Key::isValid() const
|
|
{
|
|
return ( !mRevoked && !mExpired && !mDisabled && !mInvalid );
|
|
}
|
|
|
|
|
|
bool
|
|
Key::isValidEncryptionKey() const
|
|
{
|
|
return ( !mRevoked && !mExpired && !mDisabled && !mInvalid && mCanEncrypt );
|
|
}
|
|
|
|
|
|
bool
|
|
Key::isValidSigningKey() const
|
|
{
|
|
return ( !mRevoked && !mExpired && !mDisabled && !mInvalid && mCanSign );
|
|
}
|
|
|
|
|
|
void Key::addUserID(const TQString &uid, const Validity validity,
|
|
const bool revoked, const bool invalid)
|
|
{
|
|
if (!uid.isEmpty()) {
|
|
UserID *userID = new UserID(uid, validity, revoked, invalid);
|
|
mUserIDs.append(userID);
|
|
}
|
|
}
|
|
|
|
bool Key::matchesUserID(const TQString& str, bool cs)
|
|
{
|
|
if (str.isEmpty() || mUserIDs.isEmpty())
|
|
return false;
|
|
|
|
for (UserIDListIterator it(mUserIDs); it.current(); ++it) {
|
|
if (((*it)->text().find(str, 0, cs)) != -1)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void Key::addSubkey(const KeyID& keyID, const bool secret)
|
|
{
|
|
if (!keyID.isEmpty()) {
|
|
Subkey *key = new Subkey(keyID, secret);
|
|
mSubkeys.append(key);
|
|
}
|
|
}
|
|
|
|
Subkey *Key::getSubkey(const KeyID& keyID)
|
|
{
|
|
if (keyID.isEmpty() || mSubkeys.isEmpty())
|
|
return 0;
|
|
|
|
// is the given key ID a long (16 chars) or a short (8 chars) key ID?
|
|
bool longKeyID = (keyID.length() == 16);
|
|
|
|
for (SubkeyListIterator it(mSubkeys); it.current(); ++it) {
|
|
if (longKeyID) {
|
|
if ((*it)->longKeyID() == keyID)
|
|
return (*it);
|
|
}
|
|
else {
|
|
if ((*it)->keyID() == keyID)
|
|
return (*it);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void Key::setFingerprint(const KeyID& keyID, const TQCString &fpr)
|
|
{
|
|
Subkey *key;
|
|
if ((key = getSubkey(keyID)) != 0) {
|
|
key->setFingerprint(fpr);
|
|
}
|
|
else
|
|
kdDebug(5006) << "Error: Can't set fingerprint. A subkey with key ID 0x"
|
|
<< keyID << " doesn't exist." << endl;
|
|
}
|
|
|
|
} // namespace Kpgp
|