/*****************************************************************************/

// Copyright 2006-2007 Adobe Systems Incorporated

// All Rights Reserved.

//

// NOTICE:  Adobe permits you to use, modify, and distribute this file in

// accordance with the terms of the Adobe license agreement accompanying it.

/*****************************************************************************/

/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_fingerprint.h#2 $ */ 

/* $DateTime: 2012/07/11 10:36:56 $ */

/* $Change: 838485 $ */

/* $Author: tknoll $ */

/** \file

 * Fingerprint (cryptographic hashing) support for generating strong hashes of image

 * data.

 */

/*****************************************************************************/

#ifndef __dng_fingerprint__

#define __dng_fingerprint__

/*****************************************************************************/

#include "dng_exceptions.h"

#include "dng_types.h"

#include "dng_stream.h"

#include <cstring>

/*****************************************************************************/

/// \brief Container fingerprint (MD5 only at present).

class dng_fingerprint

  {

  public:

    static const size_t kDNGFingerprintSize = 16;

    uint8 data [kDNGFingerprintSize];

  public:

    dng_fingerprint ();

    /// Check if fingerprint is all zeros.

    bool IsNull () const;

    /// Same as IsNull but expresses intention of testing validity.

    bool IsValid () const

      {

      return !IsNull ();

      }

    /// Set to all zeros, a value used to indicate an invalid fingerprint.

    void Clear ()

      {

      *this = dng_fingerprint ();

      }

    /// Test if two fingerprints are equal.

    bool operator== (const dng_fingerprint &print) const;

    /// Test if two fingerprints are not equal.

    bool operator!= (const dng_fingerprint &print) const

      {

      return !(*this == print);

      }

    /// Produce a 32-bit hash value from fingerprint used for faster hashing of

    /// fingerprints.

    uint32 Collapse32 () const; 

    /// Convert fingerprint to UTF-8 string.

    ///

    /// \param resultStr The output array to which the UTF-8 encoding of the

    /// fingerprint will be written.

    void ToUtf8HexString (char resultStr [2 * kDNGFingerprintSize + 1]) const;

    /// Convert UTF-8 string to fingerprint. Returns true on success, false on

    /// failure.

    ///

    /// \param inputStr The input array from which the UTF-8 encoding of the

    /// fingerprint will be read.

    ///

    /// \retval True indicates success.

    bool FromUtf8HexString (const char inputStr [2 * kDNGFingerprintSize + 1]);

  };

/*****************************************************************************/

/// \brief Utility to compare fingerprints (e.g., for sorting).

struct dng_fingerprint_less_than

  {

  /// Less-than comparison.

  bool operator() (const dng_fingerprint &a, 

           const dng_fingerprint &b) const

    {

    return memcmp (a.data, 

             b.data, 

             sizeof (a.data)) < 0;

    }

  };

/******************************************************************************/

// Derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm.

// Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All

// rights reserved.

// 

// License to copy and use this software is granted provided that it

// is identified as the "RSA Data Security, Inc. MD5 Message-Digest

// Algorithm" in all material mentioning or referencing this software

// or this function.

// 

// License is also granted to make and use derivative works provided

// that such works are identified as "derived from the RSA Data

// Security, Inc. MD5 Message-Digest Algorithm" in all material

// mentioning or referencing the derived work.

// 

// RSA Data Security, Inc. makes no representations concerning either

// the merchantability of this software or the suitability of this

// software for any particular purpose. It is provided "as is"

// without express or implied warranty of any kind.

// 

// These notices must be retained in any copies of any part of this

// documentation and/or software.

/// \brief Class to hash binary data to a fingerprint using the MD5 Message-Digest

/// Algorithm.

class dng_md5_printer

  {

  public:

    dng_md5_printer ();

    virtual ~dng_md5_printer ()

      {

      }

    /// Reset the fingerprint.

    void Reset ();

    /// Append the data to the stream to be hashed.

    /// \param data The data to be hashed.

    /// \param inputLen The length of data, in bytes.

    void Process (const void *data,

            uint32 inputLen);

    /// Append the string to the stream to be hashed.

    /// \param text The string to be hashed.

    void Process (const char *text)

      {

      Process (text, (uint32) strlen (text));

      }

    /// Get the fingerprint (i.e., result of the hash).

    const dng_fingerprint & Result ();

  private:

    static void Encode (uint8 *output,

              const uint32 *input,

              uint32 len);

    static void Decode (uint32 *output,

              const uint8 *input,

              uint32 len);

    // F, G, H and I are basic MD5 functions.

    static inline uint32 F (uint32 x,

                uint32 y,

                uint32 z)

      {

      return (x & y) | (~x & z);

      }

    static inline uint32 G (uint32 x,

                uint32 y,

                uint32 z)

      {

      return (x & z) | (y & ~z);

      }

    static inline uint32 H (uint32 x,

                uint32 y,

                uint32 z)

      {

      return x ^ y ^ z;

      }

    static inline uint32 I (uint32 x,

                uint32 y,

                uint32 z)

      {

      return y ^ (x | ~z);

      }

    // FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.

#if defined(__clang__) && defined(__has_attribute)

#if __has_attribute(no_sanitize)

    __attribute__((no_sanitize("unsigned-integer-overflow")))

#endif

#endif

    static inline void FF (uint32 &a,

                 uint32 b,

                 uint32 c,

                 uint32 d,

                 uint32 x,

                 uint32 s,

                 uint32 ac)

      {

      a += F (b, c, d) + x + ac;

      a = (a << s) | (a >> (32 - s));

      a += b;

      }

#if defined(__clang__) && defined(__has_attribute)

#if __has_attribute(no_sanitize)

    __attribute__((no_sanitize("unsigned-integer-overflow")))

#endif

#endif

    static inline void GG (uint32 &a,

                 uint32 b,

                 uint32 c,

                 uint32 d,

                 uint32 x,

                 uint32 s,

                 uint32 ac)

      {

      a += G (b, c, d) + x + ac;

      a = (a << s) | (a >> (32 - s));

      a += b;

      }

#if defined(__clang__) && defined(__has_attribute)

#if __has_attribute(no_sanitize)

    __attribute__((no_sanitize("unsigned-integer-overflow")))

#endif

#endif

    static inline void HH (uint32 &a,

                 uint32 b,

                 uint32 c,

                 uint32 d,

                 uint32 x,

                 uint32 s,

                 uint32 ac)

      {

      a += H (b, c, d) + x + ac;

      a = (a << s) | (a >> (32 - s));

      a += b;

      }

#if defined(__clang__) && defined(__has_attribute)

#if __has_attribute(no_sanitize)

    __attribute__((no_sanitize("unsigned-integer-overflow")))

#endif

#endif

    static inline void II (uint32 &a,

                 uint32 b,

                 uint32 c,

                 uint32 d,

                 uint32 x,

                 uint32 s,

                 uint32 ac)

      {

      a += I (b, c, d) + x + ac;

      a = (a << s) | (a >> (32 - s));

      a += b;

      }

    static void MD5Transform (uint32 state [4],

                  const uint8 block [64]);

  private:

      uint32 state [4];

      uint32 count [2];

      uint8 buffer [64];

    bool final;

    dng_fingerprint result;

  };

/*****************************************************************************/

/// \brief A dng_stream based interface to the MD5 printing logic.

class dng_md5_printer_stream : public dng_stream, dng_md5_printer

  {

  private:

    uint64 fNextOffset;

  public:

    /// Create an empty MD5 printer stream.

    dng_md5_printer_stream ()

      : fNextOffset (0)

      {

      }

    virtual uint64 DoGetLength ()

      {

      return fNextOffset;

      }

    virtual void DoRead (void * /* data */,

               uint32 /* count */,

               uint64 /* offset */)

      {

      ThrowProgramError ();

      }

    virtual void DoSetLength (uint64 length)

      {

      if (length != fNextOffset)

        {

        ThrowProgramError ();

        }

      }

    virtual void DoWrite (const void *data,

                uint32 count2,

                uint64 offset)

      {

      if (offset != fNextOffset)

        {

        ThrowProgramError ();

        }

      Process (data, count2);

      fNextOffset += count2;

      }

    const dng_fingerprint & Result ()

      {

      Flush ();

      return dng_md5_printer::Result ();

      }

  };

/*****************************************************************************/

#endif

/*****************************************************************************/