FXSecure.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                                  Security Tools                               *
*                                                                               *
*********************************************************************************
*        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 FXSECURE_H
#define FXSECURE_H

#include "FXStream.h"
#include "FXString.h"
#include <string.h>
#include <stdlib.h>
#include <new>

namespace FX {

namespace Secure { struct heap { }; }
}

#if defined(_MSC_VER) && _MSC_VER<=1310
#pragma warning(push)
#pragma warning(disable: 4290)
#endif

FXAPI void *operator new(size_t size, const FX::Secure::heap &) throw(std::bad_alloc);
FXAPI void *operator new[](size_t size, const FX::Secure::heap &) throw(std::bad_alloc);
FXAPI void operator delete(void *p, const FX::Secure::heap &) throw();
FXAPI void operator delete[](void *p, const FX::Secure::heap &) throw();
#if defined(_MSC_VER) && _MSC_VER<=1310
#pragma warning(pop)
#endif

namespace FX {
namespace Secure
{
    extern FXAPI void *mallocI(size_t size) throw();
    extern FXAPI void *callocI(size_t no, size_t size) throw();
    extern FXAPI void free(void *p) throw();
    template<typename T> T *malloc(size_t size) throw() { return (T *) mallocI(size); }
    template<typename T> T *calloc(size_t no, size_t size) throw() { return (T *) callocI(no, size); }
    template<typename T> void free(T *p) throw() { free((void *) p); }

    struct TigerHashValue
    {
        union Data_t    // 192 bits
        {
            FXuchar bytes[24];      
            FXulong longlong[3];    
        } data;
        ~TigerHashValue()
        {
            ::memset(data.bytes, 0, sizeof(data));
        }
        FXString asString() const
        {
#if FOX_BIGENDIAN==1
            FXString ret("0x%1%2%3");
#else
            FXString ret("0x%3%2%1");
#endif
            return ret.arg(data.longlong[0]).arg(data.longlong[1]).arg(data.longlong[2]);
        }
        bool operator==(const TigerHashValue &o) const throw() { return data.longlong[0]==o.data.longlong[0]
                                                            && data.longlong[1]==o.data.longlong[1]
                                                            && data.longlong[2]==o.data.longlong[2]; }
        bool operator!=(const TigerHashValue &o) const throw() { return !(*this==o); }
        friend FXStream &operator<<(FXStream &s, const TigerHashValue &v) { s.writeRawBytes(v.data.bytes, 24); return s; }
        friend FXStream &operator>>(FXStream &s, TigerHashValue &v) { s.readRawBytes(v.data.bytes, 24); return s; }
    };

    class FXAPI Randomness
    {
        Randomness();
        Randomness(const Randomness &);
        Randomness &operator=(const Randomness &);
    public:
        static FXuval readBlock(FXuchar *buffer, FXuval length);
        static FXuval size();
    };
    class FXAPI PRandomness
    {   // Defined in QSSLDevice
        PRandomness();
        PRandomness(const PRandomness &);
        PRandomness &operator=(const PRandomness &);
    public:
        static FXuval readBlock(FXuchar *buffer, FXuval length);
        static void freshen(FXuval amount);
        static FXuval size() { return (FXuval)-1; }
    };

    class FXAPI TigerHash
    {
        FXuint mypasses;
    public:
        TigerHash(FXuint passes=3) : mypasses(passes) { }
        FXuint passes() const throw() { return mypasses; }
        void setPasses(FXuint passes) throw() { mypasses=passes; }
        TigerHashValue calc(FXuchar *buffer, FXuval length) const throw();
    };

} // namespace
} // namespace
#endif

---

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