md5.hh

// Copyright (C) 2004  EPITA Research and Development Laboratory
//
// This  file is  part of  the Olena  Library.  This  library  is free
// software; you can redistribute it  and/or modify it under the terms
// of the  GNU General  Public License version  2 as published  by the
// Free Software Foundation.
//
// This library 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 library; see the  file COPYING.  If  not, write to
// the Free Software Foundation, 59  Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.
//
// As a  special exception, you  may use this  file as part of  a free
// software library without restriction.  Specifically, if other files
// instantiate templates  or use macros or inline  functions from this
// file, or  you compile  this file  and link it  with other  files to
// produce  an executable,  this file  does  not by  itself cause  the
// resulting  executable  to be  covered  by  the  GNU General  Public
// License.   This exception  does  not however  invalidate any  other
// reasons why the executable file might be covered by the GNU General
// Public License.

#ifndef OLENA_OLN_UTILS_MD5_HH
# define OLENA_OLN_UTILS_MD5_HH

# include <ntg/all.hh>
# include <vector>

# include <oln/core/abstract/image_with_type_with_dim.hh>

# include <oln/utils/key.hh>
# include <oln/utils/buffer.hh>

namespace oln {
  namespace utils {
    class MD5
    {
    public:
      typedef ntg::int_u32                      value_type; 
      typedef ntg_storage_type_(value_type)     storage_type; 

      explicit MD5(buffer b);

      key execute();

      key gen_key();

    protected:
      void sav();

      void round1();

      void round2();

      void round3();

      void round4();

      void step();

      template <class Fun>
      void sub_step(const Fun &fun,
                    storage_type &a,
                    const storage_type &b,
                    const storage_type &c,
                    const storage_type &d,
                    unsigned k,
                    unsigned s,
                    unsigned i);

      void gen_sub_key(std::vector<key::value_type> &v,
                       storage_type x,
                       unsigned base);


      buffer                    buffer_; 
      std::vector<storage_type> X; 
      std::vector<storage_type> T; 
      unsigned                  current_; 
      storage_type                      aa; 
      storage_type                      bb; 
      storage_type                      cc; 
      storage_type                      dd; 
      storage_type                      a; 
      storage_type                      b; 
      storage_type                      c; 
      storage_type                      d; 

      struct
      {
        storage_type operator()(const storage_type &x,
                                const storage_type &y,
                                const storage_type &z) const
        {
          //      return z ^ (x & (y ^ z));
          return x & y | ~x & z;
        }
      }                         F;

      struct
      {
        storage_type operator()(const storage_type &x,
                                const storage_type &y,
                                const storage_type &z) const
        {
          return x & z | y & ~z;
        }
      }                         G;

      struct
      {
        storage_type operator()(const storage_type &x,
                                const storage_type &y,
                                const storage_type &z) const
        {
          return x ^ y ^ z;
        }
      }                         H;

      struct
      {
        storage_type operator()(const storage_type &x,
                                const storage_type &y,
                                const storage_type &z) const
        {
          return y ^ (x | ~z);
        }
      }                         I;
    };

#include <oln/utils/md5.hxx>

    template <class I>
    key md5(const oln::abstract::non_vectorial_image<I> &im);

    template <class I>
    key md5(const oln::abstract::vectorial_image<I> &im);

  } // !utils
} // !oln
#endif // !OLENA_OLN_UTILS_MD5_HH

---