diff --git a/library/common.h b/library/common.h
index 9d45a0e..fb4194e 100644
--- a/library/common.h
+++ b/library/common.h
@@ -84,12 +84,12 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT32_BE
-#define MBEDTLS_GET_UINT32_BE( data , offset )              \
-    (                                                       \
-          ( (uint32_t) ( data )[( offset )    ] << 24 )     \
-        | ( (uint32_t) ( data )[( offset ) + 1] << 16 )     \
-        | ( (uint32_t) ( data )[( offset ) + 2] <<  8 )     \
-        | ( (uint32_t) ( data )[( offset ) + 3]       )     \
+#define MBEDTLS_GET_UINT32_BE( data , offset )                  \
+    (                                                           \
+          ( (uint32_t) ( data )[( offset )    ] << 24 )         \
+        | ( (uint32_t) ( data )[( offset ) + 1] << 16 )         \
+        | ( (uint32_t) ( data )[( offset ) + 2] <<  8 )         \
+        | ( (uint32_t) ( data )[( offset ) + 3]       )         \
     )
 #endif
 
@@ -103,13 +103,13 @@
  *                  byte of the 32 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT32_BE
-#define MBEDTLS_PUT_UINT32_BE( n, data, offset )                    \
-    do {                                                            \
-        ( data )[( offset )    ] = (unsigned char) ( (n) >> 24 );   \
-        ( data )[( offset ) + 1] = (unsigned char) ( (n) >> 16 );   \
-        ( data )[( offset ) + 2] = (unsigned char) ( (n) >>  8 );   \
-        ( data )[( offset ) + 3] = (unsigned char) ( (n)       );   \
-    } while( 0 )
+#define MBEDTLS_PUT_UINT32_BE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_3( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_2( n );             \
+    ( data )[( offset ) + 2] = MBEDTLS_BYTE_1( n );             \
+    ( data )[( offset ) + 3] = MBEDTLS_BYTE_0( n );             \
+}
 #endif
 
 /**
@@ -122,12 +122,12 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT32_LE
-#define MBEDTLS_GET_UINT32_LE( data, offset )              \
-    (                                                      \
-          ( (uint32_t) ( data )[( offset )    ]       )    \
-        | ( (uint32_t) ( data )[( offset ) + 1] <<  8 )    \
-        | ( (uint32_t) ( data )[( offset ) + 2] << 16 )    \
-        | ( (uint32_t) ( data )[( offset ) + 3] << 24 )    \
+#define MBEDTLS_GET_UINT32_LE( data, offset )                   \
+    (                                                           \
+          ( (uint32_t) ( data )[( offset )    ]       )         \
+        | ( (uint32_t) ( data )[( offset ) + 1] <<  8 )         \
+        | ( (uint32_t) ( data )[( offset ) + 2] << 16 )         \
+        | ( (uint32_t) ( data )[( offset ) + 3] << 24 )         \
     )
 #endif
 
@@ -141,13 +141,13 @@
  *                  byte of the 32 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT32_LE
-#define MBEDTLS_PUT_UINT32_LE( n, data, offset )                                \
-    do {                                                                        \
-        ( data )[( offset )    ] = (unsigned char) ( ( (n)       ) & 0xFF );    \
-        ( data )[( offset ) + 1] = (unsigned char) ( ( (n) >>  8 ) & 0xFF );    \
-        ( data )[( offset ) + 2] = (unsigned char) ( ( (n) >> 16 ) & 0xFF );    \
-        ( data )[( offset ) + 3] = (unsigned char) ( ( (n) >> 24 ) & 0xFF );    \
-    } while( 0 )
+#define MBEDTLS_PUT_UINT32_LE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_0( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n );             \
+    ( data )[( offset ) + 2] = MBEDTLS_BYTE_2( n );             \
+    ( data )[( offset ) + 3] = MBEDTLS_BYTE_3( n );             \
+}
 #endif
 
 /**
@@ -160,10 +160,10 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT16_LE
-#define MBEDTLS_GET_UINT16_LE( data, offset )               \
-    (                                                       \
-          ( (uint16_t) ( data )[( offset )    ]       )     \
-        | ( (uint16_t) ( data )[( offset ) + 1] <<  8 )     \
+#define MBEDTLS_GET_UINT16_LE( data, offset )                   \
+    (                                                           \
+          ( (uint16_t) ( data )[( offset )    ]       )         \
+        | ( (uint16_t) ( data )[( offset ) + 1] <<  8 )         \
     )
 #endif
 
@@ -177,16 +177,16 @@
  *                  byte of the 16 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT16_LE
-#define MBEDTLS_PUT_UINT16_LE( n, data, offset )                            \
-{                                                                           \
-    ( data )[( offset )    ] = (unsigned char) ( ( (n)       ) & 0xFF );    \
-    ( data )[( offset ) + 1] = (unsigned char) ( ( (n) >>  8 ) & 0xFF );    \
+#define MBEDTLS_PUT_UINT16_LE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_0( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n );             \
 }
 #endif
 
 /**
  * Get the unsigned 16 bits integer corresponding to two bytes in
- * big-endian order (LSB first).
+ * big-endian order (MSB first).
  *
  * \param   data    Base address of the memory to get the two bytes from.
  * \param   offset  Offset from \p base of the first and most significant
@@ -194,10 +194,10 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT16_BE
-#define MBEDTLS_GET_UINT16_BE( data, offset )              \
-    (                                                      \
-          ( (uint16_t) ( data )[( offset )    ] << 8 )     \
-        | ( (uint16_t) ( data )[( offset ) + 1]      )     \
+#define MBEDTLS_GET_UINT16_BE( data, offset )                   \
+    (                                                           \
+          ( (uint16_t) ( data )[( offset )    ] << 8 )          \
+        | ( (uint16_t) ( data )[( offset ) + 1]      )          \
     )
 #endif
 
@@ -211,10 +211,10 @@
  *                  byte of the 16 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT16_BE
-#define MBEDTLS_PUT_UINT16_BE( n, data, offset )                           \
-{                                                                          \
-    ( data )[( offset )    ] = (unsigned char) ( ( (n) >> 8 ) & 0xFF );    \
-    ( data )[( offset ) + 1] = (unsigned char) ( ( (n)      ) & 0xFF );    \
+#define MBEDTLS_PUT_UINT16_BE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_1( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_0( n );             \
 }
 #endif
 
@@ -228,16 +228,16 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT64_BE
-#define MBEDTLS_GET_UINT64_BE( data, offset )                 \
-    (                                                         \
-          ( (uint64_t) ( data )[( offset )    ] << 56 )       \
-        | ( (uint64_t) ( data )[( offset ) + 1] << 48 )       \
-        | ( (uint64_t) ( data )[( offset ) + 2] << 40 )       \
-        | ( (uint64_t) ( data )[( offset ) + 3] << 32 )       \
-        | ( (uint64_t) ( data )[( offset ) + 4] << 24 )       \
-        | ( (uint64_t) ( data )[( offset ) + 5] << 16 )       \
-        | ( (uint64_t) ( data )[( offset ) + 6] <<  8 )       \
-        | ( (uint64_t) ( data )[( offset ) + 7]       )       \
+#define MBEDTLS_GET_UINT64_BE( data, offset )                   \
+    (                                                           \
+          ( (uint64_t) ( data )[( offset )    ] << 56 )         \
+        | ( (uint64_t) ( data )[( offset ) + 1] << 48 )         \
+        | ( (uint64_t) ( data )[( offset ) + 2] << 40 )         \
+        | ( (uint64_t) ( data )[( offset ) + 3] << 32 )         \
+        | ( (uint64_t) ( data )[( offset ) + 4] << 24 )         \
+        | ( (uint64_t) ( data )[( offset ) + 5] << 16 )         \
+        | ( (uint64_t) ( data )[( offset ) + 6] <<  8 )         \
+        | ( (uint64_t) ( data )[( offset ) + 7]       )         \
     )
 #endif
 
@@ -251,16 +251,16 @@
  *                  byte of the 64 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT64_BE
-#define MBEDTLS_PUT_UINT64_BE( n, data, offset )                    \
-{                                                                   \
-    ( data )[( offset )    ] = (unsigned char) ( (n) >> 56 );       \
-    ( data )[( offset ) + 1] = (unsigned char) ( (n) >> 48 );       \
-    ( data )[( offset ) + 2] = (unsigned char) ( (n) >> 40 );       \
-    ( data )[( offset ) + 3] = (unsigned char) ( (n) >> 32 );       \
-    ( data )[( offset ) + 4] = (unsigned char) ( (n) >> 24 );       \
-    ( data )[( offset ) + 5] = (unsigned char) ( (n) >> 16 );       \
-    ( data )[( offset ) + 6] = (unsigned char) ( (n) >>  8 );       \
-    ( data )[( offset ) + 7] = (unsigned char) ( (n)       );       \
+#define MBEDTLS_PUT_UINT64_BE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_7( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_6( n );             \
+    ( data )[( offset ) + 2] = MBEDTLS_BYTE_5( n );             \
+    ( data )[( offset ) + 3] = MBEDTLS_BYTE_4( n );             \
+    ( data )[( offset ) + 4] = MBEDTLS_BYTE_3( n );             \
+    ( data )[( offset ) + 5] = MBEDTLS_BYTE_2( n );             \
+    ( data )[( offset ) + 6] = MBEDTLS_BYTE_1( n );             \
+    ( data )[( offset ) + 7] = MBEDTLS_BYTE_0( n );             \
 }
 #endif
 
@@ -274,16 +274,16 @@
  *                  integer from.
  */
 #ifndef MBEDTLS_GET_UINT64_LE
-#define MBEDTLS_GET_UINT64_LE( data, offset )               \
-    (                                                       \
-          ( (uint64_t) ( data )[( offset ) + 7] << 56 )     \
-        | ( (uint64_t) ( data )[( offset ) + 6] << 48 )     \
-        | ( (uint64_t) ( data )[( offset ) + 5] << 40 )     \
-        | ( (uint64_t) ( data )[( offset ) + 4] << 32 )     \
-        | ( (uint64_t) ( data )[( offset ) + 3] << 24 )     \
-        | ( (uint64_t) ( data )[( offset ) + 2] << 16 )     \
-        | ( (uint64_t) ( data )[( offset ) + 1] <<  8 )     \
-        | ( (uint64_t) ( data )[( offset )    ]       )     \
+#define MBEDTLS_GET_UINT64_LE( data, offset )                   \
+    (                                                           \
+          ( (uint64_t) ( data )[( offset ) + 7] << 56 )         \
+        | ( (uint64_t) ( data )[( offset ) + 6] << 48 )         \
+        | ( (uint64_t) ( data )[( offset ) + 5] << 40 )         \
+        | ( (uint64_t) ( data )[( offset ) + 4] << 32 )         \
+        | ( (uint64_t) ( data )[( offset ) + 3] << 24 )         \
+        | ( (uint64_t) ( data )[( offset ) + 2] << 16 )         \
+        | ( (uint64_t) ( data )[( offset ) + 1] <<  8 )         \
+        | ( (uint64_t) ( data )[( offset )    ]       )         \
     )
 #endif
 
@@ -297,16 +297,16 @@
  *                  byte of the 64 bits unsigned integer \p n.
  */
 #ifndef MBEDTLS_PUT_UINT64_LE
-#define MBEDTLS_PUT_UINT64_LE( n, data, offset )                    \
-{                                                                   \
-    ( data )[( offset ) + 7] = (unsigned char) ( (n) >> 56 );       \
-    ( data )[( offset ) + 6] = (unsigned char) ( (n) >> 48 );       \
-    ( data )[( offset ) + 5] = (unsigned char) ( (n) >> 40 );       \
-    ( data )[( offset ) + 4] = (unsigned char) ( (n) >> 32 );       \
-    ( data )[( offset ) + 3] = (unsigned char) ( (n) >> 24 );       \
-    ( data )[( offset ) + 2] = (unsigned char) ( (n) >> 16 );       \
-    ( data )[( offset ) + 1] = (unsigned char) ( (n) >>  8 );       \
-    ( data )[( offset )    ] = (unsigned char) ( (n)       );       \
+#define MBEDTLS_PUT_UINT64_LE( n, data, offset )                \
+{                                                               \
+    ( data )[( offset )    ] = MBEDTLS_BYTE_0( n );             \
+    ( data )[( offset ) + 1] = MBEDTLS_BYTE_1( n );             \
+    ( data )[( offset ) + 2] = MBEDTLS_BYTE_2( n );             \
+    ( data )[( offset ) + 3] = MBEDTLS_BYTE_3( n );             \
+    ( data )[( offset ) + 4] = MBEDTLS_BYTE_4( n );             \
+    ( data )[( offset ) + 5] = MBEDTLS_BYTE_5( n );             \
+    ( data )[( offset ) + 6] = MBEDTLS_BYTE_6( n );             \
+    ( data )[( offset ) + 7] = MBEDTLS_BYTE_7( n );             \
 }
 #endif