QSSLDevice.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                           Data Encryption Support                             *
*                                                                               *
*********************************************************************************
*        Copyright (C) 2003 by Niall Douglas.   All Rights Reserved.            *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* This code 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.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/

#ifndef QSSLDEVICE_H
#define QSSLDEVICE_H

#include "QIODeviceS.h"
#include "FXString.h"
#include "FXSecure.h"

namespace FX {

class FXStream;
class QSSLDevice;

class FXSSLPKeyPrivate;
class FXAPI FXSSLPKey
{
    friend class QSSLDevice;
    FXSSLPKeyPrivate *p;
public:
    enum KeyType
    {
        NoEncryption=0, 
        RSA,            
        DH              
    };
    explicit FXSSLPKey(FXuint bitsize=0, KeyType type=NoEncryption);
    ~FXSSLPKey();
    FXSSLPKey(const FXSSLPKey &other);
    FXSSLPKey &operator=(const FXSSLPKey &other);
    bool operator==(const FXSSLPKey &other) const;
    bool operator!=(const FXSSLPKey &other) const { return !(*this==other); }
    bool operator<(const FXSSLPKey &other) const;
    bool operator>(const FXSSLPKey &other) const { return !(*this<other); }
    KeyType type() const throw();
    void setType(KeyType type);
    FXString typeAsString() const;
    FXuint bytesLen() const throw();
    FXuint bitsLen() const throw();
    void setBitsLen(FXuint newsize);
    bool hasPublicKey() const throw();
    FXSSLPKey publicKey() const;
    FXString publicKeyAsString() const;
    Secure::TigerHashValue publicKeyAsHash() const;
    bool hasPrivateKey() const throw();
    FXSSLPKey privateKey() const;
    void generate();
    bool verify() const;
    void readFromPEM(QIODevice *dev);
    void writeAsPEM(QIODevice *dev) const;

    static FXSSLPKey publicKeyFromString(const FXString &s, KeyType type);
    friend FXAPI FXStream &operator<<(FXStream &s, const FXSSLPKey &i);
    friend FXAPI FXStream &operator>>(FXStream &s, FXSSLPKey &i);
};
FXAPI FXStream &operator<<(FXStream &s, const FXSSLPKey &i);
FXAPI FXStream &operator>>(FXStream &s, FXSSLPKey &i);

class FXSSLKeyPrivate;
class FXAPI FXSSLKey
{
    friend class QSSLDevice;
    FXSSLKeyPrivate *p;
public:
    enum KeyType
    {
        NoEncryption=0, 
        Blowfish,       
        AES,            
        Encrypted=0xffff 
    };
    explicit FXSSLKey(FXuint bitsize=0, KeyType type=NoEncryption, const FXString &text=(const char *) 0);
    ~FXSSLKey();
    FXSSLKey(const FXSSLKey &other);
    FXSSLKey &operator=(const FXSSLKey &other);
    bool operator==(const FXSSLKey &other) const;
    bool operator!=(const FXSSLKey &other) const { return !(*this==other); }
    bool operator<(const FXSSLKey &other) const;
    bool operator>(const FXSSLKey &other) const { return !(*this<other); }
    KeyType type() const throw();
    void setType(KeyType type);
    FXString typeAsString() const;
    FXuint saltLen() const throw();
    void setSaltLen(FXuint salt);
    FXSSLPKey *asymmetricKey() const throw();
    FXSSLKey &setAsymmetricKey(const FXSSLPKey *pkey);
    FXuint bytesLen() const throw();
    FXuint bitsLen() const throw();
    void setBitsLen(FXuint newsize);
    void generate();
    void generateFromText(const FXString &text, int rounds=65536);
    Secure::TigerHashValue hash() const throw();

    friend FXAPI FXStream &operator<<(FXStream &s, const FXSSLKey &i);
    friend FXAPI FXStream &operator>>(FXStream &s, FXSSLKey &i);
};
FXAPI FXStream &operator<<(FXStream &s, const FXSSLKey &i);
FXAPI FXStream &operator>>(FXStream &s, FXSSLKey &i);

struct QSSLDevicePrivate;
class FXAPIR QSSLDevice : public QIODeviceS
{
    QSSLDevicePrivate *p;
    QSSLDevice(const QSSLDevice &);
    QSSLDevice &operator=(const QSSLDevice &);
    virtual FXDLLLOCAL void *int_getOSHandle() const;
    inline FXDLLLOCAL void int_genEBuffer() const;
    FXDLLLOCAL void int_xorInEBuffer(char *dest, const char *src, FXuval amount);
public:
    QSSLDevice(QIODevice *encrypteddev=0, bool enablev2=false);
    ~QSSLDevice();

    QIODevice *encryptedDev() const throw();
    void setEncryptedDev(QIODevice *dev);
    const FXSSLKey &key() const;
    void setKey(const FXSSLKey &key);
    bool SSLv2Available() const throw();
    void setSSLv2Available(bool a);
    bool SSLv3Available() const throw();
    void setSSLv3Available(bool a);
    FXString ciphers() const;
    void setCiphers(const FXString &list);

    bool usingSSLv2() const;
    bool usingSSLv3() const;
    bool usingTLSv1() const;
    FXString peerHostNameByCertificate() const;
    FXString cipherName() const;
    FXuint cipherBits() const;
    FXString cipherDescription() const;
    void renegotiate();

    FXuint fileHeaderLen() const throw();

    virtual bool isSynchronous() const;
    virtual bool create(FXuint mode=IO_ReadWrite);
    virtual bool open(FXuint mode=IO_ReadWrite);
    virtual void close();
    virtual void flush();
    virtual FXfval size() const;
    virtual void truncate(FXfval size);
    virtual FXfval at() const;
    virtual bool at(FXfval newpos);
    virtual bool atEnd() const;
    virtual const FXACL &permissions() const;
    virtual void setPermissions(const FXACL &);
    virtual FXuval readBlock(char *data, FXuval maxlen);
    virtual FXuval writeBlock(const char *data, FXuval maxlen);
    virtual FXuval readBlockFrom(char *data, FXuval maxlen, FXfval pos);
    virtual FXuval writeBlockTo(FXfval pos, const char *data, FXuval maxlen);
    virtual int ungetch(int c);
public:
    static void setCertificateFile(const FXString &path);
    static void setPrivateKeyFile(const FXString &path, const FXString &password);
    static const FXString &strongestAnonCipher();
    static const FXString &fastestAnonCipher();
};

} // namespace

#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.