kpgp.h

Go to the documentation of this file.

/*
    kpgp.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 KPGP_H
#define KPGP_H

#include "libkpgp_export.h"
#include "kpgpkey.h"

#include <QtCore/QByteArray>
#include <QtCore/QString>
#include <QWidget>
#include <QComboBox>
#include <QLayout>
#include <QPushButton>
#include <QRadioButton>
#include <QCheckBox>
#include <QGridLayout>

#include <stdio.h>

class QCheckBox;
class QGridLayout;

class KConfig;

namespace Kpgp {

enum { PublicKeys = 1,
       SecretKeys = 2,
       EncryptionKeys = 4,
       SigningKeys = 8,
       ValidKeys = 16,
       TrustedKeys = 32,
       AllKeys = PublicKeys | SecretKeys | EncryptionKeys | SigningKeys,
       PubSecKeys = PublicKeys | SecretKeys,
       EncrSignKeys = EncryptionKeys | SigningKeys
};

enum Result
{
       Failure = 0,
       Ok = 1,
       Canceled = 2
};

class Base;
class Block;

class KPGP_EXPORT Module
{
  friend class Block;

private:
    // the class running pgp
    Base *pgp;

  Module();

public:
  virtual ~Module();

  virtual void readConfig();
  virtual void writeConfig(bool sync);
  virtual void init();

  bool decrypt( Block& block );

  bool verify( Block& block );

  Kpgp::Result clearsign( Block& block,
                  const KeyID& keyId, const QByteArray& charset = 0 );

  Kpgp::Result encrypt( Block& block,
                const QStringList& receivers, const KeyID& keyId,
                bool sign, const QByteArray& charset = 0 );

  Kpgp::Result getEncryptionKeys( KeyIDList& encryptionKeyIds,
                                  const QStringList& recipients,
                                  const KeyID& keyId );

  int encryptionPossible( const QStringList& recipients );

protected:
  int doEncSign( Block& block, const KeyIDList& recipientKeyIds, bool sign );

public:
  bool signKey( const KeyID& keyID );

  const KeyList publicKeys();

  const KeyList secretKeys();

  void readPublicKeys( bool reread = false );

  void readSecretKeys( bool reread = false );

  QByteArray getAsciiPublicKey( const KeyID& keyID );

  Key* publicKey( const KeyID& keyID );

  Key* publicKey( const QString& userID );

  Key* secretKey( const KeyID& keyID );

  Validity keyTrust( const KeyID& keyID );

  Validity keyTrust( const QString& userID );

  bool isTrusted( const KeyID& keyID );

  Key* rereadKey( const KeyID& keyID, const bool readTrust = true );

  bool changePassPhrase();

  void setUser(const KeyID& keyID);
  const KeyID user() const;

  void setEncryptToSelf(bool flag);
  bool encryptToSelf(void) const;

  void setStorePassPhrase(bool);
  bool storePassPhrase(void) const;

  void clear(const bool erasePassPhrase = false);

  const QString lastErrorMsg(void) const;

  // what version of PGP/GPG should we use
  enum PGPType { tAuto, tGPG, tPGP2, tPGP5, tPGP6, tOff } pgpType;

  // did we find a pgp executable?
  bool havePGP(void) const;

  bool usePGP(void) const { return (havePGP() && (pgpType != tOff)); }

  // show the result of encryption/signing?
  void setShowCipherText(const bool flag);
  bool showCipherText(void) const;

  // show the encryption keys for approval?
  void setShowKeyApprovalDlg(const bool flag);
  bool showKeyApprovalDlg(void) const;

  KeyID selectSecretKey( const QString& title,
                         const QString& text = QString(),
                         const KeyID& keyId = KeyID() );

  KeyID selectPublicKey( const QString& title,
                         const QString& text = QString(),
                         const KeyID& oldKeyId = KeyID(),
                         const QString& address = QString(),
                         const unsigned int allowedKeys = AllKeys );

  KeyIDList selectPublicKeys( const QString& title,
                              const QString& text = QString(),
                              const KeyIDList& oldKeyIds = KeyIDList(),
                              const QString& address = QString(),
                              const unsigned int allowedKeys = AllKeys );

  // FIXME: key management

  EncryptPref encryptionPreference( const QString& address );

  void setEncryptionPreference( const QString& address,
                                const EncryptPref pref );

  // -- static member functions --------------------------------------------

  static Kpgp::Module *getKpgp();

  static KConfig *getConfig();

  static bool prepareMessageForDecryption( const QByteArray& msg,
                                           QList<Block>& pgpBlocks,
                                           QList<QByteArray>& nonPgpBlocks );

private:
  bool haveTrustedEncryptionKey( const QString& person );

  KeyIDList getEncryptionKeys( const QString& person );

  bool setPassPhrase(const QString &pass);

  int prepare(bool needPassPhrase=false, Block* block = 0 );

  void cleanupPass() { if (!storePass) wipePassPhrase(); }

  void wipePassPhrase(bool free=false);

  // transform an address into canonical form
  QString canonicalAddress( const QString& person );

  KeyID selectKey( const KeyList& keys,
                   const QString& title,
                   const QString& text = QString(),
                   const KeyID& keyId = KeyID(),
                   const unsigned int allowedKeys = AllKeys );

  KeyIDList selectKeys( const KeyList& keys,
                        const QString& title,
                        const QString& text = QString(),
                        const KeyIDList& keyIds = KeyIDList(),
                        const unsigned int allowedKeys = AllKeys );

  KeyID selectKey( bool& rememberChoice,
                   const KeyList& keys,
                   const QString& title,
                   const QString& text = QString(),
                   const KeyID& keyId = KeyID(),
                   const unsigned int allowedKeys = AllKeys );

  KeyIDList selectKeys( bool& rememberChoice,
                        const KeyList& keys,
                        const QString& title,
                        const QString& text = QString(),
                        const KeyIDList& keyIds = KeyIDList(),
                        const unsigned int allowedKeys = AllKeys );

  KeyIDList keysForAddress( const QString& address );

  void setKeysForAddress( const QString& address, const KeyIDList& keyIDs );

  void removeKeyForAddress( const QString& address );

  void readAddressData();

  void writeAddressData();

  bool checkForPGP(void);
  void assignPGPBase(void);

  KConfig *config;

  struct AddressData {
    KeyIDList keyIds;
    EncryptPref encrPref;
  };
  typedef QMap<QString, AddressData> AddressDataDict;
  AddressDataDict addressDataDict;

  KeyList mPublicKeys;
  bool mPublicKeysCached : 1; // did we already read the public keys?
  KeyList mSecretKeys;
  bool mSecretKeysCached : 1; // did we already read the secret keys?

  bool storePass : 1;
  char * passphrase;
  size_t passphrase_buffer_len;

  QString errMsg;

  KeyID pgpUser; // the key ID which is used to sign/encrypt to self
  bool flagEncryptToSelf : 1;

  bool havePgp : 1;
  bool havePGP5 : 1;
  bool haveGpg : 1;
  bool havePassPhrase : 1;
  bool showEncryptionResult : 1;
  bool mShowKeyApprovalDlg : 1;
}; // class Module

// -- inlined member functions ---------------------------------------------

inline void
Module::setShowKeyApprovalDlg( const bool flag )
{
  mShowKeyApprovalDlg = flag;
}

inline bool
Module::showKeyApprovalDlg( void ) const
{
  return mShowKeyApprovalDlg;
}

// -------------------------------------------------------------------------

} // namespace Kpgp

#endif