md5.h

Go to the documentation of this file.

//
// Copyright (C) 2001-2013 Graeme Walker <graeme_walker@users.sourceforge.net>
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// ===
//
// md5.h
//
// An implementation of the RFC-1321 message digest algorithm.
//
// This code was developed from main body of RFC 1321 without reference to the
// RSA reference implementation in the appendix.
//
// A minor portability advantage over the RSA implementation is that there is no 
// need to define a datatype that is exactly 32 bits: the requirement is that 
// 'big_t' is at least 32 bits, but it can be more.
// 
// Stylistic advantages are that it is written in C++ with an enclosing namespace,
// it does not use preprocessor macros, and there is an element of layering with 
// digest_stream built on top of the low-level digest class.
//

#ifndef MD5_GHW_H
#define MD5_GHW_H

#include <string> // std::string
#include <cstdlib> // std::size_t

namespace md5
{
        typedef std::string string_type ; 
        typedef std::string::size_type size_type ; 
        typedef size_type big_t ; 
        typedef size_type small_t ; 
        typedef char assert_big_t_is_big_enough[sizeof(big_t)>=4U?1:-1] ; 
        typedef char assert_small_t_is_big_enough[sizeof(small_t)>=sizeof(size_type)?1:-1]; 
        class digest ;
        class digest_stream ;
        class format ;
        class block ;
}

class md5::digest 
{
public:
        struct state_type 
                { big_t a ; big_t b ; big_t c ; big_t d ; } ;

        digest() ; 

        explicit digest( const string_type & s ) ;

        explicit digest( state_type ) ;

        state_type state() const ;

        void add( const block & ) ;

private:
        typedef big_t (*aux_fn_t)( big_t , big_t , big_t ) ;
        enum Permutation { ABCD , DABC , CDAB , BCDA } ;
        big_t a ;
        big_t b ;
        big_t c ;
        big_t d ;

private:
        explicit digest( const block & ) ;
        void add( const digest & ) ;
        void init() ;
        void calculate( const block & ) ;
        static big_t T( small_t i ) ;
        static big_t rot32( small_t places , big_t n ) ;
        void operator()( const block & , aux_fn_t , Permutation , small_t , small_t , small_t ) ;
        static big_t op( const block & , aux_fn_t , big_t , big_t , big_t , big_t , small_t , small_t , small_t ) ;
        void round1( const block & ) ;
        void round2( const block & ) ;
        void round3( const block & ) ;
        void round4( const block & ) ;
        static big_t F( big_t x , big_t y , big_t z ) ;
        static big_t G( big_t x , big_t y , big_t z ) ;
        static big_t H( big_t x , big_t y , big_t z ) ;
        static big_t I( big_t x , big_t y , big_t z ) ;
} ;

class md5::format 
{
public:
        static string_type rfc( const digest & ) ;

        static string_type rfc( const digest::state_type & ) ;

        static string_type raw( const digest::state_type & ) ;

private:
        static string_type raw( big_t n ) ;
        static string_type str( big_t n ) ;
        static string_type str2( small_t n ) ;
        static string_type str1( small_t n ) ;
        format() ; // not implemented
} ;

class md5::block 
{
public:
        block( const string_type & s , small_t block_offset , big_t end_value ) ;

        static big_t end( small_t data_length ) ;

        static small_t blocks( small_t data_length ) ;

        big_t X( small_t ) const ;

private:
        block( const block & ) ; // not implemented
        void operator=( const block & ) ; // not implemented
        small_t x( small_t ) const ;
        static small_t rounded( small_t n ) ;

private:
        const string_type & m_s ;
        small_t m_block ;
        big_t m_end_value ;
} ;

class md5::digest_stream 
{
public:
        struct state_type 
                { digest::state_type d ; small_t n ; string_type s ; } ;

        digest_stream() ;

        digest_stream( digest::state_type d , small_t n ) ;

        void add( const string_type & ) ;

        void close() ;

        small_t size() const ;

        state_type state() const ;

private:
        digest m_digest ;
        string_type m_buffer ;
        small_t m_length ;
} ;

#endif