kpgpkey.h

Go to the documentation of this file.

/*
    kpgpkey.h

    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
 */

#ifndef KPGPKEY_H
#define KPGPKEY_H

#include <QtCore/QString>
#include <QtCore/QStringList>

#include <time.h>

namespace Kpgp {

typedef enum
{ // this is copied from gpgme.h which is a part of GPGME
  KPGP_VALIDITY_UNKNOWN = 0,   // the trust hasn't been determined
  KPGP_VALIDITY_UNDEFINED = 1, // trust is undefined
  KPGP_VALIDITY_NEVER = 2,
  KPGP_VALIDITY_MARGINAL = 3,
  KPGP_VALIDITY_FULL = 4,
  KPGP_VALIDITY_ULTIMATE = 5
} Validity;

typedef enum
{
  NeverEncrypt = -1,
  UnknownEncryptPref = 0,
  AlwaysEncrypt = 1,
  AlwaysEncryptIfPossible = 2,
  AlwaysAskForEncryption = 3,
  AskWheneverPossible = 4
} EncryptPref;


typedef QByteArray KeyID;

class KeyIDList : public QList<KeyID>
{
 public:
  KeyIDList() { }
  KeyIDList( const KeyIDList& l ) : QList<KeyID>(l) { }
  KeyIDList( const QList<KeyID>& l ) : QList<KeyID>(l) { }
  explicit KeyIDList( const KeyID& i ) { append(i); }

  QStringList toStringList() const;

  static KeyIDList fromStringList( const QStringList& );
};

class UserID
{
 public:
  explicit UserID(const QString& str,
                  const Validity validity = KPGP_VALIDITY_UNKNOWN,
                  const bool revoked = false,
                  const bool invalid = false);
  ~UserID() {}

  QString text() const;

  bool revoked() const;

  bool invalid() const;

  Validity validity() const;

  void setText(const QString& str);

  void setRevoked(const bool revoked);

  void setInvalid(const bool invalid);

  void setValidity(const Validity validity);

 protected:
  bool mRevoked : 1;
  bool mInvalid : 1;
  Validity mValidity;
  QString mText;
};

typedef QList<UserID*> UserIDList;

inline QString UserID::text() const
{
  return mText;
}

inline bool UserID::revoked() const
{
  return mRevoked;
}

inline bool UserID::invalid() const
{
  return mInvalid;
}

inline Validity UserID::validity() const
{
  return mValidity;
}

inline void UserID::setText(const QString& str)
{
  mText = str;
}

inline void UserID::setRevoked(const bool revoked)
{
  mRevoked = revoked;
}

inline void UserID::setInvalid(const bool invalid)
{
  mInvalid = invalid;
}

inline void UserID::setValidity(const Validity validity)
{
  mValidity = validity;
}


class Subkey
{
 public:
  explicit Subkey(const KeyID& keyID, const bool secret = false);
  ~Subkey() {}

  bool secret() const;

  bool revoked() const;

  bool expired() const;

  bool disabled() const;

  bool invalid() const;

  bool canEncrypt() const;

  bool canSign() const;

  bool canCertify() const;

  unsigned int keyAlgorithm() const;

  unsigned int keyLength() const;

  KeyID longKeyID() const;

  KeyID keyID() const;

  QByteArray fingerprint() const;

  time_t creationDate() const;

  time_t expirationDate() const;

  void setSecret(const bool secret);

  void setRevoked(const bool revoked);

  void setExpired(const bool expired);

  void setDisabled(const bool disabled);

  void setInvalid(const bool invalid);

  void setCanEncrypt(const bool canEncrypt);

  void setCanSign(const bool canSign);

  void setCanCertify(const bool canCertify);

  void setKeyAlgorithm(const unsigned int keyAlgo);

  void setKeyLength(const unsigned int keyLen);

  void setKeyID(const KeyID& keyID);

  void setFingerprint(const QByteArray& fingerprint);

  void setCreationDate(const time_t creationDate);

  void setExpirationDate(const time_t expirationDate);

 protected:
  bool mSecret : 1;
  bool mRevoked : 1;
  bool mExpired : 1;
  bool mDisabled : 1;
  bool mInvalid : 1;
  bool mCanEncrypt : 1;
  bool mCanSign : 1;
  bool mCanCertify : 1;

  unsigned int mKeyAlgo;
  unsigned int mKeyLen;
  KeyID mKeyID;
  QByteArray mFingerprint;
  time_t mTimestamp; 
  time_t mExpiration; 
};

inline bool Subkey::secret() const
{
  return mSecret;
}

inline bool Subkey::revoked() const
{
  return mRevoked;
}

inline bool Subkey::expired() const
{
  return mExpired;
}

inline bool Subkey::disabled() const
{
  return mDisabled;
}

inline bool Subkey::invalid() const
{
  return mInvalid;
}

inline bool Subkey::canEncrypt() const
{
  return mCanEncrypt;
}

inline bool Subkey::canSign() const
{
  return mCanSign;
}

inline bool Subkey::canCertify() const
{
  return mCanCertify;
}

inline unsigned int Subkey::keyAlgorithm() const
{
  return mKeyAlgo;
}

inline unsigned int Subkey::keyLength() const
{
  return mKeyLen;
}

inline KeyID Subkey::longKeyID() const
{
  return mKeyID;
}

inline KeyID Subkey::keyID() const
{
  return mKeyID.right(8);
}

inline QByteArray Subkey::fingerprint() const
{
  return mFingerprint;
}

inline time_t Subkey::creationDate() const
{
  return mTimestamp;
}

inline time_t Subkey::expirationDate() const
{
  return mExpiration;
}

inline void Subkey::setSecret(const bool secret)
{
  mSecret = secret;
}

inline void Subkey::setRevoked(const bool revoked)
{
  mRevoked = revoked;
}

inline void Subkey::setExpired(const bool expired)
{
  mExpired = expired;
}

inline void Subkey::setDisabled(const bool disabled)
{
  mDisabled = disabled;
}

inline void Subkey::setInvalid(const bool invalid)
{
  mInvalid = invalid;
}

inline void Subkey::setCanEncrypt(const bool canEncrypt)
{
  mCanEncrypt = canEncrypt;
}

inline void Subkey::setCanSign(const bool canSign)
{
  mCanSign = canSign;
}

inline void Subkey::setCanCertify(const bool canCertify)
{
  mCanCertify = canCertify;
}

inline void Subkey::setKeyAlgorithm(const unsigned int keyAlgo)
{
  mKeyAlgo = keyAlgo;
}

inline void Subkey::setKeyLength(const unsigned int keyLen)
{
  mKeyLen = keyLen;
}

inline void Subkey::setKeyID(const KeyID& keyID)
{
  mKeyID = keyID;
}

inline void Subkey::setFingerprint(const QByteArray& fingerprint)
{
  mFingerprint = fingerprint;
}

inline void Subkey::setCreationDate(const time_t creationDate)
{
  mTimestamp = creationDate;
}

inline void Subkey::setExpirationDate(const time_t expirationDate)
{
  mExpiration = expirationDate;
}

typedef QList<Subkey*> SubkeyList;


class Key
{
 public:
  explicit Key( const KeyID& keyid = KeyID(),
                const QString& uid = QString(),
                const bool secret = false);
  ~Key();

  void clear();

  bool secret() const;

  bool revoked() const;

  bool expired() const;

  bool disabled() const;

  bool invalid() const;

  bool canEncrypt() const;

  bool canSign() const;

  bool canCertify() const;

  void setSecret(const bool secret);

  void setRevoked(const bool revoked);

  void setExpired(const bool expired);

  void setDisabled(const bool disabled);

  void setInvalid(const bool invalid);

  void setCanEncrypt(const bool canEncrypt);

  void setCanSign(const bool canSign);

  void setCanCertify(const bool canCertify);


  EncryptPref encryptionPreference();

  void setEncryptionPreference( const EncryptPref encrPref );


  QString primaryUserID() const;

  KeyID primaryKeyID() const;

  QByteArray primaryFingerprint() const;

  bool isNull() const;

  time_t creationDate() const;

  Validity keyTrust() const;

  Validity keyTrust( const QString& uid ) const;

  void cloneKeyTrust( const Key* key );

  bool isValid() const;

  bool isValidEncryptionKey() const;

  bool isValidSigningKey() const;

  const UserIDList userIDs() const;

  const SubkeyList subkeys() const;

  void addUserID(const QString& uid,
                 const Validity validity = KPGP_VALIDITY_UNKNOWN,
                 const bool revoked = false,
                 const bool invalid = false);

  void addUserID(const UserID *userID);

  bool matchesUserID(const QString& str, bool cs = true);

  void addSubkey(const KeyID& keyID, const bool secret = false);

  void addSubkey(const Subkey *subkey);

  Subkey *getSubkey(const KeyID& keyID);

  void setFingerprint(const KeyID& keyID, const QByteArray& fpr);

 protected:
  bool mSecret : 1;
  /* global flags */
  bool mRevoked : 1;
  bool mExpired : 1;
  bool mDisabled : 1;
  bool mInvalid : 1;
  bool mCanEncrypt : 1;
  bool mCanSign : 1;
  bool mCanCertify : 1;

  EncryptPref mEncryptPref;

  SubkeyList mSubkeys;
  UserIDList mUserIDs;
};

inline bool Key::secret() const
{
  return mSecret;
}

inline bool Key::revoked() const
{
  return mRevoked;
}

inline bool Key::expired() const
{
  return mExpired;
}

inline bool Key::disabled() const
{
  return mDisabled;
}

inline bool Key::invalid() const
{
  return mInvalid;
}

inline bool Key::canEncrypt() const
{
  return mCanEncrypt;
}

inline bool Key::canSign() const
{
  return mCanSign;
}

inline bool Key::canCertify() const
{
  return mCanCertify;
}

inline void Key::setSecret(const bool secret)
{
  mSecret = secret;
}

inline void Key::setRevoked(const bool revoked)
{
  mRevoked = revoked;
}

inline void Key::setExpired(const bool expired)
{
  mExpired = expired;
}

inline void Key::setDisabled(const bool disabled)
{
  mDisabled = disabled;
}

inline void Key::setInvalid(const bool invalid)
{
  mInvalid = invalid;
}

inline void Key::setCanEncrypt(const bool canEncrypt)
{
  mCanEncrypt = canEncrypt;
}

inline void Key::setCanSign(const bool canSign)
{
  mCanSign = canSign;
}

inline void Key::setCanCertify(const bool canCertify)
{
  mCanCertify = canCertify;
}

inline EncryptPref Key::encryptionPreference()
{
  return mEncryptPref;
}

inline void Key::setEncryptionPreference( const EncryptPref encrPref )
{
  mEncryptPref = encrPref;
}

inline QString Key::primaryUserID() const
{
  UserID *uid = mUserIDs.isEmpty() ? 0 : mUserIDs.first();

  if (uid)
    return uid->text();
  else
    return QString();
}

inline KeyID Key::primaryKeyID() const
{
  Subkey *key = mSubkeys.isEmpty() ? 0 : mSubkeys.first();

  if (key)
    return key->keyID();
  else
    return KeyID();
}

inline QByteArray Key::primaryFingerprint() const
{
  Subkey *key = mSubkeys.isEmpty() ? 0 : mSubkeys.first();

  if (key)
    return key->fingerprint();
  else
    return QByteArray();
}

inline const UserIDList Key::userIDs() const
{
  return mUserIDs;
}

inline const SubkeyList Key::subkeys() const
{
  return mSubkeys;
}

inline bool Key::isNull() const
{
  return (mUserIDs.isEmpty() || mSubkeys.isEmpty());
}

inline time_t Key::creationDate() const
{
  if( !mSubkeys.isEmpty() )
    return mSubkeys.first()->creationDate();
  else
    return -1;
}

inline void Key::addUserID(const UserID *userID)
{
  if (userID)
    mUserIDs.append(const_cast<UserID*>(userID));
}

inline void Key::addSubkey(const Subkey *subkey)
{
  if (subkey)
    mSubkeys.append(const_cast<Subkey*>(subkey));
}


typedef QList<Key*> KeyList;

inline bool KeyCompare( Key* left, Key* right )
{
  const int result = QString::compare( left->primaryUserID().toLower(), right->primaryUserID().toLower() );
  return result == -1;
}

} // namespace Kpgp

#endif