kpgpbase.h

Go to the documentation of this file.

/*
    kpgpbase.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 KPGPBASE_H
#define KPGPBASE_H

#include "kpgpkey.h"
#include "kpgpblock.h"

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

namespace Kpgp {

class Base
{
public:

  Base();
  virtual ~Base();


  virtual int encrypt( Block& , const KeyIDList& ) { return OK; }

  virtual int clearsign( Block& , const char *) { return OK; }

  virtual int encsign( Block& , const KeyIDList& ,
                      const char * = 0) { return OK; }

  virtual int decrypt( Block& , const char * = 0) { return OK; }

  virtual int verify( Block& block ) { return decrypt( block, 0 ); }


  virtual Key* readPublicKey( const KeyID&, const bool = false,
                              Key* = 0 )
    { return 0; }

  virtual KeyList publicKeys( const QStringList & = QStringList() )
 { return KeyList(); }

  virtual KeyList secretKeys( const QStringList & = QStringList() )
 { return KeyList(); }

  virtual QByteArray getAsciiPublicKey(const KeyID& ) { return QByteArray(); }

  virtual int signKey(const KeyID& , const char *) { return OK; }


  virtual QString lastErrorMessage() const;


protected:
  virtual int run( const char *cmd, const char *passphrase = 0,
                   bool onlyReadFromPGP = false );
  virtual int runGpg( const char *cmd, const char *passphrase = 0,
                      bool onlyReadFromGnuPG = false );
  virtual void clear();

  QByteArray addUserId();

  QByteArray input;
  QByteArray output;
  QByteArray error;
  QString errMsg;

  QByteArray mVersion;

  int status;

};

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

class Base2 : public Base
{

public:
  Base2();
  virtual ~Base2();

  virtual int encrypt( Block& block, const KeyIDList& recipients );
  virtual int clearsign( Block& block, const char *passphrase );
  virtual int encsign( Block& block, const KeyIDList& recipients,
                       const char *passphrase = 0 );
  virtual int decrypt( Block& block, const char *passphrase = 0 );
  virtual int verify( Block& block ) { return decrypt( block, 0 ); }

  virtual Key* readPublicKey( const KeyID& keyID,
                              const bool readTrust = false,
                              Key* key = 0 );
  virtual KeyList publicKeys( const QStringList & patterns = QStringList() );
  virtual KeyList secretKeys( const QStringList & patterns = QStringList() );
  virtual QByteArray getAsciiPublicKey( const KeyID& keyID );
  virtual int signKey( const KeyID& keyID, const char *passphrase );

protected:
  KeyList doGetPublicKeys( const QByteArray & cmd,
                           const QStringList & patterns );
  virtual KeyList parseKeyList( const QByteArray&, bool );

private:
  Key* parsePublicKeyData( const QByteArray& output, Key* key = 0 );
  void parseTrustDataForKey( Key* key, const QByteArray& str );
};

class BaseG : public Base
{

public:
  BaseG();
  virtual ~BaseG();

  virtual int encrypt( Block& block, const KeyIDList& recipients );
  virtual int clearsign( Block& block, const char *passphrase );
  virtual int encsign( Block& block, const KeyIDList& recipients,
                       const char *passphrase = 0 );
  virtual int decrypt( Block& block, const char *passphrase = 0 );
  virtual int verify( Block& block ) { return decrypt( block, 0 ); }

  virtual Key* readPublicKey( const KeyID& keyID,
                              const bool readTrust = false,
                              Key* key = 0 );
  virtual KeyList publicKeys( const QStringList & patterns = QStringList() );
  virtual KeyList secretKeys( const QStringList & patterns = QStringList() );
  virtual QByteArray getAsciiPublicKey( const KeyID& keyID );
  virtual int signKey( const KeyID& keyID, const char *passphrase );

private:
  Key* parseKeyData( const QByteArray& output, int& offset, Key* key = 0 );
  KeyList parseKeyList( const QByteArray&, bool );
};


class Base5 : public Base
{

public:
  Base5();
  virtual ~Base5();

  virtual int encrypt( Block& block, const KeyIDList& recipients );
  virtual int clearsign( Block& block, const char *passphrase );
  virtual int encsign( Block& block, const KeyIDList& recipients,
                       const char *passphrase = 0 );
  virtual int decrypt( Block& block, const char *passphrase = 0 );
  virtual int verify( Block& block ) { return decrypt( block, 0 ); }

  virtual Key* readPublicKey( const KeyID& keyID,
                              const bool readTrust = false,
                              Key* key = 0 );
  virtual KeyList publicKeys( const QStringList & patterns = QStringList() );
  virtual KeyList secretKeys( const QStringList & patterns = QStringList() );
  virtual QByteArray getAsciiPublicKey( const KeyID& keyID );
  virtual int signKey( const KeyID& keyID, const char *passphrase );

private:
  Key* parseKeyData( const QByteArray& output, int& offset, Key* key = 0 );
  Key* parseSingleKey( const QByteArray& output, Key* key = 0 );
  KeyList parseKeyList( const QByteArray& output, bool );
  void parseTrustDataForKey( Key* key, const QByteArray& str );
};


class Base6 : public Base2
{

public:
  Base6();
  virtual ~Base6();

  virtual int decrypt( Block& block, const char *passphrase = 0 );
  virtual int verify( Block& block ) { return decrypt( block, 0 ); }

  virtual Key* readPublicKey( const KeyID& keyID,
                              const bool readTrust = false,
                              Key* key = 0 );
  virtual KeyList publicKeys( const QStringList & patterns = QStringList() );
  virtual KeyList secretKeys( const QStringList & patterns = QStringList() );

  virtual int isVersion6();

protected:
  virtual KeyList parseKeyList( const QByteArray &, bool );

private:
  Key* parseKeyData( const QByteArray& output, int& offset, Key* key = 0 );
  Key* parseSingleKey( const QByteArray& output, Key* key = 0 );
  void parseTrustDataForKey( Key* key, const QByteArray& str );
};

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

inline QString
Base::lastErrorMessage() const
{
  return errMsg;
}


} // namespace Kpgp

#endif