ucommon/secure.h

Go to the documentation of this file.

// Copyright (C) 2010 David Sugar, Tycho Softworks.
//
// This file is part of GNU uCommon C++.
//
// GNU uCommon C++ 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 3 of the License, or
// (at your option) any later version.
//
// GNU uCommon C++ 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 GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.

#ifndef _UCOMMON_SECURE_H_
#define _UCOMMON_SECURE_H_

#ifndef _UCOMMON_CONFIG_H_
#include <ucommon/platform.h>
#endif

#ifndef _UCOMMON_UCOMMON_H_
#include <ucommon/ucommon.h>
#endif

#define MAX_CIPHER_KEYSIZE  512
#define MAX_DIGEST_HASHSIZE 512

NAMESPACE_UCOMMON

class __EXPORT secure
{
public:
    typedef enum {OK=0, INVALID, MISSING_CERTIFICATE, MISSING_PRIVATEKEY, INVALID_CERTIFICATE, INVALID_AUTHORITY, INVALID_PEERNAME, INVALID_CIPHER} error_t;

protected:
    error_t error;

    inline secure() {error = OK;};

public:
    virtual ~secure();

    typedef secure *context_t;

    typedef void *session_t;

    typedef void *bufio_t;

    static bool init(const char *program = NULL);

    static error_t verify(session_t session, const char *peername = NULL);

    static context_t server(const char *authority = NULL);

    static context_t client(const char *authority = NULL);

    static context_t user(const char *authority);

    static void cipher(context_t context, const char *ciphers);

    inline bool is(void)
        {return error == OK;};

    inline error_t err(void)
        {return error;};
};

class __EXPORT SSocket : public TCPSocket
{
protected:
    secure::session_t ssl;
    secure::bufio_t bio;
    bool verify;

public:
    SSocket(const char *service, secure::context_t context);
    SSocket(TCPServer *server, secure::context_t context, size_t size = 536);
    ~SSocket();

    void open(const char *host, size_t size = 536);

    void open(TCPServer *server, size_t size = 536);

    void close(void);

    bool flush(void);

    void release(void);

    size_t _push(const char *address, size_t size);

    size_t _pull(char *address, size_t size);

    bool pending(void);

    bool issecure(void)
        {return bio != NULL;};
};

class __EXPORT Cipher
{
public:
    typedef enum {ENCRYPT = 1, DECRYPT = 0} mode_t;

    class __EXPORT Key
    {
    private:
        friend class Cipher;
    
        union {
            const void *algotype;
            int algoid;
        };

        union {
            const void *hashtype;
            int hashid;
        };

        int modeid;
        
        // assume 512 bit cipher keys possible...
        unsigned char keybuf[MAX_CIPHER_KEYSIZE / 8], ivbuf[MAX_CIPHER_KEYSIZE / 8];

        // generated keysize
        size_t keysize, blksize;

    public:
        Key(const char *cipher, const char *digest, const char *text, size_t size = 0, const unsigned char *salt = NULL, unsigned rounds = 1);
        Key();
        ~Key();

        void clear(void);

        inline size_t size(void)
            {return keysize;};

        inline size_t iosize(void)
            {return blksize;};
    };

    typedef Key *key_t;

private:
    Key keys;
    size_t bufsize, bufpos;
    mode_t bufmode;
    unsigned char *bufaddr;
    void *context;
    
protected:
    virtual void push(unsigned char *address, size_t size);

    void release(void);

public:
    Cipher();

    Cipher(key_t key, mode_t mode, unsigned char *address = NULL, size_t size = 0);

    ~Cipher();

    void set(unsigned char *address, size_t size = 0);

    void set(key_t key, mode_t mode, unsigned char *address, size_t size = 0);

    size_t flush(void);

    size_t put(const unsigned char *data, size_t size);

    size_t puts(const char *string);

    size_t pad(const unsigned char *address, size_t size);

    size_t process(unsigned char *address, size_t size, bool flag = false);
        
    inline size_t size(void)
        {return bufsize;};

    inline size_t pos(void)
        {return bufpos;};

    inline size_t align(void)
        {return keys.iosize();};

    static bool is(const char *name);
};

class __EXPORT Digest
{
private:
    void *context;

    union {
        const void *hashtype;
        int hashid;
    };

    unsigned bufsize;
    unsigned char buffer[MAX_DIGEST_HASHSIZE / 8];
    char text[MAX_DIGEST_HASHSIZE / 8 + 1];
    
protected:
    void release(void);

public:
    Digest(const char *type);

    Digest();

    ~Digest();

    inline bool puts(const char *str)
        {return put(str, strlen(str));};

    bool put(const void *memory, size_t size);
    
    inline unsigned size() const
        {return bufsize;};
    
    const unsigned char *get(void);

    const char *c_str(void);

    void set(const char *id);

    inline void operator=(const char *id)
        {set(id);};

    inline bool operator *=(const char *text)
        {return puts(text);};

    inline bool operator +=(const char *text)
        {return puts(text);};

    inline const char *operator*()
        {return c_str();};

    inline bool operator!() const
        {return !bufsize && context == NULL;};

    inline operator bool() const
        {return bufsize > 0 || context != NULL;};

    static bool is(const char *name);
};

class __EXPORT Random
{
public:
    static bool seed(const unsigned char *buffer, size_t size);

    static void seed(void);

    static size_t key(unsigned char *memory, size_t size);

    static size_t fill(unsigned char *memory, size_t size);

    static int get(void);

    static int get(int min, int max);

    static double real(void);

    static double real(double min, double max);

    static bool status(void);
};

typedef SSocket ssl_t;

typedef Digest digest_t;

typedef Cipher cipher_t;

typedef Cipher::Key skey_t;

inline void zerofill(void *addr, size_t size)
{
    ::memset(addr, 0, size);
}

END_NAMESPACE

#endif

---