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