libcore/include/sirikata/core/util/Sha256.hpp

Go to the documentation of this file.

/*  Sirikata Utilities -- Sirikata Cryptography Utilities
 *  Sha256.hpp
 *
 *  Copyright (c) 2009, Daniel Reiter Horn
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are
 *  met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name of Sirikata nor the names of its contributors may
 *    be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _SIRIKATA_SHA256_HPP_
#define _SIRIKATA_SHA256_HPP_

#include <string>
#include <cstdlib>
#include <cstring>
#include <exception>
#include "Platform.hpp"
#include "Array.hpp"

namespace Sirikata {

class SIRIKATA_EXPORT SHA256 {
    friend class SHA256Context;
public:
    enum {static_size=32,hex_size=64};
    typedef Array<unsigned char, static_size> Digest;
private:
    Digest mData;
public:
    struct Hasher {
        size_t operator() (const SHA256 &hash) const{
            return *((size_t*)(hash.rawData().data()));
        }
    };

    unsigned int size()const{
        return static_size;
    }
    std::string convertToHexString()const;
    std::string toString() const { return convertToHexString(); }
    Array<char,hex_size> convertToHex()const;
    const Digest &rawData()const {
        return mData;
    }

    bool operator==(const SHA256& other) const {
        return mData==other.mData;
    }
    bool operator!=(const SHA256& other) const {
        return !(mData==other.mData);
    }
    bool operator<(const SHA256& other) const{
        return mData<other.mData;
    }
    static SHA256 convertFromHex(const char*digest);
    static SHA256 convertFromHex(const std::string&digest);
    static SHA256 convertFromBinary(const Digest&digest) {
        return convertFromBinary(digest.data());
    }
    static SHA256 convertFromBinary(const void*digest){
        SHA256 retval;
        memcpy(retval.mData.data(),digest,static_size);
        return retval;
    }
    static SHA256 computeDigest(const void *data, size_t length);
    static SHA256 computeDigest(const std::string&data);
    static const SHA256&null(){
        static SHA256 null0;
        static char empty_array[static_size]={0};
        static void* result=std::memcpy(null0.mData.data(),empty_array,static_size);
        return result?null0:null0;
    }
    static const SHA256&emptyDigest() {
        static SHA256 empty=computeDigest(NULL,0);
        return empty;
    }

    friend inline std::ostream &operator <<(std::ostream &os, const SHA256&shasum) {
        return os << shasum.convertToHexString();
    }

};

class SIRIKATA_EXPORT SHA256Context {
    SHA256Context(const SHA256Context &other);
    SHA256Context & operator=(const SHA256Context &other);

    void *mCtx;

    SHA256 mRetval;
public:
    SHA256Context();
    ~SHA256Context();

    void update(const void *data, size_t length);
    inline void update(const std::string &data) {
        update(data.data(), data.length());
    }
    void updateZeros(size_t length);

    const SHA256& get();
};

}

#endif //_SIRIKATA_SHA256_HPP_