md5.hpp

/*
  ANCH Framework: ANother C++ Hack is a C++ framework based on C++11 standard
  Copyright (C) 2012 Vincent Lachenal

  This file is part of ANCH Framework.

  ANCH Framework 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.

  ANCH Framework 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 ANCH Framework.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _ANCH_CRYPTO_MD5_H_
#define _ANCH_CRYPTO_MD5_H_

#include "crypto/hash/hash.hpp"

#include <cstring>


namespace anch {
  namespace crypto {

    template<typename H> H HMAC(const std::string&, const std::string&);

    class MD5: public Hash<16,64> {

      friend MD5 anch::crypto::HMAC<MD5>(const std::string&, const std::string&);

    private:
      struct Context {
        uint32_t handle[2];

        uint32_t buffer[4];

        uint32_t input[16];

        std::array<uint8_t,16> digest;

        Context() {
          reset();
        }

        void reset() {
          static uint32_t HANDLE_INIT[2] = { 0, 0 };
          std::memcpy(handle, HANDLE_INIT, 2 * sizeof(uint32_t));
          static uint32_t BUFFER_INIT[4] = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, };
          std::memcpy(buffer, BUFFER_INIT, 4 * sizeof(uint32_t));
        }
      };

      // Attributes +
    private:
      Context _context;
      // Attributes -

      // Constructors +
    public:
      MD5();

      template<class CharT, class Traits, class Allocator>
      MD5(const std::basic_string<CharT,Traits,Allocator>& data) {
        Hash::digest(data);
      }

      template<class CharT, class Traits>
      MD5(std::basic_istream<CharT,Traits>& stream) {
        Hash::digest(stream);
      }

    private:
      MD5(const uint8_t* data, std::size_t len) {
        Hash::digest(data, len);
      }
      // Constructors -

      // Destructor +
    public:
      virtual ~MD5();
      // Destructor -

      // Methods +
    public:
      virtual const std::array<uint8_t,16>& digest() const override;

    protected:
      virtual void reset() override {
        _context.reset();
      }

      virtual void addData(const uint8_t* data, std::size_t len) override;

      virtual void finalize() override;

    private:
      void transform();

      template<class Core>
      static inline void transform(uint32_t& a,
                                   uint32_t b,
                                   uint32_t c,
                                   uint32_t d,
                                   uint32_t in,
                                   int bits) {
        a += Core::apply(b,c,d) + in;
        a = (a << bits | a >> (32 - bits)) + b;
      }
      // Methods -

      // Core functions +
    private:
      class Core1 {
      public:
        inline static uint32_t apply(uint32_t a, uint32_t b, uint32_t c) {
          return (c ^ (a & (b ^ c)));
        }
      };

      class Core2 {
      public:
        inline static uint32_t apply(uint32_t a, uint32_t b, uint32_t c) {
          return Core1::apply(c, a, b);
        }
      };

      class Core3 {
      public:
        inline static uint32_t apply(uint32_t a, uint32_t b, uint32_t c) {
          return (a ^ b ^ c);
        }
      };

      class Core4 {
      public:
        inline static uint32_t apply(uint32_t a, uint32_t b, uint32_t c) {
          return (b ^ (a | ~c));
        }
      };
      // Core functions -

    };

    extern template MD5 HMAC<MD5>(const std::string&, const std::string&);

  }
}

#endif // _ANCH_CRYPTO_MD5_H_