ext/amazon-freertos/libraries/c_sdk/standard/common/iot_device_metrics.c - a71ch-crypto-support - Git at Google

 /*
  * FreeRTOS Common V1.1.1
  * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
  * this software and associated documentation files (the "Software"), to deal in
  * the Software without restriction, including without limitation the rights to
  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  * the Software, and to permit persons to whom the Software is furnished to do so,
  * subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in all
  * copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  *
  * http://aws.amazon.com/freertos
  * http://www.FreeRTOS.org
  */

 /**
  * @file iot_mqtt_metrics.c
  * @brief Source code for generating device metrics for AWS IOT.
  * The generated metrics will be included within the username field of MQTT CONNECT message.
  */
 #include <string.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <string.h>
 #include <stdio.h>

 #include "iot_config.h"

 #include "platform/iot_clock.h"
 #include "iot_atomic.h"

 /*
  * @brief Total length of the hash in bytes.
  */
 #define MD5_HASH_LENGTH_BYTES            ( 16 )

 /*
  * Encode Length of one byte for the identifier.
  */
 #define IDENTIFIER_BYTE_ENCODE_LENGTH    ( 2 )

 /*
  * @brief Length in bytes of each chunk used for MD5 hash computation.
  */
 #define MD5_CHUNK_LENGTH                 ( 64 )

 /*
  * @brief Number of bytes used for padding message length to input bytes.
  */
 #define MD5_MSGLEN_PADDING_LENGTH        ( 8 )

 /*
  * @brief The first byte of the bit padding ( Most significant bit should be 1 ).
  */
 #define MD5_BIT_PADDING_FIRST_BYTE       ( 0x80 )

 /*
  * @brief Total length of the input after padding.
  */
 #define MD5_PADDED_LENGTH( length )    ( ( length + MD5_MSGLEN_PADDING_LENGTH + MD5_CHUNK_LENGTH ) & ~( MD5_CHUNK_LENGTH - 1 ) )

 /*
  * @brief Length of device identifier.
  * Device identifier is represented as hex string of MD5 hash of the device certificate.
  */
 #define AWS_IOT_DEVICE_IDENTIFIER_LENGTH    ( MD5_HASH_LENGTH_BYTES * 2 )

 /**
  * @brief Device metrics name format
  */
 #define AWS_IOT_METRICS_FORMAT              "?SDK=" IOT_SDK_NAME "&Version=" IOT_SDK_VERSION "&Platform=" IOT_PLATFORM_NAME "&AFRDevID=%.*s"

 /**
  * @brief Length of #AWS_IOT_METRICS_FORMAT.
  */
 #define AWS_IOT_METRICS_FORMAT_LENGTH       ( ( uint16_t ) ( sizeof( AWS_IOT_METRICS_FORMAT ) + AWS_IOT_DEVICE_IDENTIFIER_LENGTH ) )

 /*
  * @brief Macro for left rotatation at each round of MD5 hash operation.
  */
 #define LEFT_ROTATE( x, c )    ( ( x << c ) | ( x >> ( 32 - c ) ) )


 /*
  * @brief Generates 128-bit MD5 hash from the input data.
  * The hash algorithm is adapted from wikipedia and does not dependent on any third party libraries.
  *
  * @param[in] pData Data on which hash needs to be calculated.
  * @param[in] dataLength Length in bytes of the input data
  * @param[in] pHash   Memory location where the hash value is stored.
  * @param[out] hashLength Total size of the memory location for hash storage.
  */
 void Utils_generateMD5Hash( const char * pData,
                             size_t dataLength,
                             uint8_t * pHash,
                             size_t hashLength );

 /*
  * @brief Generates a unique identifier string from the input data.
  * Uses MD5 hash algorithm to generate a 128-bit unique identifier and
  * encodes as a hexadecimal string.
  */

 static void _generateUniqueIdentifier( const char * pInput,
                                        size_t length,
                                        char * pIdentifier,
                                        size_t identifierLength );

 /*
  * @brief generates device metrics from the device identifier
  */
 static void _generateDeviceMetrics( const char * pDeviceIdentifier,
                                     size_t deviceIdentifierLength,
                                     char * pDeviceMetrics,
                                     size_t deviceMetricsLength );

 /*
  * @brief Spinlock lock implementation using atomic compare and swap.
  */
 static void _atomicSpinlock_lock( uint32_t * lock );

 /*
  * @brief Spinlock unlock implementation using atomic compare and swap.
  */
 static void _atomicSpinlock_unlock( uint32_t * lock );

 /**
  * @brief Metrics for the device.
  */
 static char deviceMetrics[ AWS_IOT_METRICS_FORMAT_LENGTH + 1 ] = { 0 };

 /**
  * @brief Unique identifier for the device.
  */
 static char deviceIdentifier[ AWS_IOT_DEVICE_IDENTIFIER_LENGTH + 1 ] = { 0 };

 /*
  * @brief Constants used for left rotation.
  */
 static const unsigned char S[ 64 ] =
 {
     7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
     5, 9,  14, 20, 5, 9,  14, 20, 5, 9,  14, 20, 5, 9,  14, 20,
     4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
     6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21
 };

 /*
  * @brief Constants representing the binary integer part of the sines of integers from 0 to 63.
  */
 static const uint32_t K[ 64 ] =
 {
     0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
     0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
     0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
     0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
     0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
     0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
     0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
     0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
     0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
     0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
     0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
     0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
     0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
     0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
     0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
     0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
 };


 void Utils_generateMD5Hash( const char * pData,
                             size_t dataLength,
                             uint8_t * pHash,
                             size_t hashLength )
 {
     uint8_t chunk[ MD5_CHUNK_LENGTH ] = { 0 };
     uint32_t * pOutput = ( uint32_t * ) pHash;
     const uint32_t * pCurrent = NULL;
     size_t paddingOffset, bytesConsumed = 0;
     size_t paddingLength, totalLength = MD5_PADDED_LENGTH( dataLength );
     uint64_t numBits = ( dataLength * 8 );
     bool isPadding = false;
     int i;

     uint32_t A, B, C, D, F, G;

     /*Initialize variables */
     pOutput[ 0 ] = 0x67452301;
     pOutput[ 1 ] = 0xefcdab89;
     pOutput[ 2 ] = 0x98badcfe;
     pOutput[ 3 ] = 0x10325476;

     configASSERT( hashLength >= MD5_HASH_LENGTH_BYTES );

     while( bytesConsumed < totalLength )
     {
         if( ( bytesConsumed + MD5_CHUNK_LENGTH ) <= dataLength )
         {
             pCurrent = ( uint32_t * ) pData;
             pData += MD5_CHUNK_LENGTH;
             bytesConsumed += MD5_CHUNK_LENGTH;
         }
         else
         {
             if( bytesConsumed < dataLength )
             {
                 memcpy( chunk, pData, ( dataLength - bytesConsumed ) );
                 paddingOffset = ( dataLength - bytesConsumed );
             }
             else
             {
                 paddingOffset = 0;
             }

             paddingLength = ( MD5_CHUNK_LENGTH - paddingOffset );

             if( ( paddingLength >= 1 ) && ( isPadding == false ) )
             {
                 chunk[ paddingOffset++ ] = MD5_BIT_PADDING_FIRST_BYTE;
                 paddingLength--;
                 isPadding = true;
             }

             if( paddingLength > MD5_MSGLEN_PADDING_LENGTH )
             {
                 memset( &chunk[ paddingOffset ], 0x00, ( paddingLength - MD5_MSGLEN_PADDING_LENGTH ) );
                 paddingOffset += ( paddingLength - MD5_MSGLEN_PADDING_LENGTH );
                 paddingLength = MD5_MSGLEN_PADDING_LENGTH;
             }

             if( paddingLength == MD5_MSGLEN_PADDING_LENGTH )
             {
                 chunk[ paddingOffset++ ] = ( numBits & 0xFF );
                 chunk[ paddingOffset++ ] = ( ( numBits >> 8 ) & 0xFF );
                 chunk[ paddingOffset++ ] = ( ( numBits >> 16 ) & 0xFF );
                 chunk[ paddingOffset++ ] = ( ( numBits >> 24 ) & 0xFF );
                 chunk[ paddingOffset++ ] = ( ( numBits >> 32 ) & 0xFF );
                 chunk[ paddingOffset++ ] = ( ( numBits >> 40 ) & 0xFF );
                 chunk[ paddingOffset++ ] = ( ( numBits >> 48 ) & 0xFF );
                 chunk[ paddingOffset++ ] = ( ( numBits >> 56 ) & 0xFF );
             }

             pCurrent = ( uint32_t * ) chunk;
             bytesConsumed += MD5_CHUNK_LENGTH;
         }

         A = pOutput[ 0 ];
         B = pOutput[ 1 ];
         C = pOutput[ 2 ];
         D = pOutput[ 3 ];

         for( i = 0; i < 64; i++ )
         {
             if( i < 16 )
             {
                 F = ( B & C ) | ( ( ~B ) & D );
                 G = i;
             }
             else if( i < 32 )
             {
                 F = ( D & B ) | ( ( ~D ) & C );
                 G = ( ( 5 * i ) + 1 ) % 16;
             }
             else if( i < 48 )
             {
                 F = ( B ^ C ) ^ D;
                 G = ( ( 3 * i ) + 5 ) % 16;
             }
             else
             {
                 F = C ^ ( B | ( ~D ) );
                 G = ( 7 * i ) % 16;
             }

             F = F + A + K[ i ] + pCurrent[ G ];
             A = D;
             D = C;
             C = B;
             B = B + LEFT_ROTATE( F, S[ i ] );
         }

         pOutput[ 0 ] += A;
         pOutput[ 1 ] += B;
         pOutput[ 2 ] += C;
         pOutput[ 3 ] += D;
     }
 }

 static void _generateDeviceMetrics( const char * pDeviceIdentifier,
                                     size_t deviceIdentifierLength,
                                     char * pDeviceMetrics,
                                     size_t deviceMetricsLength )
 {
     size_t length;

     length = snprintf( pDeviceMetrics,
                        deviceMetricsLength,
                        AWS_IOT_METRICS_FORMAT,
                        deviceIdentifierLength,
                        pDeviceIdentifier );

     configASSERT( length > 0 );
 }

 static void _atomicSpinlock_lock( uint32_t * lock )
 {
     uint32_t current = 0;
     uint32_t store = 1;

     for( ; ; )
     {
         if( Atomic_CompareAndSwap_u32( lock, store, current ) == 1 )
         {
             break;
         }

         /* Does context switch with negligible delay. */
         IotClock_SleepMs( 1 );
     }
 }

 static void _atomicSpinlock_unlock( uint32_t * lock )
 {
     uint32_t current = 1;
     uint32_t store = 0;

     for( ; ; )
     {
         if( Atomic_CompareAndSwap_u32( lock, store, current ) == 1 )
         {
             break;
         }

         /* Does context switch with negligible delay. */
         IotClock_SleepMs( 1 );
     }
 }

 static void _generateUniqueIdentifier( const char * pInput,
                                        size_t length,
                                        char * pIdentifier,
                                        size_t identifierLength )
 {
     uint8_t hash[ MD5_HASH_LENGTH_BYTES ] = { 0 };
     int i;
     size_t ret;

     configASSERT( identifierLength >= ( 2 * MD5_HASH_LENGTH_BYTES ) );
     Utils_generateMD5Hash( pInput, length, hash, MD5_HASH_LENGTH_BYTES );

     for( i = 0; i < MD5_HASH_LENGTH_BYTES; i++ )
     {
         ret = snprintf( pIdentifier, ( IDENTIFIER_BYTE_ENCODE_LENGTH + 1 ), "%02X", hash[ i ] );
         configASSERT( ret > 0 );
         pIdentifier += IDENTIFIER_BYTE_ENCODE_LENGTH;
     }
 }

 /*
  * @brief Retrieves the device identifier.
  */
 const char * getDeviceIdentifier( void )
 {
     const char * pCertificate = IOT_DEVICE_CERTIFICATE;
     static uint32_t lock = 0;

     if( deviceIdentifier[ 0 ] == '\0' )
     {
         _atomicSpinlock_lock( &lock );

         if( deviceIdentifier[ 0 ] == '\0' )
         {
             if( ( pCertificate != NULL ) &&
                 ( strcmp( pCertificate, "" ) != 0 ) )
             {
                 _generateUniqueIdentifier( pCertificate, strlen( pCertificate ), deviceIdentifier, sizeof( deviceIdentifier ) );
             }
             else
             {
                 strncpy( deviceIdentifier, "Unknown", sizeof( deviceIdentifier ) );
             }
         }

         _atomicSpinlock_unlock( &lock );
     }

     return deviceIdentifier;
 }

 /*
  * @brief Retrieves the device metrics.
  */
 const char * getDeviceMetrics( void )
 {
     const char * pDeviceIdentifier = NULL;
     static uint32_t lock = 0;

     if( deviceMetrics[ 0 ] == '\0' )
     {
         _atomicSpinlock_lock( &lock );

         if( deviceMetrics[ 0 ] == '\0' )
         {
             pDeviceIdentifier = getDeviceIdentifier();
             _generateDeviceMetrics( pDeviceIdentifier, strlen( pDeviceIdentifier ), deviceMetrics, sizeof( deviceMetrics ) );
         }

         _atomicSpinlock_unlock( &lock );
     }

     return deviceMetrics;
 }

 /*
  * @brief Retrieves the device metrics length.
  */
 uint16_t getDeviceMetricsLength( void )
 {
     const char * pDeviceMetrics = getDeviceMetrics();

     return ( uint16_t ) ( strlen( pDeviceMetrics ) );
 }
	/*
	* FreeRTOS Common V1.1.1
	* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a copy of
	* this software and associated documentation files (the "Software"), to deal in
	* the Software without restriction, including without limitation the rights to
	* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
	* the Software, and to permit persons to whom the Software is furnished to do so,
	* subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included in all
	* copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
	* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
	* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
	* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	*
	* http://aws.amazon.com/freertos
	* http://www.FreeRTOS.org
	*/

	/**
	* @file iot_mqtt_metrics.c
	* @brief Source code for generating device metrics for AWS IOT.
	* The generated metrics will be included within the username field of MQTT CONNECT message.
	*/
	#include <string.h>
	#include <stdint.h>
	#include <stdbool.h>
	#include <string.h>
	#include <stdio.h>

	#include "iot_config.h"

	#include "platform/iot_clock.h"
	#include "iot_atomic.h"

	/*
	* @brief Total length of the hash in bytes.
	*/
	#define MD5_HASH_LENGTH_BYTES ( 16 )

	/*
	* Encode Length of one byte for the identifier.
	*/
	#define IDENTIFIER_BYTE_ENCODE_LENGTH ( 2 )

	/*
	* @brief Length in bytes of each chunk used for MD5 hash computation.
	*/
	#define MD5_CHUNK_LENGTH ( 64 )

	/*
	* @brief Number of bytes used for padding message length to input bytes.
	*/
	#define MD5_MSGLEN_PADDING_LENGTH ( 8 )

	/*
	* @brief The first byte of the bit padding ( Most significant bit should be 1 ).
	*/
	#define MD5_BIT_PADDING_FIRST_BYTE ( 0x80 )

	/*
	* @brief Total length of the input after padding.
	*/
	#define MD5_PADDED_LENGTH( length ) ( ( length + MD5_MSGLEN_PADDING_LENGTH + MD5_CHUNK_LENGTH ) & ~( MD5_CHUNK_LENGTH - 1 ) )

	/*
	* @brief Length of device identifier.
	* Device identifier is represented as hex string of MD5 hash of the device certificate.
	*/
	#define AWS_IOT_DEVICE_IDENTIFIER_LENGTH ( MD5_HASH_LENGTH_BYTES * 2 )

	/**
	* @brief Device metrics name format
	*/
	#define AWS_IOT_METRICS_FORMAT "?SDK=" IOT_SDK_NAME "&Version=" IOT_SDK_VERSION "&Platform=" IOT_PLATFORM_NAME "&AFRDevID=%.*s"

	/**
	* @brief Length of #AWS_IOT_METRICS_FORMAT.
	*/
	#define AWS_IOT_METRICS_FORMAT_LENGTH ( ( uint16_t ) ( sizeof( AWS_IOT_METRICS_FORMAT ) + AWS_IOT_DEVICE_IDENTIFIER_LENGTH ) )

	/*
	* @brief Macro for left rotatation at each round of MD5 hash operation.
	*/
	#define LEFT_ROTATE( x, c ) ( ( x << c ) \| ( x >> ( 32 - c ) ) )


	/*
	* @brief Generates 128-bit MD5 hash from the input data.
	* The hash algorithm is adapted from wikipedia and does not dependent on any third party libraries.
	*
	* @param[in] pData Data on which hash needs to be calculated.
	* @param[in] dataLength Length in bytes of the input data
	* @param[in] pHash Memory location where the hash value is stored.
	* @param[out] hashLength Total size of the memory location for hash storage.
	*/
	void Utils_generateMD5Hash( const char * pData,
	size_t dataLength,
	uint8_t * pHash,
	size_t hashLength );

	/*
	* @brief Generates a unique identifier string from the input data.
	* Uses MD5 hash algorithm to generate a 128-bit unique identifier and
	* encodes as a hexadecimal string.
	*/

	static void _generateUniqueIdentifier( const char * pInput,
	size_t length,
	char * pIdentifier,
	size_t identifierLength );

	/*
	* @brief generates device metrics from the device identifier
	*/
	static void _generateDeviceMetrics( const char * pDeviceIdentifier,
	size_t deviceIdentifierLength,
	char * pDeviceMetrics,
	size_t deviceMetricsLength );

	/*
	* @brief Spinlock lock implementation using atomic compare and swap.
	*/
	static void _atomicSpinlock_lock( uint32_t * lock );

	/*
	* @brief Spinlock unlock implementation using atomic compare and swap.
	*/
	static void _atomicSpinlock_unlock( uint32_t * lock );

	/**
	* @brief Metrics for the device.
	*/
	static char deviceMetrics[ AWS_IOT_METRICS_FORMAT_LENGTH + 1 ] = { 0 };

	/**
	* @brief Unique identifier for the device.
	*/
	static char deviceIdentifier[ AWS_IOT_DEVICE_IDENTIFIER_LENGTH + 1 ] = { 0 };

	/*
	* @brief Constants used for left rotation.
	*/
	static const unsigned char S[ 64 ] =
	{
	7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
	5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,
	4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
	6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21
	};

	/*
	* @brief Constants representing the binary integer part of the sines of integers from 0 to 63.
	*/
	static const uint32_t K[ 64 ] =
	{
	0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
	0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
	0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
	0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
	0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
	0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
	0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
	0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
	0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
	0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
	0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
	0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
	0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
	0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
	0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
	0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
	};


	void Utils_generateMD5Hash( const char * pData,
	size_t dataLength,
	uint8_t * pHash,
	size_t hashLength )
	{
	uint8_t chunk[ MD5_CHUNK_LENGTH ] = { 0 };
	uint32_t * pOutput = ( uint32_t * ) pHash;
	const uint32_t * pCurrent = NULL;
	size_t paddingOffset, bytesConsumed = 0;
	size_t paddingLength, totalLength = MD5_PADDED_LENGTH( dataLength );
	uint64_t numBits = ( dataLength * 8 );
	bool isPadding = false;
	int i;

	uint32_t A, B, C, D, F, G;

	/Initialize variables /
	pOutput[ 0 ] = 0x67452301;
	pOutput[ 1 ] = 0xefcdab89;
	pOutput[ 2 ] = 0x98badcfe;
	pOutput[ 3 ] = 0x10325476;

	configASSERT( hashLength >= MD5_HASH_LENGTH_BYTES );

	while( bytesConsumed < totalLength )
	{
	if( ( bytesConsumed + MD5_CHUNK_LENGTH ) <= dataLength )
	{
	pCurrent = ( uint32_t * ) pData;
	pData += MD5_CHUNK_LENGTH;
	bytesConsumed += MD5_CHUNK_LENGTH;
	}
	else
	{
	if( bytesConsumed < dataLength )
	{
	memcpy( chunk, pData, ( dataLength - bytesConsumed ) );
	paddingOffset = ( dataLength - bytesConsumed );
	}
	else
	{
	paddingOffset = 0;
	}

	paddingLength = ( MD5_CHUNK_LENGTH - paddingOffset );

	if( ( paddingLength >= 1 ) && ( isPadding == false ) )
	{
	chunk[ paddingOffset++ ] = MD5_BIT_PADDING_FIRST_BYTE;
	paddingLength--;
	isPadding = true;
	}

	if( paddingLength > MD5_MSGLEN_PADDING_LENGTH )
	{
	memset( &chunk[ paddingOffset ], 0x00, ( paddingLength - MD5_MSGLEN_PADDING_LENGTH ) );
	paddingOffset += ( paddingLength - MD5_MSGLEN_PADDING_LENGTH );
	paddingLength = MD5_MSGLEN_PADDING_LENGTH;
	}

	if( paddingLength == MD5_MSGLEN_PADDING_LENGTH )
	{
	chunk[ paddingOffset++ ] = ( numBits & 0xFF );
	chunk[ paddingOffset++ ] = ( ( numBits >> 8 ) & 0xFF );
	chunk[ paddingOffset++ ] = ( ( numBits >> 16 ) & 0xFF );
	chunk[ paddingOffset++ ] = ( ( numBits >> 24 ) & 0xFF );
	chunk[ paddingOffset++ ] = ( ( numBits >> 32 ) & 0xFF );
	chunk[ paddingOffset++ ] = ( ( numBits >> 40 ) & 0xFF );
	chunk[ paddingOffset++ ] = ( ( numBits >> 48 ) & 0xFF );
	chunk[ paddingOffset++ ] = ( ( numBits >> 56 ) & 0xFF );
	}

	pCurrent = ( uint32_t * ) chunk;
	bytesConsumed += MD5_CHUNK_LENGTH;
	}

	A = pOutput[ 0 ];
	B = pOutput[ 1 ];
	C = pOutput[ 2 ];
	D = pOutput[ 3 ];

	for( i = 0; i < 64; i++ )
	{
	if( i < 16 )
	{
	F = ( B & C ) \| ( ( ~B ) & D );
	G = i;
	}
	else if( i < 32 )
	{
	F = ( D & B ) \| ( ( ~D ) & C );
	G = ( ( 5 * i ) + 1 ) % 16;
	}
	else if( i < 48 )
	{
	F = ( B ^ C ) ^ D;
	G = ( ( 3 * i ) + 5 ) % 16;
	}
	else
	{
	F = C ^ ( B \| ( ~D ) );
	G = ( 7 * i ) % 16;
	}

	F = F + A + K[ i ] + pCurrent[ G ];
	A = D;
	D = C;
	C = B;
	B = B + LEFT_ROTATE( F, S[ i ] );
	}

	pOutput[ 0 ] += A;
	pOutput[ 1 ] += B;
	pOutput[ 2 ] += C;
	pOutput[ 3 ] += D;
	}
	}

	static void _generateDeviceMetrics( const char * pDeviceIdentifier,
	size_t deviceIdentifierLength,
	char * pDeviceMetrics,
	size_t deviceMetricsLength )
	{
	size_t length;

	length = snprintf( pDeviceMetrics,
	deviceMetricsLength,
	AWS_IOT_METRICS_FORMAT,
	deviceIdentifierLength,
	pDeviceIdentifier );

	configASSERT( length > 0 );
	}

	static void _atomicSpinlock_lock( uint32_t * lock )
	{
	uint32_t current = 0;
	uint32_t store = 1;

	for( ; ; )
	{
	if( Atomic_CompareAndSwap_u32( lock, store, current ) == 1 )
	{
	break;
	}

	/* Does context switch with negligible delay. */
	IotClock_SleepMs( 1 );
	}
	}

	static void _atomicSpinlock_unlock( uint32_t * lock )
	{
	uint32_t current = 1;
	uint32_t store = 0;

	for( ; ; )
	{
	if( Atomic_CompareAndSwap_u32( lock, store, current ) == 1 )
	{
	break;
	}

	/* Does context switch with negligible delay. */
	IotClock_SleepMs( 1 );
	}
	}

	static void _generateUniqueIdentifier( const char * pInput,
	size_t length,
	char * pIdentifier,
	size_t identifierLength )
	{
	uint8_t hash[ MD5_HASH_LENGTH_BYTES ] = { 0 };
	int i;
	size_t ret;

	configASSERT( identifierLength >= ( 2 * MD5_HASH_LENGTH_BYTES ) );
	Utils_generateMD5Hash( pInput, length, hash, MD5_HASH_LENGTH_BYTES );

	for( i = 0; i < MD5_HASH_LENGTH_BYTES; i++ )
	{
	ret = snprintf( pIdentifier, ( IDENTIFIER_BYTE_ENCODE_LENGTH + 1 ), "%02X", hash[ i ] );
	configASSERT( ret > 0 );
	pIdentifier += IDENTIFIER_BYTE_ENCODE_LENGTH;
	}
	}

	/*
	* @brief Retrieves the device identifier.
	*/
	const char * getDeviceIdentifier( void )
	{
	const char * pCertificate = IOT_DEVICE_CERTIFICATE;
	static uint32_t lock = 0;

	if( deviceIdentifier[ 0 ] == '\0' )
	{
	_atomicSpinlock_lock( &lock );

	if( deviceIdentifier[ 0 ] == '\0' )
	{
	if( ( pCertificate != NULL ) &&
	( strcmp( pCertificate, "" ) != 0 ) )
	{
	_generateUniqueIdentifier( pCertificate, strlen( pCertificate ), deviceIdentifier, sizeof( deviceIdentifier ) );
	}
	else
	{
	strncpy( deviceIdentifier, "Unknown", sizeof( deviceIdentifier ) );
	}
	}

	_atomicSpinlock_unlock( &lock );
	}

	return deviceIdentifier;
	}

	/*
	* @brief Retrieves the device metrics.
	*/
	const char * getDeviceMetrics( void )
	{
	const char * pDeviceIdentifier = NULL;
	static uint32_t lock = 0;

	if( deviceMetrics[ 0 ] == '\0' )
	{
	_atomicSpinlock_lock( &lock );

	if( deviceMetrics[ 0 ] == '\0' )
	{
	pDeviceIdentifier = getDeviceIdentifier();
	_generateDeviceMetrics( pDeviceIdentifier, strlen( pDeviceIdentifier ), deviceMetrics, sizeof( deviceMetrics ) );
	}

	_atomicSpinlock_unlock( &lock );
	}

	return deviceMetrics;
	}

	/*
	* @brief Retrieves the device metrics length.
	*/
	uint16_t getDeviceMetricsLength( void )
	{
	const char * pDeviceMetrics = getDeviceMetrics();

	return ( uint16_t ) ( strlen( pDeviceMetrics ) );
	}