summaryrefslogtreecommitdiffstats
path: root/libkpgp/kpgp.h
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit460c52653ab0dcca6f19a4f492ed2c5e4e963ab0 (patch)
tree67208f7c145782a7e90b123b982ca78d88cc2c87 /libkpgp/kpgp.h
downloadtdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.tar.gz
tdepim-460c52653ab0dcca6f19a4f492ed2c5e4e963ab0.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdepim@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'libkpgp/kpgp.h')
-rw-r--r--libkpgp/kpgp.h469
1 files changed, 469 insertions, 0 deletions
diff --git a/libkpgp/kpgp.h b/libkpgp/kpgp.h
new file mode 100644
index 000000000..9b3ade727
--- /dev/null
+++ b/libkpgp/kpgp.h
@@ -0,0 +1,469 @@
+/*
+ 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 <qstring.h>
+#include <qstrlist.h>
+#include <qdialog.h>
+#include <qwidget.h>
+#include <qcombobox.h>
+#include <qlayout.h>
+#include <qpushbutton.h>
+#include <qlistview.h>
+#include <qbuttongroup.h>
+#include <qradiobutton.h>
+#include <qmultilineedit.h>
+#include <qcheckbox.h>
+
+#include <kdialogbase.h>
+
+#include "kpgpkey.h"
+#include <kdepimmacros.h>
+
+class QLineEdit;
+class QCursor;
+class QCheckBox;
+class QGridLayout;
+
+class KConfig;
+
+namespace Kpgp {
+
+/** This enumerated type is used by Kpgp::* to indicate which keys can be
+ selected by the user. The following values are available:
+ - Kpgp::PublicKeys: Public keys are shown in the selection dialog.
+ - Kpgp::SecretKeys: Secret keys are shown in the selection dialog.
+ - Kpgp::EncryptionKeys: Encryption keys can be selected.
+ - Kpgp::SigningKeys: Signing keys can be selected.
+ - Kpgp::ValidKeys: Only valid keys can be selected.
+ - Kpgp::TrustedKeys: Only trusted keys can be selected.
+ - Kpgp::AllKeys == PublicKeys | SecretKeys | EncryptionKeys | SigningKeys
+*/
+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 KDE_EXPORT Module
+{
+ friend class Block;
+
+private:
+ // the class running pgp
+ Base *pgp;
+
+public:
+ Module();
+ virtual ~Module();
+
+ /** the following virtual function form the interface to the
+ application using Kpgp
+ */
+ virtual void readConfig();
+ virtual void writeConfig(bool sync);
+ virtual void init();
+
+ /** decrypts the given OpenPGP block if the passphrase is good.
+ returns false otherwise */
+ bool decrypt( Block& block );
+
+ /** Tries to verify the given OpenPGP block */
+ bool verify( Block& block );
+
+ /** clearsigns the given OpenPGP block with the key corresponding to the
+ given key id. The charset is needed to display the text correctly.
+ Returns
+ Failure if there was an unresolvable error
+ Canceled if signing was canceled
+ Ok if everything is o.k.
+ */
+ Kpgp::Result clearsign( Block& block,
+ const KeyID& keyId, const QCString& charset = 0 );
+
+ /** encrypts the given OpenPGP block for a list of persons. if sign is true
+ then the block is clearsigned with the key corresponding to the given
+ key id. The charset is needed to display the text correctly.
+ Returns
+ Failure if there was an unresolvable error
+ Canceled if encryption was canceled
+ Ok if everything is o.k.
+ */
+ Kpgp::Result encrypt( Block& block,
+ const QStringList& receivers, const KeyID& keyId,
+ bool sign, const QCString& charset = 0 );
+
+ /** Determines the keys which should be used for encrypting the message
+ to the given list of recipients.
+ Returns:
+ Failure if there was an unresolvable error
+ Canceled if encryption was canceled
+ Ok if everything is o.k.
+ */
+ Kpgp::Result getEncryptionKeys( KeyIDList& encryptionKeyIds,
+ const QStringList& recipients,
+ const KeyID& keyId );
+
+ /** checks if encrypting to the given list of persons is possible and
+ desired, i.e. if we have a (trusted) key for every recipient and
+ if encryption to all keys is allowed.
+ Returns
+ 0 if encryption is not possible or not desired,
+ 1 if encryption is possible and desired,
+ 2 if encryption is possible, but the user wants to be asked and
+ -1 if there is a conflict which can't be automatically resolved.
+ */
+ int encryptionPossible( const QStringList& recipients );
+
+protected:
+ int doEncSign( Block& block, const KeyIDList& recipientKeyIds, bool sign );
+
+public:
+ /** sign a key in the keyring with users signature. */
+ bool signKey( const KeyID& keyID );
+
+ /** get the list of cached public keys. */
+ const KeyList publicKeys();
+
+ /** get the list of cached secret keys. */
+ const KeyList secretKeys();
+
+ /** Reads the list of public keys if necessary or if <em>reread</em> is true.
+ */
+ void readPublicKeys( bool reread = false );
+
+ /** Reads the list of secret keys if necessary or if <em>reread</em> is true.
+ */
+ void readSecretKeys( bool reread = false );
+
+ /** try to get an ascii armored key block for the given public key */
+ QCString getAsciiPublicKey( const KeyID& keyID );
+
+ /** Returns the public key with the given key ID or null if no matching
+ key is found.
+ */
+ Key* publicKey( const KeyID& keyID );
+
+ /** Returns the first public key with the given user ID or null if no
+ matching key is found.
+ */
+ Key* publicKey( const QString& userID );
+
+ /** Returns the secret key with the given key ID or null if no matching
+ key is found.
+ */
+ Key* secretKey( const KeyID& keyID );
+
+ /** Returns the trust value for the given key. This is the maximal trust
+ value of any of the user ids of this key.
+ */
+ Validity keyTrust( const KeyID& keyID );
+
+ /** Returns the trust value of a key with the given user id. If more than
+ one key have this user id then the first key with this user id will be
+ chosen.
+ */
+ Validity keyTrust( const QString& userID );
+
+ /** Returns TRUE if the given key is at least trusted marginally. Otherwise
+ FALSE is returned.
+ */
+ bool isTrusted( const KeyID& keyID );
+
+ /** Rereads the key data for the given key and returns the reread data. If
+ <em>readTrust</em> is true then the trust of this key will be determined.
+ */
+ Key* rereadKey( const KeyID& keyID, const bool readTrust = true );
+
+ /** Request the change of the passphrase of the actual secret
+ key. TBI */
+ bool changePassPhrase();
+
+ /** set a user identity to use (if you have more than one...)
+ by default, pgp uses the identity which was generated last. */
+ void setUser(const KeyID& keyID);
+ /** Returns the actual key ID of the currently set key. */
+ const KeyID user() const;
+
+ /** always encrypt message to oneself? */
+ void setEncryptToSelf(bool flag);
+ bool encryptToSelf(void) const;
+
+ /** store passphrase in pgp object
+ Problem: passphrase stays in memory.
+ Advantage: you can call en-/decrypt without always passing the
+ passphrase
+ */
+ void setStorePassPhrase(bool);
+ bool storePassPhrase(void) const;
+
+ /** clears everything from memory */
+ void clear(const bool erasePassPhrase = FALSE);
+
+ /** returns the last error that occurred */
+ 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;
+
+ /** Should PGP/GnuPG be used? */
+ 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;
+
+ /** Shows a key selection dialog with all secret keys and the given title
+ and the (optional) text. If <em>keyId</em> is given, then the
+ corresponding key is selected.
+ */
+ KeyID selectSecretKey( const QString& title,
+ const QString& text = QString::null,
+ const KeyID& keyId = KeyID() );
+
+ /** Shows a key selection dialog with all public keys and the given title
+ and the (optional) text. If <em>oldKeyId</em> is given, then the
+ corresponding key is selected. If <em>address</em> is given, then the
+ chosen key will be stored (if the user wants it to be stored).
+ <em>mode</em> specifies which keys can be selected.
+ */
+ KeyID selectPublicKey( const QString& title,
+ const QString& text = QString::null,
+ const KeyID& oldKeyId = KeyID(),
+ const QString& address = QString::null,
+ const unsigned int allowedKeys = AllKeys );
+
+ /** Shows a key selection dialog with all public keys and the given title
+ and the (optional) text. If <em>oldKeyId</em> is given, then the
+ corresponding key is selected. If <em>address</em> is given, then the
+ chosen key will be stored (if the user wants it to be stored).
+ <em>mode</em> specifies which keys can be selected.
+ */
+ KeyIDList selectPublicKeys( const QString& title,
+ const QString& text = QString::null,
+ const KeyIDList& oldKeyIds = KeyIDList(),
+ const QString& address = QString::null,
+ const unsigned int allowedKeys = AllKeys );
+
+ // FIXME: key management
+
+ /** Reads the encryption preference for the given address
+ from the config file.
+ */
+ EncryptPref encryptionPreference( const QString& address );
+
+ /** Writes the given encryption preference for the given address
+ to the config file.
+ */
+ void setEncryptionPreference( const QString& address,
+ const EncryptPref pref );
+
+ // -- static member functions --------------------------------------------
+
+ /** return the actual pgp object */
+ static Kpgp::Module *getKpgp();
+
+ /** get the kpgp config object */
+ static KConfig *getConfig();
+
+ /** Parses the given message and splits it into OpenPGP blocks and
+ Non-OpenPGP blocks.
+ Returns TRUE if the message contains at least one OpenPGP block and
+ FALSE otherwise.
+ The format is then:
+ <pre>
+ 1st Non-OpenPGP block
+ 1st OpenPGP block
+ 2nd Non-OpenPGP block
+ ...
+ n-th OpenPGP block
+ (n+1)-th Non-OpenPGP block
+ </pre>
+ */
+ static bool prepareMessageForDecryption( const QCString& msg,
+ QPtrList<Block>& pgpBlocks,
+ QStrList& nonPgpBlocks );
+
+private:
+ /** check if we have a trusted encryption key for the given person */
+ bool haveTrustedEncryptionKey( const QString& person );
+
+ /** get a list of encryption keys to be used for the given recipient */
+ KeyIDList getEncryptionKeys( const QString& person );
+
+ /** Set pass phrase */
+ bool setPassPhrase(const char* pass);
+
+ /** test if the PGP executable is found and if there is a passphrase
+ set or given. Returns:
+ 1 if everything is ok
+ 0 (together with some warning message) if something is missing
+ -1 if the passphrase dialog was canceled
+ */
+ int prepare(bool needPassPhrase=FALSE, Block* block = 0 );
+
+ /** cleanup passphrase if it should not be stored. */
+ void cleanupPass() { if (!storePass) wipePassPhrase(); }
+
+ /** Wipes and optionally frees the memory used to hold the
+ passphrase. */
+ void wipePassPhrase(bool free=false);
+
+ // transform an address into canonical form
+ QString canonicalAddress( const QString& person );
+
+ /** Shows a dialog to let the user select a key from the given list of keys
+ */
+ KeyID selectKey( const KeyList& keys,
+ const QString& title,
+ const QString& text = QString::null,
+ const KeyID& keyId = KeyID(),
+ const unsigned int allowedKeys = AllKeys );
+
+ /** Shows a dialog to let the user select a key from the given list of keys
+ */
+ KeyIDList selectKeys( const KeyList& keys,
+ const QString& title,
+ const QString& text = QString::null,
+ const KeyIDList& keyIds = KeyIDList(),
+ const unsigned int allowedKeys = AllKeys );
+
+ /** Shows a dialog to let the user select a key from the given list of keys.
+ The dialog includes a checkbox ("Remember decision"). The state of the
+ checkbox is returned in rememberChoice.
+ */
+ KeyID selectKey( bool& rememberChoice,
+ const KeyList& keys,
+ const QString& title,
+ const QString& text = QString::null,
+ const KeyID& keyId = KeyID(),
+ const unsigned int allowedKeys = AllKeys );
+
+ /** Shows a dialog to let the user select a list of keys from the given
+ list of keys. The dialog includes a checkbox ("Remember decision").
+ The state of the checkbox is returned in rememberChoice.
+ */
+ KeyIDList selectKeys( bool& rememberChoice,
+ const KeyList& keys,
+ const QString& title,
+ const QString& text = QString::null,
+ const KeyIDList& keyIds = KeyIDList(),
+ const unsigned int allowedKeys = AllKeys );
+
+ /** Returns the OpenPGP keys which should be used for encryption to the
+ given address.
+ */
+ KeyIDList keysForAddress( const QString& address );
+
+ /** Set an email address -> list of OpenPGP keys association.
+ */
+ void setKeysForAddress( const QString& address, const KeyIDList& keyIDs );
+
+ /** Remove an email address -> OpenPGP key association. */
+ void removeKeyForAddress( const QString& address );
+
+ /** Reads the email address -> OpenPGP key associations from the config
+ file.
+ */
+ void readAddressData();
+
+ /** Writes the email address -> OpenPGP key associations to the config
+ file.
+ */
+ void writeAddressData();
+
+ bool checkForPGP(void);
+ void assignPGPBase(void);
+
+ static Kpgp::Module *kpgpObject;
+ 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
+