kpgp.h

/*
    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 <stdio.h>
#include <tqstring.h>
#include <tqstrlist.h>
#include <tqdialog.h>
#include <tqwidget.h>
#include <tqcombobox.h>
#include <tqlayout.h>
#include <tqpushbutton.h>
#include <tqlistview.h>
#include <tqbuttongroup.h>
#include <tqradiobutton.h>
#include <tqmultilineedit.h>
#include <tqcheckbox.h>
 
#include <kdialogbase.h>
 
#include "kpgpkey.h"
#include <tdemacros.h>
 
class TQLineEdit;
class TQCursor;
class TQCheckBox;
class TQGridLayout;
 
class TDEConfig;
 
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 TDE_EXPORT Module
{
  friend class Block;
 
private:
    // the class running pgp
    Base *pgp;
 
public:
    Module();
    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 TQCString& charset = 0 );
 
  Kpgp::Result encrypt( Block& block,
                const TQStringList& receivers, const KeyID& keyId,
                bool sign, const TQCString& charset = 0 );
 
  Kpgp::Result getEncryptionKeys( KeyIDList& encryptionKeyIds,
                                  const TQStringList& recipients,
                                  const KeyID& keyId );
 
  int encryptionPossible( const TQStringList& 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 );
 
  TQCString getAsciiPublicKey( const KeyID& keyID );
 
  Key* publicKey( const KeyID& keyID );
 
  Key* publicKey( const TQString& userID );
 
  Key* secretKey( const KeyID& keyID );
 
  Validity keyTrust( const KeyID& keyID );
 
  Validity keyTrust( const TQString& 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 TQString 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 TQString& title,
                         const TQString& text = TQString(),
                         const KeyID& keyId = KeyID() );
 
  KeyID selectPublicKey( const TQString& title,
                         const TQString& text = TQString(),
                         const KeyID& oldKeyId = KeyID(),
                         const TQString& address = TQString(),
                         const unsigned int allowedKeys = AllKeys );
 
  KeyIDList selectPublicKeys( const TQString& title,
                              const TQString& text = TQString(),
                              const KeyIDList& oldKeyIds = KeyIDList(),
                              const TQString& address = TQString(),
                              const unsigned int allowedKeys = AllKeys );
 
  // FIXME: key management
 
  EncryptPref encryptionPreference( const TQString& address );
 
  void setEncryptionPreference( const TQString& address,
                                const EncryptPref pref );
 
  // -- static member functions --------------------------------------------
 
  static Kpgp::Module *getKpgp();
 
  static TDEConfig *getConfig();
 
  static bool prepareMessageForDecryption( const TQCString& msg,
                                           TQPtrList<Block>& pgpBlocks,
                                           TQStrList& nonPgpBlocks );
 
private:
  bool haveTrustedEncryptionKey( const TQString& person );
 
  KeyIDList getEncryptionKeys( const TQString& person );
 
  bool setPassPhrase(const TQString &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
  TQString canonicalAddress( const TQString& person );
 
  KeyID selectKey( const KeyList& keys,
                   const TQString& title,
                   const TQString& text = TQString(),
                   const KeyID& keyId = KeyID(),
                   const unsigned int allowedKeys = AllKeys );
 
  KeyIDList selectKeys( const KeyList& keys,
                        const TQString& title,
                        const TQString& text = TQString(),
                        const KeyIDList& keyIds = KeyIDList(),
                        const unsigned int allowedKeys = AllKeys );
 
  KeyID selectKey( bool& rememberChoice,
                   const KeyList& keys,
                   const TQString& title,
                   const TQString& text = TQString(),
                   const KeyID& keyId = KeyID(),
                   const unsigned int allowedKeys = AllKeys );
 
  KeyIDList selectKeys( bool& rememberChoice,
                        const KeyList& keys,
                        const TQString& title,
                        const TQString& text = TQString(),
                        const KeyIDList& keyIds = KeyIDList(),
                        const unsigned int allowedKeys = AllKeys );
 
  KeyIDList keysForAddress( const TQString& address );
 
  void setKeysForAddress( const TQString& address, const KeyIDList& keyIDs );
 
  void removeKeyForAddress( const TQString& address );
 
  void readAddressData();
 
  void writeAddressData();
 
  bool checkForPGP(void);
  void assignPGPBase(void);
 
  static Kpgp::Module *kpgpObject;
  TDEConfig *config;
 
  struct AddressData {
    KeyIDList keyIds;
    EncryptPref encrPref;
  };
  typedef TQMap<TQString, 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;
  TQString passphrase;
 
  TQString 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