qcaprovider.h

Go to the documentation of this file.
00001 /*
00002  * qcaprovider.h - QCA Plugin API
00003  * Copyright (C) 2003-2007  Justin Karneges <justin@affinix.com>
00004  * Copyright (C) 2004,2005  Brad Hards <bradh@frogmouth.net>
00005  *
00006  * This library is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2.1 of the License, or (at your option) any later version.
00010  *
00011  * This library is distributed in the hope that it will be useful,
00012  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00013  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014  * Lesser General Public License for more details.
00015  *
00016  * You should have received a copy of the GNU Lesser General Public
00017  * License along with this library; if not, write to the Free Software
00018  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
00019  * 02110-1301  USA
00020  *
00021  */
00022 
00033 #ifndef QCAPROVIDER_H
00034 #define QCAPROVIDER_H
00035 
00036 #include "qca_core.h"
00037 #include "qca_basic.h"
00038 #include "qca_publickey.h"
00039 #include "qca_cert.h"
00040 #include "qca_keystore.h"
00041 #include "qca_securelayer.h"
00042 #include "qca_securemessage.h"
00043 
00044 #include <limits>
00045 
00046 #ifndef DOXYGEN_NO_PROVIDER_API
00047 
00082 class QCA_EXPORT QCAPlugin
00083 {
00084 public:
00088         virtual ~QCAPlugin() {}
00089 
00093         virtual QCA::Provider *createProvider() = 0;
00094 };
00095 
00096 Q_DECLARE_INTERFACE(QCAPlugin, "com.affinix.qca.Plugin/1.0")
00097 
00098 namespace QCA {
00099 
00110 class QCA_EXPORT InfoContext : public BasicContext
00111 {
00112         Q_OBJECT
00113 public:
00119         InfoContext(Provider *p) : BasicContext(p, "info") {}
00120 
00124         virtual QStringList supportedHashTypes() const;
00125 
00129         virtual QStringList supportedCipherTypes() const;
00130 
00134         virtual QStringList supportedMACTypes() const;
00135 };
00136 
00147 class QCA_EXPORT RandomContext : public BasicContext
00148 {
00149         Q_OBJECT
00150 public:
00156         RandomContext(Provider *p) : BasicContext(p, "random") {}
00157 
00163         virtual SecureArray nextBytes(int size) = 0;
00164 };
00165 
00176 class QCA_EXPORT HashContext : public BasicContext
00177 {
00178         Q_OBJECT
00179 public:
00186         HashContext(Provider *p, const QString &type) : BasicContext(p, type) {}
00187 
00191         virtual void clear() = 0;
00192 
00198         virtual void update(const MemoryRegion &a) = 0;
00199 
00203         virtual MemoryRegion final() = 0;
00204 };
00205 
00216 class QCA_EXPORT CipherContext : public BasicContext
00217 {
00218         Q_OBJECT
00219 public:
00229         CipherContext(Provider *p, const QString &type) : BasicContext(p, type) {}
00230 
00238         virtual void setup(Direction dir, const SymmetricKey &key, const InitializationVector &iv) = 0;
00239 
00243         virtual KeyLength keyLength() const = 0;
00244 
00248         virtual int blockSize() const = 0;
00249 
00256         virtual bool update(const SecureArray &in, SecureArray *out) = 0;
00257 
00263         virtual bool final(SecureArray *out) = 0;
00264 };
00265 
00277 class QCA_EXPORT MACContext : public BasicContext
00278 {
00279         Q_OBJECT
00280 public:
00286         MACContext(Provider *p, const QString &type) : BasicContext(p, type) {}
00287 
00293         virtual void setup(const SymmetricKey &key) = 0;
00294 
00298         virtual KeyLength keyLength() const = 0;
00299 
00305         virtual void update(const MemoryRegion &in) = 0;
00306 
00312         virtual void final(MemoryRegion *out) = 0;
00313 
00314 protected:
00318         KeyLength anyKeyLength() const
00319         {
00320                 // this is used instead of a default implementation to make sure that
00321                 // provider authors think about it, at least a bit.
00322                 // See Meyers, Effective C++, Effective C++ (2nd Ed), Item 36
00323                 return KeyLength( 0, INT_MAX, 1 );
00324         }
00325 };
00326 
00338 class QCA_EXPORT KDFContext : public BasicContext
00339 {
00340         Q_OBJECT
00341 public:
00348         KDFContext(Provider *p, const QString &type) : BasicContext(p, type) {}
00349 
00358         virtual SymmetricKey makeKey(const SecureArray &secret, const InitializationVector &salt, unsigned int keyLength, unsigned int iterationCount) = 0;
00359 };
00360 
00371 class QCA_EXPORT DLGroupContext : public Provider::Context
00372 {
00373         Q_OBJECT
00374 public:
00380         DLGroupContext(Provider *p) : Provider::Context(p, "dlgroup") {}
00381 
00385         virtual QList<DLGroupSet> supportedGroupSets() const = 0;
00386 
00390         virtual bool isNull() const = 0;
00391 
00405         virtual void fetchGroup(DLGroupSet set, bool block) = 0;
00406 
00415         virtual void getResult(BigInteger *p, BigInteger *q, BigInteger *g) const = 0;
00416 
00417 Q_SIGNALS:
00422         void finished();
00423 };
00424 
00436 class QCA_EXPORT PKeyBase : public BasicContext
00437 {
00438         Q_OBJECT
00439 public:
00446         PKeyBase(Provider *p, const QString &type);
00447 
00453         virtual bool isNull() const = 0;
00454 
00458         virtual PKey::Type type() const = 0;
00459 
00463         virtual bool isPrivate() const = 0;
00464 
00470         virtual bool canExport() const = 0;
00471 
00478         virtual void convertToPublic() = 0;
00479 
00483         virtual int bits() const = 0;
00484 
00491         virtual int maximumEncryptSize(EncryptionAlgorithm alg) const;
00492 
00499         virtual SecureArray encrypt(const SecureArray &in, EncryptionAlgorithm alg);
00500 
00509         virtual bool decrypt(const SecureArray &in, SecureArray *out, EncryptionAlgorithm alg);
00510 
00517         virtual void startSign(SignatureAlgorithm alg, SignatureFormat format);
00518 
00525         virtual void startVerify(SignatureAlgorithm alg, SignatureFormat format);
00526 
00533         virtual void update(const MemoryRegion &in);
00534 
00540         virtual QByteArray endSign();
00541 
00549         virtual bool endVerify(const QByteArray &sig);
00550 
00559         virtual SymmetricKey deriveKey(const PKeyBase &theirs);
00560 
00561 Q_SIGNALS:
00566         void finished();
00567 };
00568 
00580 class QCA_EXPORT RSAContext : public PKeyBase
00581 {
00582         Q_OBJECT
00583 public:
00589         RSAContext(Provider *p) : PKeyBase(p, "rsa") {}
00590 
00605         virtual void createPrivate(int bits, int exp, bool block) = 0;
00606 
00616         virtual void createPrivate(const BigInteger &n, const BigInteger &e, const BigInteger &p, const BigInteger &q, const BigInteger &d) = 0;
00617 
00624         virtual void createPublic(const BigInteger &n, const BigInteger &e) = 0;
00625 
00629         virtual BigInteger n() const = 0;
00630 
00634         virtual BigInteger e() const = 0;
00635 
00639         virtual BigInteger p() const = 0;
00640 
00644         virtual BigInteger q() const = 0;
00645 
00649         virtual BigInteger d() const = 0;
00650 };
00651 
00663 class QCA_EXPORT DSAContext : public PKeyBase
00664 {
00665         Q_OBJECT
00666 public:
00672         DSAContext(Provider *p) : PKeyBase(p, "dsa") {}
00673 
00687         virtual void createPrivate(const DLGroup &domain, bool block) = 0;
00688 
00696         virtual void createPrivate(const DLGroup &domain, const BigInteger &y, const BigInteger &x) = 0;
00697 
00704         virtual void createPublic(const DLGroup &domain, const BigInteger &y) = 0;
00705 
00709         virtual DLGroup domain() const = 0;
00710 
00714         virtual BigInteger y() const = 0;
00715 
00719         virtual BigInteger x() const = 0;
00720 };
00721 
00733 class QCA_EXPORT DHContext : public PKeyBase
00734 {
00735         Q_OBJECT
00736 public:
00742         DHContext(Provider *p) : PKeyBase(p, "dh") {}
00743 
00757         virtual void createPrivate(const DLGroup &domain, bool block) = 0;
00758 
00767         virtual void createPrivate(const DLGroup &domain, const BigInteger &y, const BigInteger &x) = 0;
00768 
00776         virtual void createPublic(const DLGroup &domain, const BigInteger &y) = 0;
00777 
00781         virtual DLGroup domain() const = 0;
00782 
00786         virtual BigInteger y() const = 0;
00787 
00791         virtual BigInteger x() const = 0;
00792 };
00793 
00809 class QCA_EXPORT PKeyContext : public BasicContext
00810 {
00811         Q_OBJECT
00812 public:
00818         PKeyContext(Provider *p) : BasicContext(p, "pkey") {}
00819 
00823         virtual QList<PKey::Type> supportedTypes() const = 0;
00824 
00829         virtual QList<PKey::Type> supportedIOTypes() const = 0;
00830 
00835         virtual QList<PBEAlgorithm> supportedPBEAlgorithms() const = 0;
00836 
00840         virtual PKeyBase *key() = 0;
00841 
00845         virtual const PKeyBase *key() const = 0;
00846 
00854         virtual void setKey(PKeyBase *key) = 0;
00855 
00867         virtual bool importKey(const PKeyBase *key) = 0;
00868 
00874         virtual QByteArray publicToDER() const;
00875 
00881         virtual QString publicToPEM() const;
00882 
00891         virtual ConvertResult publicFromDER(const QByteArray &a);
00892 
00901         virtual ConvertResult publicFromPEM(const QString &s);
00902 
00912         virtual SecureArray privateToDER(const SecureArray &passphrase, PBEAlgorithm pbe) const;
00913 
00923         virtual QString privateToPEM(const SecureArray &passphrase, PBEAlgorithm pbe) const;
00924 
00934         virtual ConvertResult privateFromDER(const SecureArray &a, const SecureArray &passphrase);
00935 
00945         virtual ConvertResult privateFromPEM(const QString &s, const SecureArray &passphrase);
00946 };
00947 
00959 class QCA_EXPORT CertBase : public BasicContext
00960 {
00961         Q_OBJECT
00962 public:
00969         CertBase(Provider *p, const QString &type) : BasicContext(p, type) {}
00970 
00976         virtual QByteArray toDER() const = 0;
00977 
00983         virtual QString toPEM() const = 0;
00984 
00993         virtual ConvertResult fromDER(const QByteArray &a) = 0;
00994 
01003         virtual ConvertResult fromPEM(const QString &s) = 0;
01004 };
01005 
01020 class QCA_EXPORT CertContextProps
01021 {
01022 public:
01028         int version;
01029 
01035         QDateTime start;
01036 
01042         QDateTime end;
01043 
01047         CertificateInfoOrdered subject;
01048 
01054         CertificateInfoOrdered issuer;
01055 
01059         Constraints constraints;
01060 
01064         QStringList policies;
01065 
01071         QStringList crlLocations;
01072 
01078         QStringList issuerLocations;
01079 
01085         QStringList ocspLocations;
01086 
01092         BigInteger serial;
01093 
01098         bool isCA;
01099 
01105         bool isSelfSigned;
01106 
01110         int pathLimit;
01111 
01115         QByteArray sig;
01116 
01120         SignatureAlgorithm sigalgo;
01121 
01127         QByteArray subjectId;
01128 
01134         QByteArray issuerId;
01135 
01141         QString challenge;
01142 
01148         CertificateRequestFormat format;
01149 };
01150 
01163 class QCA_EXPORT CRLContextProps
01164 {
01165 public:
01169         CertificateInfoOrdered issuer;
01170 
01174         int number;
01175 
01179         QDateTime thisUpdate;
01180 
01184         QDateTime nextUpdate;
01185 
01189         QList<CRLEntry> revoked;
01190 
01194         QByteArray sig;
01195 
01199         SignatureAlgorithm sigalgo;
01200 
01204         QByteArray issuerId;
01205 };
01206 
01207 class CRLContext;
01208 
01219 class QCA_EXPORT CertContext : public CertBase
01220 {
01221         Q_OBJECT
01222 public:
01228         CertContext(Provider *p) : CertBase(p, "cert") {}
01229 
01241         virtual bool createSelfSigned(const CertificateOptions &opts, const PKeyContext &priv) = 0;
01242 
01246         virtual const CertContextProps *props() const = 0;
01247 
01254         virtual bool compare(const CertContext *other) const = 0;
01255 
01260         virtual PKeyContext *subjectPublicKey() const = 0;
01261 
01268         virtual bool isIssuerOf(const CertContext *other) const = 0;
01269 
01281         virtual Validity validate(const QList<CertContext*> &trusted, const QList<CertContext*> &untrusted, const QList<CRLContext*> &crls, UsageMode u, ValidateFlags vf) const = 0;
01282 
01298         virtual Validity validate_chain(const QList<CertContext*> &chain, const QList<CertContext*> &trusted, const QList<CRLContext*> &crls, UsageMode u, ValidateFlags vf) const = 0;
01299 };
01300 
01312 class QCA_EXPORT CSRContext : public CertBase
01313 {
01314         Q_OBJECT
01315 public:
01321         CSRContext(Provider *p) : CertBase(p, "csr") {}
01322 
01329         virtual bool canUseFormat(CertificateRequestFormat f) const = 0;
01330 
01342         virtual bool createRequest(const CertificateOptions &opts, const PKeyContext &priv) = 0;
01343 
01347         virtual const CertContextProps *props() const = 0;
01348 
01355         virtual bool compare(const CSRContext *other) const = 0;
01356 
01361         virtual PKeyContext *subjectPublicKey() const = 0;
01362 
01369         virtual QString toSPKAC() const = 0;
01370 
01380         virtual ConvertResult fromSPKAC(const QString &s) = 0;
01381 };
01382 
01393 class QCA_EXPORT CRLContext : public CertBase
01394 {
01395         Q_OBJECT
01396 public:
01402         CRLContext(Provider *p) : CertBase(p, "crl") {}
01403 
01407         virtual const CRLContextProps *props() const = 0;
01408 
01414         virtual bool compare(const CRLContext *other) const = 0;
01415 };
01416 
01428 class QCA_EXPORT CertCollectionContext : public BasicContext
01429 {
01430         Q_OBJECT
01431 public:
01437         CertCollectionContext(Provider *p) : BasicContext(p, "certcollection") {}
01438 
01447         virtual QByteArray toPKCS7(const QList<CertContext*> &certs, const QList<CRLContext*> &crls) const = 0;
01448 
01462         virtual ConvertResult fromPKCS7(const QByteArray &a, QList<CertContext*> *certs, QList<CRLContext*> *crls) const = 0;
01463 };
01464 
01476 class QCA_EXPORT CAContext : public BasicContext
01477 {
01478         Q_OBJECT
01479 public:
01485         CAContext(Provider *p) : BasicContext(p, "ca") {}
01486 
01495         virtual void setup(const CertContext &cert, const PKeyContext &priv) = 0;
01496 
01501         virtual CertContext *certificate() const = 0;
01502 
01510         virtual CertContext *signRequest(const CSRContext &req, const QDateTime &notValidAfter) const = 0;
01511 
01519         virtual CertContext *createCertificate(const PKeyContext &pub, const CertificateOptions &opts) const = 0;
01520 
01529         virtual CRLContext *createCRL(const QDateTime &nextUpdate) const = 0;
01530 
01540         virtual CRLContext *updateCRL(const CRLContext &crl, const QList<CRLEntry> &entries, const QDateTime &nextUpdate) const = 0;
01541 };
01542 
01553 class QCA_EXPORT PKCS12Context : public BasicContext
01554 {
01555         Q_OBJECT
01556 public:
01562         PKCS12Context(Provider *p) : BasicContext(p, "pkcs12") {}
01563 
01574         virtual QByteArray toPKCS12(const QString &name, const QList<const CertContext*> &chain, const PKeyContext &priv, const SecureArray &passphrase) const = 0;
01575 
01590         virtual ConvertResult fromPKCS12(const QByteArray &in, const SecureArray &passphrase, QString *name, QList<CertContext*> *chain, PKeyContext **priv) const = 0;
01591 };
01592 
01605 class QCA_EXPORT PGPKeyContextProps
01606 {
01607 public:
01611         QString keyId;
01612 
01617         QStringList userIds;
01618 
01622         bool isSecret;
01623 
01627         QDateTime creationDate;
01628 
01632         QDateTime expirationDate;
01633 
01639         QString fingerprint;
01640 
01645         bool inKeyring;
01646 
01651         bool isTrusted;
01652 };
01653 
01664 class QCA_EXPORT PGPKeyContext : public BasicContext
01665 {
01666         Q_OBJECT
01667 public:
01673         PGPKeyContext(Provider *p) : BasicContext(p, "pgpkey") {}
01674 
01678         virtual const PGPKeyContextProps *props() const = 0;
01679 
01683         virtual QByteArray toBinary() const = 0;
01684 
01688         virtual QString toAscii() const = 0;
01689 
01698         virtual ConvertResult fromBinary(const QByteArray &a) = 0;
01699 
01708         virtual ConvertResult fromAscii(const QString &s) = 0;
01709 };
01710 
01722 class QCA_EXPORT KeyStoreEntryContext : public BasicContext
01723 {
01724         Q_OBJECT
01725 public:
01731         KeyStoreEntryContext(Provider *p) : BasicContext(p, "keystoreentry") {}
01732 
01736         virtual KeyStoreEntry::Type type() const = 0;
01737 
01743         virtual QString id() const = 0;
01744 
01748         virtual QString name() const = 0;
01749 
01753         virtual QString storeId() const = 0;
01754 
01758         virtual QString storeName() const = 0;
01759 
01763         virtual bool isAvailable() const;
01764 
01773         virtual QString serialize() const = 0;
01774 
01779         virtual KeyBundle keyBundle() const;
01780 
01785         virtual Certificate certificate() const;
01786 
01791         virtual CRL crl() const;
01792 
01797         virtual PGPKey pgpSecretKey() const;
01798 
01804         virtual PGPKey pgpPublicKey() const;
01805 
01814         virtual bool ensureAccess();
01815 };
01816 
01827 class QCA_EXPORT KeyStoreListContext : public Provider::Context
01828 {
01829         Q_OBJECT
01830 public:
01836         KeyStoreListContext(Provider *p) : Provider::Context(p, "keystorelist") {}
01837 
01841         virtual void start();
01842 
01851         virtual void setUpdatesEnabled(bool enabled);
01852 
01862         virtual QList<int> keyStores() = 0;
01863 
01870         virtual KeyStore::Type type(int id) const = 0;
01871 
01883         virtual QString storeId(int id) const = 0;
01884 
01891         virtual QString name(int id) const = 0;
01892 
01901         virtual bool isReadOnly(int id) const;
01902 
01912         virtual QList<KeyStoreEntry::Type> entryTypes(int id) const = 0;
01913 
01922         virtual QList<KeyStoreEntryContext*> entryList(int id) = 0;
01923 
01933         virtual KeyStoreEntryContext *entry(int id, const QString &entryId);
01934 
01947         virtual KeyStoreEntryContext *entryPassive(const QString &serialized);
01948 
01958         virtual QString writeEntry(int id, const KeyBundle &kb);
01959 
01969         virtual QString writeEntry(int id, const Certificate &cert);
01970 
01980         virtual QString writeEntry(int id, const CRL &crl);
01981 
01991         virtual QString writeEntry(int id, const PGPKey &key);
01992 
02002         virtual bool removeEntry(int id, const QString &entryId);
02003 
02004 Q_SIGNALS:
02022         void busyStart();
02023 
02031         void busyEnd();
02032 
02037         void updated();
02038 
02044         void diagnosticText(const QString &str);
02045 
02052         void storeUpdated(int id);
02053 };
02054 
02065 class QCA_EXPORT TLSSessionContext : public BasicContext
02066 {
02067         Q_OBJECT
02068 public:
02074         TLSSessionContext(Provider *p) : BasicContext(p, "tlssession") {}
02075 };
02076 
02087 class QCA_EXPORT TLSContext : public Provider::Context
02088 {
02089         Q_OBJECT
02090 public:
02100         class SessionInfo
02101         {
02102         public:
02106                 bool isCompressed;
02107 
02111                 TLS::Version version;
02112 
02118                 QString cipherSuite;
02119 
02123                 int cipherBits;
02124 
02129                 int cipherMaxBits;
02130 
02135                 TLSSessionContext *id;
02136         };
02137 
02141         enum Result
02142         {
02143                 Success, 
02144                 Error,   
02145                 Continue 
02146         };
02147 
02154         TLSContext(Provider *p, const QString &type) : Provider::Context(p, type) {}
02155 
02159         virtual void reset() = 0;
02160 
02168         virtual QStringList supportedCipherSuites(const TLS::Version &version) const = 0;
02169 
02173         virtual bool canCompress() const = 0;
02174 
02178         virtual bool canSetHostName() const = 0;
02179 
02183         virtual int maxSSF() const = 0;
02184 
02195         virtual void setup(bool serverMode, const QString &hostName, bool compress) = 0;
02196 
02205         virtual void setConstraints(int minSSF, int maxSSF) = 0;
02206 
02219         virtual void setConstraints(const QStringList &cipherSuiteList) = 0;
02220 
02228         virtual void setTrustedCertificates(const CertificateCollection &trusted) = 0;
02229 
02239         virtual void setIssuerList(const QList<CertificateInfoOrdered> &issuerList) = 0;
02240 
02249         virtual void setCertificate(const CertificateChain &cert, const PrivateKey &key) = 0;
02250 
02258         virtual void setSessionId(const TLSSessionContext &id) = 0;
02259 
02268         virtual void shutdown() = 0;
02269 
02277         virtual void setMTU(int size);
02278 
02291         virtual void start() = 0;
02292 
02318         virtual void update(const QByteArray &from_net, const QByteArray &from_app) = 0;
02319 
02329         virtual bool waitForResultsReady(int msecs) = 0;
02330 
02334         virtual Result result() const = 0;
02335 
02339         virtual QByteArray to_net() = 0;
02340 
02345         virtual int encoded() const = 0;
02346 
02351         virtual QByteArray to_app() = 0;
02352 
02356         virtual bool eof() const = 0;
02357 
02364         virtual bool clientHelloReceived() const = 0;
02365 
02371         virtual bool serverHelloReceived() const = 0;
02372 
02379         virtual QString hostName() const = 0;
02380 
02386         virtual bool certificateRequested() const = 0;
02387 
02393         virtual QList<CertificateInfoOrdered> issuerList() const = 0;
02394 
02400         virtual Validity peerCertificateValidity() const = 0;
02401 
02407         virtual CertificateChain peerCertificateChain() const = 0;
02408 
02414         virtual SessionInfo sessionInfo() const = 0;
02415 
02421         virtual QByteArray unprocessed() = 0;
02422 
02423 Q_SIGNALS:
02427         void resultsReady();
02428 
02433         void dtlsTimeout();
02434 };
02435 
02446 class QCA_EXPORT SASLContext : public Provider::Context
02447 {
02448         Q_OBJECT
02449 public:
02459         class HostPort
02460         {
02461         public:
02465                 QString addr;
02466 
02470                 quint16 port;
02471         };
02472 
02476         enum Result
02477         {
02478                 Success,   
02479                 Error,     
02480                 Params,    
02481                 AuthCheck, 
02482                 Continue   
02483         };
02484 
02490         SASLContext(Provider *p) : Provider::Context(p, "sasl") {}
02491 
02495         virtual void reset() = 0;
02496 
02518         virtual void setup(const QString &service, const QString &host, const HostPort *local, const HostPort *remote, const QString &ext_id, int ext_ssf) = 0;
02519 
02530         virtual void setConstraints(SASL::AuthFlags f, int minSSF, int maxSSF) = 0;
02531 
02547         virtual void startClient(const QStringList &mechlist, bool allowClientSendFirst) = 0;
02548 
02564         virtual void startServer(const QString &realm, bool disableServerSendLast) = 0;
02565 
02579         virtual void serverFirstStep(const QString &mech, const QByteArray *clientInit) = 0;
02580 
02592         virtual void nextStep(const QByteArray &from_net) = 0;
02593 
02603         virtual void tryAgain() = 0;
02604 
02617         virtual void update(const QByteArray &from_net, const QByteArray &from_app) = 0;
02618 
02629         virtual bool waitForResultsReady(int msecs) = 0;
02630 
02634         virtual Result result() const = 0;
02635 
02639         virtual QStringList mechlist() const = 0;
02640 
02644         virtual QString mech() const = 0;
02645 
02649         virtual bool haveClientInit() const = 0;
02650 
02655         virtual QByteArray stepData() const = 0;
02656 
02661         virtual QByteArray to_net() = 0;
02662 
02667         virtual int encoded() const = 0;
02668 
02673         virtual QByteArray to_app() = 0;
02674 
02680         virtual int ssf() const = 0;
02681 
02688         virtual SASL::AuthCondition authCondition() const = 0;
02689 
02695         virtual SASL::Params clientParams() const = 0;
02696 
02705         virtual void setClientParams(const QString *user, const QString *authzid, const SecureArray *pass, const QString *realm) = 0;
02706 
02713         virtual QStringList realmlist() const = 0;
02714 
02720         virtual QString username() const = 0;
02721 
02727         virtual QString authzid() const = 0;
02728 
02729 Q_SIGNALS:
02734         void resultsReady();
02735 };
02736 
02748 class QCA_EXPORT MessageContext : public Provider::Context
02749 {
02750         Q_OBJECT
02751 public:
02755         enum Operation
02756         {
02757                 Encrypt,       
02758                 Decrypt,       
02759                 Sign,          
02760                 Verify,        
02761                 SignAndEncrypt 
02762         };
02763 
02770         MessageContext(Provider *p, const QString &type) : Provider::Context(p, type) {}
02771 
02776         virtual bool canSignMultiple() const = 0;
02777 
02781         virtual SecureMessage::Type type() const = 0;
02782 
02786         virtual void reset() = 0;
02787 
02793         virtual void setupEncrypt(const SecureMessageKeyList &keys) = 0;
02794 
02803         virtual void setupSign(const SecureMessageKeyList &keys, SecureMessage::SignMode m, bool bundleSigner, bool smime) = 0;
02804 
02810         virtual void setupVerify(const QByteArray &detachedSig) = 0;
02811 
02825         virtual void start(SecureMessage::Format f, Operation op) = 0;
02826 
02832         virtual void update(const QByteArray &in) = 0;
02833 
02837         virtual QByteArray read() = 0;
02838 
02843         virtual int written() = 0;
02844 
02848         virtual void end() = 0;
02849 
02853         virtual bool finished() const = 0;
02854 
02864         virtual bool waitForFinished(int msecs) = 0;
02865 
02871         virtual bool success() const = 0;
02872 
02879         virtual SecureMessage::Error errorCode() const = 0;
02880 
02887         virtual QByteArray signature() const = 0;
02888 
02895         virtual QString hashName() const = 0;
02896 
02903         virtual SecureMessageSignatureList signers() const = 0;
02904 
02912         virtual QString diagnosticText() const;
02913 
02914 Q_SIGNALS:
02919         void updated();
02920 };
02921 
02933 class QCA_EXPORT SMSContext : public BasicContext
02934 {
02935         Q_OBJECT
02936 public:
02943         SMSContext(Provider *p, const QString &type) : BasicContext(p, type) {}
02944 
02955         virtual void setTrustedCertificates(const CertificateCollection &trusted);
02956 
02965         virtual void setUntrustedCertificates(const CertificateCollection &untrusted);
02966 
02975         virtual void setPrivateKeys(const QList<SecureMessageKey> &keys);
02976 
02981         virtual MessageContext *createMessage() = 0;
02982 };
02983 
02984 }
02985 #endif
02986 
02987 #endif

Generated on Wed Apr 29 15:15:45 2009 for Qt Cryptographic Architecture by  doxygen 1.5.5