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  02110-1301, USA
00019  *
00020  */
00021 
00032 #ifndef QCAPROVIDER_H
00033 #define QCAPROVIDER_H
00034 
00035 #include "qca_core.h"
00036 #include "qca_basic.h"
00037 #include "qca_publickey.h"
00038 #include "qca_cert.h"
00039 #include "qca_keystore.h"
00040 #include "qca_securelayer.h"
00041 #include "qca_securemessage.h"
00042 
00043 #include <limits>
00044 
00045 #ifndef DOXYGEN_NO_PROVIDER_API
00046 
00081 class QCA_EXPORT QCAPlugin
00082 {
00083 public:
00087         virtual ~QCAPlugin() {}
00088 
00092         virtual QCA::Provider *createProvider() = 0;
00093 };
00094 
00095 Q_DECLARE_INTERFACE(QCAPlugin, "com.affinix.qca.Plugin/1.0")
00096 
00097 namespace QCA {
00098 
00109 class QCA_EXPORT InfoContext : public BasicContext
00110 {
00111         Q_OBJECT
00112 public:
00118         InfoContext(Provider *p) : BasicContext(p, "info") {}
00119 
00123         virtual QStringList supportedHashTypes() const;
00124 
00128         virtual QStringList supportedCipherTypes() const;
00129 
00133         virtual QStringList supportedMACTypes() const;
00134 };
00135 
00146 class QCA_EXPORT RandomContext : public BasicContext
00147 {
00148         Q_OBJECT
00149 public:
00155         RandomContext(Provider *p) : BasicContext(p, "random") {}
00156 
00162         virtual SecureArray nextBytes(int size) = 0;
00163 };
00164 
00175 class QCA_EXPORT HashContext : public BasicContext
00176 {
00177         Q_OBJECT
00178 public:
00185         HashContext(Provider *p, const QString &type) : BasicContext(p, type) {}
00186 
00190         virtual void clear() = 0;
00191 
00197         virtual void update(const MemoryRegion &a) = 0;
00198 
00202         virtual MemoryRegion final() = 0;
00203 };
00204 
00215 class QCA_EXPORT CipherContext : public BasicContext
00216 {
00217         Q_OBJECT
00218 public:
00228         CipherContext(Provider *p, const QString &type) : BasicContext(p, type) {}
00229 
00237         virtual void setup(Direction dir, const SymmetricKey &key, const InitializationVector &iv) = 0;
00238 
00242         virtual KeyLength keyLength() const = 0;
00243 
00247         virtual int blockSize() const = 0;
00248 
00255         virtual bool update(const SecureArray &in, SecureArray *out) = 0;
00256 
00262         virtual bool final(SecureArray *out) = 0;
00263 };
00264 
00276 class QCA_EXPORT MACContext : public BasicContext
00277 {
00278         Q_OBJECT
00279 public:
00285         MACContext(Provider *p, const QString &type) : BasicContext(p, type) {}
00286 
00292         virtual void setup(const SymmetricKey &key) = 0;
00293 
00297         virtual KeyLength keyLength() const = 0;
00298 
00304         virtual void update(const MemoryRegion &in) = 0;
00305 
00311         virtual void final(MemoryRegion *out) = 0;
00312 
00313 protected:
00317         KeyLength anyKeyLength() const
00318         {
00319                 // this is used instead of a default implementation to make sure that
00320                 // provider authors think about it, at least a bit.
00321                 // See Meyers, Effective C++, Effective C++ (2nd Ed), Item 36
00322                 return KeyLength( 0, INT_MAX, 1 );
00323         }
00324 };
00325 
00337 class QCA_EXPORT KDFContext : public BasicContext
00338 {
00339         Q_OBJECT
00340 public:
00347         KDFContext(Provider *p, const QString &type) : BasicContext(p, type) {}
00348 
00357         virtual SymmetricKey makeKey(const SecureArray &secret, const InitializationVector &salt, unsigned int keyLength, unsigned int iterationCount) = 0;
00358 };
00359 
00370 class QCA_EXPORT DLGroupContext : public Provider::Context
00371 {
00372         Q_OBJECT
00373 public:
00379         DLGroupContext(Provider *p) : Provider::Context(p, "dlgroup") {}
00380 
00384         virtual QList<DLGroupSet> supportedGroupSets() const = 0;
00385 
00389         virtual bool isNull() const = 0;
00390 
00404         virtual void fetchGroup(DLGroupSet set, bool block) = 0;
00405 
00414         virtual void getResult(BigInteger *p, BigInteger *q, BigInteger *g) const = 0;
00415 
00416 Q_SIGNALS:
00421         void finished();
00422 };
00423 
00435 class QCA_EXPORT PKeyBase : public BasicContext
00436 {
00437         Q_OBJECT
00438 public:
00445         PKeyBase(Provider *p, const QString &type);
00446 
00452         virtual bool isNull() const = 0;
00453 
00457         virtual PKey::Type type() const = 0;
00458 
00462         virtual bool isPrivate() const = 0;
00463 
00469         virtual bool canExport() const = 0;
00470 
00477         virtual void convertToPublic() = 0;
00478 
00482         virtual int bits() const = 0;
00483 
00490         virtual int maximumEncryptSize(EncryptionAlgorithm alg) const;
00491 
00498         virtual SecureArray encrypt(const SecureArray &in, EncryptionAlgorithm alg);
00499 
00508         virtual bool decrypt(const SecureArray &in, SecureArray *out, EncryptionAlgorithm alg);
00509 
00516         virtual void startSign(SignatureAlgorithm alg, SignatureFormat format);
00517 
00524         virtual void startVerify(SignatureAlgorithm alg, SignatureFormat format);
00525 
00532         virtual void update(const MemoryRegion &in);
00533 
00539         virtual QByteArray endSign();
00540 
00548         virtual bool endVerify(const QByteArray &sig);
00549 
00558         virtual SymmetricKey deriveKey(const PKeyBase &theirs);
00559 
00560 Q_SIGNALS:
00565         void finished();
00566 };
00567 
00579 class QCA_EXPORT RSAContext : public PKeyBase
00580 {
00581         Q_OBJECT
00582 public:
00588         RSAContext(Provider *p) : PKeyBase(p, "rsa") {}
00589 
00604         virtual void createPrivate(int bits, int exp, bool block) = 0;
00605 
00615         virtual void createPrivate(const BigInteger &n, const BigInteger &e, const BigInteger &p, const BigInteger &q, const BigInteger &d) = 0;
00616 
00623         virtual void createPublic(const BigInteger &n, const BigInteger &e) = 0;
00624 
00628         virtual BigInteger n() const = 0;
00629 
00633         virtual BigInteger e() const = 0;
00634 
00638         virtual BigInteger p() const = 0;
00639 
00643         virtual BigInteger q() const = 0;
00644 
00648         virtual BigInteger d() const = 0;
00649 };
00650 
00662 class QCA_EXPORT DSAContext : public PKeyBase
00663 {
00664         Q_OBJECT
00665 public:
00671         DSAContext(Provider *p) : PKeyBase(p, "dsa") {}
00672 
00686         virtual void createPrivate(const DLGroup &domain, bool block) = 0;
00687 
00695         virtual void createPrivate(const DLGroup &domain, const BigInteger &y, const BigInteger &x) = 0;
00696 
00703         virtual void createPublic(const DLGroup &domain, const BigInteger &y) = 0;
00704 
00708         virtual DLGroup domain() const = 0;
00709 
00713         virtual BigInteger y() const = 0;
00714 
00718         virtual BigInteger x() const = 0;
00719 };
00720 
00732 class QCA_EXPORT DHContext : public PKeyBase
00733 {
00734         Q_OBJECT
00735 public:
00741         DHContext(Provider *p) : PKeyBase(p, "dh") {}
00742 
00756         virtual void createPrivate(const DLGroup &domain, bool block) = 0;
00757 
00766         virtual void createPrivate(const DLGroup &domain, const BigInteger &y, const BigInteger &x) = 0;
00767 
00775         virtual void createPublic(const DLGroup &domain, const BigInteger &y) = 0;
00776 
00780         virtual DLGroup domain() const = 0;
00781 
00785         virtual BigInteger y() const = 0;
00786 
00790         virtual BigInteger x() const = 0;
00791 };
00792 
00808 class QCA_EXPORT PKeyContext : public BasicContext
00809 {
00810         Q_OBJECT
00811 public:
00817         PKeyContext(Provider *p) : BasicContext(p, "pkey") {}
00818 
00822         virtual QList<PKey::Type> supportedTypes() const = 0;
00823 
00828         virtual QList<PKey::Type> supportedIOTypes() const = 0;
00829 
00834         virtual QList<PBEAlgorithm> supportedPBEAlgorithms() const = 0;
00835 
00839         virtual PKeyBase *key() = 0;
00840 
00844         virtual const PKeyBase *key() const = 0;
00845 
00853         virtual void setKey(PKeyBase *key) = 0;
00854 
00866         virtual bool importKey(const PKeyBase *key) = 0;
00867 
00873         virtual QByteArray publicToDER() const;
00874 
00880         virtual QString publicToPEM() const;
00881 
00890         virtual ConvertResult publicFromDER(const QByteArray &a);
00891 
00900         virtual ConvertResult publicFromPEM(const QString &s);
00901 
00911         virtual SecureArray privateToDER(const SecureArray &passphrase, PBEAlgorithm pbe) const;
00912 
00922         virtual QString privateToPEM(const SecureArray &passphrase, PBEAlgorithm pbe) const;
00923 
00933         virtual ConvertResult privateFromDER(const SecureArray &a, const SecureArray &passphrase);
00934 
00944         virtual ConvertResult privateFromPEM(const QString &s, const SecureArray &passphrase);
00945 };
00946 
00958 class QCA_EXPORT CertBase : public BasicContext
00959 {
00960         Q_OBJECT
00961 public:
00968         CertBase(Provider *p, const QString &type) : BasicContext(p, type) {}
00969 
00975         virtual QByteArray toDER() const = 0;
00976 
00982         virtual QString toPEM() const = 0;
00983 
00992         virtual ConvertResult fromDER(const QByteArray &a) = 0;
00993 
01002         virtual ConvertResult fromPEM(const QString &s) = 0;
01003 };
01004 
01019 class QCA_EXPORT CertContextProps
01020 {
01021 public:
01027         int version;
01028 
01034         QDateTime start;
01035 
01041         QDateTime end;
01042 
01046         CertificateInfoOrdered subject;
01047 
01053         CertificateInfoOrdered issuer;
01054 
01058         Constraints constraints;
01059 
01063         QStringList policies;
01064 
01070         QStringList crlLocations;
01071 
01077         QStringList issuerLocations;
01078 
01084         QStringList ocspLocations;
01085 
01091         BigInteger serial;
01092 
01097         bool isCA;
01098 
01104         bool isSelfSigned;
01105 
01109         int pathLimit;
01110 
01114         QByteArray sig;
01115 
01119         SignatureAlgorithm sigalgo;
01120 
01126         QByteArray subjectId;
01127 
01133         QByteArray issuerId;
01134 
01140         QString challenge;
01141 
01147         CertificateRequestFormat format;
01148 };
01149 
01162 class QCA_EXPORT CRLContextProps
01163 {
01164 public:
01168         CertificateInfoOrdered issuer;
01169 
01173         int number;
01174 
01178         QDateTime thisUpdate;
01179 
01183         QDateTime nextUpdate;
01184 
01188         QList<CRLEntry> revoked;
01189 
01193         QByteArray sig;
01194 
01198         SignatureAlgorithm sigalgo;
01199 
01203         QByteArray issuerId;
01204 };
01205 
01206 class CRLContext;
01207 
01218 class QCA_EXPORT CertContext : public CertBase
01219 {
01220         Q_OBJECT
01221 public:
01227         CertContext(Provider *p) : CertBase(p, "cert") {}
01228 
01240         virtual bool createSelfSigned(const CertificateOptions &opts, const PKeyContext &priv) = 0;
01241 
01245         virtual const CertContextProps *props() const = 0;
01246 
01253         virtual bool compare(const CertContext *other) const = 0;
01254 
01259         virtual PKeyContext *subjectPublicKey() const = 0;
01260 
01267         virtual bool isIssuerOf(const CertContext *other) const = 0;
01268 
01280         virtual Validity validate(const QList<CertContext*> &trusted, const QList<CertContext*> &untrusted, const QList<CRLContext*> &crls, UsageMode u, ValidateFlags vf) const = 0;
01281 
01297         virtual Validity validate_chain(const QList<CertContext*> &chain, const QList<CertContext*> &trusted, const QList<CRLContext*> &crls, UsageMode u, ValidateFlags vf) const = 0;
01298 };
01299 
01311 class QCA_EXPORT CSRContext : public CertBase
01312 {
01313         Q_OBJECT
01314 public:
01320         CSRContext(Provider *p) : CertBase(p, "csr") {}
01321 
01328         virtual bool canUseFormat(CertificateRequestFormat f) const = 0;
01329 
01341         virtual bool createRequest(const CertificateOptions &opts, const PKeyContext &priv) = 0;
01342 
01346         virtual const CertContextProps *props() const = 0;
01347 
01354         virtual bool compare(const CSRContext *other) const = 0;
01355 
01360         virtual PKeyContext *subjectPublicKey() const = 0;
01361 
01368         virtual QString toSPKAC() const = 0;
01369 
01379         virtual ConvertResult fromSPKAC(const QString &s) = 0;
01380 };
01381 
01392 class QCA_EXPORT CRLContext : public CertBase
01393 {
01394         Q_OBJECT
01395 public:
01401         CRLContext(Provider *p) : CertBase(p, "crl") {}
01402 
01406         virtual const CRLContextProps *props() const = 0;
01407 
01413         virtual bool compare(const CRLContext *other) const = 0;
01414 };
01415 
01427 class QCA_EXPORT CertCollectionContext : public BasicContext
01428 {
01429         Q_OBJECT
01430 public:
01436         CertCollectionContext(Provider *p) : BasicContext(p, "certcollection") {}
01437 
01446         virtual QByteArray toPKCS7(const QList<CertContext*> &certs, const QList<CRLContext*> &crls) const = 0;
01447 
01461         virtual ConvertResult fromPKCS7(const QByteArray &a, QList<CertContext*> *certs, QList<CRLContext*> *crls) const = 0;
01462 };
01463 
01475 class QCA_EXPORT CAContext : public BasicContext
01476 {
01477         Q_OBJECT
01478 public:
01484         CAContext(Provider *p) : BasicContext(p, "ca") {}
01485 
01494         virtual void setup(const CertContext &cert, const PKeyContext &priv) = 0;
01495 
01500         virtual CertContext *certificate() const = 0;
01501 
01509         virtual CertContext *signRequest(const CSRContext &req, const QDateTime &notValidAfter) const = 0;
01510 
01518         virtual CertContext *createCertificate(const PKeyContext &pub, const CertificateOptions &opts) const = 0;
01519 
01528         virtual CRLContext *createCRL(const QDateTime &nextUpdate) const = 0;
01529 
01539         virtual CRLContext *updateCRL(const CRLContext &crl, const QList<CRLEntry> &entries, const QDateTime &nextUpdate) const = 0;
01540 };
01541 
01552 class QCA_EXPORT PKCS12Context : public BasicContext
01553 {
01554         Q_OBJECT
01555 public:
01561         PKCS12Context(Provider *p) : BasicContext(p, "pkcs12") {}
01562 
01573         virtual QByteArray toPKCS12(const QString &name, const QList<const CertContext*> &chain, const PKeyContext &priv, const SecureArray &passphrase) const = 0;
01574 
01589         virtual ConvertResult fromPKCS12(const QByteArray &in, const SecureArray &passphrase, QString *name, QList<CertContext*> *chain, PKeyContext **priv) const = 0;
01590 };
01591 
01604 class QCA_EXPORT PGPKeyContextProps
01605 {
01606 public:
01610         QString keyId;
01611 
01616         QStringList userIds;
01617 
01621         bool isSecret;
01622 
01626         QDateTime creationDate;
01627 
01631         QDateTime expirationDate;
01632 
01638         QString fingerprint;
01639 
01644         bool inKeyring;
01645 
01650         bool isTrusted;
01651 };
01652 
01663 class QCA_EXPORT PGPKeyContext : public BasicContext
01664 {
01665         Q_OBJECT
01666 public:
01672         PGPKeyContext(Provider *p) : BasicContext(p, "pgpkey") {}
01673 
01677         virtual const PGPKeyContextProps *props() const = 0;
01678 
01682         virtual QByteArray toBinary() const = 0;
01683 
01687         virtual QString toAscii() const = 0;
01688 
01697         virtual ConvertResult fromBinary(const QByteArray &a) = 0;
01698 
01707         virtual ConvertResult fromAscii(const QString &s) = 0;
01708 };
01709 
01721 class QCA_EXPORT KeyStoreEntryContext : public BasicContext
01722 {
01723         Q_OBJECT
01724 public:
01730         KeyStoreEntryContext(Provider *p) : BasicContext(p, "keystoreentry") {}
01731 
01735         virtual KeyStoreEntry::Type type() const = 0;
01736 
01742         virtual QString id() const = 0;
01743 
01747         virtual QString name() const = 0;
01748 
01752         virtual QString storeId() const = 0;
01753 
01757         virtual QString storeName() const = 0;
01758 
01762         virtual bool isAvailable() const;
01763 
01772         virtual QString serialize() const = 0;
01773 
01778         virtual KeyBundle keyBundle() const;
01779 
01784         virtual Certificate certificate() const;
01785 
01790         virtual CRL crl() const;
01791 
01796         virtual PGPKey pgpSecretKey() const;
01797 
01803         virtual PGPKey pgpPublicKey() const;
01804 
01813         virtual bool ensureAccess();
01814 };
01815 
01826 class QCA_EXPORT KeyStoreListContext : public Provider::Context
01827 {
01828         Q_OBJECT
01829 public:
01835         KeyStoreListContext(Provider *p) : Provider::Context(p, "keystorelist") {}
01836 
01840         virtual void start();
01841 
01850         virtual void setUpdatesEnabled(bool enabled);
01851 
01861         virtual QList<int> keyStores() = 0;
01862 
01869         virtual KeyStore::Type type(int id) const = 0;
01870 
01882         virtual QString storeId(int id) const = 0;
01883 
01890         virtual QString name(int id) const = 0;
01891 
01900         virtual bool isReadOnly(int id) const;
01901 
01911         virtual QList<KeyStoreEntry::Type> entryTypes(int id) const = 0;
01912 
01921         virtual QList<KeyStoreEntryContext*> entryList(int id) = 0;
01922 
01932         virtual KeyStoreEntryContext *entry(int id, const QString &entryId);
01933 
01946         virtual KeyStoreEntryContext *entryPassive(const QString &serialized);
01947 
01957         virtual QString writeEntry(int id, const KeyBundle &kb);
01958 
01968         virtual QString writeEntry(int id, const Certificate &cert);
01969 
01979         virtual QString writeEntry(int id, const CRL &crl);
01980 
01990         virtual QString writeEntry(int id, const PGPKey &key);
01991 
02001         virtual bool removeEntry(int id, const QString &entryId);
02002 
02003 Q_SIGNALS:
02021         void busyStart();
02022 
02030         void busyEnd();
02031 
02036         void updated();
02037 
02043         void diagnosticText(const QString &str);
02044 
02051         void storeUpdated(int id);
02052 };
02053 
02064 class QCA_EXPORT TLSSessionContext : public BasicContext
02065 {
02066         Q_OBJECT
02067 public:
02073         TLSSessionContext(Provider *p) : BasicContext(p, "tlssession") {}
02074 };
02075 
02086 class QCA_EXPORT TLSContext : public Provider::Context
02087 {
02088         Q_OBJECT
02089 public:
02099         class SessionInfo
02100         {
02101         public:
02105                 bool isCompressed;
02106 
02110                 TLS::Version version;
02111 
02117                 QString cipherSuite;
02118 
02122                 int cipherBits;
02123 
02128                 int cipherMaxBits;
02129 
02134                 TLSSessionContext *id;
02135         };
02136 
02140         enum Result
02141         {
02142                 Success, 
02143                 Error,   
02144                 Continue 
02145         };
02146 
02153         TLSContext(Provider *p, const QString &type) : Provider::Context(p, type) {}
02154 
02158         virtual void reset() = 0;
02159 
02167         virtual QStringList supportedCipherSuites(const TLS::Version &version) const = 0;
02168 
02172         virtual bool canCompress() const = 0;
02173 
02177         virtual bool canSetHostName() const = 0;
02178 
02182         virtual int maxSSF() const = 0;
02183 
02194         virtual void setup(bool serverMode, const QString &hostName, bool compress) = 0;
02195 
02204         virtual void setConstraints(int minSSF, int maxSSF) = 0;
02205 
02218         virtual void setConstraints(const QStringList &cipherSuiteList) = 0;
02219 
02227         virtual void setTrustedCertificates(const CertificateCollection &trusted) = 0;
02228 
02238         virtual void setIssuerList(const QList<CertificateInfoOrdered> &issuerList) = 0;
02239 
02248         virtual void setCertificate(const CertificateChain &cert, const PrivateKey &key) = 0;
02249 
02257         virtual void setSessionId(const TLSSessionContext &id) = 0;
02258 
02267         virtual void shutdown() = 0;
02268 
02276         virtual void setMTU(int size);
02277 
02290         virtual void start() = 0;
02291 
02317         virtual void update(const QByteArray &from_net, const QByteArray &from_app) = 0;
02318 
02328         virtual bool waitForResultsReady(int msecs) = 0;
02329 
02333         virtual Result result() const = 0;
02334 
02338         virtual QByteArray to_net() = 0;
02339 
02344         virtual int encoded() const = 0;
02345 
02350         virtual QByteArray to_app() = 0;
02351 
02355         virtual bool eof() const = 0;
02356 
02363         virtual bool clientHelloReceived() const = 0;
02364 
02370         virtual bool serverHelloReceived() const = 0;
02371 
02378         virtual QString hostName() const = 0;
02379 
02385         virtual bool certificateRequested() const = 0;
02386 
02392         virtual QList<CertificateInfoOrdered> issuerList() const = 0;
02393 
02399         virtual Validity peerCertificateValidity() const = 0;
02400 
02406         virtual CertificateChain peerCertificateChain() const = 0;
02407 
02413         virtual SessionInfo sessionInfo() const = 0;
02414 
02420         virtual QByteArray unprocessed() = 0;
02421 
02422 Q_SIGNALS:
02426         void resultsReady();
02427 
02432         void dtlsTimeout();
02433 };
02434 
02445 class QCA_EXPORT SASLContext : public Provider::Context
02446 {
02447         Q_OBJECT
02448 public:
02458         class HostPort
02459         {
02460         public:
02464                 QString addr;
02465 
02469                 quint16 port;
02470         };
02471 
02475         enum Result
02476         {
02477                 Success,   
02478                 Error,     
02479                 Params,    
02480                 AuthCheck, 
02481                 Continue   
02482         };
02483 
02489         SASLContext(Provider *p) : Provider::Context(p, "sasl") {}
02490 
02494         virtual void reset() = 0;
02495 
02517         virtual void setup(const QString &service, const QString &host, const HostPort *local, const HostPort *remote, const QString &ext_id, int ext_ssf) = 0;
02518 
02529         virtual void setConstraints(SASL::AuthFlags f, int minSSF, int maxSSF) = 0;
02530 
02546         virtual void startClient(const QStringList &mechlist, bool allowClientSendFirst) = 0;
02547 
02563         virtual void startServer(const QString &realm, bool disableServerSendLast) = 0;
02564 
02578         virtual void serverFirstStep(const QString &mech, const QByteArray *clientInit) = 0;
02579 
02591         virtual void nextStep(const QByteArray &from_net) = 0;
02592 
02602         virtual void tryAgain() = 0;
02603 
02616         virtual void update(const QByteArray &from_net, const QByteArray &from_app) = 0;
02617 
02628         virtual bool waitForResultsReady(int msecs) = 0;
02629 
02633         virtual Result result() const = 0;
02634 
02638         virtual QStringList mechlist() const = 0;
02639 
02643         virtual QString mech() const = 0;
02644 
02648         virtual bool haveClientInit() const = 0;
02649 
02654         virtual QByteArray stepData() const = 0;
02655 
02660         virtual QByteArray to_net() = 0;
02661 
02666         virtual int encoded() const = 0;
02667 
02672         virtual QByteArray to_app() = 0;
02673 
02679         virtual int ssf() const = 0;
02680 
02687         virtual SASL::AuthCondition authCondition() const = 0;
02688 
02694         virtual SASL::Params clientParams() const = 0;
02695 
02704         virtual void setClientParams(const QString *user, const QString *authzid, const SecureArray *pass, const QString *realm) = 0;
02705 
02712         virtual QStringList realmlist() const = 0;
02713 
02719         virtual QString username() const = 0;
02720 
02726         virtual QString authzid() const = 0;
02727 
02728 Q_SIGNALS:
02733         void resultsReady();
02734 };
02735 
02747 class QCA_EXPORT MessageContext : public Provider::Context
02748 {
02749         Q_OBJECT
02750 public:
02754         enum Operation
02755         {
02756                 Encrypt,       
02757                 Decrypt,       
02758                 Sign,          
02759                 Verify,        
02760                 SignAndEncrypt 
02761         };
02762 
02769         MessageContext(Provider *p, const QString &type) : Provider::Context(p, type) {}
02770 
02775         virtual bool canSignMultiple() const = 0;
02776 
02780         virtual SecureMessage::Type type() const = 0;
02781 
02785         virtual void reset() = 0;
02786 
02792         virtual void setupEncrypt(const SecureMessageKeyList &keys) = 0;
02793 
02802         virtual void setupSign(const SecureMessageKeyList &keys, SecureMessage::SignMode m, bool bundleSigner, bool smime) = 0;
02803 
02809         virtual void setupVerify(const QByteArray &detachedSig) = 0;
02810 
02824         virtual void start(SecureMessage::Format f, Operation op) = 0;
02825 
02831         virtual void update(const QByteArray &in) = 0;
02832 
02836         virtual QByteArray read() = 0;
02837 
02842         virtual int written() = 0;
02843 
02847         virtual void end() = 0;
02848 
02852         virtual bool finished() const = 0;
02853 
02863         virtual bool waitForFinished(int msecs) = 0;
02864 
02870         virtual bool success() const = 0;
02871 
02878         virtual SecureMessage::Error errorCode() const = 0;
02879 
02886         virtual QByteArray signature() const = 0;
02887 
02894         virtual QString hashName() const = 0;
02895 
02902         virtual SecureMessageSignatureList signers() const = 0;
02903 
02911         virtual QString diagnosticText() const;
02912 
02913 Q_SIGNALS:
02918         void updated();
02919 };
02920 
02932 class QCA_EXPORT SMSContext : public BasicContext
02933 {
02934         Q_OBJECT
02935 public:
02942         SMSContext(Provider *p, const QString &type) : BasicContext(p, type) {}
02943 
02954         virtual void setTrustedCertificates(const CertificateCollection &trusted);
02955 
02964         virtual void setUntrustedCertificates(const CertificateCollection &untrusted);
02965 
02974         virtual void setPrivateKeys(const QList<SecureMessageKey> &keys);
02975 
02980         virtual MessageContext *createMessage() = 0;
02981 };
02982 
02983 }
02984 #endif
02985 
02986 #endif

Generated on Thu Sep 6 19:13:36 2007 for Qt Cryptographic Architecture by  doxygen 1.5.2