qca_publickey.h

Go to the documentation of this file.

/*
 * qca_publickey.h - Qt Cryptographic Architecture
 * Copyright (C) 2003-2007  Justin Karneges <justin@affinix.com>
 * Copyright (C) 2004,2005  Brad Hards <bradh@frogmouth.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301  USA
 *
 */
 
#ifndef QCA_PUBLICKEY_H
#define QCA_PUBLICKEY_H
 
#include "qca_core.h"
#include <QObject>
 
namespace QCA {
 
class PublicKey;
class PrivateKey;
class KeyGenerator;
class RSAPublicKey;
class RSAPrivateKey;
class DSAPublicKey;
class DSAPrivateKey;
class DHPublicKey;
class DHPrivateKey;
 
enum EncryptionAlgorithm
{
    EME_PKCS1v15,     
    EME_PKCS1_OAEP,   
    EME_PKCS1v15_SSL, 
    EME_NO_PADDING    
};
 
enum SignatureAlgorithm
{
    SignatureUnknown, 
    EMSA1_SHA1,       
    EMSA3_SHA1,       
    EMSA3_MD5,        
    EMSA3_MD2,        
    EMSA3_RIPEMD160,  
    EMSA3_Raw,        
    EMSA3_SHA224,     
    EMSA3_SHA256,     
    EMSA3_SHA384,     
    EMSA3_SHA512      
};
 
enum SignatureFormat
{
    DefaultFormat, 
    IEEE_1363,     
    DERSequence    
};
 
enum PBEAlgorithm
{
    PBEDefault,           
    PBES2_DES_SHA1,       
    PBES2_TripleDES_SHA1, 
    PBES2_AES128_SHA1,    
    PBES2_AES192_SHA1,    
    PBES2_AES256_SHA1     
};
 
enum ConvertResult
{
    ConvertGood,     
    ErrorDecode,     
    ErrorPassphrase, 
    ErrorFile        
};
 
enum DLGroupSet
{
    DSA_512,   
    DSA_768,   
    DSA_1024,  
    IETF_768,  
    IETF_1024, 
    IETF_1536, 
    IETF_2048, 
    IETF_3072, 
    IETF_4096, 
    IETF_6144, 
    IETF_8192  
 
};
 
QCA_EXPORT QByteArray emsa3Encode(const QString &hashName, const QByteArray &digest, int size = -1);
 
class QCA_EXPORT DLGroup
{
public:
    DLGroup();
 
    DLGroup(const BigInteger &p, const BigInteger &q, const BigInteger &g);
 
    DLGroup(const BigInteger &p, const BigInteger &g);
 
    DLGroup(const DLGroup &from);
    ~DLGroup();
 
    DLGroup &operator=(const DLGroup &from);
 
    static QList<DLGroupSet> supportedGroupSets(const QString &provider = QString());
 
    bool isNull() const;
 
    BigInteger p() const;
 
    BigInteger q() const;
 
    BigInteger g() const;
 
private:
    class Private;
    Private *d;
};
 
class QCA_EXPORT PKey : public Algorithm
{
public:
    enum Type
    {
        RSA, 
        DSA, 
        DH   
    };
 
    PKey();
 
    PKey(const PKey &from);
 
    ~PKey() override;
 
    PKey &operator=(const PKey &from);
 
    static QList<Type> supportedTypes(const QString &provider = QString());
 
    static QList<Type> supportedIOTypes(const QString &provider = QString());
 
    bool isNull() const;
 
    Type type() const;
 
    int bitSize() const;
 
    bool isRSA() const;
 
    bool isDSA() const;
 
    bool isDH() const;
 
    bool isPublic() const;
 
    bool isPrivate() const;
 
    bool canExport() const;
 
    bool canKeyAgree() const;
 
    PublicKey toPublicKey() const;
 
    PrivateKey toPrivateKey() const;
 
    bool operator==(const PKey &a) const;
 
    bool operator!=(const PKey &a) const;
 
protected:
    PKey(const QString &type, const QString &provider);
 
    void set(const PKey &k);
 
    RSAPublicKey toRSAPublicKey() const;
 
    RSAPrivateKey toRSAPrivateKey() const;
 
    DSAPublicKey toDSAPublicKey() const;
 
    DSAPrivateKey toDSAPrivateKey() const;
 
    DHPublicKey toDHPublicKey() const;
 
    DHPrivateKey toDHPrivateKey() const;
 
private:
    void assignToPublic(PKey *dest) const;
    void assignToPrivate(PKey *dest) const;
 
    class Private;
    Private *d;
};
 
class QCA_EXPORT PublicKey : public PKey
{
public:
    PublicKey();
 
    PublicKey(const PrivateKey &k);
 
    PublicKey(const QString &fileName);
 
    PublicKey(const PublicKey &from);
 
    ~PublicKey() override;
 
    PublicKey &operator=(const PublicKey &from);
 
    RSAPublicKey toRSA() const;
 
    DSAPublicKey toDSA() const;
 
    DHPublicKey toDH() const;
 
    bool canEncrypt() const;
 
    bool canDecrypt() const;
 
    bool canVerify() const;
 
    int maximumEncryptSize(EncryptionAlgorithm alg) const;
 
    SecureArray encrypt(const SecureArray &a, EncryptionAlgorithm alg);
 
    bool decrypt(const SecureArray &in, SecureArray *out, EncryptionAlgorithm alg);
 
    void startVerify(SignatureAlgorithm alg, SignatureFormat format = DefaultFormat);
 
    void update(const MemoryRegion &a);
 
    bool validSignature(const QByteArray &sig);
 
    bool verifyMessage(const MemoryRegion &a,
                       const QByteArray &  sig,
                       SignatureAlgorithm  alg,
                       SignatureFormat     format = DefaultFormat);
 
    QByteArray toDER() const;
 
    QString toPEM() const;
 
    bool toPEMFile(const QString &fileName) const;
 
    static PublicKey fromDER(const QByteArray &a, ConvertResult *result = nullptr, const QString &provider = QString());
 
    static PublicKey fromPEM(const QString &s, ConvertResult *result = nullptr, const QString &provider = QString());
 
    static PublicKey
    fromPEMFile(const QString &fileName, ConvertResult *result = nullptr, const QString &provider = QString());
 
protected:
    PublicKey(const QString &type, const QString &provider);
 
private:
    class Private;
    Private *d;
};
 
class QCA_EXPORT PrivateKey : public PKey
{
public:
    PrivateKey();
 
    explicit PrivateKey(const QString &fileName, const SecureArray &passphrase = SecureArray());
 
    PrivateKey(const PrivateKey &from);
 
    ~PrivateKey() override;
 
    PrivateKey &operator=(const PrivateKey &from);
 
    RSAPrivateKey toRSA() const;
 
    DSAPrivateKey toDSA() const;
 
    DHPrivateKey toDH() const;
 
    bool canDecrypt() const;
 
    bool canEncrypt() const;
 
    bool canSign() const;
 
    int maximumEncryptSize(EncryptionAlgorithm alg) const;
 
    bool decrypt(const SecureArray &in, SecureArray *out, EncryptionAlgorithm alg);
 
    SecureArray encrypt(const SecureArray &a, EncryptionAlgorithm alg);
 
    void startSign(SignatureAlgorithm alg, SignatureFormat format = DefaultFormat);
 
    void update(const MemoryRegion &a);
 
    QByteArray signature();
 
    QByteArray signMessage(const MemoryRegion &a, SignatureAlgorithm alg, SignatureFormat format = DefaultFormat);
 
    SymmetricKey deriveKey(const PublicKey &theirs);
 
    static QList<PBEAlgorithm> supportedPBEAlgorithms(const QString &provider = QString());
 
    SecureArray toDER(const SecureArray &passphrase = SecureArray(), PBEAlgorithm pbe = PBEDefault) const;
 
    QString toPEM(const SecureArray &passphrase = SecureArray(), PBEAlgorithm pbe = PBEDefault) const;
 
    bool toPEMFile(const QString &    fileName,
                   const SecureArray &passphrase = SecureArray(),
                   PBEAlgorithm       pbe        = PBEDefault) const;
 
    static PrivateKey fromDER(const SecureArray &a,
                              const SecureArray &passphrase = SecureArray(),
                              ConvertResult *    result     = nullptr,
                              const QString &    provider   = QString());
 
    static PrivateKey fromPEM(const QString &    s,
                              const SecureArray &passphrase = SecureArray(),
                              ConvertResult *    result     = nullptr,
                              const QString &    provider   = QString());
 
    static PrivateKey fromPEMFile(const QString &    fileName,
                                  const SecureArray &passphrase = SecureArray(),
                                  ConvertResult *    result     = nullptr,
                                  const QString &    provider   = QString());
 
protected:
    PrivateKey(const QString &type, const QString &provider);
 
private:
    class Private;
    Private *d;
};
 
class QCA_EXPORT KeyGenerator : public QObject
{
    Q_OBJECT
public:
    KeyGenerator(QObject *parent = nullptr);
 
    ~KeyGenerator() override;
 
    bool blockingEnabled() const;
 
    void setBlockingEnabled(bool b);
 
    bool isBusy() const;
 
    PrivateKey createRSA(int bits, int exp = 65537, const QString &provider = QString());
 
    PrivateKey createDSA(const DLGroup &domain, const QString &provider = QString());
 
    PrivateKey createDH(const DLGroup &domain, const QString &provider = QString());
 
    PrivateKey key() const;
 
    DLGroup createDLGroup(QCA::DLGroupSet set, const QString &provider = QString());
 
    DLGroup dlGroup() const;
 
Q_SIGNALS:
    void finished();
 
private:
    Q_DISABLE_COPY(KeyGenerator)
 
    class Private;
    friend class Private;
    Private *d;
};
 
class QCA_EXPORT RSAPublicKey : public PublicKey
{
public:
    RSAPublicKey();
 
    RSAPublicKey(const BigInteger &n, const BigInteger &e, const QString &provider = QString());
 
    RSAPublicKey(const RSAPrivateKey &k);
 
    BigInteger n() const;
 
    BigInteger e() const;
};
 
class QCA_EXPORT RSAPrivateKey : public PrivateKey
{
public:
    RSAPrivateKey();
 
    RSAPrivateKey(const BigInteger &n,
                  const BigInteger &e,
                  const BigInteger &p,
                  const BigInteger &q,
                  const BigInteger &d,
                  const QString &   provider = QString());
 
    BigInteger n() const;
 
    BigInteger e() const;
 
    BigInteger p() const;
 
    BigInteger q() const;
 
    BigInteger d() const;
};
 
class QCA_EXPORT DSAPublicKey : public PublicKey
{
public:
    DSAPublicKey();
 
    DSAPublicKey(const DLGroup &domain, const BigInteger &y, const QString &provider = QString());
 
    DSAPublicKey(const DSAPrivateKey &k);
 
    DLGroup domain() const;
 
    BigInteger y() const;
};
 
class QCA_EXPORT DSAPrivateKey : public PrivateKey
{
public:
    DSAPrivateKey();
 
    DSAPrivateKey(const DLGroup &domain, const BigInteger &y, const BigInteger &x, const QString &provider = QString());
 
    DLGroup domain() const;
 
    BigInteger y() const;
 
    BigInteger x() const;
};
 
class QCA_EXPORT DHPublicKey : public PublicKey
{
public:
    DHPublicKey();
 
    DHPublicKey(const DLGroup &domain, const BigInteger &y, const QString &provider = QString());
 
    DHPublicKey(const DHPrivateKey &k);
 
    DLGroup domain() const;
 
    BigInteger y() const;
};
 
class QCA_EXPORT DHPrivateKey : public PrivateKey
{
public:
    DHPrivateKey();
 
    DHPrivateKey(const DLGroup &domain, const BigInteger &y, const BigInteger &x, const QString &provider = QString());
 
    DLGroup domain() const;
 
    BigInteger y() const;
 
    BigInteger x() const;
};
}
 
#endif