# qca_core.h

Go to the documentation of this file.

    00001 /*
    00002  * qca_core.h - Qt Cryptographic Architecture
    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 QCA_CORE_H
    00034 #define QCA_CORE_H
    00035
    00043 #define QCA_VERSION 0x020002
    00044
    00045 #include <QString>
    00046 #include <QStringList>
    00047 #include <QList>
    00048 #include <QSharedData>
    00049 #include <QSharedDataPointer>
    00050 #include "qca_export.h"
    00051 #include "qca_support.h"
    00052 #include "qca_tools.h"
    00053
    00060 QCA_EXPORT int qcaVersion();
    00061
    00065 namespace QCA {
    00066
    00067 class Provider;
    00068 class Random;
    00069 class CertificateCollection;
    00070 class Global;
    00071 class KeyStore;
    00072 class KeyStoreEntry;
    00073 class KeyStoreInfo;
    00074 class KeyStoreManager;
    00075 class Logger;
    00076
    00086 typedef QList<Provider*> ProviderList;
    00087
    00102 enum MemoryMode
    00103 {
    00104         Practical,
    00105         Locking,
    00106         LockingKeepPrivileges
    00107 };
    00108
    00115 enum Direction
    00116 {
    00117         Encode,
    00118         Decode
    00119 };
    00120
    00126 QCA_EXPORT void init();
    00127
    00135 QCA_EXPORT void init(MemoryMode m, int prealloc);
    00136
    00144 QCA_EXPORT void deinit();
    00145
    00151 QCA_EXPORT bool haveSecureMemory();
    00152
    00161 QCA_EXPORT bool haveSecureRandom();
    00162
    00194 QCA_EXPORT bool isSupported(const char *features, const QString &provider = QString());
    00195
    00204 QCA_EXPORT bool isSupported(const QStringList &features, const QString &provider = QString());
    00205
    00222 QCA_EXPORT QStringList supportedFeatures();
    00223
    00241 QCA_EXPORT QStringList defaultFeatures();
    00242
    00258 QCA_EXPORT bool insertProvider(Provider *p, int priority = 0);
    00259
    00291 QCA_EXPORT void setProviderPriority(const QString &name, int priority);
    00292
    00306 QCA_EXPORT int providerPriority(const QString &name);
    00307
    00317 QCA_EXPORT ProviderList providers();
    00318
    00324 QCA_EXPORT Provider *findProvider(const QString &name);
    00325
    00329 QCA_EXPORT Provider *defaultProvider();
    00330
    00334 QCA_EXPORT void scanForPlugins();
    00335
    00339 QCA_EXPORT void unloadAllPlugins();
    00340
    00344 QCA_EXPORT QString pluginDiagnosticText();
    00345
    00349 QCA_EXPORT void clearPluginDiagnosticText();
    00350
    00358 QCA_EXPORT void appendPluginDiagnosticText(const QString &text);
    00359
    00368 QCA_EXPORT void setProperty(const QString &name, const QVariant &value);
    00369
    00377 QCA_EXPORT QVariant getProperty(const QString &name);
    00378
    00387 QCA_EXPORT void setProviderConfig(const QString &name, const QVariantMap &config);
    00388
    00394 QCA_EXPORT QVariantMap getProviderConfig(const QString &name);
    00395
    00401 QCA_EXPORT void saveProviderConfig(const QString &name);
    00402
    00406 QCA_EXPORT QString globalRandomProvider();
    00407
    00418 QCA_EXPORT void setGlobalRandomProvider(const QString &provider);
    00419
    00426 QCA_EXPORT Logger *logger();
    00427
    00438 #define QCA_logTextMessage(message, severity) \
    00439         do { \
    00440                 register QCA::Logger::Severity s = severity; \
    00441                 register QCA::Logger *l = QCA::logger (); \
    00442                 if (s <= l->level ()) { \
    00443                         l->logTextMessage (message, s); \
    00444                 } \
    00445         } while (false)
    00446
    00457 #define QCA_logBinaryMessage(blob, severity) \
    00458         do { \
    00459                 register QCA::Logger::Severity s = severity; \
    00460                 register QCA::Logger *l = QCA::logger (); \
    00461                 if (s <= l->level ()) { \
    00462                         l->logBinaryMessage (blob, s); \
    00463                 } \
    00464         } while (false)
    00465
    00474 QCA_EXPORT bool haveSystemStore();
    00475
    00496 QCA_EXPORT CertificateCollection systemStore();
    00497
    00505 QCA_EXPORT QString appName();
    00506
    00516 QCA_EXPORT void setAppName(const QString &name);
    00517
    00538 QCA_EXPORT QString arrayToHex(const QByteArray &array);
    00539
    00565 QCA_EXPORT QByteArray hexToArray(const QString &hexString);
    00566
    00578 class QCA_EXPORT Initializer
    00579 {
    00580 public:
    00588         explicit Initializer(MemoryMode m = Practical, int prealloc = 64);
    00589         ~Initializer();
    00590 };
    00591
    00616 class QCA_EXPORT KeyLength
    00617 {
    00618 public:
    00627         KeyLength(int min, int max, int multiple)
    00628                 : _min( min ), _max(max), _multiple( multiple )
    00629         { }
    00630
    00634         int minimum() const { return _min; }
    00635
    00639         int maximum() const { return _max; }
    00640
    00647         int multiple() const { return _multiple; }
    00648
    00649 private:
    00650         const int _min, _max, _multiple;
    00651 };
    00652
    00668 class QCA_EXPORT Provider
    00669 {
    00670 public:
    00671         virtual ~Provider();
    00672
    00673         class Context;
    00674
    00684         virtual void init();
    00685
    00695         virtual void deinit();
    00696
    00705         virtual int version() const;
    00706
    00718         virtual int qcaVersion() const = 0;
    00719
    00737         virtual QString name() const = 0;
    00738
    00754         virtual QStringList features() const = 0;
    00755
    00766         virtual QString credit() const;
    00767
    00794         virtual Context *createContext(const QString &type) = 0;
    00795
    00820         virtual QVariantMap defaultConfig() const;
    00821
    00831         virtual void configChanged(const QVariantMap &config);
    00832 };
    00833
    00843 class QCA_EXPORT Provider::Context : public QObject
    00844 {
    00845         Q_OBJECT
    00846 public:
    00847         virtual ~Context();
    00848
    00852         Provider *provider() const;
    00853
    00857         QString type() const;
    00858
    00862         virtual Context *clone() const = 0;
    00863
    00872         bool sameProvider(const Context *c) const;
    00873
    00874 protected:
    00882         Context(Provider *parent, const QString &type);
    00883
    00889         Context(const Context &from);
    00890
    00891 private:
    00892         // disable assignment
    00893         Context & operator=(const Context &from);
    00894
    00895         Provider *_provider;
    00896         QString _type;
    00897 };
    00898
    00913 class QCA_EXPORT BasicContext : public Provider::Context
    00914 {
    00915         Q_OBJECT
    00916 public:
    00917         ~BasicContext();
    00918
    00919 protected:
    00927         BasicContext(Provider *parent, const QString &type);
    00928
    00934         BasicContext(const BasicContext &from);
    00935
    00936 private:
    00937         // disable assignment
    00938         BasicContext & operator=(const BasicContext &from);
    00939 };
    00940
    00955 class QCA_EXPORT BufferedComputation
    00956 {
    00957 public:
    00958         virtual ~BufferedComputation();
    00959
    00963         virtual void clear() = 0;
    00964
    00971         virtual void update(const MemoryRegion &a) = 0;
    00972
    00976         virtual MemoryRegion final() = 0;
    00977
    00990         MemoryRegion process(const MemoryRegion &a);
    00991 };
    00992
    01011 class QCA_EXPORT Filter
    01012 {
    01013 public:
    01014         virtual ~Filter();
    01015
    01019         virtual void clear() = 0;
    01020
    01027         virtual MemoryRegion update(const MemoryRegion &a) = 0;
    01028
    01033         virtual MemoryRegion final() = 0;
    01034
    01040         virtual bool ok() const = 0;
    01041
    01054         MemoryRegion process(const MemoryRegion &a);
    01055 };
    01056
    01067 class QCA_EXPORT Algorithm
    01068 {
    01069 public:
    01075         Algorithm(const Algorithm &from);
    01076
    01077         virtual ~Algorithm();
    01078
    01084         Algorithm & operator=(const Algorithm &from);
    01085
    01089         QString type() const;
    01090
    01097         Provider *provider() const;
    01098
    01099         // Note: The next five functions are not public!
    01100
    01106         Provider::Context *context();
    01107
    01113         const Provider::Context *context() const;
    01114
    01122         void change(Provider::Context *c);
    01123
    01132         void change(const QString &type, const QString &provider);
    01133
    01139         Provider::Context *takeContext();
    01140
    01141 protected:
    01145         Algorithm();
    01146
    01153         Algorithm(const QString &type, const QString &provider);
    01154
    01155 private:
    01156         class Private;
    01157         QSharedDataPointer<Private> d;
    01158 };
    01159
    01167 class QCA_EXPORT SymmetricKey : public SecureArray
    01168 {
    01169 public:
    01173         SymmetricKey();
    01174
    01182         SymmetricKey(int size);
    01183
    01189         SymmetricKey(const SecureArray &a);
    01190
    01196         SymmetricKey(const QByteArray &a);
    01197
    01203         bool isWeakDESKey();
    01204 };
    01205
    01213 class QCA_EXPORT InitializationVector : public SecureArray
    01214 {
    01215 public:
    01219         InitializationVector();
    01220
    01226         InitializationVector(int size);
    01227
    01233         InitializationVector(const SecureArray &a);
    01234
    01240         InitializationVector(const QByteArray &a);
    01241 };
    01242
    01257 class QCA_EXPORT Event
    01258 {
    01259 public:
    01265         enum Type
    01266         {
    01267                 Password,
    01268                 Token
    01269         };
    01270
    01283         enum Source
    01284         {
    01285                 KeyStore,
    01286                 Data
    01287         };
    01288
    01297         enum PasswordStyle
    01298         {
    01299                 StylePassword,
    01300                 StylePassphrase,
    01301                 StylePIN
    01302         };
    01303
    01307         Event();
    01308
    01314         Event(const Event &from);
    01315
    01319         ~Event();
    01320
    01326         Event & operator=(const Event &from);
    01327
    01331         bool isNull() const;
    01332
    01336         Type type() const;
    01337
    01341         Source source() const;
    01342
    01350         PasswordStyle passwordStyle() const;
    01351
    01357         KeyStoreInfo keyStoreInfo() const;
    01358
    01364         KeyStoreEntry keyStoreEntry() const;
    01365
    01372         QString fileName() const;
    01373
    01377         void *ptr() const;
    01378
    01392         void setPasswordKeyStore(PasswordStyle pstyle, const KeyStoreInfo &keyStoreInfo, const KeyStoreEntry &keyStoreEntry, void *ptr);
    01393
    01405         void setPasswordData(PasswordStyle pstyle, const QString &fileName, void *ptr);
    01406
    01418         void setToken(const KeyStoreInfo &keyStoreInfo, const KeyStoreEntry &keyStoreEntry, void *ptr);
    01419
    01420 private:
    01421         class Private;
    01422         QSharedDataPointer<Private> d;
    01423 };
    01424
    01442 class QCA_EXPORT EventHandler : public QObject
    01443 {
    01444         Q_OBJECT
    01445 public:
    01451         EventHandler(QObject *parent = 0);
    01452         ~EventHandler();
    01453
    01459         void start();
    01460
    01471         void submitPassword(int id, const SecureArray &password);
    01472
    01482         void tokenOkay(int id);
    01483
    01493         void reject(int id);
    01494
    01495 Q_SIGNALS:
    01505         void eventReady(int id, const QCA::Event &context);
    01506
    01507 private:
    01508         Q_DISABLE_COPY(EventHandler)
    01509
    01510         class Private;
    01511         friend class Private;
    01512         Private *d;
    01513 };
    01514
    01524 class QCA_EXPORT PasswordAsker : public QObject
    01525 {
    01526         Q_OBJECT
    01527 public:
    01533         PasswordAsker(QObject *parent = 0);
    01534         ~PasswordAsker();
    01535
    01547         void ask(Event::PasswordStyle pstyle, const KeyStoreInfo &keyStoreInfo, const KeyStoreEntry &keyStoreEntry, void *ptr);
    01548
    01558         void ask(Event::PasswordStyle pstyle, const QString &fileName, void *ptr);
    01559
    01563         void cancel();
    01564
    01572         void waitForResponse();
    01573
    01582         bool accepted() const;
    01583
    01588         SecureArray password() const;
    01589
    01590 Q_SIGNALS:
    01597         void responseReady();
    01598
    01599 private:
    01600         Q_DISABLE_COPY(PasswordAsker)
    01601
    01602         class Private;
    01603         friend class Private;
    01604         Private *d;
    01605 };
    01606
    01616 class QCA_EXPORT TokenAsker : public QObject
    01617 {
    01618         Q_OBJECT
    01619 public:
    01625         TokenAsker(QObject *parent = 0);
    01626         ~TokenAsker();
    01627
    01637         void ask(const KeyStoreInfo &keyStoreInfo, const KeyStoreEntry &keyStoreEntry, void *ptr);
    01638
    01642         void cancel();
    01643
    01650         void waitForResponse();
    01651
    01657         bool accepted() const;
    01658
    01659 Q_SIGNALS:
    01666         void responseReady();
    01667
    01668 private:
    01669         Q_DISABLE_COPY(TokenAsker)
    01670
    01671         class Private;
    01672         friend class Private;
    01673         Private *d;
    01674 };
    01675
    01676 }
    01677
    01678 #endif