libkpgp/kpgpblock.h

   1 /*
   2     kpgpblock.h
   3
   4     Copyright (C) 2001,2002 the KPGP authors
   5     See file AUTHORS.kpgp for details
   6
   7     This file is part of KPGP, the KDE PGP/GnuPG support library.
   8
   9     KPGP is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software Foundation,
  16     Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef KPGPBLOCK_H
  20 #define KPGPBLOCK_H
  21
  22 #include "libkpgp_export.h"
  23 #include "kpgp.h"
  24
  25 #include <QStringList>
  26 #include <QString>
  27
  28 namespace Kpgp
  29 {
  30
  31 #ifdef ERROR
  32 # undef ERROR
  33 #endif
  34
  35 enum BlockType {
  36     UnknownBlock = -1,        // BEGIN PGP ???
  37     NoPgpBlock = 0,
  38     PgpMessageBlock = 1,      // BEGIN PGP MESSAGE
  39     MultiPgpMessageBlock = 2, // BEGIN PGP MESSAGE, PART X[/Y]
  40     SignatureBlock = 3,       // BEGIN PGP SIGNATURE
  41     ClearsignedBlock = 4,     // BEGIN PGP SIGNED MESSAGE
  42     PublicKeyBlock = 5,       // BEGIN PGP PUBLIC KEY BLOCK
  43     PrivateKeyBlock = 6       // BEGIN PGP PRIVATE KEY BLOCK (PGP 2.x: ...SECRET...)
  44 };
  45
  46 enum MessageStatus {
  47     OK          =  0x0000,
  48     RUN_ERR     =  0x0001,
  49     ERROR       =  0x0001,
  50     ENCRYPTED   =  0x0002,
  51     SIGNED      =  0x0004,
  52     GOODSIG     =  0x0008,
  53     ERR_SIGNING =  0x0010,
  54     UNKNOWN_SIG =  0x0020,
  55     BADPHRASE   =  0x0040,
  56     BADKEYS     =  0x0080,
  57     NO_SEC_KEY  =  0x0100,
  58     MISSINGKEY  =  0x0200,
  59     CANCEL      =  0x8000
  60 };
  61
  62 /*
  63  * BEGIN PGP MESSAGE
  64  *     Used for signed, encrypted, or compressed files.
  65  *
  66  * BEGIN PGP PUBLIC KEY BLOCK
  67  *     Used for armoring public keys
  68  *
  69  * BEGIN PGP PRIVATE KEY BLOCK (PGP 2.x: BEGIN PGP SECRET KEY BLOCK)
  70  *     Used for armoring private keys
  71  *
  72  * BEGIN PGP MESSAGE, PART X/Y
  73  *     Used for multi-part messages, where the armor is split amongst Y
  74  *     parts, and this is the Xth part out of Y.
  75  *
  76  * BEGIN PGP MESSAGE, PART X
  77  *     Used for multi-part messages, where this is the Xth part of an
  78  *     unspecified number of parts. Requires the MESSAGE-ID Armor
  79  *     Header to be used.
  80  *
  81  * BEGIN PGP SIGNATURE
  82  *     Used for detached signatures, OpenPGP/MIME signatures, and
  83  *     signatures following clearsigned messages. Note that PGP 2.x
  84  *     uses BEGIN PGP MESSAGE for detached signatures.
  85  *
  86  * BEGIN PGP SIGNED MESSAGE
  87  *     Used for cleartext signed messages.
  88  */
  89 class LIBKPGP_EXPORT Block
  90 {
  91 public:
  92
  93     explicit Block(const QByteArray &str = QByteArray());
  94     ~Block();
  95
  96     QByteArray text() const;
  97     void setText(const QByteArray &str);
  98
  99     void setProcessedText(const QByteArray &str);
 100
 101     int status() const;
 102     void setStatus(const int status);
 103
 104     BlockType type() const;
 105
 106     /** is the message encrypted ? */
 107     bool isEncrypted() const;
 108
 109     /** is the message signed by someone */
 110     bool isSigned() const;
 111
 112     /** is the signature good ? */
 113     bool goodSignature() const;
 114
 115     /** returns the primary user id of the signer or a null string if we
 116         don't have the public key of the signer */
 117     QString signatureUserId() const;
 118     void setSignatureUserId(const QString &userId);
 119
 120     /** keyID of signer */
 121     QByteArray signatureKeyId() const;
 122     void setSignatureKeyId(const QByteArray &keyId);
 123
 124     /** date of the signature
 125         WARNING: Will most likely be changed to QDateTime */
 126     QByteArray signatureDate() const;
 127     void setSignatureDate(const QByteArray &date);
 128
 129     /** the persons who can decrypt the message */
 130     const QStringList encryptedFor() const;
 131
 132     /** shows the secret key which is needed
 133       to decrypt the message */
 134     QByteArray requiredKey() const;
 135     void setRequiredKey(const QByteArray &keyId);
 136
 137     QString requiredUserId() const;
 138     void setRequiredUserId(const QString &userId);
 139
 140     QByteArray error() const;
 141     void setError(const QByteArray &str);
 142
 143     /** Resets all information about this OpenPGP block */
 144     void reset();
 145
 146     /** decrypts this OpenPGP block if the passphrase is good.
 147         returns false otherwise */
 148     bool decrypt();
 149
 150     /** tries to verify this (clearsigned) OpenPGP block */
 151     bool verify();
 152
 153     /** clearsigns this OpenPGP block with the key corresponding to the
 154         given key id. The charset is needed to display the text correctly.
 155         Returns
 156         false  if there was an unresolvable error or if signing was canceled
 157         true   if everything is o.k.
 158     */
 159     Kpgp::Result clearsign(const QByteArray &keyId,
 160                            const QByteArray &charset = QByteArray());
 161
 162     /** encrypts this OpenPGP block for a list of persons. if sign is true then
 163         the message is signed with the key corresponding to the given key id.
 164         Returns
 165         false  if there was an unresolvable error or if encryption was canceled
 166         true   if everything is o.k.
 167     */
 168     Kpgp::Result encrypt(const QStringList &receivers, const QByteArray &keyId,
 169                          const bool sign, const QByteArray &charset = QByteArray());
 170
 171 private:
 172     void clear();
 173
 174     BlockType determineType() const;
 175
 176     QByteArray mText;
 177     QByteArray mProcessedText;
 178     QByteArray mError;
 179     QString mSignatureUserId;
 180     QByteArray mSignatureKeyId;
 181     QByteArray mSignatureDate;
 182     QByteArray mRequiredKey;
 183     QString mRequiredUserId;
 184     QStringList mEncryptedFor;
 185     int mStatus;
 186     bool mHasBeenProcessed;
 187     mutable BlockType mType;
 188 };
 189
 190 // -- inlined member functions ---------------------------------------------
 191
 192 inline QByteArray
 193 Block::text() const
 194 {
 195     if (mHasBeenProcessed) {
 196         return mProcessedText;
 197     } else {
 198         return mText;
 199     }
 200 }
 201
 202 inline void
 203 Block::setText(const QByteArray &str)
 204 {
 205     clear();
 206     mText = str;
 207 }
 208
 209 inline void
 210 Block::setProcessedText(const QByteArray &str)
 211 {
 212     mProcessedText = str;
 213     mHasBeenProcessed = true;
 214 }
 215
 216 inline QByteArray
 217 Block::error() const
 218 {
 219     return mError;
 220 }
 221
 222 inline void
 223 Block::setError(const QByteArray &str)
 224 {
 225     mError = str;
 226 }
 227
 228 inline int
 229 Block::status() const
 230 {
 231     return mStatus;
 232 }
 233
 234 inline void
 235 Block::setStatus(const int status)
 236 {
 237     mStatus = status;
 238 }
 239
 240 inline BlockType
 241 Block::type() const
 242 {
 243     if (mType == NoPgpBlock) {
 244         mType = determineType();
 245     }
 246     return mType;
 247 }
 248
 249 inline QString
 250 Block::signatureUserId() const
 251 {
 252     return mSignatureUserId;
 253 }
 254
 255 inline void
 256 Block::setSignatureUserId(const QString &userId)
 257 {
 258     mSignatureUserId = userId;
 259 }
 260
 261 inline QByteArray
 262 Block::signatureKeyId() const
 263 {
 264     return mSignatureKeyId;
 265 }
 266
 267 inline void
 268 Block::setSignatureKeyId(const QByteArray &keyId)
 269 {
 270     mSignatureKeyId = keyId;
 271 }
 272
 273 inline QByteArray
 274 Block::signatureDate() const
 275 {
 276     return mSignatureDate;
 277 }
 278
 279 inline void
 280 Block::setSignatureDate(const QByteArray &date)
 281 {
 282     mSignatureDate = date;
 283 }
 284
 285 inline QByteArray
 286 Block::requiredKey() const
 287 {
 288     return mRequiredKey;
 289 }
 290
 291 inline void
 292 Block::setRequiredKey(const QByteArray &keyId)
 293 {
 294     mRequiredKey = keyId;
 295 }
 296
 297 inline QString
 298 Block::requiredUserId() const
 299 {
 300     return mRequiredUserId;
 301 }
 302
 303 inline void
 304 Block::setRequiredUserId(const QString &userId)
 305 {
 306     mRequiredUserId = userId;
 307 }
 308
 309 inline const QStringList
 310 Block::encryptedFor() const
 311 {
 312     return mEncryptedFor;
 313 }
 314
 315 inline bool
 316 Block::isEncrypted() const
 317 {
 318     if (mStatus & ENCRYPTED) {
 319         return true;
 320     }
 321     return false;
 322 }
 323
 324 inline bool
 325 Block::isSigned() const
 326 {
 327     if (mStatus & SIGNED) {
 328         return true;
 329     }
 330     return false;
 331 }
 332
 333 inline bool
 334 Block::goodSignature() const
 335 {
 336     if (mStatus & GOODSIG) {
 337         return true;
 338     }
 339     return false;
 340 }
 341
 342 /*
 343 inline bool
 344 Block::unknownSigner() const
 345 {
 346   if( mStatus & UNKNOWN_SIG )
 347     return true;
 348   return false;
 349 }
 350 */
 351
 352 // -------------------------------------------------------------------------
 353
 354 } // namespace Kpgp
 355
 356 #endif
 357