source/dng_fingerprint.h - platform/external/dng_sdk - Git at Google

 /*****************************************************************************/
 // 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

 /*****************************************************************************/
	/*****************************************************************************/
	// 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

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