SERVER-18579: Clang-Format - reformat code, no comment reflow

15 files changed, 2141 insertions, 1568 deletions

diff --git a/src/mongo/crypto/crypto.h b/src/mongo/crypto/crypto.h
index 2a74b55dc52..7b08e371a84 100644
--- a/src/mongo/crypto/crypto.h
+++ b/src/mongo/crypto/crypto.h
@@ -32,22 +32,20 @@
 
 namespace mongo {
 namespace crypto {
-    /*
-     * Computes a SHA-1 hash of 'input'.
-     */
-    bool sha1(const unsigned char* input,
-              const size_t inputLen,
-              unsigned char* output);
+/*
+ * Computes a SHA-1 hash of 'input'.
+ */
+bool sha1(const unsigned char* input, const size_t inputLen, unsigned char* output);
 
-    /*
-     * Computes a HMAC SHA-1 keyed hash of 'input' using the key 'key'
-     */
-    bool hmacSha1(const unsigned char* key,
-                  const size_t keyLen,
-                  const unsigned char* input,
-                  const size_t inputLen,
-                  unsigned char* output,
-                  unsigned int* outputLen);
+/*
+ * Computes a HMAC SHA-1 keyed hash of 'input' using the key 'key'
+ */
+bool hmacSha1(const unsigned char* key,
+              const size_t keyLen,
+              const unsigned char* input,
+              const size_t inputLen,
+              unsigned char* output,
+              unsigned int* outputLen);
 
-} // namespace crypto
-} // namespace mongo
+}  // namespace crypto
+}  // namespace mongo
diff --git a/src/mongo/crypto/crypto_openssl.cpp b/src/mongo/crypto/crypto_openssl.cpp
index 79e48243475..62b42f4f1ca 100644
--- a/src/mongo/crypto/crypto_openssl.cpp
+++ b/src/mongo/crypto/crypto_openssl.cpp
@@ -42,45 +42,36 @@
 
 namespace mongo {
 namespace crypto {
-    /*
-     * Computes a SHA-1 hash of 'input'.
-     */
-    bool sha1(const unsigned char* input,
-              const size_t inputLen,
-              unsigned char* output) {
-
-        EVP_MD_CTX digestCtx;
-        EVP_MD_CTX_init(&digestCtx);
-        ON_BLOCK_EXIT(EVP_MD_CTX_cleanup, &digestCtx);
-
-        if (1 != EVP_DigestInit_ex(&digestCtx, EVP_sha1(), NULL)) {
-            return false;
-        }
-
-        if (1 != EVP_DigestUpdate(&digestCtx, input, inputLen)) {
-            return false;
-        }
+/*
+ * Computes a SHA-1 hash of 'input'.
+ */
+bool sha1(const unsigned char* input, const size_t inputLen, unsigned char* output) {
+    EVP_MD_CTX digestCtx;
+    EVP_MD_CTX_init(&digestCtx);
+    ON_BLOCK_EXIT(EVP_MD_CTX_cleanup, &digestCtx);
 
-        return (1 == EVP_DigestFinal_ex(&digestCtx, output, NULL));
+    if (1 != EVP_DigestInit_ex(&digestCtx, EVP_sha1(), NULL)) {
+        return false;
     }
 
-    /*
-     * Computes a HMAC SHA-1 keyed hash of 'input' using the key 'key'
-     */
-    bool hmacSha1(const unsigned char* key,
-                  const size_t keyLen,
-                  const unsigned char* input,
-                  const size_t inputLen,
-                  unsigned char* output,
-                  unsigned int* outputLen) {
-        return HMAC(EVP_sha1(),
-                    key,
-                    keyLen,
-                    input,
-                    inputLen,
-                    output,
-                    outputLen);
+    if (1 != EVP_DigestUpdate(&digestCtx, input, inputLen)) {
+        return false;
     }
 
-} // namespace crypto
-} // namespace mongo
+    return (1 == EVP_DigestFinal_ex(&digestCtx, output, NULL));
+}
+
+/*
+ * Computes a HMAC SHA-1 keyed hash of 'input' using the key 'key'
+ */
+bool hmacSha1(const unsigned char* key,
+              const size_t keyLen,
+              const unsigned char* input,
+              const size_t inputLen,
+              unsigned char* output,
+              unsigned int* outputLen) {
+    return HMAC(EVP_sha1(), key, keyLen, input, inputLen, output, outputLen);
+}
+
+}  // namespace crypto
+}  // namespace mongo
diff --git a/src/mongo/crypto/crypto_test.cpp b/src/mongo/crypto/crypto_test.cpp
index d15e8081a0b..52d488b92cf 100644
--- a/src/mongo/crypto/crypto_test.cpp
+++ b/src/mongo/crypto/crypto_test.cpp
@@ -31,118 +31,491 @@
 
 namespace mongo {
 namespace {
-    const int digestLen = 20;
+const int digestLen = 20;
 
-    // SHA-1 test vectors from http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/SHA_All.pdf
-    const struct {
-        const char *msg;
-        unsigned char hash[digestLen];
-    } sha1Tests[] = {
-        { "abc",
-        { 0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a,
-          0xba, 0x3e, 0x25, 0x71, 0x78, 0x50, 0xc2, 0x6c,
-          0x9c, 0xd0, 0xd8, 0x9d }},
+// SHA-1 test vectors from http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/SHA_All.pdf
+const struct {
+    const char* msg;
+    unsigned char hash[digestLen];
+} sha1Tests[] = {{"abc",
+                  {0xa9,
+                   0x99,
+                   0x3e,
+                   0x36,
+                   0x47,
+                   0x06,
+                   0x81,
+                   0x6a,
+                   0xba,
+                   0x3e,
+                   0x25,
+                   0x71,
+                   0x78,
+                   0x50,
+                   0xc2,
+                   0x6c,
+                   0x9c,
+                   0xd0,
+                   0xd8,
+                   0x9d}},
 
-        { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
-        { 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E,
-          0xBA, 0xAE, 0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5,
-          0xE5, 0x46, 0x70, 0xF1 }}
-    };
+                 {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+                  {0x84,
+                   0x98,
+                   0x3E,
+                   0x44,
+                   0x1C,
+                   0x3B,
+                   0xD2,
+                   0x6E,
+                   0xBA,
+                   0xAE,
+                   0x4A,
+                   0xA1,
+                   0xF9,
+                   0x51,
+                   0x29,
+                   0xE5,
+                   0xE5,
+                   0x46,
+                   0x70,
+                   0xF1}}};
 
-    TEST(CryptoVectors, SHA1) {
-        unsigned char sha1Result[digestLen];
-        size_t numTests = sizeof(sha1Tests) / sizeof(sha1Tests[0]);
-        for (size_t i=0; i<numTests; i++) {
-            ASSERT(crypto::sha1(reinterpret_cast<const unsigned char*>(sha1Tests[i].msg),
-                                     strlen(sha1Tests[i].msg),
-                                     sha1Result)) << "Failed SHA1 iteration " << i;
-            ASSERT(0 == memcmp(sha1Tests[i].hash, sha1Result, digestLen)) <<
-                "Failed SHA1 iteration " << i;
-        }
+TEST(CryptoVectors, SHA1) {
+    unsigned char sha1Result[digestLen];
+    size_t numTests = sizeof(sha1Tests) / sizeof(sha1Tests[0]);
+    for (size_t i = 0; i < numTests; i++) {
+        ASSERT(crypto::sha1(reinterpret_cast<const unsigned char*>(sha1Tests[i].msg),
+                            strlen(sha1Tests[i].msg),
+                            sha1Result))
+            << "Failed SHA1 iteration " << i;
+        ASSERT(0 == memcmp(sha1Tests[i].hash, sha1Result, digestLen)) << "Failed SHA1 iteration "
+                                                                      << i;
     }
+}
 
-    const int maxKeySize = 80;
-    const int maxDataSize = 54;
-    // HMAC-SHA-1 test vectors from http://tools.ietf.org/html/rfc2202.html
-    const struct {
-        unsigned char key[maxKeySize];
-        int keyLen;
-        unsigned char data[maxDataSize];
-        int dataLen;
-        unsigned char hash[digestLen];
-    } hmacSha1Tests[] = {
-        // RFC test case 1
-        {{0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
-          0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b},
-          20,
-          {0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
-          8,
-         {0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64, 0xe2, 0x8b,
-          0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e, 0xf1, 0x46, 0xbe, 0x00}},
+const int maxKeySize = 80;
+const int maxDataSize = 54;
+// HMAC-SHA-1 test vectors from http://tools.ietf.org/html/rfc2202.html
+const struct {
+    unsigned char key[maxKeySize];
+    int keyLen;
+    unsigned char data[maxDataSize];
+    int dataLen;
+    unsigned char hash[digestLen];
+} hmacSha1Tests[] = {
+    // RFC test case 1
+    {{0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b,
+      0x0b},
+     20,
+     {0x48, 0x69, 0x20, 0x54, 0x68, 0x65, 0x72, 0x65},
+     8,
+     {0xb6,
+      0x17,
+      0x31,
+      0x86,
+      0x55,
+      0x05,
+      0x72,
+      0x64,
+      0xe2,
+      0x8b,
+      0xc0,
+      0xb6,
+      0xfb,
+      0x37,
+      0x8c,
+      0x8e,
+      0xf1,
+      0x46,
+      0xbe,
+      0x00}},
 
-        // RFC test case 3
-        {{0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-          0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa},
-          20,
-         {0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-          0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-          0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-          0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
-          0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd},
-          50,
-         {0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, 0x11, 0xcd, 0x91, 0xa3,
-          0x9a, 0xf4, 0x8a, 0xa1, 0x7b, 0x4f, 0x63, 0xf1, 0x75, 0xd3}},
+    // RFC test case 3
+    {{0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa},
+     20,
+     {0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd,
+      0xdd},
+     50,
+     {0x12,
+      0x5d,
+      0x73,
+      0x42,
+      0xb9,
+      0xac,
+      0x11,
+      0xcd,
+      0x91,
+      0xa3,
+      0x9a,
+      0xf4,
+      0x8a,
+      0xa1,
+      0x7b,
+      0x4f,
+      0x63,
+      0xf1,
+      0x75,
+      0xd3}},
 
-        // RFC test case 4
-        {{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-          0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-          0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19},
-          25,
-         {0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
-          0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
-          0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
-          0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
-          0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd},
-          50,
-         {0x4c, 0x90, 0x07, 0xf4, 0x02, 0x62, 0x50, 0xc6, 0xbc, 0x84,
-          0x14, 0xf9, 0xbf, 0x50, 0xc8, 0x6c, 0x2d, 0x72, 0x35, 0xda}},
+    // RFC test case 4
+    {{0x01,
+      0x02,
+      0x03,
+      0x04,
+      0x05,
+      0x06,
+      0x07,
+      0x08,
+      0x09,
+      0x0a,
+      0x0b,
+      0x0c,
+      0x0d,
+      0x0e,
+      0x0f,
+      0x10,
+      0x11,
+      0x12,
+      0x13,
+      0x14,
+      0x15,
+      0x16,
+      0x17,
+      0x18,
+      0x19},
+     25,
+     {0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd,
+      0xcd},
+     50,
+     {0x4c,
+      0x90,
+      0x07,
+      0xf4,
+      0x02,
+      0x62,
+      0x50,
+      0xc6,
+      0xbc,
+      0x84,
+      0x14,
+      0xf9,
+      0xbf,
+      0x50,
+      0xc8,
+      0x6c,
+      0x2d,
+      0x72,
+      0x35,
+      0xda}},
 
-        // RFC test case 6
-        {{0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-          0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-          0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-          0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-          0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-          0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-          0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
-          0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa},
-          80,
-         {0x54, 0x65, 0x73, 0x74, 0x20, 0x55, 0x73, 0x69, 0x6e, 0x67,
-          0x20, 0x4c, 0x61, 0x72, 0x67, 0x65, 0x72, 0x20, 0x54, 0x68,
-          0x61, 0x6e, 0x20, 0x42, 0x6c, 0x6f, 0x63, 0x6b, 0x2d, 0x53,
-          0x69, 0x7a, 0x65, 0x20, 0x4b, 0x65, 0x79, 0x20, 0x2d, 0x20,
-          0x48, 0x61, 0x73, 0x68, 0x20, 0x4b, 0x65, 0x79, 0x20, 0x46,
-          0x69, 0x72, 0x73, 0x74},
-          54,
-         {0xaa, 0x4a, 0xe5, 0xe1, 0x52, 0x72, 0xd0, 0x0e, 0x95, 0x70,
-          0x56, 0x37, 0xce, 0x8a, 0x3b, 0x55, 0xed, 0x40, 0x21, 0x12}}
-        };
+    // RFC test case 6
+    {{0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa,
+      0xaa},
+     80,
+     {0x54,
+      0x65,
+      0x73,
+      0x74,
+      0x20,
+      0x55,
+      0x73,
+      0x69,
+      0x6e,
+      0x67,
+      0x20,
+      0x4c,
+      0x61,
+      0x72,
+      0x67,
+      0x65,
+      0x72,
+      0x20,
+      0x54,
+      0x68,
+      0x61,
+      0x6e,
+      0x20,
+      0x42,
+      0x6c,
+      0x6f,
+      0x63,
+      0x6b,
+      0x2d,
+      0x53,
+      0x69,
+      0x7a,
+      0x65,
+      0x20,
+      0x4b,
+      0x65,
+      0x79,
+      0x20,
+      0x2d,
+      0x20,
+      0x48,
+      0x61,
+      0x73,
+      0x68,
+      0x20,
+      0x4b,
+      0x65,
+      0x79,
+      0x20,
+      0x46,
+      0x69,
+      0x72,
+      0x73,
+      0x74},
+     54,
+     {0xaa,
+      0x4a,
+      0xe5,
+      0xe1,
+      0x52,
+      0x72,
+      0xd0,
+      0x0e,
+      0x95,
+      0x70,
+      0x56,
+      0x37,
+      0xce,
+      0x8a,
+      0x3b,
+      0x55,
+      0xed,
+      0x40,
+      0x21,
+      0x12}}};
 
-    TEST(CryptoVectors, HMACSHA1) {
-        unsigned char hmacSha1Result[digestLen];
-        unsigned int hashLen = digestLen;
+TEST(CryptoVectors, HMACSHA1) {
+    unsigned char hmacSha1Result[digestLen];
+    unsigned int hashLen = digestLen;
 
-        size_t numTests = sizeof(hmacSha1Tests) / sizeof(hmacSha1Tests[0]);
-        for (size_t i=0; i<numTests; i++) {
-            ASSERT(crypto::hmacSha1(hmacSha1Tests[i].key,
-                                    hmacSha1Tests[i].keyLen,
-                                    hmacSha1Tests[i].data,
-                                    hmacSha1Tests[i].dataLen,
-                                    hmacSha1Result,
-                                    &hashLen)) << "Failed HMAC-SHA1 iteration " << i;
-            ASSERT(0 == memcmp(hmacSha1Tests[i].hash, hmacSha1Result, digestLen)) <<
-                "Failed HMAC-SHA1 iteration " << i;
-        }
+    size_t numTests = sizeof(hmacSha1Tests) / sizeof(hmacSha1Tests[0]);
+    for (size_t i = 0; i < numTests; i++) {
+        ASSERT(crypto::hmacSha1(hmacSha1Tests[i].key,
+                                hmacSha1Tests[i].keyLen,
+                                hmacSha1Tests[i].data,
+                                hmacSha1Tests[i].dataLen,
+                                hmacSha1Result,
+                                &hashLen))
+            << "Failed HMAC-SHA1 iteration " << i;
+        ASSERT(0 == memcmp(hmacSha1Tests[i].hash, hmacSha1Result, digestLen))
+            << "Failed HMAC-SHA1 iteration " << i;
     }
+}
 }  // namespace
 }  // namespace mongo
diff --git a/src/mongo/crypto/crypto_tom.cpp b/src/mongo/crypto/crypto_tom.cpp
index f3ed3fe5d14..de4ae4ae5ae 100644
--- a/src/mongo/crypto/crypto_tom.cpp
+++ b/src/mongo/crypto/crypto_tom.cpp
@@ -36,59 +36,51 @@
 
 namespace mongo {
 namespace crypto {
-    /*
-     * Computes a SHA-1 hash of 'input'.
-     */
-    bool sha1(const unsigned char* input,
-              const size_t inputLen,
-              unsigned char* output) {
-        hash_state hashState;
-        if (sha1_init(&hashState) != CRYPT_OK) {
-            return false;
-        }
-        if (sha1_process(&hashState, input, inputLen) != CRYPT_OK) {
-            return false;
-        }
-        if (sha1_done(&hashState, output) != CRYPT_OK) {
-            return false;
-        }
-
-        return true;
+/*
+ * Computes a SHA-1 hash of 'input'.
+ */
+bool sha1(const unsigned char* input, const size_t inputLen, unsigned char* output) {
+    hash_state hashState;
+    if (sha1_init(&hashState) != CRYPT_OK) {
+        return false;
+    }
+    if (sha1_process(&hashState, input, inputLen) != CRYPT_OK) {
+        return false;
+    }
+    if (sha1_done(&hashState, output) != CRYPT_OK) {
+        return false;
     }
 
-    /*
-     * Computes a HMAC SHA-1 keyed hash of 'input' using the key 'key'
-     */
-    bool hmacSha1(const unsigned char* key,
-                  const size_t keyLen,
-                  const unsigned char* input,
-                  const size_t inputLen,
-                  unsigned char* output,
-                  unsigned int* outputLen) {
-        if (!key || !input || !output) {
-            return false;
-        }
+    return true;
+}
 
-        static int hashId = -1;
-        if (hashId == -1) {
-            register_hash (&sha1_desc);
-            hashId = find_hash("sha1");
-        }
+/*
+ * Computes a HMAC SHA-1 keyed hash of 'input' using the key 'key'
+ */
+bool hmacSha1(const unsigned char* key,
+              const size_t keyLen,
+              const unsigned char* input,
+              const size_t inputLen,
+              unsigned char* output,
+              unsigned int* outputLen) {
+    if (!key || !input || !output) {
+        return false;
+    }
 
-        unsigned long sha1HashLen = 20;
-        if (hmac_memory(hashId,
-                        key,
-                        keyLen,
-                        input,
-                        inputLen,
-                        output,
-                        &sha1HashLen) != CRYPT_OK) {
-            return false;
-        }
+    static int hashId = -1;
+    if (hashId == -1) {
+        register_hash(&sha1_desc);
+        hashId = find_hash("sha1");
+    }
 
-        *outputLen = sha1HashLen;
-        return true;
+    unsigned long sha1HashLen = 20;
+    if (hmac_memory(hashId, key, keyLen, input, inputLen, output, &sha1HashLen) != CRYPT_OK) {
+        return false;
     }
 
-} // namespace crypto
-} // namespace mongo
+    *outputLen = sha1HashLen;
+    return true;
+}
+
+}  // namespace crypto
+}  // namespace mongo
diff --git a/src/mongo/crypto/mechanism_scram.cpp b/src/mongo/crypto/mechanism_scram.cpp
index 34f7c870a93..13e8fb193a2 100644
--- a/src/mongo/crypto/mechanism_scram.cpp
+++ b/src/mongo/crypto/mechanism_scram.cpp
@@ -40,211 +40,191 @@
 namespace mongo {
 namespace scram {
 
-    using boost::scoped_ptr;
-
-    // Compute the SCRAM step Hi() as defined in RFC5802
-    static void HMACIteration(const unsigned char input[],
-                              size_t inputLen,
-                              const unsigned char salt[],
-                              size_t saltLen,
-                              unsigned int iterationCount,
-                              unsigned char output[]){
-        unsigned char intermediateDigest[hashSize];
-        unsigned char startKey[hashSize];
-        // Placeholder for HMAC return size, will always be scram::hashSize for HMAC SHA-1
-        unsigned int hashLen = 0;
-
-        uassert(17450, "invalid salt length provided", saltLen + 4 == hashSize);
-        memcpy (startKey, salt, saltLen);
-
-        startKey[saltLen] = 0;
-        startKey[saltLen+1] = 0;
-        startKey[saltLen+2] = 0;
-        startKey[saltLen+3] = 1;
-
-        // U1 = HMAC(input, salt + 0001)
-        fassert(17494, crypto::hmacSha1(input,
-                                        inputLen,
-                                        startKey,
-                                        saltLen + 4,
-                                        output,
-                                        &hashLen));
-
-        memcpy(intermediateDigest, output, hashSize);
-
-        // intermediateDigest contains Ui and output contains the accumulated XOR:ed result
-        for (size_t i = 2; i <= iterationCount; i++) {
-            unsigned char intermediateOutput[hashSize];
-            fassert(17495, crypto::hmacSha1(input,
-                                            inputLen,
-                                            intermediateDigest,
-                                            hashSize,
-                                            intermediateOutput,
-                                            &hashLen));
-            memcpy(intermediateDigest, intermediateOutput, hashSize);
-            for (size_t k = 0; k < hashSize; k++) {
-                output[k] ^= intermediateDigest[k];
-            }
+using boost::scoped_ptr;
+
+// Compute the SCRAM step Hi() as defined in RFC5802
+static void HMACIteration(const unsigned char input[],
+                          size_t inputLen,
+                          const unsigned char salt[],
+                          size_t saltLen,
+                          unsigned int iterationCount,
+                          unsigned char output[]) {
+    unsigned char intermediateDigest[hashSize];
+    unsigned char startKey[hashSize];
+    // Placeholder for HMAC return size, will always be scram::hashSize for HMAC SHA-1
+    unsigned int hashLen = 0;
+
+    uassert(17450, "invalid salt length provided", saltLen + 4 == hashSize);
+    memcpy(startKey, salt, saltLen);
+
+    startKey[saltLen] = 0;
+    startKey[saltLen + 1] = 0;
+    startKey[saltLen + 2] = 0;
+    startKey[saltLen + 3] = 1;
+
+    // U1 = HMAC(input, salt + 0001)
+    fassert(17494, crypto::hmacSha1(input, inputLen, startKey, saltLen + 4, output, &hashLen));
+
+    memcpy(intermediateDigest, output, hashSize);
+
+    // intermediateDigest contains Ui and output contains the accumulated XOR:ed result
+    for (size_t i = 2; i <= iterationCount; i++) {
+        unsigned char intermediateOutput[hashSize];
+        fassert(17495,
+                crypto::hmacSha1(
+                    input, inputLen, intermediateDigest, hashSize, intermediateOutput, &hashLen));
+        memcpy(intermediateDigest, intermediateOutput, hashSize);
+        for (size_t k = 0; k < hashSize; k++) {
+            output[k] ^= intermediateDigest[k];
         }
     }
-
-    // Iterate the hash function to generate SaltedPassword
-    void generateSaltedPassword(const StringData& hashedPassword,
-                                const unsigned char* salt,
-                                const int saltLen,
-                                const int iterationCount,
-                                unsigned char saltedPassword[hashSize]) {
-        // saltedPassword = Hi(hashedPassword, salt)
-        HMACIteration(reinterpret_cast<const unsigned char*>(hashedPassword.rawData()),
-                      hashedPassword.size(),
-                      salt,
-                      saltLen,
-                      iterationCount,
-                      saltedPassword);
-    }
-
-    void generateSecrets(const std::string& hashedPassword,
-                         const unsigned char salt[],
-                         size_t saltLen,
-                         size_t iterationCount,
-                         unsigned char storedKey[hashSize],
-                         unsigned char serverKey[hashSize]) {
-
-        unsigned char saltedPassword[hashSize];
-        unsigned char clientKey[hashSize];
-        unsigned int hashLen = 0;
-
-        generateSaltedPassword(hashedPassword,
-                               salt,
-                               saltLen,
-                               iterationCount,
-                               saltedPassword);
-
-        // clientKey = HMAC(saltedPassword, "Client Key")
-        fassert(17498, 
-                crypto::hmacSha1(saltedPassword,
-                                 hashSize,
-                                 reinterpret_cast<const unsigned char*>(clientKeyConst.data()),
-                                 clientKeyConst.size(),
-                                 clientKey,
-                                 &hashLen));
-
-        // storedKey = H(clientKey)
-        fassert(17499, crypto::sha1(clientKey, hashSize, storedKey));
-
-        // serverKey = HMAC(saltedPassword, "Server Key")
-        fassert(17500, 
-                crypto::hmacSha1(saltedPassword,
-                                 hashSize,
-                                 reinterpret_cast<const unsigned char*>(serverKeyConst.data()),
-                                 serverKeyConst.size(),
-                                 serverKey,
-                                 &hashLen));
-    }
-
-    BSONObj generateCredentials(const std::string& hashedPassword, int iterationCount) {
-
-        const int saltLenQWords = 2;
-
-        // Generate salt
-        uint64_t userSalt[saltLenQWords];
-
-        scoped_ptr<SecureRandom> sr(SecureRandom::create());
-
-        userSalt[0] = sr->nextInt64();
-        userSalt[1] = sr->nextInt64();
-        std::string encodedUserSalt =
-            base64::encode(reinterpret_cast<char*>(userSalt), sizeof(userSalt));
-
-        // Compute SCRAM secrets serverKey and storedKey
-        unsigned char storedKey[hashSize];
-        unsigned char serverKey[hashSize];
-
-        generateSecrets(hashedPassword,
-                        reinterpret_cast<unsigned char*>(userSalt),
-                        saltLenQWords*sizeof(uint64_t),
-                        iterationCount,
-                        storedKey,
-                        serverKey);
-
-        std::string encodedStoredKey =
-            base64::encode(reinterpret_cast<char*>(storedKey), hashSize);
-        std::string encodedServerKey =
-            base64::encode(reinterpret_cast<char*>(serverKey), hashSize);
-
-        return BSON(iterationCountFieldName << iterationCount <<
-                    saltFieldName << encodedUserSalt <<
-                    storedKeyFieldName << encodedStoredKey <<
-                    serverKeyFieldName << encodedServerKey);
-    }
-
-    std::string generateClientProof(const unsigned char saltedPassword[hashSize],
-                                    const std::string& authMessage) {
-
-        // ClientKey := HMAC(saltedPassword, "Client Key")
-        unsigned char clientKey[hashSize];
-        unsigned int hashLen = 0;
-        fassert(18689,
-                crypto::hmacSha1(saltedPassword,
-                                 hashSize,
-                                 reinterpret_cast<const unsigned char*>(clientKeyConst.data()),
-                                 clientKeyConst.size(),
-                                 clientKey,
-                                 &hashLen));
-
-        // StoredKey := H(clientKey)
-        unsigned char storedKey[hashSize];
-        fassert(18701, crypto::sha1(clientKey, hashSize, storedKey));
-
-        // ClientSignature := HMAC(StoredKey, AuthMessage)
-        unsigned char clientSignature[hashSize];
-        fassert(18702,
-                crypto::hmacSha1(storedKey,
-                                 hashSize,
-                                 reinterpret_cast<const unsigned char*>(authMessage.c_str()),
-                                 authMessage.size(),
-                                 clientSignature,
-                                 &hashLen));
-
-        // ClientProof   := ClientKey XOR ClientSignature
-        unsigned char clientProof[hashSize];
-        for (size_t i = 0; i<hashSize; i++) {
-            clientProof[i] = clientKey[i] ^ clientSignature[i];
-        }
-
-        return base64::encode(reinterpret_cast<char*>(clientProof), hashSize);
-
-    }
-
-    bool verifyServerSignature(const unsigned char saltedPassword[hashSize],
-                               const std::string& authMessage,
-                               const std::string& receivedServerSignature) {
-
-        // ServerKey       := HMAC(SaltedPassword, "Server Key")
-        unsigned int hashLen;
-        unsigned char serverKey[hashSize];
-        fassert(18703,
-                crypto::hmacSha1(saltedPassword,
-                                 hashSize,
-                                 reinterpret_cast<const unsigned char*>(serverKeyConst.data()),
-                                 serverKeyConst.size(),
-                                 serverKey,
-                                 &hashLen));
-
-        // ServerSignature := HMAC(ServerKey, AuthMessage)
-        unsigned char serverSignature[hashSize];
-        fassert(18704,
-                crypto::hmacSha1(serverKey,
-                                 hashSize,
-                                 reinterpret_cast<const unsigned char*>(authMessage.c_str()),
-                                 authMessage.size(),
-                                 serverSignature,
-                                 &hashLen));
-
-        std::string encodedServerSignature =
-            base64::encode(reinterpret_cast<char*>(serverSignature), sizeof(serverSignature));
-        return (receivedServerSignature == encodedServerSignature);
+}
+
+// Iterate the hash function to generate SaltedPassword
+void generateSaltedPassword(const StringData& hashedPassword,
+                            const unsigned char* salt,
+                            const int saltLen,
+                            const int iterationCount,
+                            unsigned char saltedPassword[hashSize]) {
+    // saltedPassword = Hi(hashedPassword, salt)
+    HMACIteration(reinterpret_cast<const unsigned char*>(hashedPassword.rawData()),
+                  hashedPassword.size(),
+                  salt,
+                  saltLen,
+                  iterationCount,
+                  saltedPassword);
+}
+
+void generateSecrets(const std::string& hashedPassword,
+                     const unsigned char salt[],
+                     size_t saltLen,
+                     size_t iterationCount,
+                     unsigned char storedKey[hashSize],
+                     unsigned char serverKey[hashSize]) {
+    unsigned char saltedPassword[hashSize];
+    unsigned char clientKey[hashSize];
+    unsigned int hashLen = 0;
+
+    generateSaltedPassword(hashedPassword, salt, saltLen, iterationCount, saltedPassword);
+
+    // clientKey = HMAC(saltedPassword, "Client Key")
+    fassert(17498,
+            crypto::hmacSha1(saltedPassword,
+                             hashSize,
+                             reinterpret_cast<const unsigned char*>(clientKeyConst.data()),
+                             clientKeyConst.size(),
+                             clientKey,
+                             &hashLen));
+
+    // storedKey = H(clientKey)
+    fassert(17499, crypto::sha1(clientKey, hashSize, storedKey));
+
+    // serverKey = HMAC(saltedPassword, "Server Key")
+    fassert(17500,
+            crypto::hmacSha1(saltedPassword,
+                             hashSize,
+                             reinterpret_cast<const unsigned char*>(serverKeyConst.data()),
+                             serverKeyConst.size(),
+                             serverKey,
+                             &hashLen));
+}
+
+BSONObj generateCredentials(const std::string& hashedPassword, int iterationCount) {
+    const int saltLenQWords = 2;
+
+    // Generate salt
+    uint64_t userSalt[saltLenQWords];
+
+    scoped_ptr<SecureRandom> sr(SecureRandom::create());
+
+    userSalt[0] = sr->nextInt64();
+    userSalt[1] = sr->nextInt64();
+    std::string encodedUserSalt =
+        base64::encode(reinterpret_cast<char*>(userSalt), sizeof(userSalt));
+
+    // Compute SCRAM secrets serverKey and storedKey
+    unsigned char storedKey[hashSize];
+    unsigned char serverKey[hashSize];
+
+    generateSecrets(hashedPassword,
+                    reinterpret_cast<unsigned char*>(userSalt),
+                    saltLenQWords * sizeof(uint64_t),
+                    iterationCount,
+                    storedKey,
+                    serverKey);
+
+    std::string encodedStoredKey = base64::encode(reinterpret_cast<char*>(storedKey), hashSize);
+    std::string encodedServerKey = base64::encode(reinterpret_cast<char*>(serverKey), hashSize);
+
+    return BSON(iterationCountFieldName << iterationCount << saltFieldName << encodedUserSalt
+                                        << storedKeyFieldName << encodedStoredKey
+                                        << serverKeyFieldName << encodedServerKey);
+}
+
+std::string generateClientProof(const unsigned char saltedPassword[hashSize],
+                                const std::string& authMessage) {
+    // ClientKey := HMAC(saltedPassword, "Client Key")
+    unsigned char clientKey[hashSize];
+    unsigned int hashLen = 0;
+    fassert(18689,
+            crypto::hmacSha1(saltedPassword,
+                             hashSize,
+                             reinterpret_cast<const unsigned char*>(clientKeyConst.data()),
+                             clientKeyConst.size(),
+                             clientKey,
+                             &hashLen));
+
+    // StoredKey := H(clientKey)
+    unsigned char storedKey[hashSize];
+    fassert(18701, crypto::sha1(clientKey, hashSize, storedKey));
+
+    // ClientSignature := HMAC(StoredKey, AuthMessage)
+    unsigned char clientSignature[hashSize];
+    fassert(18702,
+            crypto::hmacSha1(storedKey,
+                             hashSize,
+                             reinterpret_cast<const unsigned char*>(authMessage.c_str()),
+                             authMessage.size(),
+                             clientSignature,
+                             &hashLen));
+
+    // ClientProof   := ClientKey XOR ClientSignature
+    unsigned char clientProof[hashSize];
+    for (size_t i = 0; i < hashSize; i++) {
+        clientProof[i] = clientKey[i] ^ clientSignature[i];
     }
 
-} // namespace scram
-} // namespace mongo
+    return base64::encode(reinterpret_cast<char*>(clientProof), hashSize);
+}
+
+bool verifyServerSignature(const unsigned char saltedPassword[hashSize],
+                           const std::string& authMessage,
+                           const std::string& receivedServerSignature) {
+    // ServerKey       := HMAC(SaltedPassword, "Server Key")
+    unsigned int hashLen;
+    unsigned char serverKey[hashSize];
+    fassert(18703,
+            crypto::hmacSha1(saltedPassword,
+                             hashSize,
+                             reinterpret_cast<const unsigned char*>(serverKeyConst.data()),
+                             serverKeyConst.size(),
+                             serverKey,
+                             &hashLen));
+
+    // ServerSignature := HMAC(ServerKey, AuthMessage)
+    unsigned char serverSignature[hashSize];
+    fassert(18704,
+            crypto::hmacSha1(serverKey,
+                             hashSize,
+                             reinterpret_cast<const unsigned char*>(authMessage.c_str()),
+                             authMessage.size(),
+                             serverSignature,
+                             &hashLen));
+
+    std::string encodedServerSignature =
+        base64::encode(reinterpret_cast<char*>(serverSignature), sizeof(serverSignature));
+    return (receivedServerSignature == encodedServerSignature);
+}
+
+}  // namespace scram
+}  // namespace mongo
diff --git a/src/mongo/crypto/mechanism_scram.h b/src/mongo/crypto/mechanism_scram.h
index 19d7e2b1c8b..87655887c60 100644
--- a/src/mongo/crypto/mechanism_scram.h
+++ b/src/mongo/crypto/mechanism_scram.h
@@ -35,62 +35,62 @@
 
 namespace mongo {
 namespace scram {
-    const unsigned int hashSize = 20;
+const unsigned int hashSize = 20;
 
-    const std::string serverKeyConst = "Server Key";
-    const std::string clientKeyConst = "Client Key";
+const std::string serverKeyConst = "Server Key";
+const std::string clientKeyConst = "Client Key";
 
-    const std::string iterationCountFieldName = "iterationCount";
-    const std::string saltFieldName = "salt";
-    const std::string storedKeyFieldName = "storedKey";
-    const std::string serverKeyFieldName = "serverKey";
+const std::string iterationCountFieldName = "iterationCount";
+const std::string saltFieldName = "salt";
+const std::string storedKeyFieldName = "storedKey";
+const std::string serverKeyFieldName = "serverKey";
 
-    /*
-     * Computes the SaltedPassword from password, salt and iterationCount.
-     */
-    void generateSaltedPassword(const StringData& hashedPassword,
-                                const unsigned char* salt,
-                                const int saltLen,
-                                const int iterationCount,
-                                unsigned char saltedPassword[hashSize]);
+/*
+ * Computes the SaltedPassword from password, salt and iterationCount.
+ */
+void generateSaltedPassword(const StringData& hashedPassword,
+                            const unsigned char* salt,
+                            const int saltLen,
+                            const int iterationCount,
+                            unsigned char saltedPassword[hashSize]);
 
-    /*
-     * Computes the SCRAM secrets storedKey and serverKey using the salt 'salt'
-     * and iteration count 'iterationCount' as defined in RFC5802 (server side). 
-     */
-    void generateSecrets(const std::string& hashedPassword,
-                         const unsigned char salt[],
-                         size_t saltLen,
-                         size_t iterationCount,
-                         unsigned char storedKey[hashSize],
-                         unsigned char serverKey[hashSize]); 
+/*
+ * Computes the SCRAM secrets storedKey and serverKey using the salt 'salt'
+ * and iteration count 'iterationCount' as defined in RFC5802 (server side).
+ */
+void generateSecrets(const std::string& hashedPassword,
+                     const unsigned char salt[],
+                     size_t saltLen,
+                     size_t iterationCount,
+                     unsigned char storedKey[hashSize],
+                     unsigned char serverKey[hashSize]);
 
-    /*
-     * Generates the user salt and the SCRAM secrets storedKey and serverKey as
-     * defined in RFC5802 (server side).
-     */
-    BSONObj generateCredentials(const std::string& hashedPassword, int iterationCount);
+/*
+ * Generates the user salt and the SCRAM secrets storedKey and serverKey as
+ * defined in RFC5802 (server side).
+ */
+BSONObj generateCredentials(const std::string& hashedPassword, int iterationCount);
 
-    /*
-     * Computes the ClientProof from SaltedPassword and authMessage (client side).
-     */
-    std::string generateClientProof(const unsigned char saltedPassword[hashSize],
-                                    const std::string& authMessage);
+/*
+ * Computes the ClientProof from SaltedPassword and authMessage (client side).
+ */
+std::string generateClientProof(const unsigned char saltedPassword[hashSize],
+                                const std::string& authMessage);
 
-    /*
-     * Validates that the provided password 'hashedPassword' generates the serverKey
-     * 'serverKey' given iteration count 'iterationCount' and salt 'salt'.
-     */
-    bool validatePassword(const std::string& hashedPassword,
-                          int iterationCount,
-                          const std::string& salt,
-                          const std::string& storedKey);
+/*
+ * Validates that the provided password 'hashedPassword' generates the serverKey
+ * 'serverKey' given iteration count 'iterationCount' and salt 'salt'.
+ */
+bool validatePassword(const std::string& hashedPassword,
+                      int iterationCount,
+                      const std::string& salt,
+                      const std::string& storedKey);
 
-    /*
-     * Verifies ServerSignature (client side).
-     */
-    bool verifyServerSignature(const unsigned char saltedPassword[hashSize],
-                               const std::string& authMessage,
-                               const std::string& serverSignature);
-} // namespace scram
-} // namespace mongo
+/*
+ * Verifies ServerSignature (client side).
+ */
+bool verifyServerSignature(const unsigned char saltedPassword[hashSize],
+                           const std::string& authMessage,
+                           const std::string& serverSignature);
+}  // namespace scram
+}  // namespace mongo
diff --git a/src/mongo/crypto/tom/tomcrypt.h b/src/mongo/crypto/tom/tomcrypt.h
index 3f0392dd916..b1a887f0f95 100644
--- a/src/mongo/crypto/tom/tomcrypt.h
+++ b/src/mongo/crypto/tom/tomcrypt.h
@@ -31,51 +31,51 @@ extern "C" {
 #endif
 
 /* version */
-#define CRYPT   0x0117
-#define SCRYPT  "1.17"
+#define CRYPT 0x0117
+#define SCRYPT "1.17"
 
 /* max size of either a cipher/hash block or symmetric key [largest of the two] */
-#define MAXBLOCKSIZE  128
+#define MAXBLOCKSIZE 128
 
 /* descriptor table size */
-#define TAB_SIZE      32
+#define TAB_SIZE 32
 
 /* error codes [will be expanded in future releases] */
 enum {
-    CRYPT_OK=0,             /* Result OK */
-    CRYPT_ERROR,            /* Generic Error */
-    CRYPT_NOP,              /* Not a failure but no operation was performed */
+    CRYPT_OK = 0, /* Result OK */
+    CRYPT_ERROR,  /* Generic Error */
+    CRYPT_NOP,    /* Not a failure but no operation was performed */
 
-    CRYPT_INVALID_KEYSIZE,  /* Invalid key size given */
-    CRYPT_INVALID_ROUNDS,   /* Invalid number of rounds */
-    CRYPT_FAIL_TESTVECTOR,  /* Algorithm failed test vectors */
+    CRYPT_INVALID_KEYSIZE, /* Invalid key size given */
+    CRYPT_INVALID_ROUNDS,  /* Invalid number of rounds */
+    CRYPT_FAIL_TESTVECTOR, /* Algorithm failed test vectors */
 
-    CRYPT_BUFFER_OVERFLOW,  /* Not enough space for output */
-    CRYPT_INVALID_PACKET,   /* Invalid input packet given */
+    CRYPT_BUFFER_OVERFLOW, /* Not enough space for output */
+    CRYPT_INVALID_PACKET,  /* Invalid input packet given */
 
     CRYPT_INVALID_PRNGSIZE, /* Invalid number of bits for a PRNG */
     CRYPT_ERROR_READPRNG,   /* Could not read enough from PRNG */
 
-    CRYPT_INVALID_CIPHER,   /* Invalid cipher specified */
-    CRYPT_INVALID_HASH,     /* Invalid hash specified */
-    CRYPT_INVALID_PRNG,     /* Invalid PRNG specified */
+    CRYPT_INVALID_CIPHER, /* Invalid cipher specified */
+    CRYPT_INVALID_HASH,   /* Invalid hash specified */
+    CRYPT_INVALID_PRNG,   /* Invalid PRNG specified */
 
-    CRYPT_MEM,              /* Out of memory */
+    CRYPT_MEM, /* Out of memory */
 
     CRYPT_PK_TYPE_MISMATCH, /* Not equivalent types of PK keys */
     CRYPT_PK_NOT_PRIVATE,   /* Requires a private PK key */
 
-    CRYPT_INVALID_ARG,      /* Generic invalid argument */
-    CRYPT_FILE_NOTFOUND,    /* File Not Found */
+    CRYPT_INVALID_ARG,   /* Generic invalid argument */
+    CRYPT_FILE_NOTFOUND, /* File Not Found */
 
-    CRYPT_PK_INVALID_TYPE,  /* Invalid type of PK key */
-    CRYPT_PK_INVALID_SYSTEM,/* Invalid PK system specified */
-    CRYPT_PK_DUP,           /* Duplicate key already in key ring */
-    CRYPT_PK_NOT_FOUND,     /* Key not found in keyring */
-    CRYPT_PK_INVALID_SIZE,  /* Invalid size input for PK parameters */
+    CRYPT_PK_INVALID_TYPE,   /* Invalid type of PK key */
+    CRYPT_PK_INVALID_SYSTEM, /* Invalid PK system specified */
+    CRYPT_PK_DUP,            /* Duplicate key already in key ring */
+    CRYPT_PK_NOT_FOUND,      /* Key not found in keyring */
+    CRYPT_PK_INVALID_SIZE,   /* Invalid size input for PK parameters */
 
-    CRYPT_INVALID_PRIME_SIZE,/* Invalid size of prime requested */
-    CRYPT_PK_INVALID_PADDING /* Invalid padding on input */
+    CRYPT_INVALID_PRIME_SIZE, /* Invalid size of prime requested */
+    CRYPT_PK_INVALID_PADDING  /* Invalid padding on input */
 };
 
 #include "tomcrypt_cfg.h"
diff --git a/src/mongo/crypto/tom/tomcrypt_argchk.h b/src/mongo/crypto/tom/tomcrypt_argchk.h
index 0ae4d5e9447..895402552f5 100644
--- a/src/mongo/crypto/tom/tomcrypt_argchk.h
+++ b/src/mongo/crypto/tom/tomcrypt_argchk.h
@@ -20,8 +20,11 @@
 #include <signal.h>
 
 /* this is the default LibTomCrypt macro  */
-void crypt_argchk(const char *v, const char *s, int d);
-#define LTC_ARGCHK(x) if (!(x)) { crypt_argchk(#x, __FILE__, __LINE__); }
+void crypt_argchk(const char* v, const char* s, int d);
+#define LTC_ARGCHK(x)                         \
+    if (!(x)) {                               \
+        crypt_argchk(#x, __FILE__, __LINE__); \
+    }
 #define LTC_ARGCHKVD(x) LTC_ARGCHK(x)
 
 #elif ARGTYPE == 1
@@ -32,7 +35,10 @@ void crypt_argchk(const char *v, const char *s, int d);
 
 #elif ARGTYPE == 2
 
-#define LTC_ARGCHK(x) if (!(x)) { fprintf(stderr, "\nwarning: ARGCHK failed at %s:%d\n", __FILE__, __LINE__); }
+#define LTC_ARGCHK(x)                                                               \
+    if (!(x)) {                                                                     \
+        fprintf(stderr, "\nwarning: ARGCHK failed at %s:%d\n", __FILE__, __LINE__); \
+    }
 #define LTC_ARGCHKVD(x) LTC_ARGCHK(x)
 
 #elif ARGTYPE == 3
@@ -42,8 +48,12 @@ void crypt_argchk(const char *v, const char *s, int d);
 
 #elif ARGTYPE == 4
 
-#define LTC_ARGCHK(x)   if (!(x)) return CRYPT_INVALID_ARG;
-#define LTC_ARGCHKVD(x) if (!(x)) return;
+#define LTC_ARGCHK(x) \
+    if (!(x))         \
+        return CRYPT_INVALID_ARG;
+#define LTC_ARGCHKVD(x) \
+    if (!(x))           \
+        return;
 
 #endif
 
diff --git a/src/mongo/crypto/tom/tomcrypt_cfg.h b/src/mongo/crypto/tom/tomcrypt_cfg.h
index 6c08fd6a1ee..daae2890d67 100644
--- a/src/mongo/crypto/tom/tomcrypt_cfg.h
+++ b/src/mongo/crypto/tom/tomcrypt_cfg.h
@@ -26,7 +26,7 @@
 #define LTC_CALL __cdecl
 #else
 #ifndef LTC_CALL
-    #define LTC_CALL
+#define LTC_CALL
 #endif
 #endif
 
@@ -38,29 +38,30 @@
 #ifndef LTC_NO_PROTOTYPES
 
 /* you can change how memory allocation works ... */
-LTC_EXPORT void * LTC_CALL XMALLOC(size_t n);
-LTC_EXPORT void * LTC_CALL XREALLOC(void *p, size_t n);
-LTC_EXPORT void * LTC_CALL XCALLOC(size_t n, size_t s);
-LTC_EXPORT void LTC_CALL XFREE(void *p);
+LTC_EXPORT void* LTC_CALL XMALLOC(size_t n);
+LTC_EXPORT void* LTC_CALL XREALLOC(void* p, size_t n);
+LTC_EXPORT void* LTC_CALL XCALLOC(size_t n, size_t s);
+LTC_EXPORT void LTC_CALL XFREE(void* p);
 
-LTC_EXPORT void LTC_CALL XQSORT(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));
+LTC_EXPORT void LTC_CALL
+XQSORT(void* base, size_t nmemb, size_t size, int (*compar)(const void*, const void*));
 
 
 /* change the clock function too */
 LTC_EXPORT clock_t LTC_CALL XCLOCK(void);
 
 /* various other functions */
-LTC_EXPORT void * LTC_CALL XMEMCPY(void *dest, const void *src, size_t n);
-LTC_EXPORT int   LTC_CALL XMEMCMP(const void *s1, const void *s2, size_t n);
-LTC_EXPORT void * LTC_CALL XMEMSET(void *s, int c, size_t n);
+LTC_EXPORT void* LTC_CALL XMEMCPY(void* dest, const void* src, size_t n);
+LTC_EXPORT int LTC_CALL XMEMCMP(const void* s1, const void* s2, size_t n);
+LTC_EXPORT void* LTC_CALL XMEMSET(void* s, int c, size_t n);
 
-LTC_EXPORT int   LTC_CALL XSTRCMP(const char *s1, const char *s2);
+LTC_EXPORT int LTC_CALL XSTRCMP(const char* s1, const char* s2);
 
 #endif
 
 /* type of argument checking, 0=default, 1=fatal and 2=error+continue, 3=nothing */
 #ifndef ARGTYPE
-    #define ARGTYPE  0
+#define ARGTYPE 0
 #endif
 
 /* Controls endianess and size of registers.  Leave uncommented to get platform neutral [slower] code
@@ -71,62 +72,66 @@ LTC_EXPORT int   LTC_CALL XSTRCMP(const char *s1, const char *s2);
  */
 
 /* detect x86-32 machines somewhat */
-#if !defined(__STRICT_ANSI__) && (defined(INTEL_CC) || (defined(_MSC_VER) && defined(WIN32)) || (defined(__GNUC__) && (defined(__DJGPP__) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__i386__))))
-    #define ENDIAN_LITTLE
-    #define ENDIAN_32BITWORD
-    #define LTC_FAST
-    #define LTC_FAST_TYPE    unsigned long
+#if !defined(__STRICT_ANSI__) &&                                   \
+    (defined(INTEL_CC) || (defined(_MSC_VER) && defined(WIN32)) || \
+     (defined(__GNUC__) &&                                         \
+      (defined(__DJGPP__) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__i386__))))
+#define ENDIAN_LITTLE
+#define ENDIAN_32BITWORD
+#define LTC_FAST
+#define LTC_FAST_TYPE unsigned long
 #endif
 
 /* detects MIPS R5900 processors (PS2) */
-#if (defined(__R5900) || defined(R5900) || defined(__R5900__)) && (defined(_mips) || defined(__mips__) || defined(mips))
-    #define ENDIAN_LITTLE
-    #define ENDIAN_64BITWORD
+#if (defined(__R5900) || defined(R5900) || defined(__R5900__)) && \
+    (defined(_mips) || defined(__mips__) || defined(mips))
+#define ENDIAN_LITTLE
+#define ENDIAN_64BITWORD
 #endif
 
 /* detect amd64 */
 #if !defined(__STRICT_ANSI__) && defined(__x86_64__)
-    #define ENDIAN_LITTLE
-    #define ENDIAN_64BITWORD
-    #define LTC_FAST
-    #define LTC_FAST_TYPE    unsigned long
+#define ENDIAN_LITTLE
+#define ENDIAN_64BITWORD
+#define LTC_FAST
+#define LTC_FAST_TYPE unsigned long
 #endif
 
 /* detect PPC32 */
 #if !defined(__STRICT_ANSI__) && defined(LTC_PPC32)
-    #define ENDIAN_BIG
-    #define ENDIAN_32BITWORD
-    #define LTC_FAST
-    #define LTC_FAST_TYPE    unsigned long
+#define ENDIAN_BIG
+#define ENDIAN_32BITWORD
+#define LTC_FAST
+#define LTC_FAST_TYPE unsigned long
 #endif
 
 /* detect sparc and sparc64 */
 #if defined(__sparc__)
-    #define ENDIAN_BIG
-    #if defined(__arch64__)
-        #define ENDIAN_64BITWORD
-    #else
-        #define ENDIAN_32BITWORD
-    #endif
+#define ENDIAN_BIG
+#if defined(__arch64__)
+#define ENDIAN_64BITWORD
+#else
+#define ENDIAN_32BITWORD
+#endif
 #endif
 
 
 #ifdef LTC_NO_FAST
-    #ifdef LTC_FAST
-        #undef LTC_FAST
-    #endif
+#ifdef LTC_FAST
+#undef LTC_FAST
+#endif
 #endif
 
 /* No asm is a quick way to disable anything "not portable" */
 #ifdef LTC_NO_ASM
-    #undef ENDIAN_LITTLE
-    #undef ENDIAN_BIG
-    #undef ENDIAN_32BITWORD
-    #undef ENDIAN_64BITWORD
-    #undef LTC_FAST
-    #undef LTC_FAST_TYPE
-    #define LTC_NO_ROLC
-	#define LTC_NO_BSWAP
+#undef ENDIAN_LITTLE
+#undef ENDIAN_BIG
+#undef ENDIAN_32BITWORD
+#undef ENDIAN_64BITWORD
+#undef LTC_FAST
+#undef LTC_FAST_TYPE
+#define LTC_NO_ROLC
+#define LTC_NO_BSWAP
 #endif
 
 /* #define ENDIAN_LITTLE */
@@ -135,12 +140,13 @@ LTC_EXPORT int   LTC_CALL XSTRCMP(const char *s1, const char *s2);
 /* #define ENDIAN_32BITWORD */
 /* #define ENDIAN_64BITWORD */
 
-#if (defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE)) && !(defined(ENDIAN_32BITWORD) || defined(ENDIAN_64BITWORD))
-    #error You must specify a word size as well as endianess in tomcrypt_cfg.h
+#if (defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE)) && \
+    !(defined(ENDIAN_32BITWORD) || defined(ENDIAN_64BITWORD))
+#error You must specify a word size as well as endianess in tomcrypt_cfg.h
 #endif
 
 #if !(defined(ENDIAN_BIG) || defined(ENDIAN_LITTLE))
-    #define ENDIAN_NEUTRAL
+#define ENDIAN_NEUTRAL
 #endif
 
 #endif
diff --git a/src/mongo/crypto/tom/tomcrypt_cipher.h b/src/mongo/crypto/tom/tomcrypt_cipher.h
index f0ef7d2629e..43efbacc752 100644
--- a/src/mongo/crypto/tom/tomcrypt_cipher.h
+++ b/src/mongo/crypto/tom/tomcrypt_cipher.h
@@ -60,9 +60,7 @@ struct kseed_key {
 
 #ifdef LTC_KASUMI
 struct kasumi_key {
-    ulong32 KLi1[8], KLi2[8],
-            KOi1[8], KOi2[8], KOi3[8],
-            KIi1[8], KIi2[8], KIi3[8];
+    ulong32 KLi1[8], KLi2[8], KOi1[8], KOi2[8], KOi3[8], KIi1[8], KIi2[8], KIi3[8];
 };
 #endif
 
@@ -74,32 +72,36 @@ struct xtea_key {
 
 #ifdef LTC_TWOFISH
 #ifndef LTC_TWOFISH_SMALL
-    struct twofish_key {
-        ulong32 S[4][256], K[40];
-    };
+struct twofish_key {
+    ulong32 S[4][256], K[40];
+};
 #else
-    struct twofish_key {
-        ulong32 K[40];
-        unsigned char S[32], start;
-    };
+struct twofish_key {
+    ulong32 K[40];
+    unsigned char S[32], start;
+};
 #endif
 #endif
 
 #ifdef LTC_SAFER
-#define LTC_SAFER_K64_DEFAULT_NOF_ROUNDS     6
-#define LTC_SAFER_K128_DEFAULT_NOF_ROUNDS   10
-#define LTC_SAFER_SK64_DEFAULT_NOF_ROUNDS    8
-#define LTC_SAFER_SK128_DEFAULT_NOF_ROUNDS  10
-#define LTC_SAFER_MAX_NOF_ROUNDS            13
-#define LTC_SAFER_BLOCK_LEN                  8
-#define LTC_SAFER_KEY_LEN     (1 + LTC_SAFER_BLOCK_LEN * (1 + 2 * LTC_SAFER_MAX_NOF_ROUNDS))
+#define LTC_SAFER_K64_DEFAULT_NOF_ROUNDS 6
+#define LTC_SAFER_K128_DEFAULT_NOF_ROUNDS 10
+#define LTC_SAFER_SK64_DEFAULT_NOF_ROUNDS 8
+#define LTC_SAFER_SK128_DEFAULT_NOF_ROUNDS 10
+#define LTC_SAFER_MAX_NOF_ROUNDS 13
+#define LTC_SAFER_BLOCK_LEN 8
+#define LTC_SAFER_KEY_LEN (1 + LTC_SAFER_BLOCK_LEN * (1 + 2 * LTC_SAFER_MAX_NOF_ROUNDS))
 typedef unsigned char safer_block_t[LTC_SAFER_BLOCK_LEN];
 typedef unsigned char safer_key_t[LTC_SAFER_KEY_LEN];
-struct safer_key { safer_key_t key; };
+struct safer_key {
+    safer_key_t key;
+};
 #endif
 
 #ifdef LTC_RC2
-struct rc2_key { unsigned xkey[64]; };
+struct rc2_key {
+    unsigned xkey[64];
+};
 #endif
 
 #ifdef LTC_DES
@@ -165,62 +167,62 @@ typedef union Symmetric_key {
     struct safer_key safer;
 #endif
 #ifdef LTC_TWOFISH
-    struct twofish_key  twofish;
+    struct twofish_key twofish;
 #endif
 #ifdef LTC_BLOWFISH
     struct blowfish_key blowfish;
 #endif
 #ifdef LTC_RC5
-    struct rc5_key      rc5;
+    struct rc5_key rc5;
 #endif
 #ifdef LTC_RC6
-    struct rc6_key      rc6;
+    struct rc6_key rc6;
 #endif
 #ifdef LTC_SAFERP
-    struct saferp_key   saferp;
+    struct saferp_key saferp;
 #endif
 #ifdef LTC_RIJNDAEL
     struct rijndael_key rijndael;
 #endif
 #ifdef LTC_XTEA
-    struct xtea_key     xtea;
+    struct xtea_key xtea;
 #endif
 #ifdef LTC_CAST5
-    struct cast5_key    cast5;
+    struct cast5_key cast5;
 #endif
 #ifdef LTC_NOEKEON
-    struct noekeon_key  noekeon;
+    struct noekeon_key noekeon;
 #endif
 #ifdef LTC_SKIPJACK
     struct skipjack_key skipjack;
 #endif
 #ifdef LTC_KHAZAD
-    struct khazad_key   khazad;
+    struct khazad_key khazad;
 #endif
 #ifdef LTC_ANUBIS
-    struct anubis_key   anubis;
+    struct anubis_key anubis;
 #endif
 #ifdef LTC_KSEED
-    struct kseed_key    kseed;
+    struct kseed_key kseed;
 #endif
 #ifdef LTC_KASUMI
-    struct kasumi_key   kasumi;
+    struct kasumi_key kasumi;
 #endif
 #ifdef LTC_MULTI2
-    struct multi2_key   multi2;
+    struct multi2_key multi2;
 #endif
-    void   *data;
+    void* data;
 } symmetric_key;
 
 #ifdef LTC_ECB_MODE
 /** A block cipher ECB structure */
 typedef struct {
     /** The index of the cipher chosen */
-    int                 cipher,
-    /** The block size of the given cipher */
-                        blocklen;
+    int cipher,
+        /** The block size of the given cipher */
+        blocklen;
     /** The scheduled key */
-    symmetric_key       key;
+    symmetric_key key;
 } symmetric_ECB;
 #endif
 
@@ -228,17 +230,17 @@ typedef struct {
 /** A block cipher CFB structure */
 typedef struct {
     /** The index of the cipher chosen */
-    int                 cipher,
-    /** The block size of the given cipher */
-                        blocklen,
-    /** The padding offset */
-                        padlen;
+    int cipher,
+        /** The block size of the given cipher */
+        blocklen,
+        /** The padding offset */
+        padlen;
     /** The current IV */
-    unsigned char       IV[MAXBLOCKSIZE],
-    /** The pad used to encrypt/decrypt */
-                        pad[MAXBLOCKSIZE];
+    unsigned char IV[MAXBLOCKSIZE],
+        /** The pad used to encrypt/decrypt */
+        pad[MAXBLOCKSIZE];
     /** The scheduled key */
-    symmetric_key       key;
+    symmetric_key key;
 } symmetric_CFB;
 #endif
 
@@ -246,15 +248,15 @@ typedef struct {
 /** A block cipher OFB structure */
 typedef struct {
     /** The index of the cipher chosen */
-    int                 cipher,
-    /** The block size of the given cipher */
-                        blocklen,
-    /** The padding offset */
-                        padlen;
+    int cipher,
+        /** The block size of the given cipher */
+        blocklen,
+        /** The padding offset */
+        padlen;
     /** The current IV */
-    unsigned char       IV[MAXBLOCKSIZE];
+    unsigned char IV[MAXBLOCKSIZE];
     /** The scheduled key */
-    symmetric_key       key;
+    symmetric_key key;
 } symmetric_OFB;
 #endif
 
@@ -262,13 +264,13 @@ typedef struct {
 /** A block cipher CBC structure */
 typedef struct {
     /** The index of the cipher chosen */
-    int                 cipher,
-    /** The block size of the given cipher */
-                        blocklen;
+    int cipher,
+        /** The block size of the given cipher */
+        blocklen;
     /** The current IV */
-    unsigned char       IV[MAXBLOCKSIZE];
+    unsigned char IV[MAXBLOCKSIZE];
     /** The scheduled key */
-    symmetric_key       key;
+    symmetric_key key;
 } symmetric_CBC;
 #endif
 
@@ -277,22 +279,22 @@ typedef struct {
 /** A block cipher CTR structure */
 typedef struct {
     /** The index of the cipher chosen */
-    int                 cipher,
-    /** The block size of the given cipher */
-                        blocklen,
-    /** The padding offset */
-                        padlen,
-    /** The mode (endianess) of the CTR, 0==little, 1==big */
-                        mode,
-    /** counter width */
-                        ctrlen;
+    int cipher,
+        /** The block size of the given cipher */
+        blocklen,
+        /** The padding offset */
+        padlen,
+        /** The mode (endianess) of the CTR, 0==little, 1==big */
+        mode,
+        /** counter width */
+        ctrlen;
 
     /** The counter */
-    unsigned char       ctr[MAXBLOCKSIZE],
-    /** The pad used to encrypt/decrypt */
-                        pad[MAXBLOCKSIZE];
+    unsigned char ctr[MAXBLOCKSIZE],
+        /** The pad used to encrypt/decrypt */
+        pad[MAXBLOCKSIZE];
     /** The scheduled key */
-    symmetric_key       key;
+    symmetric_key key;
 } symmetric_CTR;
 #endif
 
@@ -301,23 +303,23 @@ typedef struct {
 /** A LRW structure */
 typedef struct {
     /** The index of the cipher chosen (must be a 128-bit block cipher) */
-    int               cipher;
+    int cipher;
 
     /** The current IV */
-    unsigned char     IV[16],
+    unsigned char IV[16],
 
-    /** the tweak key */
-                      tweak[16],
+        /** the tweak key */
+        tweak[16],
 
-    /** The current pad, it's the product of the first 15 bytes against the tweak key */
-                      pad[16];
+        /** The current pad, it's the product of the first 15 bytes against the tweak key */
+        pad[16];
 
     /** The scheduled symmetric key */
-    symmetric_key     key;
+    symmetric_key key;
 
 #ifdef LRW_TABLES
     /** The pre-computed multiplication table */
-    unsigned char     PC[16][256][16];
+    unsigned char PC[16][256][16];
 #endif
 } symmetric_LRW;
 #endif
@@ -326,18 +328,17 @@ typedef struct {
 /** A block cipher F8 structure */
 typedef struct {
     /** The index of the cipher chosen */
-    int                 cipher,
-    /** The block size of the given cipher */
-                        blocklen,
-    /** The padding offset */
-                        padlen;
+    int cipher,
+        /** The block size of the given cipher */
+        blocklen,
+        /** The padding offset */
+        padlen;
     /** The current IV */
-    unsigned char       IV[MAXBLOCKSIZE],
-                        MIV[MAXBLOCKSIZE];
+    unsigned char IV[MAXBLOCKSIZE], MIV[MAXBLOCKSIZE];
     /** Current block count */
-    ulong32             blockcnt;
+    ulong32 blockcnt;
     /** The scheduled key */
-    symmetric_key       key;
+    symmetric_key key;
 } symmetric_F8;
 #endif
 
@@ -345,17 +346,17 @@ typedef struct {
 /** cipher descriptor table, last entry has "name == NULL" to mark the end of table */
 extern struct ltc_cipher_descriptor {
     /** name of cipher */
-    char *name;
+    char* name;
     /** internal ID */
     unsigned char ID;
     /** min keysize (octets) */
-    int  min_key_length,
-    /** max keysize (octets) */
-            max_key_length,
-    /** block size (octets) */
-            block_length,
-    /** default number of rounds */
-            default_rounds;
+    int min_key_length,
+        /** max keysize (octets) */
+        max_key_length,
+        /** block size (octets) */
+        block_length,
+        /** default number of rounds */
+        default_rounds;
     /** Setup the cipher
         @param key         The input symmetric key
         @param keylen      The length of the input key (octets)
@@ -363,21 +364,21 @@ extern struct ltc_cipher_descriptor {
         @param skey        [out] The destination of the scheduled key
         @return CRYPT_OK if successful
     */
-    int  (*setup)(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
+    int (*setup)(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
     /** Encrypt a block
         @param pt      The plaintex
         @param ct      [out] The ciphertex
         @param skey    The scheduled key
         @return CRYPT_OK if successful
     */
-    int (*ecb_encrypt)(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
+    int (*ecb_encrypt)(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
     /** Decrypt a block
         @param ct      The ciphertex
         @param pt      [out] The plaintex
         @param skey    The scheduled key
         @return CRYPT_OK if successful
     */
-    int (*ecb_decrypt)(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+    int (*ecb_decrypt)(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
     /** Test the block cipher
         @return CRYPT_OK if successful, CRYPT_NOP if self-testing has been disabled
     */
@@ -386,15 +387,15 @@ extern struct ltc_cipher_descriptor {
     /** Terminate the contex
         @param skey    The scheduled key
     */
-    void (*done)(symmetric_key *skey);
+    void (*done)(symmetric_key* skey);
 
     /** Determine a key size
         @param keysize    [in/out] The size of the key desired and the suggested size
         @return CRYPT_OK if successful
     */
-    int  (*keysize)(int *keysize);
+    int (*keysize)(int* keysize);
 
-/** Accelerators **/
+    /** Accelerators **/
     /** Accelerated ECB encryption
         @param pt      Plaintex
         @param ct      Ciphertex
@@ -402,7 +403,10 @@ extern struct ltc_cipher_descriptor {
         @param skey    The scheduled key contex
         @return CRYPT_OK if successful
     */
-    int (*accel_ecb_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, symmetric_key *skey);
+    int (*accel_ecb_encrypt)(const unsigned char* pt,
+                             unsigned char* ct,
+                             unsigned long blocks,
+                             symmetric_key* skey);
 
     /** Accelerated ECB decryption
         @param pt      Plaintex
@@ -411,7 +415,10 @@ extern struct ltc_cipher_descriptor {
         @param skey    The scheduled key contex
         @return CRYPT_OK if successful
     */
-    int (*accel_ecb_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, symmetric_key *skey);
+    int (*accel_ecb_decrypt)(const unsigned char* ct,
+                             unsigned char* pt,
+                             unsigned long blocks,
+                             symmetric_key* skey);
 
     /** Accelerated CBC encryption
         @param pt      Plaintex
@@ -421,7 +428,11 @@ extern struct ltc_cipher_descriptor {
         @param skey    The scheduled key contex
         @return CRYPT_OK if successful
     */
-    int (*accel_cbc_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, symmetric_key *skey);
+    int (*accel_cbc_encrypt)(const unsigned char* pt,
+                             unsigned char* ct,
+                             unsigned long blocks,
+                             unsigned char* IV,
+                             symmetric_key* skey);
 
     /** Accelerated CBC decryption
        @param pt      Plaintex
@@ -431,7 +442,11 @@ extern struct ltc_cipher_descriptor {
        @param skey    The scheduled key contex
        @return CRYPT_OK if successful
     */
-    int (*accel_cbc_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, unsigned char *IV, symmetric_key *skey);
+    int (*accel_cbc_decrypt)(const unsigned char* ct,
+                             unsigned char* pt,
+                             unsigned long blocks,
+                             unsigned char* IV,
+                             symmetric_key* skey);
 
     /** Accelerated CTR encryption
         @param pt      Plaintex
@@ -442,7 +457,12 @@ extern struct ltc_cipher_descriptor {
         @param skey    The scheduled key contex
         @return CRYPT_OK if successful
     */
-    int (*accel_ctr_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, int mode, symmetric_key *skey);
+    int (*accel_ctr_encrypt)(const unsigned char* pt,
+                             unsigned char* ct,
+                             unsigned long blocks,
+                             unsigned char* IV,
+                             int mode,
+                             symmetric_key* skey);
 
     /** Accelerated LRW
         @param pt      Plaintex
@@ -453,7 +473,12 @@ extern struct ltc_cipher_descriptor {
         @param skey    The scheduled key contex
         @return CRYPT_OK if successful
     */
-    int (*accel_lrw_encrypt)(const unsigned char *pt, unsigned char *ct, unsigned long blocks, unsigned char *IV, const unsigned char *tweak, symmetric_key *skey);
+    int (*accel_lrw_encrypt)(const unsigned char* pt,
+                             unsigned char* ct,
+                             unsigned long blocks,
+                             unsigned char* IV,
+                             const unsigned char* tweak,
+                             symmetric_key* skey);
 
     /** Accelerated LRW
         @param ct      Ciphertex
@@ -464,7 +489,12 @@ extern struct ltc_cipher_descriptor {
         @param skey    The scheduled key contex
         @return CRYPT_OK if successful
     */
-    int (*accel_lrw_decrypt)(const unsigned char *ct, unsigned char *pt, unsigned long blocks, unsigned char *IV, const unsigned char *tweak, symmetric_key *skey);
+    int (*accel_lrw_decrypt)(const unsigned char* ct,
+                             unsigned char* pt,
+                             unsigned long blocks,
+                             unsigned char* IV,
+                             const unsigned char* tweak,
+                             symmetric_key* skey);
 
     /** Accelerated CCM packet (one-shot)
         @param key        The secret key to use
@@ -482,15 +512,19 @@ extern struct ltc_cipher_descriptor {
         @param direction  Encrypt or Decrypt direction (0 or 1)
         @return CRYPT_OK if successful
     */
-    int (*accel_ccm_memory)(
-        const unsigned char *key,    unsigned long keylen,
-        symmetric_key       *uskey,
-        const unsigned char *nonce,  unsigned long noncelen,
-        const unsigned char *header, unsigned long headerlen,
-                unsigned char *pt,     unsigned long ptlen,
-                unsigned char *ct,
-                unsigned char *tag,    unsigned long *taglen,
-                        int  direction);
+    int (*accel_ccm_memory)(const unsigned char* key,
+                            unsigned long keylen,
+                            symmetric_key* uskey,
+                            const unsigned char* nonce,
+                            unsigned long noncelen,
+                            const unsigned char* header,
+                            unsigned long headerlen,
+                            unsigned char* pt,
+                            unsigned long ptlen,
+                            unsigned char* ct,
+                            unsigned char* tag,
+                            unsigned long* taglen,
+                            int direction);
 
     /** Accelerated GCM packet (one shot)
         @param key        The secret key
@@ -507,14 +541,18 @@ extern struct ltc_cipher_descriptor {
         @param direction  Encrypt or Decrypt mode (GCM_ENCRYPT or GCM_DECRYPT)
         @return CRYPT_OK on success
     */
-    int (*accel_gcm_memory)(
-        const unsigned char *key,    unsigned long keylen,
-        const unsigned char *IV,     unsigned long IVlen,
-        const unsigned char *adata,  unsigned long adatalen,
-                unsigned char *pt,     unsigned long ptlen,
-                unsigned char *ct,
-                unsigned char *tag,    unsigned long *taglen,
-                        int direction);
+    int (*accel_gcm_memory)(const unsigned char* key,
+                            unsigned long keylen,
+                            const unsigned char* IV,
+                            unsigned long IVlen,
+                            const unsigned char* adata,
+                            unsigned long adatalen,
+                            unsigned char* pt,
+                            unsigned long ptlen,
+                            unsigned char* ct,
+                            unsigned char* tag,
+                            unsigned long* taglen,
+                            int direction);
 
     /** Accelerated one shot LTC_OMAC
         @param key            The secret key
@@ -525,10 +563,12 @@ extern struct ltc_cipher_descriptor {
         @param outlen         [in/out] Initial and final size of ou
         @return CRYPT_OK on success
     */
-    int (*omac_memory)(
-        const unsigned char *key, unsigned long keylen,
-        const unsigned char *in,  unsigned long inlen,
-                unsigned char *out, unsigned long *outlen);
+    int (*omac_memory)(const unsigned char* key,
+                       unsigned long keylen,
+                       const unsigned char* in,
+                       unsigned long inlen,
+                       unsigned char* out,
+                       unsigned long* outlen);
 
     /** Accelerated one shot XCBC
         @param key            The secret key
@@ -539,10 +579,12 @@ extern struct ltc_cipher_descriptor {
         @param outlen         [in/out] Initial and final size of ou
         @return CRYPT_OK on success
     */
-    int (*xcbc_memory)(
-        const unsigned char *key, unsigned long keylen,
-        const unsigned char *in,  unsigned long inlen,
-                unsigned char *out, unsigned long *outlen);
+    int (*xcbc_memory)(const unsigned char* key,
+                       unsigned long keylen,
+                       const unsigned char* in,
+                       unsigned long inlen,
+                       unsigned char* out,
+                       unsigned long* outlen);
 
     /** Accelerated one shot F9
         @param key            The secret key
@@ -554,277 +596,293 @@ extern struct ltc_cipher_descriptor {
         @return CRYPT_OK on success
         @remark Requires manual padding
     */
-    int (*f9_memory)(
-        const unsigned char *key, unsigned long keylen,
-        const unsigned char *in,  unsigned long inlen,
-        unsigned char *out, unsigned long *outlen);
+    int (*f9_memory)(const unsigned char* key,
+                     unsigned long keylen,
+                     const unsigned char* in,
+                     unsigned long inlen,
+                     unsigned char* out,
+                     unsigned long* outlen);
 } cipher_descriptor[];
 
 #ifdef LTC_BLOWFISH
-int blowfish_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int blowfish_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int blowfish_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int blowfish_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int blowfish_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int blowfish_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int blowfish_test(void);
-void blowfish_done(symmetric_key *skey);
-int blowfish_keysize(int *keysize);
+void blowfish_done(symmetric_key* skey);
+int blowfish_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor blowfish_desc;
 #endif
 
 #ifdef LTC_RC5
-int rc5_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int rc5_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int rc5_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int rc5_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int rc5_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int rc5_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int rc5_test(void);
-void rc5_done(symmetric_key *skey);
-int rc5_keysize(int *keysize);
+void rc5_done(symmetric_key* skey);
+int rc5_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor rc5_desc;
 #endif
 
 #ifdef LTC_RC6
-int rc6_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int rc6_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int rc6_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int rc6_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int rc6_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int rc6_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int rc6_test(void);
-void rc6_done(symmetric_key *skey);
-int rc6_keysize(int *keysize);
+void rc6_done(symmetric_key* skey);
+int rc6_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor rc6_desc;
 #endif
 
 #ifdef LTC_RC2
-int rc2_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int rc2_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int rc2_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int rc2_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int rc2_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int rc2_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int rc2_test(void);
-void rc2_done(symmetric_key *skey);
-int rc2_keysize(int *keysize);
+void rc2_done(symmetric_key* skey);
+int rc2_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor rc2_desc;
 #endif
 
 #ifdef LTC_SAFERP
-int saferp_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int saferp_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int saferp_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int saferp_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int saferp_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int saferp_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int saferp_test(void);
-void saferp_done(symmetric_key *skey);
-int saferp_keysize(int *keysize);
+void saferp_done(symmetric_key* skey);
+int saferp_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor saferp_desc;
 #endif
 
 #ifdef LTC_SAFER
-int safer_k64_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int safer_sk64_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int safer_k128_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int safer_sk128_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int safer_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *key);
-int safer_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *key);
+int safer_k64_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int safer_sk64_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int safer_k128_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int safer_sk128_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int safer_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* key);
+int safer_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* key);
 int safer_k64_test(void);
 int safer_sk64_test(void);
 int safer_sk128_test(void);
-void safer_done(symmetric_key *skey);
-int safer_64_keysize(int *keysize);
-int safer_128_keysize(int *keysize);
-extern const struct ltc_cipher_descriptor safer_k64_desc, safer_k128_desc, safer_sk64_desc, safer_sk128_desc;
+void safer_done(symmetric_key* skey);
+int safer_64_keysize(int* keysize);
+int safer_128_keysize(int* keysize);
+extern const struct ltc_cipher_descriptor safer_k64_desc, safer_k128_desc, safer_sk64_desc,
+    safer_sk128_desc;
 #endif
 
 #ifdef LTC_RIJNDAEL
 
 /* make aes an alias */
-#define aes_setup           rijndael_setup
-#define aes_ecb_encrypt     rijndael_ecb_encryp
-#define aes_ecb_decrypt     rijndael_ecb_decryp
-#define aes_test            rijndael_tes
-#define aes_done            rijndael_done
-#define aes_keysize         rijndael_keysize
-
-#define aes_enc_setup           rijndael_enc_setup
-#define aes_enc_ecb_encrypt     rijndael_enc_ecb_encryp
-#define aes_enc_keysize         rijndael_enc_keysize
-
-int rijndael_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int rijndael_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int rijndael_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+#define aes_setup rijndael_setup
+#define aes_ecb_encrypt rijndael_ecb_encryp
+#define aes_ecb_decrypt rijndael_ecb_decryp
+#define aes_test rijndael_tes
+#define aes_done rijndael_done
+#define aes_keysize rijndael_keysize
+
+#define aes_enc_setup rijndael_enc_setup
+#define aes_enc_ecb_encrypt rijndael_enc_ecb_encryp
+#define aes_enc_keysize rijndael_enc_keysize
+
+int rijndael_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int rijndael_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int rijndael_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int rijndael_test(void);
-void rijndael_done(symmetric_key *skey);
-int rijndael_keysize(int *keysize);
-int rijndael_enc_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int rijndael_enc_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-void rijndael_enc_done(symmetric_key *skey);
-int rijndael_enc_keysize(int *keysize);
+void rijndael_done(symmetric_key* skey);
+int rijndael_keysize(int* keysize);
+int rijndael_enc_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int rijndael_enc_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+void rijndael_enc_done(symmetric_key* skey);
+int rijndael_enc_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor rijndael_desc, aes_desc;
 extern const struct ltc_cipher_descriptor rijndael_enc_desc, aes_enc_desc;
 #endif
 
 #ifdef LTC_XTEA
-int xtea_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int xtea_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int xtea_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int xtea_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int xtea_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int xtea_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int xtea_test(void);
-void xtea_done(symmetric_key *skey);
-int xtea_keysize(int *keysize);
+void xtea_done(symmetric_key* skey);
+int xtea_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor xtea_desc;
 #endif
 
 #ifdef LTC_TWOFISH
-int twofish_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int twofish_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int twofish_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int twofish_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int twofish_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int twofish_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int twofish_test(void);
-void twofish_done(symmetric_key *skey);
-int twofish_keysize(int *keysize);
+void twofish_done(symmetric_key* skey);
+int twofish_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor twofish_desc;
 #endif
 
 #ifdef LTC_DES
-int des_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int des_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int des_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int des_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int des_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int des_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int des_test(void);
-void des_done(symmetric_key *skey);
-int des_keysize(int *keysize);
-int des3_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int des3_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int des3_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+void des_done(symmetric_key* skey);
+int des_keysize(int* keysize);
+int des3_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int des3_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int des3_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int des3_test(void);
-void des3_done(symmetric_key *skey);
-int des3_keysize(int *keysize);
+void des3_done(symmetric_key* skey);
+int des3_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor des_desc, des3_desc;
 #endif
 
 #ifdef LTC_CAST5
-int cast5_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int cast5_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int cast5_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int cast5_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int cast5_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int cast5_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int cast5_test(void);
-void cast5_done(symmetric_key *skey);
-int cast5_keysize(int *keysize);
+void cast5_done(symmetric_key* skey);
+int cast5_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor cast5_desc;
 #endif
 
 #ifdef LTC_NOEKEON
-int noekeon_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int noekeon_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int noekeon_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int noekeon_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int noekeon_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int noekeon_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int noekeon_test(void);
-void noekeon_done(symmetric_key *skey);
-int noekeon_keysize(int *keysize);
+void noekeon_done(symmetric_key* skey);
+int noekeon_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor noekeon_desc;
 #endif
 
 #ifdef LTC_SKIPJACK
-int skipjack_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int skipjack_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int skipjack_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int skipjack_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int skipjack_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int skipjack_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int skipjack_test(void);
-void skipjack_done(symmetric_key *skey);
-int skipjack_keysize(int *keysize);
+void skipjack_done(symmetric_key* skey);
+int skipjack_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor skipjack_desc;
 #endif
 
 #ifdef LTC_KHAZAD
-int khazad_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int khazad_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int khazad_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int khazad_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int khazad_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int khazad_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int khazad_test(void);
-void khazad_done(symmetric_key *skey);
-int khazad_keysize(int *keysize);
+void khazad_done(symmetric_key* skey);
+int khazad_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor khazad_desc;
 #endif
 
 #ifdef LTC_ANUBIS
-int anubis_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int anubis_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int anubis_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int anubis_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int anubis_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int anubis_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int anubis_test(void);
-void anubis_done(symmetric_key *skey);
-int anubis_keysize(int *keysize);
+void anubis_done(symmetric_key* skey);
+int anubis_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor anubis_desc;
 #endif
 
 #ifdef LTC_KSEED
-int kseed_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int kseed_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int kseed_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int kseed_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int kseed_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int kseed_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int kseed_test(void);
-void kseed_done(symmetric_key *skey);
-int kseed_keysize(int *keysize);
+void kseed_done(symmetric_key* skey);
+int kseed_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor kseed_desc;
 #endif
 
 #ifdef LTC_KASUMI
-int kasumi_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int kasumi_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int kasumi_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int kasumi_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int kasumi_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int kasumi_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int kasumi_test(void);
-void kasumi_done(symmetric_key *skey);
-int kasumi_keysize(int *keysize);
+void kasumi_done(symmetric_key* skey);
+int kasumi_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor kasumi_desc;
 #endif
 
 
 #ifdef LTC_MULTI2
-int multi2_setup(const unsigned char *key, int keylen, int num_rounds, symmetric_key *skey);
-int multi2_ecb_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_key *skey);
-int multi2_ecb_decrypt(const unsigned char *ct, unsigned char *pt, symmetric_key *skey);
+int multi2_setup(const unsigned char* key, int keylen, int num_rounds, symmetric_key* skey);
+int multi2_ecb_encrypt(const unsigned char* pt, unsigned char* ct, symmetric_key* skey);
+int multi2_ecb_decrypt(const unsigned char* ct, unsigned char* pt, symmetric_key* skey);
 int multi2_test(void);
-void multi2_done(symmetric_key *skey);
-int multi2_keysize(int *keysize);
+void multi2_done(symmetric_key* skey);
+int multi2_keysize(int* keysize);
 extern const struct ltc_cipher_descriptor multi2_desc;
 #endif
 
 #ifdef LTC_ECB_MODE
-int ecb_start(int cipher, const unsigned char *key,
-              int keylen, int num_rounds, symmetric_ECB *ecb);
-int ecb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_ECB *ecb);
-int ecb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_ECB *ecb);
-int ecb_done(symmetric_ECB *ecb);
+int ecb_start(int cipher, const unsigned char* key, int keylen, int num_rounds, symmetric_ECB* ecb);
+int ecb_encrypt(const unsigned char* pt, unsigned char* ct, unsigned long len, symmetric_ECB* ecb);
+int ecb_decrypt(const unsigned char* ct, unsigned char* pt, unsigned long len, symmetric_ECB* ecb);
+int ecb_done(symmetric_ECB* ecb);
 #endif
 
 #ifdef LTC_CFB_MODE
-int cfb_start(int cipher, const unsigned char *IV, const unsigned char *key,
-              int keylen, int num_rounds, symmetric_CFB *cfb);
-int cfb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CFB *cfb);
-int cfb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CFB *cfb);
-int cfb_getiv(unsigned char *IV, unsigned long *len, symmetric_CFB *cfb);
-int cfb_setiv(const unsigned char *IV, unsigned long len, symmetric_CFB *cfb);
-int cfb_done(symmetric_CFB *cfb);
+int cfb_start(int cipher,
+              const unsigned char* IV,
+              const unsigned char* key,
+              int keylen,
+              int num_rounds,
+              symmetric_CFB* cfb);
+int cfb_encrypt(const unsigned char* pt, unsigned char* ct, unsigned long len, symmetric_CFB* cfb);
+int cfb_decrypt(const unsigned char* ct, unsigned char* pt, unsigned long len, symmetric_CFB* cfb);
+int cfb_getiv(unsigned char* IV, unsigned long* len, symmetric_CFB* cfb);
+int cfb_setiv(const unsigned char* IV, unsigned long len, symmetric_CFB* cfb);
+int cfb_done(symmetric_CFB* cfb);
 #endif
 
 #ifdef LTC_OFB_MODE
-int ofb_start(int cipher, const unsigned char *IV, const unsigned char *key,
-              int keylen, int num_rounds, symmetric_OFB *ofb);
-int ofb_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_OFB *ofb);
-int ofb_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_OFB *ofb);
-int ofb_getiv(unsigned char *IV, unsigned long *len, symmetric_OFB *ofb);
-int ofb_setiv(const unsigned char *IV, unsigned long len, symmetric_OFB *ofb);
-int ofb_done(symmetric_OFB *ofb);
+int ofb_start(int cipher,
+              const unsigned char* IV,
+              const unsigned char* key,
+              int keylen,
+              int num_rounds,
+              symmetric_OFB* ofb);
+int ofb_encrypt(const unsigned char* pt, unsigned char* ct, unsigned long len, symmetric_OFB* ofb);
+int ofb_decrypt(const unsigned char* ct, unsigned char* pt, unsigned long len, symmetric_OFB* ofb);
+int ofb_getiv(unsigned char* IV, unsigned long* len, symmetric_OFB* ofb);
+int ofb_setiv(const unsigned char* IV, unsigned long len, symmetric_OFB* ofb);
+int ofb_done(symmetric_OFB* ofb);
 #endif
 
 #ifdef LTC_CBC_MODE
-int cbc_start(int cipher, const unsigned char *IV, const unsigned char *key,
-               int keylen, int num_rounds, symmetric_CBC *cbc);
-int cbc_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CBC *cbc);
-int cbc_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CBC *cbc);
-int cbc_getiv(unsigned char *IV, unsigned long *len, symmetric_CBC *cbc);
-int cbc_setiv(const unsigned char *IV, unsigned long len, symmetric_CBC *cbc);
-int cbc_done(symmetric_CBC *cbc);
+int cbc_start(int cipher,
+              const unsigned char* IV,
+              const unsigned char* key,
+              int keylen,
+              int num_rounds,
+              symmetric_CBC* cbc);
+int cbc_encrypt(const unsigned char* pt, unsigned char* ct, unsigned long len, symmetric_CBC* cbc);
+int cbc_decrypt(const unsigned char* ct, unsigned char* pt, unsigned long len, symmetric_CBC* cbc);
+int cbc_getiv(unsigned char* IV, unsigned long* len, symmetric_CBC* cbc);
+int cbc_setiv(const unsigned char* IV, unsigned long len, symmetric_CBC* cbc);
+int cbc_done(symmetric_CBC* cbc);
 #endif
 
 #ifdef LTC_CTR_MODE
 
-#define CTR_COUNTER_LITTLE_ENDIAN    0x0000
-#define CTR_COUNTER_BIG_ENDIAN       0x1000
-#define LTC_CTR_RFC3686              0x2000
-
-int ctr_start(               int   cipher,
-              const unsigned char *IV,
-              const unsigned char *key,       int keylen,
-                             int  num_rounds, int ctr_mode,
-                   symmetric_CTR *ctr);
-int ctr_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_CTR *ctr);
-int ctr_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_CTR *ctr);
-int ctr_getiv(unsigned char *IV, unsigned long *len, symmetric_CTR *ctr);
-int ctr_setiv(const unsigned char *IV, unsigned long len, symmetric_CTR *ctr);
-int ctr_done(symmetric_CTR *ctr);
+#define CTR_COUNTER_LITTLE_ENDIAN 0x0000
+#define CTR_COUNTER_BIG_ENDIAN 0x1000
+#define LTC_CTR_RFC3686 0x2000
+
+int ctr_start(int cipher,
+              const unsigned char* IV,
+              const unsigned char* key,
+              int keylen,
+              int num_rounds,
+              int ctr_mode,
+              symmetric_CTR* ctr);
+int ctr_encrypt(const unsigned char* pt, unsigned char* ct, unsigned long len, symmetric_CTR* ctr);
+int ctr_decrypt(const unsigned char* ct, unsigned char* pt, unsigned long len, symmetric_CTR* ctr);
+int ctr_getiv(unsigned char* IV, unsigned long* len, symmetric_CTR* ctr);
+int ctr_setiv(const unsigned char* IV, unsigned long len, symmetric_CTR* ctr);
+int ctr_done(symmetric_CTR* ctr);
 int ctr_test(void);
 #endif
 
@@ -833,70 +891,76 @@ int ctr_test(void);
 #define LRW_ENCRYPT 0
 #define LRW_DECRYPT 1
 
-int lrw_start(               int   cipher,
-              const unsigned char *IV,
-              const unsigned char *key,       int keylen,
-              const unsigned char *tweak,
-                             int  num_rounds,
-                   symmetric_LRW *lrw);
-int lrw_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_LRW *lrw);
-int lrw_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_LRW *lrw);
-int lrw_getiv(unsigned char *IV, unsigned long *len, symmetric_LRW *lrw);
-int lrw_setiv(const unsigned char *IV, unsigned long len, symmetric_LRW *lrw);
-int lrw_done(symmetric_LRW *lrw);
+int lrw_start(int cipher,
+              const unsigned char* IV,
+              const unsigned char* key,
+              int keylen,
+              const unsigned char* tweak,
+              int num_rounds,
+              symmetric_LRW* lrw);
+int lrw_encrypt(const unsigned char* pt, unsigned char* ct, unsigned long len, symmetric_LRW* lrw);
+int lrw_decrypt(const unsigned char* ct, unsigned char* pt, unsigned long len, symmetric_LRW* lrw);
+int lrw_getiv(unsigned char* IV, unsigned long* len, symmetric_LRW* lrw);
+int lrw_setiv(const unsigned char* IV, unsigned long len, symmetric_LRW* lrw);
+int lrw_done(symmetric_LRW* lrw);
 int lrw_test(void);
 
 /* don't call */
-int lrw_process(const unsigned char *pt, unsigned char *ct, unsigned long len, int mode, symmetric_LRW *lrw);
+int lrw_process(
+    const unsigned char* pt, unsigned char* ct, unsigned long len, int mode, symmetric_LRW* lrw);
 #endif
 
 #ifdef LTC_F8_MODE
-int f8_start(                int  cipher, const unsigned char *IV,
-             const unsigned char *key,                    int  keylen,
-             const unsigned char *salt_key,               int  skeylen,
-                             int  num_rounds,   symmetric_F8  *f8);
-int f8_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_F8 *f8);
-int f8_decrypt(const unsigned char *ct, unsigned char *pt, unsigned long len, symmetric_F8 *f8);
-int f8_getiv(unsigned char *IV, unsigned long *len, symmetric_F8 *f8);
-int f8_setiv(const unsigned char *IV, unsigned long len, symmetric_F8 *f8);
-int f8_done(symmetric_F8 *f8);
+int f8_start(int cipher,
+             const unsigned char* IV,
+             const unsigned char* key,
+             int keylen,
+             const unsigned char* salt_key,
+             int skeylen,
+             int num_rounds,
+             symmetric_F8* f8);
+int f8_encrypt(const unsigned char* pt, unsigned char* ct, unsigned long len, symmetric_F8* f8);
+int f8_decrypt(const unsigned char* ct, unsigned char* pt, unsigned long len, symmetric_F8* f8);
+int f8_getiv(unsigned char* IV, unsigned long* len, symmetric_F8* f8);
+int f8_setiv(const unsigned char* IV, unsigned long len, symmetric_F8* f8);
+int f8_done(symmetric_F8* f8);
 int f8_test_mode(void);
 #endif
 
 #ifdef LTC_XTS_MODE
 typedef struct {
-    symmetric_key  key1, key2;
-    int            cipher;
+    symmetric_key key1, key2;
+    int cipher;
 } symmetric_xts;
 
-int xts_start(                int  cipher,
-              const unsigned char *key1,
-              const unsigned char *key2,
-                    unsigned long  keylen,
-                              int  num_rounds,
-                    symmetric_xts *xts);
-
-int xts_encrypt(
-    const unsigned char *pt, unsigned long ptlen,
-            unsigned char *ct,
-    const unsigned char *tweak,
-            symmetric_xts *xts);
-int xts_decrypt(
-    const unsigned char *ct, unsigned long ptlen,
-            unsigned char *pt,
-    const unsigned char *tweak,
-            symmetric_xts *xts);
-
-void xts_done(symmetric_xts *xts);
-int  xts_test(void);
-void xts_mult_x(unsigned char *I);
-#endif
-
-int find_cipher(const char *name);
-int find_cipher_any(const char *name, int blocklen, int keylen);
+int xts_start(int cipher,
+              const unsigned char* key1,
+              const unsigned char* key2,
+              unsigned long keylen,
+              int num_rounds,
+              symmetric_xts* xts);
+
+int xts_encrypt(const unsigned char* pt,
+                unsigned long ptlen,
+                unsigned char* ct,
+                const unsigned char* tweak,
+                symmetric_xts* xts);
+int xts_decrypt(const unsigned char* ct,
+                unsigned long ptlen,
+                unsigned char* pt,
+                const unsigned char* tweak,
+                symmetric_xts* xts);
+
+void xts_done(symmetric_xts* xts);
+int xts_test(void);
+void xts_mult_x(unsigned char* I);
+#endif
+
+int find_cipher(const char* name);
+int find_cipher_any(const char* name, int blocklen, int keylen);
 int find_cipher_id(unsigned char ID);
-int register_cipher(const struct ltc_cipher_descriptor *cipher);
-int unregister_cipher(const struct ltc_cipher_descriptor *cipher);
+int register_cipher(const struct ltc_cipher_descriptor* cipher);
+int unregister_cipher(const struct ltc_cipher_descriptor* cipher);
 int cipher_is_valid(int idx);
 
 LTC_MUTEX_PROTO(ltc_cipher_mutex)
diff --git a/src/mongo/crypto/tom/tomcrypt_custom.h b/src/mongo/crypto/tom/tomcrypt_custom.h
index 5819f245f06..07d64fc83f6 100644
--- a/src/mongo/crypto/tom/tomcrypt_custom.h
+++ b/src/mongo/crypto/tom/tomcrypt_custom.h
@@ -18,103 +18,103 @@
 
 /* macros for various libc functions you can change for embedded targets */
 #ifndef XMALLOC
-    #ifdef malloc
-    #define LTC_NO_PROTOTYPES
-    #endif
-#define XMALLOC  malloc
+#ifdef malloc
+#define LTC_NO_PROTOTYPES
+#endif
+#define XMALLOC malloc
 #endif
 #ifndef XREALLOC
-    #ifdef realloc
-    #define LTC_NO_PROTOTYPES
-    #endif
+#ifdef realloc
+#define LTC_NO_PROTOTYPES
+#endif
 #define XREALLOC realloc
 #endif
 #ifndef XCALLOC
-    #ifdef calloc
-    #define LTC_NO_PROTOTYPES
-    #endif
-#define XCALLOC  calloc
+#ifdef calloc
+#define LTC_NO_PROTOTYPES
+#endif
+#define XCALLOC calloc
 #endif
 #ifndef XFREE
-    #ifdef free
-    #define LTC_NO_PROTOTYPES
-    #endif
-#define XFREE    free
+#ifdef free
+#define LTC_NO_PROTOTYPES
+#endif
+#define XFREE free
 #endif
 
 #ifndef XMEMSET
-    #ifdef memse
-    #define LTC_NO_PROTOTYPES
-    #endif
-#define XMEMSET  memse
+#ifdef memse
+#define LTC_NO_PROTOTYPES
+#endif
+#define XMEMSET memse
 #endif
 #ifndef XMEMCPY
-    #ifdef memcpy
-    #define LTC_NO_PROTOTYPES
-    #endif
-#define XMEMCPY  memcpy
+#ifdef memcpy
+#define LTC_NO_PROTOTYPES
+#endif
+#define XMEMCPY memcpy
 #endif
 #ifndef XMEMCMP
-    #ifdef memcmp
-    #define LTC_NO_PROTOTYPES
-    #endif
-#define XMEMCMP  memcmp
+#ifdef memcmp
+#define LTC_NO_PROTOTYPES
+#endif
+#define XMEMCMP memcmp
 #endif
 #ifndef XSTRCMP
-    #ifdef strcmp
-    #define LTC_NO_PROTOTYPES
-    #endif
+#ifdef strcmp
+#define LTC_NO_PROTOTYPES
+#endif
 #define XSTRCMP strcmp
 #endif
 
 #ifndef XCLOCK
-#define XCLOCK   clock
+#define XCLOCK clock
 #endif
 #ifndef XCLOCKS_PER_SEC
 #define XCLOCKS_PER_SEC CLOCKS_PER_SEC
 #endif
 
 #ifndef XQSORT
-    #ifdef qsor
-        #define LTC_NO_PROTOTYPES
-    #endif
+#ifdef qsor
+#define LTC_NO_PROTOTYPES
+#endif
 #define XQSORT qsor
 #endif
 
 /* Easy button? */
 #ifdef LTC_EASY
-    #define LTC_NO_CIPHERS
-    #define LTC_RIJNDAEL
-    #define LTC_BLOWFISH
-    #define LTC_DES
-    #define LTC_CAST5
-
-    #define LTC_NO_MODES
-    #define LTC_ECB_MODE
-    #define LTC_CBC_MODE
-    #define LTC_CTR_MODE
-
-    #define LTC_NO_HASHES
-    #define LTC_SHA1
-    #define LTC_SHA512
-    #define LTC_SHA384
-    #define LTC_SHA256
-    #define LTC_SHA224
-
-    #define LTC_NO_MACS
-    #define LTC_HMAC
-    #define LTC_OMAC
-    #define LTC_CCM_MODE
-
-    #define LTC_NO_PRNGS
-    #define LTC_SPRNG
-    #define LTC_YARROW
-    #define LTC_DEVRANDOM
-    #define TRY_URANDOM_FIRST
-
-    #define LTC_NO_PK
-    #define LTC_MRSA
-    #define LTC_MECC
+#define LTC_NO_CIPHERS
+#define LTC_RIJNDAEL
+#define LTC_BLOWFISH
+#define LTC_DES
+#define LTC_CAST5
+
+#define LTC_NO_MODES
+#define LTC_ECB_MODE
+#define LTC_CBC_MODE
+#define LTC_CTR_MODE
+
+#define LTC_NO_HASHES
+#define LTC_SHA1
+#define LTC_SHA512
+#define LTC_SHA384
+#define LTC_SHA256
+#define LTC_SHA224
+
+#define LTC_NO_MACS
+#define LTC_HMAC
+#define LTC_OMAC
+#define LTC_CCM_MODE
+
+#define LTC_NO_PRNGS
+#define LTC_SPRNG
+#define LTC_YARROW
+#define LTC_DEVRANDOM
+#define TRY_URANDOM_FIRST
+
+#define LTC_NO_PK
+#define LTC_MRSA
+#define LTC_MECC
 #endif
 
 /* Use small code where possible */
@@ -122,7 +122,7 @@
 
 /* Enable self-test test vector checking */
 #ifndef LTC_NO_TEST
-    #define LTC_TEST
+#define LTC_TEST
 #endif
 
 /* clean the stack of functions which put private information on stack */
@@ -154,10 +154,10 @@
  * (saves 4KB of ram), _ALL_TABLES enables all tables during setup */
 #define LTC_TWOFISH
 #ifndef LTC_NO_TABLES
-    #define LTC_TWOFISH_TABLES
-    /* #define LTC_TWOFISH_ALL_TABLES */
+#define LTC_TWOFISH_TABLES
+/* #define LTC_TWOFISH_ALL_TABLES */
 #else
-    #define LTC_TWOFISH_SMALL
+#define LTC_TWOFISH_SMALL
 #endif
 /* #define LTC_TWOFISH_SMALL */
 /* LTC_DES includes EDE triple-LTC_DES */
@@ -190,10 +190,10 @@
 /* LRW mode */
 #define LTC_LRW_MODE
 #ifndef LTC_NO_TABLES
-    /* like GCM mode this will enable 16 8x128 tables [64KB] that make
-        * seeking very fast.
-        */
-    #define LRW_TABLES
+/* like GCM mode this will enable 16 8x128 tables [64KB] that make
+    * seeking very fast.
+    */
+#define LRW_TABLES
 #endif
 
 /* XTS mode */
@@ -233,14 +233,14 @@
 //#define LTC_PELICAN
 
 #if defined(LTC_PELICAN) && !defined(LTC_RIJNDAEL)
-    #error Pelican-MAC requires LTC_RIJNDAEL
+#error Pelican-MAC requires LTC_RIJNDAEL
 #endif
 
 /* ---> Encrypt + Authenticate Modes <--- */
 
 #define LTC_EAX_MODE
 #if defined(LTC_EAX_MODE) && !(defined(LTC_CTR_MODE) && defined(LTC_OMAC))
-    #error LTC_EAX_MODE requires CTR and LTC_OMAC mode
+#error LTC_EAX_MODE requires CTR and LTC_OMAC mode
 #endif
 
 #define LTC_OCB_MODE
@@ -249,7 +249,7 @@
 
 /* Use 64KiB tables */
 #ifndef LTC_NO_TABLES
-    #define LTC_GCM_TABLES
+#define LTC_GCM_TABLES
 #endif
 
 /* USE SSE2? requires GCC works on x86_32 and x86_64*/
@@ -272,7 +272,7 @@
 #define LTC_YARROW_AES 0
 
 #if defined(LTC_YARROW) && !defined(LTC_CTR_MODE)
-    #error LTC_YARROW requires LTC_CTR_MODE chaining mode to be defined!
+#error LTC_YARROW requires LTC_CTR_MODE chaining mode to be defined!
 #endif
 
 /* a PRNG that simply reads from an available system source */
@@ -284,7 +284,7 @@
 /* Fortuna PRNG */
 #define LTC_FORTUNA
 /* reseed every N calls to the read function */
-#define LTC_FORTUNA_WD    10
+#define LTC_FORTUNA_WD 10
 /* number of pools (4..32) can save a bit of ram by lowering the count */
 #define LTC_FORTUNA_POOLS 32
 
@@ -328,7 +328,7 @@
 #define LTC_ECC_SHAMIR
 
 #if defined(TFM_LTC_DESC) && defined(LTC_MECC)
-    #define LTC_MECC_ACCEL
+#define LTC_MECC_ACCEL
 #endif
 
 /* do we want fixed point ECC */
@@ -355,32 +355,33 @@
 #ifdef LTC_MECC
 /* Supported ECC Key Sizes */
 #ifndef LTC_NO_CURVES
-    #define ECC112
-    #define ECC128
-    #define ECC160
-    #define ECC192
-    #define ECC224
-    #define ECC256
-    #define ECC384
-    #define ECC521
+#define ECC112
+#define ECC128
+#define ECC160
+#define ECC192
+#define ECC224
+#define ECC256
+#define ECC384
+#define ECC521
 #endif
 #endif
 
 #if defined(LTC_MECC) || defined(LTC_MRSA) || defined(LTC_MDSA) || defined(MKATJA)
-    /* Include the MPI functionality?  (required by the PK algorithms) */
-    #define MPI
+/* Include the MPI functionality?  (required by the PK algorithms) */
+#define MPI
 #endif
 
 #ifdef LTC_MRSA
-    #define LTC_PKCS_1
+#define LTC_PKCS_1
 #endif
 
 #if defined(LTC_DER) && !defined(MPI)
-    #error ASN.1 DER requires MPI functionality
+#error ASN.1 DER requires MPI functionality
 #endif
 
-#if (defined(LTC_MDSA) || defined(LTC_MRSA) || defined(LTC_MECC) || defined(MKATJA)) && !defined(LTC_DER)
-    #error PK requires ASN.1 DER functionality, make sure LTC_DER is enabled
+#if (defined(LTC_MDSA) || defined(LTC_MRSA) || defined(LTC_MECC) || defined(MKATJA)) && \
+    !defined(LTC_DER)
+#error PK requires ASN.1 DER functionality, make sure LTC_DER is enabled
 #endif
 
 /* THREAD management */
@@ -388,12 +389,12 @@
 
 #include <pthread.h>
 
-#define LTC_MUTEX_GLOBAL(x)   pthread_mutex_t x = PTHREAD_MUTEX_INITIALIZER;
-#define LTC_MUTEX_PROTO(x)    extern pthread_mutex_t x;
-#define LTC_MUTEX_TYPE(x)     pthread_mutex_t x;
-#define LTC_MUTEX_INIT(x)     pthread_mutex_init(x, NULL);
-#define LTC_MUTEX_LOCK(x)     pthread_mutex_lock(x);
-#define LTC_MUTEX_UNLOCK(x)   pthread_mutex_unlock(x);
+#define LTC_MUTEX_GLOBAL(x) pthread_mutex_t x = PTHREAD_MUTEX_INITIALIZER;
+#define LTC_MUTEX_PROTO(x) extern pthread_mutex_t x;
+#define LTC_MUTEX_TYPE(x) pthread_mutex_t x;
+#define LTC_MUTEX_INIT(x) pthread_mutex_init(x, NULL);
+#define LTC_MUTEX_LOCK(x) pthread_mutex_lock(x);
+#define LTC_MUTEX_UNLOCK(x) pthread_mutex_unlock(x);
 
 #else
 
@@ -415,7 +416,6 @@
 #endif
 
 
-
 /* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_custom.h,v $ */
 /* $Revision: 1.73 $ */
 /* $Date: 2007/05/12 14:37:41 $ */
diff --git a/src/mongo/crypto/tom/tomcrypt_hash.h b/src/mongo/crypto/tom/tomcrypt_hash.h
index dbd559de0c5..7060353d4c2 100644
--- a/src/mongo/crypto/tom/tomcrypt_hash.h
+++ b/src/mongo/crypto/tom/tomcrypt_hash.h
@@ -16,7 +16,7 @@
 /* ---- HASH FUNCTIONS ---- */
 #ifdef LTC_SHA512
 struct sha512_state {
-    ulong64  length, state[8];
+    ulong64 length, state[8];
     unsigned long curlen;
     unsigned char buf[128];
 };
@@ -132,19 +132,19 @@ typedef union Hash_state {
     struct sha256_state sha256;
 #endif
 #ifdef LTC_SHA1
-    struct sha1_state   sha1;
+    struct sha1_state sha1;
 #endif
 #ifdef LTC_MD5
-    struct md5_state    md5;
+    struct md5_state md5;
 #endif
 #ifdef LTC_MD4
-    struct md4_state    md4;
+    struct md4_state md4;
 #endif
 #ifdef LTC_MD2
-    struct md2_state    md2;
+    struct md2_state md2;
 #endif
 #ifdef LTC_TIGER
-    struct tiger_state  tiger;
+    struct tiger_state tiger;
 #endif
 #ifdef LTC_RIPEMD128
     struct rmd128_state rmd128;
@@ -158,13 +158,13 @@ typedef union Hash_state {
 #ifdef LTC_RIPEMD320
     struct rmd320_state rmd320;
 #endif
-    void *data;
+    void* data;
 } hash_state;
 
 /** hash descriptor */
-extern  struct ltc_hash_descriptor {
+extern struct ltc_hash_descriptor {
     /** name of hash */
-    char *name;
+    char* name;
     /** internal ID */
     unsigned char ID;
     /** Size of digest in octets */
@@ -180,214 +180,222 @@ extern  struct ltc_hash_descriptor {
       @param hash   The hash to initialize
       @return CRYPT_OK if successful
     */
-    int (*init)(hash_state *hash);
+    int (*init)(hash_state* hash);
     /** Process a block of data
       @param hash   The hash state
       @param in     The data to hash
       @param inlen  The length of the data (octets)
       @return CRYPT_OK if successful
     */
-    int (*process)(hash_state *hash, const unsigned char *in, unsigned long inlen);
+    int (*process)(hash_state* hash, const unsigned char* in, unsigned long inlen);
     /** Produce the digest and store it
       @param hash   The hash state
       @param out    [out] The destination of the digest
       @return CRYPT_OK if successful
     */
-    int (*done)(hash_state *hash, unsigned char *out);
+    int (*done)(hash_state* hash, unsigned char* out);
     /** Self-test
       @return CRYPT_OK if successful, CRYPT_NOP if self-tests have been disabled
     */
     int (*test)(void);
 
     /* accelerated hmac callback: if you need to-do multiple packets just use the generic hmac_memory and provide a hash callback */
-    int  (*hmac_block)(const unsigned char *key, unsigned long  keylen,
-                       const unsigned char *in,  unsigned long  inlen, 
-                             unsigned char *out, unsigned long *outlen);
+    int (*hmac_block)(const unsigned char* key,
+                      unsigned long keylen,
+                      const unsigned char* in,
+                      unsigned long inlen,
+                      unsigned char* out,
+                      unsigned long* outlen);
 
 } hash_descriptor[];
 
 #ifdef LTC_CHC_HASH
 int chc_register(int cipher);
-int chc_init(hash_state * md);
-int chc_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int chc_done(hash_state * md, unsigned char *hash);
+int chc_init(hash_state* md);
+int chc_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int chc_done(hash_state* md, unsigned char* hash);
 int chc_test(void);
 extern const struct ltc_hash_descriptor chc_desc;
 #endif
 
 #ifdef LTC_WHIRLPOOL
-int whirlpool_init(hash_state * md);
-int whirlpool_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int whirlpool_done(hash_state * md, unsigned char *hash);
+int whirlpool_init(hash_state* md);
+int whirlpool_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int whirlpool_done(hash_state* md, unsigned char* hash);
 int whirlpool_test(void);
 extern const struct ltc_hash_descriptor whirlpool_desc;
 #endif
 
 #ifdef LTC_SHA512
-int sha512_init(hash_state * md);
-int sha512_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int sha512_done(hash_state * md, unsigned char *hash);
+int sha512_init(hash_state* md);
+int sha512_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int sha512_done(hash_state* md, unsigned char* hash);
 int sha512_test(void);
 extern const struct ltc_hash_descriptor sha512_desc;
 #endif
 
 #ifdef LTC_SHA384
 #ifndef LTC_SHA512
-    #error LTC_SHA512 is required for LTC_SHA384
+#error LTC_SHA512 is required for LTC_SHA384
 #endif
-int sha384_init(hash_state * md);
+int sha384_init(hash_state* md);
 #define sha384_process sha512_process
-int sha384_done(hash_state * md, unsigned char *hash);
+int sha384_done(hash_state* md, unsigned char* hash);
 int sha384_test(void);
 extern const struct ltc_hash_descriptor sha384_desc;
 #endif
 
 #ifdef LTC_SHA256
-int sha256_init(hash_state * md);
-int sha256_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int sha256_done(hash_state * md, unsigned char *hash);
+int sha256_init(hash_state* md);
+int sha256_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int sha256_done(hash_state* md, unsigned char* hash);
 int sha256_test(void);
 extern const struct ltc_hash_descriptor sha256_desc;
 
 #ifdef LTC_SHA224
 #ifndef LTC_SHA256
-    #error LTC_SHA256 is required for LTC_SHA224
+#error LTC_SHA256 is required for LTC_SHA224
 #endif
-int sha224_init(hash_state * md);
+int sha224_init(hash_state* md);
 #define sha224_process sha256_process
-int sha224_done(hash_state * md, unsigned char *hash);
+int sha224_done(hash_state* md, unsigned char* hash);
 int sha224_test(void);
 extern const struct ltc_hash_descriptor sha224_desc;
 #endif
 #endif
 
 #ifdef LTC_SHA1
-int sha1_init(hash_state * md);
-int sha1_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int sha1_done(hash_state * md, unsigned char *hash);
+int sha1_init(hash_state* md);
+int sha1_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int sha1_done(hash_state* md, unsigned char* hash);
 int sha1_test(void);
 extern const struct ltc_hash_descriptor sha1_desc;
 #endif
 
 #ifdef LTC_MD5
-int md5_init(hash_state * md);
-int md5_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int md5_done(hash_state * md, unsigned char *hash);
+int md5_init(hash_state* md);
+int md5_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int md5_done(hash_state* md, unsigned char* hash);
 int md5_test(void);
 extern const struct ltc_hash_descriptor md5_desc;
 #endif
 
 #ifdef LTC_MD4
-int md4_init(hash_state * md);
-int md4_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int md4_done(hash_state * md, unsigned char *hash);
+int md4_init(hash_state* md);
+int md4_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int md4_done(hash_state* md, unsigned char* hash);
 int md4_test(void);
 extern const struct ltc_hash_descriptor md4_desc;
 #endif
 
 #ifdef LTC_MD2
-int md2_init(hash_state * md);
-int md2_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int md2_done(hash_state * md, unsigned char *hash);
+int md2_init(hash_state* md);
+int md2_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int md2_done(hash_state* md, unsigned char* hash);
 int md2_test(void);
 extern const struct ltc_hash_descriptor md2_desc;
 #endif
 
 #ifdef LTC_TIGER
-int tiger_init(hash_state * md);
-int tiger_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int tiger_done(hash_state * md, unsigned char *hash);
+int tiger_init(hash_state* md);
+int tiger_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int tiger_done(hash_state* md, unsigned char* hash);
 int tiger_test(void);
 extern const struct ltc_hash_descriptor tiger_desc;
 #endif
 
 #ifdef LTC_RIPEMD128
-int rmd128_init(hash_state * md);
-int rmd128_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int rmd128_done(hash_state * md, unsigned char *hash);
+int rmd128_init(hash_state* md);
+int rmd128_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int rmd128_done(hash_state* md, unsigned char* hash);
 int rmd128_test(void);
 extern const struct ltc_hash_descriptor rmd128_desc;
 #endif
 
 #ifdef LTC_RIPEMD160
-int rmd160_init(hash_state * md);
-int rmd160_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int rmd160_done(hash_state * md, unsigned char *hash);
+int rmd160_init(hash_state* md);
+int rmd160_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int rmd160_done(hash_state* md, unsigned char* hash);
 int rmd160_test(void);
 extern const struct ltc_hash_descriptor rmd160_desc;
 #endif
 
 #ifdef LTC_RIPEMD256
-int rmd256_init(hash_state * md);
-int rmd256_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int rmd256_done(hash_state * md, unsigned char *hash);
+int rmd256_init(hash_state* md);
+int rmd256_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int rmd256_done(hash_state* md, unsigned char* hash);
 int rmd256_test(void);
 extern const struct ltc_hash_descriptor rmd256_desc;
 #endif
 
 #ifdef LTC_RIPEMD320
-int rmd320_init(hash_state * md);
-int rmd320_process(hash_state * md, const unsigned char *in, unsigned long inlen);
-int rmd320_done(hash_state * md, unsigned char *hash);
+int rmd320_init(hash_state* md);
+int rmd320_process(hash_state* md, const unsigned char* in, unsigned long inlen);
+int rmd320_done(hash_state* md, unsigned char* hash);
 int rmd320_test(void);
 extern const struct ltc_hash_descriptor rmd320_desc;
 #endif
 
 
-int find_hash(const char *name);
+int find_hash(const char* name);
 int find_hash_id(unsigned char ID);
-int find_hash_oid(const unsigned long *ID, unsigned long IDlen);
-int find_hash_any(const char *name, int digestlen);
-int register_hash(const struct ltc_hash_descriptor *hash);
-int unregister_hash(const struct ltc_hash_descriptor *hash);
+int find_hash_oid(const unsigned long* ID, unsigned long IDlen);
+int find_hash_any(const char* name, int digestlen);
+int register_hash(const struct ltc_hash_descriptor* hash);
+int unregister_hash(const struct ltc_hash_descriptor* hash);
 int hash_is_valid(int idx);
 
 LTC_MUTEX_PROTO(ltc_hash_mutex)
 
 int hash_memory(int hash,
-                const unsigned char *in,  unsigned long inlen,
-                      unsigned char *out, unsigned long *outlen);
-int hash_memory_multi(int hash, unsigned char *out, unsigned long *outlen,
-                      const unsigned char *in, unsigned long inlen, ...);
-int hash_filehandle(int hash, FILE *in, unsigned char *out, unsigned long *outlen);
-int hash_file(int hash, const char *fname, unsigned char *out, unsigned long *outlen);
+                const unsigned char* in,
+                unsigned long inlen,
+                unsigned char* out,
+                unsigned long* outlen);
+int hash_memory_multi(int hash,
+                      unsigned char* out,
+                      unsigned long* outlen,
+                      const unsigned char* in,
+                      unsigned long inlen,
+                      ...);
+int hash_filehandle(int hash, FILE* in, unsigned char* out, unsigned long* outlen);
+int hash_file(int hash, const char* fname, unsigned char* out, unsigned long* outlen);
 
 /* a simple macro for making hash "process" functions */
-#define HASH_PROCESS(func_name, compress_name, state_var, block_size)                       \
-int func_name (hash_state * md, const unsigned char *in, unsigned long inlen)               \
-{                                                                                           \
-    unsigned long n;                                                                        \
-    int           err;                                                                      \
-    LTC_ARGCHK(md != NULL);                                                                 \
-    LTC_ARGCHK(in != NULL);                                                                 \
-    if (md-> state_var .curlen > sizeof(md-> state_var .buf)) {                             \
-       return CRYPT_INVALID_ARG;                                                            \
-    }                                                                                       \
-    while (inlen > 0) {                                                                     \
-        if (md-> state_var .curlen == 0 && inlen >= block_size) {                           \
-           if ((err = compress_name (md, (unsigned char *)in)) != CRYPT_OK) {               \
-              return err;                                                                   \
-           }                                                                                \
-           md-> state_var .length += block_size * 8;                                        \
-           in             += block_size;                                                    \
-           inlen          -= block_size;                                                    \
-        } else {                                                                            \
-           n = MIN(inlen, (block_size - md-> state_var .curlen));                           \
-           memcpy(md-> state_var .buf + md-> state_var.curlen, in, (size_t)n);              \
-           md-> state_var .curlen += n;                                                     \
-           in             += n;                                                             \
-           inlen          -= n;                                                             \
-           if (md-> state_var .curlen == block_size) {                                      \
-              if ((err = compress_name (md, md-> state_var .buf)) != CRYPT_OK) {            \
-                 return err;                                                                \
-              }                                                                             \
-              md-> state_var .length += 8*block_size;                                       \
-              md-> state_var .curlen = 0;                                                   \
-           }                                                                                \
-       }                                                                                    \
-    }                                                                                       \
-    return CRYPT_OK;                                                                        \
-}
+#define HASH_PROCESS(func_name, compress_name, state_var, block_size)               \
+    int func_name(hash_state* md, const unsigned char* in, unsigned long inlen) {   \
+        unsigned long n;                                                            \
+        int err;                                                                    \
+        LTC_ARGCHK(md != NULL);                                                     \
+        LTC_ARGCHK(in != NULL);                                                     \
+        if (md->state_var.curlen > sizeof(md->state_var.buf)) {                     \
+            return CRYPT_INVALID_ARG;                                               \
+        }                                                                           \
+        while (inlen > 0) {                                                         \
+            if (md->state_var.curlen == 0 && inlen >= block_size) {                 \
+                if ((err = compress_name(md, (unsigned char*)in)) != CRYPT_OK) {    \
+                    return err;                                                     \
+                }                                                                   \
+                md->state_var.length += block_size * 8;                             \
+                in += block_size;                                                   \
+                inlen -= block_size;                                                \
+            } else {                                                                \
+                n = MIN(inlen, (block_size - md->state_var.curlen));                \
+                memcpy(md->state_var.buf + md->state_var.curlen, in, (size_t)n);    \
+                md->state_var.curlen += n;                                          \
+                in += n;                                                            \
+                inlen -= n;                                                         \
+                if (md->state_var.curlen == block_size) {                           \
+                    if ((err = compress_name(md, md->state_var.buf)) != CRYPT_OK) { \
+                        return err;                                                 \
+                    }                                                               \
+                    md->state_var.length += 8 * block_size;                         \
+                    md->state_var.curlen = 0;                                       \
+                }                                                                   \
+            }                                                                       \
+        }                                                                           \
+        return CRYPT_OK;                                                            \
+    }
 
 /* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_hash.h,v $ */
 /* $Revision: 1.22 $ */
diff --git a/src/mongo/crypto/tom/tomcrypt_mac.h b/src/mongo/crypto/tom/tomcrypt_mac.h
index b6fbcecc482..e850aa88a3a 100644
--- a/src/mongo/crypto/tom/tomcrypt_mac.h
+++ b/src/mongo/crypto/tom/tomcrypt_mac.h
@@ -15,196 +15,254 @@
 
 #ifdef LTC_HMAC
 typedef struct Hmac_state {
-     hash_state     md;
-     int            hash;
-     hash_state     hashstate;
-     unsigned char  *key;
+    hash_state md;
+    int hash;
+    hash_state hashstate;
+    unsigned char* key;
 } hmac_state;
 
-int hmac_init(hmac_state *hmac, int hash, const unsigned char *key, unsigned long keylen);
-int hmac_process(hmac_state *hmac, const unsigned char *in, unsigned long inlen);
-int hmac_done(hmac_state *hmac, unsigned char *out, unsigned long *outlen);
+int hmac_init(hmac_state* hmac, int hash, const unsigned char* key, unsigned long keylen);
+int hmac_process(hmac_state* hmac, const unsigned char* in, unsigned long inlen);
+int hmac_done(hmac_state* hmac, unsigned char* out, unsigned long* outlen);
 int hmac_test(void);
 int hmac_memory(int hash,
-                const unsigned char *key, unsigned long keylen,
-                const unsigned char *in,  unsigned long inlen,
-                      unsigned char *out, unsigned long *outlen);
+                const unsigned char* key,
+                unsigned long keylen,
+                const unsigned char* in,
+                unsigned long inlen,
+                unsigned char* out,
+                unsigned long* outlen);
 int hmac_memory_multi(int hash,
-                const unsigned char *key,  unsigned long keylen,
-                      unsigned char *out,  unsigned long *outlen,
-                const unsigned char *in,   unsigned long inlen, ...);
-int hmac_file(int hash, const char *fname, const unsigned char *key,
+                      const unsigned char* key,
+                      unsigned long keylen,
+                      unsigned char* out,
+                      unsigned long* outlen,
+                      const unsigned char* in,
+                      unsigned long inlen,
+                      ...);
+int hmac_file(int hash,
+              const char* fname,
+              const unsigned char* key,
               unsigned long keylen,
-              unsigned char *dst, unsigned long *dstlen);
+              unsigned char* dst,
+              unsigned long* dstlen);
 #endif
 
 #ifdef LTC_OMAC
 
 typedef struct {
-    int             cipher_idx,
-                    buflen,
-                    blklen;
-    unsigned char   block[MAXBLOCKSIZE],
-                    prev[MAXBLOCKSIZE],
-                    Lu[2][MAXBLOCKSIZE];
-    symmetric_key   key;
+    int cipher_idx, buflen, blklen;
+    unsigned char block[MAXBLOCKSIZE], prev[MAXBLOCKSIZE], Lu[2][MAXBLOCKSIZE];
+    symmetric_key key;
 } omac_state;
 
-int omac_init(omac_state *omac, int cipher, const unsigned char *key, unsigned long keylen);
-int omac_process(omac_state *omac, const unsigned char *in, unsigned long inlen);
-int omac_done(omac_state *omac, unsigned char *out, unsigned long *outlen);
+int omac_init(omac_state* omac, int cipher, const unsigned char* key, unsigned long keylen);
+int omac_process(omac_state* omac, const unsigned char* in, unsigned long inlen);
+int omac_done(omac_state* omac, unsigned char* out, unsigned long* outlen);
 int omac_memory(int cipher,
-               const unsigned char *key, unsigned long keylen,
-               const unsigned char *in,  unsigned long inlen,
-                     unsigned char *out, unsigned long *outlen);
+                const unsigned char* key,
+                unsigned long keylen,
+                const unsigned char* in,
+                unsigned long inlen,
+                unsigned char* out,
+                unsigned long* outlen);
 int omac_memory_multi(int cipher,
-                const unsigned char *key, unsigned long keylen,
-                      unsigned char *out, unsigned long *outlen,
-                const unsigned char *in,  unsigned long inlen, ...);
+                      const unsigned char* key,
+                      unsigned long keylen,
+                      unsigned char* out,
+                      unsigned long* outlen,
+                      const unsigned char* in,
+                      unsigned long inlen,
+                      ...);
 int omac_file(int cipher,
-              const unsigned char *key, unsigned long keylen,
-              const          char *filename,
-                    unsigned char *out, unsigned long *outlen);
+              const unsigned char* key,
+              unsigned long keylen,
+              const char* filename,
+              unsigned char* out,
+              unsigned long* outlen);
 int omac_test(void);
 #endif /* LTC_OMAC */
 
 #ifdef LTC_PMAC
 
 typedef struct {
-    unsigned char     Ls[32][MAXBLOCKSIZE],    /* L shifted by i bits to the left */
-                        Li[MAXBLOCKSIZE],        /* value of Li [current value, we calc from previous recall] */
-                        Lr[MAXBLOCKSIZE],        /* L * x^-1 */
-                        block[MAXBLOCKSIZE],     /* currently accumulated block */
-                        checksum[MAXBLOCKSIZE];  /* current checksum */
-
-    symmetric_key     key;                     /* scheduled key for cipher */
-    unsigned long     block_index;             /* index # for current block */
-    int               cipher_idx,              /* cipher idx */
-                        block_len,               /* length of block */
-                        buflen;                  /* number of bytes in the buffer */
+    unsigned char Ls[32][MAXBLOCKSIZE], /* L shifted by i bits to the left */
+        Li[MAXBLOCKSIZE],       /* value of Li [current value, we calc from previous recall] */
+        Lr[MAXBLOCKSIZE],       /* L * x^-1 */
+        block[MAXBLOCKSIZE],    /* currently accumulated block */
+        checksum[MAXBLOCKSIZE]; /* current checksum */
+
+    symmetric_key key;         /* scheduled key for cipher */
+    unsigned long block_index; /* index # for current block */
+    int cipher_idx,            /* cipher idx */
+        block_len,             /* length of block */
+        buflen;                /* number of bytes in the buffer */
 } pmac_state;
 
-int pmac_init(pmac_state *pmac, int cipher, const unsigned char *key, unsigned long keylen);
-int pmac_process(pmac_state *pmac, const unsigned char *in, unsigned long inlen);
-int pmac_done(pmac_state *pmac, unsigned char *out, unsigned long *outlen);
+int pmac_init(pmac_state* pmac, int cipher, const unsigned char* key, unsigned long keylen);
+int pmac_process(pmac_state* pmac, const unsigned char* in, unsigned long inlen);
+int pmac_done(pmac_state* pmac, unsigned char* out, unsigned long* outlen);
 
 int pmac_memory(int cipher,
-               const unsigned char *key, unsigned long keylen,
-               const unsigned char *msg, unsigned long msglen,
-                     unsigned char *out, unsigned long *outlen);
+                const unsigned char* key,
+                unsigned long keylen,
+                const unsigned char* msg,
+                unsigned long msglen,
+                unsigned char* out,
+                unsigned long* outlen);
 
 int pmac_memory_multi(int cipher,
-                const unsigned char *key, unsigned long keylen,
-                      unsigned char *out, unsigned long *outlen,
-                const unsigned char *in, unsigned long inlen, ...);
+                      const unsigned char* key,
+                      unsigned long keylen,
+                      unsigned char* out,
+                      unsigned long* outlen,
+                      const unsigned char* in,
+                      unsigned long inlen,
+                      ...);
 
 int pmac_file(int cipher,
-             const unsigned char *key, unsigned long keylen,
-             const          char *filename,
-                   unsigned char *out, unsigned long *outlen);
+              const unsigned char* key,
+              unsigned long keylen,
+              const char* filename,
+              unsigned char* out,
+              unsigned long* outlen);
 
 int pmac_test(void);
 
 /* internal functions */
 int pmac_ntz(unsigned long x);
-void pmac_shift_xor(pmac_state *pmac);
+void pmac_shift_xor(pmac_state* pmac);
 
 #endif /* PMAC */
 
 #ifdef LTC_EAX_MODE
 
 #if !(defined(LTC_OMAC) && defined(LTC_CTR_MODE))
-    #error LTC_EAX_MODE requires LTC_OMAC and CTR
+#error LTC_EAX_MODE requires LTC_OMAC and CTR
 #endif
 
 typedef struct {
     unsigned char N[MAXBLOCKSIZE];
     symmetric_CTR ctr;
-    omac_state    headeromac, ctomac;
+    omac_state headeromac, ctomac;
 } eax_state;
 
-int eax_init(eax_state *eax, int cipher, const unsigned char *key, unsigned long keylen,
-             const unsigned char *nonce, unsigned long noncelen,
-             const unsigned char *header, unsigned long headerlen);
+int eax_init(eax_state* eax,
+             int cipher,
+             const unsigned char* key,
+             unsigned long keylen,
+             const unsigned char* nonce,
+             unsigned long noncelen,
+             const unsigned char* header,
+             unsigned long headerlen);
 
-int eax_encrypt(eax_state *eax, const unsigned char *pt, unsigned char *ct, unsigned long length);
-int eax_decrypt(eax_state *eax, const unsigned char *ct, unsigned char *pt, unsigned long length);
-int eax_addheader(eax_state *eax, const unsigned char *header, unsigned long length);
-int eax_done(eax_state *eax, unsigned char *tag, unsigned long *taglen);
+int eax_encrypt(eax_state* eax, const unsigned char* pt, unsigned char* ct, unsigned long length);
+int eax_decrypt(eax_state* eax, const unsigned char* ct, unsigned char* pt, unsigned long length);
+int eax_addheader(eax_state* eax, const unsigned char* header, unsigned long length);
+int eax_done(eax_state* eax, unsigned char* tag, unsigned long* taglen);
 
 int eax_encrypt_authenticate_memory(int cipher,
-    const unsigned char *key,    unsigned long keylen,
-    const unsigned char *nonce,  unsigned long noncelen,
-    const unsigned char *header, unsigned long headerlen,
-    const unsigned char *pt,     unsigned long ptlen,
-          unsigned char *ct,
-          unsigned char *tag,    unsigned long *taglen);
+                                    const unsigned char* key,
+                                    unsigned long keylen,
+                                    const unsigned char* nonce,
+                                    unsigned long noncelen,
+                                    const unsigned char* header,
+                                    unsigned long headerlen,
+                                    const unsigned char* pt,
+                                    unsigned long ptlen,
+                                    unsigned char* ct,
+                                    unsigned char* tag,
+                                    unsigned long* taglen);
 
 int eax_decrypt_verify_memory(int cipher,
-    const unsigned char *key,    unsigned long keylen,
-    const unsigned char *nonce,  unsigned long noncelen,
-    const unsigned char *header, unsigned long headerlen,
-    const unsigned char *ct,     unsigned long ctlen,
-          unsigned char *pt,
-          unsigned char *tag,    unsigned long taglen,
-          int           *stat);
+                              const unsigned char* key,
+                              unsigned long keylen,
+                              const unsigned char* nonce,
+                              unsigned long noncelen,
+                              const unsigned char* header,
+                              unsigned long headerlen,
+                              const unsigned char* ct,
+                              unsigned long ctlen,
+                              unsigned char* pt,
+                              unsigned char* tag,
+                              unsigned long taglen,
+                              int* stat);
 
 int eax_test(void);
 #endif /* EAX MODE */
 
 #ifdef LTC_OCB_MODE
 typedef struct {
-    unsigned char     L[MAXBLOCKSIZE],         /* L value */
-                        Ls[32][MAXBLOCKSIZE],    /* L shifted by i bits to the left */
-                        Li[MAXBLOCKSIZE],        /* value of Li [current value, we calc from previous recall] */
-                        Lr[MAXBLOCKSIZE],        /* L * x^-1 */
-                        R[MAXBLOCKSIZE],         /* R value */
-                        checksum[MAXBLOCKSIZE];  /* current checksum */
-
-    symmetric_key     key;                     /* scheduled key for cipher */
-    unsigned long     block_index;             /* index # for current block */
-    int               cipher,                  /* cipher idx */
-                      block_len;               /* length of block */
+    unsigned char L[MAXBLOCKSIZE], /* L value */
+        Ls[32][MAXBLOCKSIZE],      /* L shifted by i bits to the left */
+        Li[MAXBLOCKSIZE],          /* value of Li [current value, we calc from previous recall] */
+        Lr[MAXBLOCKSIZE],          /* L * x^-1 */
+        R[MAXBLOCKSIZE],           /* R value */
+        checksum[MAXBLOCKSIZE];    /* current checksum */
+
+    symmetric_key key;         /* scheduled key for cipher */
+    unsigned long block_index; /* index # for current block */
+    int cipher,                /* cipher idx */
+        block_len;             /* length of block */
 } ocb_state;
 
-int ocb_init(ocb_state *ocb, int cipher,
-             const unsigned char *key, unsigned long keylen, const unsigned char *nonce);
-
-int ocb_encrypt(ocb_state *ocb, const unsigned char *pt, unsigned char *ct);
-int ocb_decrypt(ocb_state *ocb, const unsigned char *ct, unsigned char *pt);
-
-int ocb_done_encrypt(ocb_state *ocb,
-                     const unsigned char *pt,  unsigned long ptlen,
-                           unsigned char *ct,
-                           unsigned char *tag, unsigned long *taglen);
-
-int ocb_done_decrypt(ocb_state *ocb,
-                     const unsigned char *ct,  unsigned long ctlen,
-                           unsigned char *pt,
-                     const unsigned char *tag, unsigned long taglen, int *stat);
+int ocb_init(ocb_state* ocb,
+             int cipher,
+             const unsigned char* key,
+             unsigned long keylen,
+             const unsigned char* nonce);
+
+int ocb_encrypt(ocb_state* ocb, const unsigned char* pt, unsigned char* ct);
+int ocb_decrypt(ocb_state* ocb, const unsigned char* ct, unsigned char* pt);
+
+int ocb_done_encrypt(ocb_state* ocb,
+                     const unsigned char* pt,
+                     unsigned long ptlen,
+                     unsigned char* ct,
+                     unsigned char* tag,
+                     unsigned long* taglen);
+
+int ocb_done_decrypt(ocb_state* ocb,
+                     const unsigned char* ct,
+                     unsigned long ctlen,
+                     unsigned char* pt,
+                     const unsigned char* tag,
+                     unsigned long taglen,
+                     int* stat);
 
 int ocb_encrypt_authenticate_memory(int cipher,
-    const unsigned char *key,    unsigned long keylen,
-    const unsigned char *nonce,
-    const unsigned char *pt,     unsigned long ptlen,
-          unsigned char *ct,
-          unsigned char *tag,    unsigned long *taglen);
+                                    const unsigned char* key,
+                                    unsigned long keylen,
+                                    const unsigned char* nonce,
+                                    const unsigned char* pt,
+                                    unsigned long ptlen,
+                                    unsigned char* ct,
+                                    unsigned char* tag,
+                                    unsigned long* taglen);
 
 int ocb_decrypt_verify_memory(int cipher,
-    const unsigned char *key,    unsigned long keylen,
-    const unsigned char *nonce,
-    const unsigned char *ct,     unsigned long ctlen,
-          unsigned char *pt,
-    const unsigned char *tag,    unsigned long taglen,
-          int           *stat);
+                              const unsigned char* key,
+                              unsigned long keylen,
+                              const unsigned char* nonce,
+                              const unsigned char* ct,
+                              unsigned long ctlen,
+                              unsigned char* pt,
+                              const unsigned char* tag,
+                              unsigned long taglen,
+                              int* stat);
 
 int ocb_test(void);
 
 /* internal functions */
-void ocb_shift_xor(ocb_state *ocb, unsigned char *Z);
+void ocb_shift_xor(ocb_state* ocb, unsigned char* Z);
 int ocb_ntz(unsigned long x);
-int s_ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen,
-               unsigned char *ct, unsigned char *tag, unsigned long *taglen, int mode);
+int s_ocb_done(ocb_state* ocb,
+               const unsigned char* pt,
+               unsigned long ptlen,
+               unsigned char* ct,
+               unsigned char* tag,
+               unsigned long* taglen,
+               int mode);
 
 #endif /* LTC_OCB_MODE */
 
@@ -214,26 +272,32 @@ int s_ocb_done(ocb_state *ocb, const unsigned char *pt, unsigned long ptlen,
 #define CCM_DECRYPT 1
 
 int ccm_memory(int cipher,
-    const unsigned char *key,    unsigned long keylen,
-    symmetric_key       *uskey,
-    const unsigned char *nonce,  unsigned long noncelen,
-    const unsigned char *header, unsigned long headerlen,
-          unsigned char *pt,     unsigned long ptlen,
-          unsigned char *ct,
-          unsigned char *tag,    unsigned long *taglen,
-                    int  direction);
+               const unsigned char* key,
+               unsigned long keylen,
+               symmetric_key* uskey,
+               const unsigned char* nonce,
+               unsigned long noncelen,
+               const unsigned char* header,
+               unsigned long headerlen,
+               unsigned char* pt,
+               unsigned long ptlen,
+               unsigned char* ct,
+               unsigned char* tag,
+               unsigned long* taglen,
+               int direction);
 
 int ccm_test(void);
 
 #endif /* LTC_CCM_MODE */
 
 #if defined(LRW_MODE) || defined(LTC_GCM_MODE)
-void gcm_gf_mult(const unsigned char *a, const unsigned char *b, unsigned char *c);
+void gcm_gf_mult(const unsigned char* a, const unsigned char* b, unsigned char* c);
 #endif
 
 
 /* table shared between GCM and LRW */
-#if defined(LTC_GCM_TABLES) || defined(LRW_TABLES) || ((defined(LTC_GCM_MODE) || defined(LTC_GCM_MODE)) && defined(LTC_FAST))
+#if defined(LTC_GCM_TABLES) || defined(LRW_TABLES) || \
+    ((defined(LTC_GCM_MODE) || defined(LTC_GCM_MODE)) && defined(LTC_FAST))
 extern const unsigned char gcm_shift_table[];
 #endif
 
@@ -242,119 +306,125 @@ extern const unsigned char gcm_shift_table[];
 #define GCM_ENCRYPT 0
 #define GCM_DECRYPT 1
 
-#define LTC_GCM_MODE_IV    0
-#define LTC_GCM_MODE_AAD   1
-#define LTC_GCM_MODE_TEXT  2
+#define LTC_GCM_MODE_IV 0
+#define LTC_GCM_MODE_AAD 1
+#define LTC_GCM_MODE_TEXT 2
 
 typedef struct {
-    symmetric_key       K;
-    unsigned char       H[16],        /* multiplier */
-                        X[16],        /* accumulator */
-                        Y[16],        /* counter */
-                        Y_0[16],      /* initial counter */
-                        buf[16];      /* buffer for stuff */
+    symmetric_key K;
+    unsigned char H[16], /* multiplier */
+        X[16],           /* accumulator */
+        Y[16],           /* counter */
+        Y_0[16],         /* initial counter */
+        buf[16];         /* buffer for stuff */
 
-    int                 cipher,       /* which cipher */
-                        ivmode,       /* Which mode is the IV in? */
-                        mode,         /* mode the GCM code is in */
-                        buflen;       /* length of data in buf */
+    int cipher, /* which cipher */
+        ivmode, /* Which mode is the IV in? */
+        mode,   /* mode the GCM code is in */
+        buflen; /* length of data in buf */
 
-    ulong64             totlen,       /* 64-bit counter used for IV and AAD */
-                        pttotlen;     /* 64-bit counter for the PT */
+    ulong64 totlen, /* 64-bit counter used for IV and AAD */
+        pttotlen;   /* 64-bit counter for the PT */
 
 #ifdef LTC_GCM_TABLES
-    unsigned char       PC[16][256][16]  /* 16 tables of 8x128 */
+    unsigned char PC[16][256][16] /* 16 tables of 8x128 */
 #ifdef LTC_GCM_TABLES_SSE2
-__attribute__ ((aligned (16)))
+        __attribute__((aligned(16)))
 #endif
-;
+        ;
 #endif
 } gcm_state;
 
-void gcm_mult_h(gcm_state *gcm, unsigned char *I);
+void gcm_mult_h(gcm_state* gcm, unsigned char* I);
 
-int gcm_init(gcm_state *gcm, int cipher,
-             const unsigned char *key, int keylen);
+int gcm_init(gcm_state* gcm, int cipher, const unsigned char* key, int keylen);
 
-int gcm_reset(gcm_state *gcm);
+int gcm_reset(gcm_state* gcm);
 
-int gcm_add_iv(gcm_state *gcm,
-               const unsigned char *IV,     unsigned long IVlen);
+int gcm_add_iv(gcm_state* gcm, const unsigned char* IV, unsigned long IVlen);
 
-int gcm_add_aad(gcm_state *gcm,
-               const unsigned char *adata,  unsigned long adatalen);
+int gcm_add_aad(gcm_state* gcm, const unsigned char* adata, unsigned long adatalen);
 
-int gcm_process(gcm_state *gcm,
-                     unsigned char *pt,     unsigned long ptlen,
-                     unsigned char *ct,
-                     int direction);
+int gcm_process(
+    gcm_state* gcm, unsigned char* pt, unsigned long ptlen, unsigned char* ct, int direction);
 
-int gcm_done(gcm_state *gcm,
-                     unsigned char *tag,    unsigned long *taglen);
+int gcm_done(gcm_state* gcm, unsigned char* tag, unsigned long* taglen);
 
-int gcm_memory(      int           cipher,
-               const unsigned char *key,    unsigned long keylen,
-               const unsigned char *IV,     unsigned long IVlen,
-               const unsigned char *adata,  unsigned long adatalen,
-                     unsigned char *pt,     unsigned long ptlen,
-                     unsigned char *ct,
-                     unsigned char *tag,    unsigned long *taglen,
-                               int direction);
+int gcm_memory(int cipher,
+               const unsigned char* key,
+               unsigned long keylen,
+               const unsigned char* IV,
+               unsigned long IVlen,
+               const unsigned char* adata,
+               unsigned long adatalen,
+               unsigned char* pt,
+               unsigned long ptlen,
+               unsigned char* ct,
+               unsigned char* tag,
+               unsigned long* taglen,
+               int direction);
 int gcm_test(void);
 
 #endif /* LTC_GCM_MODE */
 
 #ifdef LTC_PELICAN
 
-typedef struct pelican_state
-{
+typedef struct pelican_state {
     symmetric_key K;
     unsigned char state[16];
-    int           buflen;
+    int buflen;
 } pelican_state;
 
-int pelican_init(pelican_state *pelmac, const unsigned char *key, unsigned long keylen);
-int pelican_process(pelican_state *pelmac, const unsigned char *in, unsigned long inlen);
-int pelican_done(pelican_state *pelmac, unsigned char *out);
+int pelican_init(pelican_state* pelmac, const unsigned char* key, unsigned long keylen);
+int pelican_process(pelican_state* pelmac, const unsigned char* in, unsigned long inlen);
+int pelican_done(pelican_state* pelmac, unsigned char* out);
 int pelican_test(void);
 
-int pelican_memory(const unsigned char *key, unsigned long keylen,
-                   const unsigned char *in, unsigned long inlen,
-                         unsigned char *out);
+int pelican_memory(const unsigned char* key,
+                   unsigned long keylen,
+                   const unsigned char* in,
+                   unsigned long inlen,
+                   unsigned char* out);
 
 #endif
 
 #ifdef LTC_XCBC
 
 /* add this to "keylen" to xcbc_init to use a pure three-key XCBC MAC */
-#define LTC_XCBC_PURE  0x8000UL
+#define LTC_XCBC_PURE 0x8000UL
 
 typedef struct {
-    unsigned char K[3][MAXBLOCKSIZE],
-                    IV[MAXBLOCKSIZE];
+    unsigned char K[3][MAXBLOCKSIZE], IV[MAXBLOCKSIZE];
 
     symmetric_key key;
 
-                int cipher,
-                    buflen,
-                    blocksize;
+    int cipher, buflen, blocksize;
 } xcbc_state;
 
-int xcbc_init(xcbc_state *xcbc, int cipher, const unsigned char *key, unsigned long keylen);
-int xcbc_process(xcbc_state *xcbc, const unsigned char *in, unsigned long inlen);
-int xcbc_done(xcbc_state *xcbc, unsigned char *out, unsigned long *outlen);
+int xcbc_init(xcbc_state* xcbc, int cipher, const unsigned char* key, unsigned long keylen);
+int xcbc_process(xcbc_state* xcbc, const unsigned char* in, unsigned long inlen);
+int xcbc_done(xcbc_state* xcbc, unsigned char* out, unsigned long* outlen);
 int xcbc_memory(int cipher,
-               const unsigned char *key, unsigned long keylen,
-               const unsigned char *in,  unsigned long inlen,
-                     unsigned char *out, unsigned long *outlen);
+                const unsigned char* key,
+                unsigned long keylen,
+                const unsigned char* in,
+                unsigned long inlen,
+                unsigned char* out,
+                unsigned long* outlen);
 int xcbc_memory_multi(int cipher,
-                const unsigned char *key, unsigned long keylen,
-                      unsigned char *out, unsigned long *outlen,
-                const unsigned char *in,  unsigned long inlen, ...);
+                      const unsigned char* key,
+                      unsigned long keylen,
+                      unsigned char* out,
+                      unsigned long* outlen,
+                      const unsigned char* in,
+                      unsigned long inlen,
+                      ...);
 int xcbc_file(int cipher,
-              const unsigned char *key, unsigned long keylen,
-              const          char *filename,
-                    unsigned char *out, unsigned long *outlen);
+              const unsigned char* key,
+              unsigned long keylen,
+              const char* filename,
+              unsigned char* out,
+              unsigned long* outlen);
 int xcbc_test(void);
 
 #endif
@@ -362,33 +432,37 @@ int xcbc_test(void);
 #ifdef LTC_F9_MODE
 
 typedef struct {
-    unsigned char akey[MAXBLOCKSIZE],
-                    ACC[MAXBLOCKSIZE],
-                    IV[MAXBLOCKSIZE];
+    unsigned char akey[MAXBLOCKSIZE], ACC[MAXBLOCKSIZE], IV[MAXBLOCKSIZE];
 
     symmetric_key key;
 
-                int cipher,
-                    buflen,
-                    keylen,
-                    blocksize;
+    int cipher, buflen, keylen, blocksize;
 } f9_state;
 
-int f9_init(f9_state *f9, int cipher, const unsigned char *key, unsigned long keylen);
-int f9_process(f9_state *f9, const unsigned char *in, unsigned long inlen);
-int f9_done(f9_state *f9, unsigned char *out, unsigned long *outlen);
+int f9_init(f9_state* f9, int cipher, const unsigned char* key, unsigned long keylen);
+int f9_process(f9_state* f9, const unsigned char* in, unsigned long inlen);
+int f9_done(f9_state* f9, unsigned char* out, unsigned long* outlen);
 int f9_memory(int cipher,
-               const unsigned char *key, unsigned long keylen,
-               const unsigned char *in,  unsigned long inlen,
-                     unsigned char *out, unsigned long *outlen);
+              const unsigned char* key,
+              unsigned long keylen,
+              const unsigned char* in,
+              unsigned long inlen,
+              unsigned char* out,
+              unsigned long* outlen);
 int f9_memory_multi(int cipher,
-                const unsigned char *key, unsigned long keylen,
-                      unsigned char *out, unsigned long *outlen,
-                const unsigned char *in,  unsigned long inlen, ...);
+                    const unsigned char* key,
+                    unsigned long keylen,
+                    unsigned char* out,
+                    unsigned long* outlen,
+                    const unsigned char* in,
+                    unsigned long inlen,
+                    ...);
 int f9_file(int cipher,
-              const unsigned char *key, unsigned long keylen,
-              const          char *filename,
-                    unsigned char *out, unsigned long *outlen);
+            const unsigned char* key,
+            unsigned long keylen,
+            const char* filename,
+            unsigned char* out,
+            unsigned long* outlen);
 int f9_test(void);
 
 #endif
diff --git a/src/mongo/crypto/tom/tomcrypt_macros.h b/src/mongo/crypto/tom/tomcrypt_macros.h
index 80d52105673..e043c2bb36d 100644
--- a/src/mongo/crypto/tom/tomcrypt_macros.h
+++ b/src/mongo/crypto/tom/tomcrypt_macros.h
@@ -15,99 +15,131 @@
 
 /* fix for MSVC ...evil! */
 #ifdef _MSC_VER
-    #define CONST64(n) n ## ui64
-    typedef unsigned __int64 ulong64;
+#define CONST64(n) n##ui64
+typedef unsigned __int64 ulong64;
 #else
-    #define CONST64(n) n ## ULL
-    typedef unsigned long long ulong64;
+#define CONST64(n) n##ULL
+typedef unsigned long long ulong64;
 #endif
 
 /* this is the "32-bit at least" data type
  * Re-define it to suit your platform but it must be at least 32-bits
  */
 #if defined(__x86_64__) || (defined(__sparc__) && defined(__arch64__))
-    typedef unsigned ulong32;
+typedef unsigned ulong32;
 #else
-    typedef unsigned long ulong32;
+typedef unsigned long ulong32;
 #endif
 
 /* ---- HELPER MACROS ---- */
 #ifdef ENDIAN_NEUTRAL
 
-#define STORE32L(x, y)                                                                     \
-     { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255);   \
-       (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
-
-#define LOAD32L(x, y)                            \
-     { x = ((unsigned long)((y)[3] & 255)<<24) | \
-           ((unsigned long)((y)[2] & 255)<<16) | \
-           ((unsigned long)((y)[1] & 255)<<8)  | \
-           ((unsigned long)((y)[0] & 255)); }
-
-#define STORE64L(x, y)                                                                     \
-     { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255);   \
-       (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255);   \
-       (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255);   \
-       (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
-
-#define LOAD64L(x, y)                                                       \
-     { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \
-           (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \
-           (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \
-           (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); }
-
-#define STORE32H(x, y)                                                                     \
-     { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255);   \
-       (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); }
-
-#define LOAD32H(x, y)                            \
-     { x = ((unsigned long)((y)[0] & 255)<<24) | \
-           ((unsigned long)((y)[1] & 255)<<16) | \
-           ((unsigned long)((y)[2] & 255)<<8)  | \
-           ((unsigned long)((y)[3] & 255)); }
-
-#define STORE64H(x, y)                                                                     \
-    { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255);     \
-        (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255);     \
-        (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255);     \
-        (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); }
-
-#define LOAD64H(x, y)                                                      \
-    { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \
-            (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \
-            (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \
-            (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); }
+#define STORE32L(x, y)                               \
+    {                                                \
+        (y)[3] = (unsigned char)(((x) >> 24) & 255); \
+        (y)[2] = (unsigned char)(((x) >> 16) & 255); \
+        (y)[1] = (unsigned char)(((x) >> 8) & 255);  \
+        (y)[0] = (unsigned char)((x)&255);           \
+    }
+
+#define LOAD32L(x, y)                                                                       \
+    {                                                                                       \
+        x = ((unsigned long)((y)[3] & 255) << 24) | ((unsigned long)((y)[2] & 255) << 16) | \
+            ((unsigned long)((y)[1] & 255) << 8) | ((unsigned long)((y)[0] & 255));         \
+    }
+
+#define STORE64L(x, y)                               \
+    {                                                \
+        (y)[7] = (unsigned char)(((x) >> 56) & 255); \
+        (y)[6] = (unsigned char)(((x) >> 48) & 255); \
+        (y)[5] = (unsigned char)(((x) >> 40) & 255); \
+        (y)[4] = (unsigned char)(((x) >> 32) & 255); \
+        (y)[3] = (unsigned char)(((x) >> 24) & 255); \
+        (y)[2] = (unsigned char)(((x) >> 16) & 255); \
+        (y)[1] = (unsigned char)(((x) >> 8) & 255);  \
+        (y)[0] = (unsigned char)((x)&255);           \
+    }
+
+#define LOAD64L(x, y)                                                               \
+    {                                                                               \
+        x = (((ulong64)((y)[7] & 255)) << 56) | (((ulong64)((y)[6] & 255)) << 48) | \
+            (((ulong64)((y)[5] & 255)) << 40) | (((ulong64)((y)[4] & 255)) << 32) | \
+            (((ulong64)((y)[3] & 255)) << 24) | (((ulong64)((y)[2] & 255)) << 16) | \
+            (((ulong64)((y)[1] & 255)) << 8) | (((ulong64)((y)[0] & 255)));         \
+    }
+
+#define STORE32H(x, y)                               \
+    {                                                \
+        (y)[0] = (unsigned char)(((x) >> 24) & 255); \
+        (y)[1] = (unsigned char)(((x) >> 16) & 255); \
+        (y)[2] = (unsigned char)(((x) >> 8) & 255);  \
+        (y)[3] = (unsigned char)((x)&255);           \
+    }
+
+#define LOAD32H(x, y)                                                                       \
+    {                                                                                       \
+        x = ((unsigned long)((y)[0] & 255) << 24) | ((unsigned long)((y)[1] & 255) << 16) | \
+            ((unsigned long)((y)[2] & 255) << 8) | ((unsigned long)((y)[3] & 255));         \
+    }
+
+#define STORE64H(x, y)                               \
+    {                                                \
+        (y)[0] = (unsigned char)(((x) >> 56) & 255); \
+        (y)[1] = (unsigned char)(((x) >> 48) & 255); \
+        (y)[2] = (unsigned char)(((x) >> 40) & 255); \
+        (y)[3] = (unsigned char)(((x) >> 32) & 255); \
+        (y)[4] = (unsigned char)(((x) >> 24) & 255); \
+        (y)[5] = (unsigned char)(((x) >> 16) & 255); \
+        (y)[6] = (unsigned char)(((x) >> 8) & 255);  \
+        (y)[7] = (unsigned char)((x)&255);           \
+    }
+
+#define LOAD64H(x, y)                                                               \
+    {                                                                               \
+        x = (((ulong64)((y)[0] & 255)) << 56) | (((ulong64)((y)[1] & 255)) << 48) | \
+            (((ulong64)((y)[2] & 255)) << 40) | (((ulong64)((y)[3] & 255)) << 32) | \
+            (((ulong64)((y)[4] & 255)) << 24) | (((ulong64)((y)[5] & 255)) << 16) | \
+            (((ulong64)((y)[6] & 255)) << 8) | (((ulong64)((y)[7] & 255)));         \
+    }
 
 #endif /* ENDIAN_NEUTRAL */
 
 #ifdef ENDIAN_LITTLE
 
-#if !defined(LTC_NO_BSWAP) && (defined(INTEL_CC) || (defined(__GNUC__) && (defined(__DJGPP__) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__i386__) || defined(__x86_64__))))
-
-#define STORE32H(x, y)           \
-asm __volatile__ (               \
-    "bswapl %0     \n\t"          \
-    "movl   %0,(%1)\n\t"          \
-    "bswapl %0     \n\t"          \
-        ::"r"(x), "r"(y));
-
-#define LOAD32H(x, y)          \
-asm __volatile__ (             \
-    "movl (%1),%0\n\t"          \
-    "bswapl %0\n\t"             \
-    :"=r"(x): "r"(y));
+#if !defined(LTC_NO_BSWAP) &&                                                                    \
+    (defined(INTEL_CC) ||                                                                        \
+     (defined(__GNUC__) && (defined(__DJGPP__) || defined(__CYGWIN__) || defined(__MINGW32__) || \
+                            defined(__i386__) || defined(__x86_64__))))
+
+#define STORE32H(x, y)                 \
+    asm __volatile__(                  \
+        "bswapl %0     \n\t"           \
+        "movl   %0,(%1)\n\t"           \
+        "bswapl %0     \n\t" ::"r"(x), \
+        "r"(y));
+
+#define LOAD32H(x, y)      \
+    asm __volatile__(      \
+        "movl (%1),%0\n\t" \
+        "bswapl %0\n\t"    \
+        : "=r"(x)          \
+        : "r"(y));
 
 #else
 
-#define STORE32H(x, y)                                                                     \
-    { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255);   \
-    (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); }
+#define STORE32H(x, y)                               \
+    {                                                \
+        (y)[0] = (unsigned char)(((x) >> 24) & 255); \
+        (y)[1] = (unsigned char)(((x) >> 16) & 255); \
+        (y)[2] = (unsigned char)(((x) >> 8) & 255);  \
+        (y)[3] = (unsigned char)((x)&255);           \
+    }
 
-#define LOAD32H(x, y)                            \
-    { x = ((unsigned long)((y)[0] & 255)<<24) | \
-        ((unsigned long)((y)[1] & 255)<<16) | \
-        ((unsigned long)((y)[2] & 255)<<8)  | \
-        ((unsigned long)((y)[3] & 255)); }
+#define LOAD32H(x, y)                                                                       \
+    {                                                                                       \
+        x = ((unsigned long)((y)[0] & 255) << 24) | ((unsigned long)((y)[1] & 255) << 16) | \
+            ((unsigned long)((y)[2] & 255) << 8) | ((unsigned long)((y)[3] & 255));         \
+    }
 
 #endif
 
@@ -115,67 +147,95 @@ asm __volatile__ (             \
 /* x86_64 processor */
 #if !defined(LTC_NO_BSWAP) && (defined(__GNUC__) && defined(__x86_64__))
 
-#define STORE64H(x, y)           \
-asm __volatile__ (               \
-    "bswapq %0     \n\t"          \
-    "movq   %0,(%1)\n\t"          \
-    "bswapq %0     \n\t"          \
-        ::"r"(x), "r"(y));
+#define STORE64H(x, y)                 \
+    asm __volatile__(                  \
+        "bswapq %0     \n\t"           \
+        "movq   %0,(%1)\n\t"           \
+        "bswapq %0     \n\t" ::"r"(x), \
+        "r"(y));
 
-#define LOAD64H(x, y)          \
-asm __volatile__ (             \
-    "movq (%1),%0\n\t"          \
-    "bswapq %0\n\t"             \
-    :"=r"(x): "r"(y));
+#define LOAD64H(x, y)      \
+    asm __volatile__(      \
+        "movq (%1),%0\n\t" \
+        "bswapq %0\n\t"    \
+        : "=r"(x)          \
+        : "r"(y));
 
 #else
 
-#define STORE64H(x, y)                                                                     \
-    { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255);     \
-        (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255);     \
-        (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255);     \
-        (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); }
-
-#define LOAD64H(x, y)                                                      \
-    { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \
-            (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \
-            (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \
-            (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); }
+#define STORE64H(x, y)                               \
+    {                                                \
+        (y)[0] = (unsigned char)(((x) >> 56) & 255); \
+        (y)[1] = (unsigned char)(((x) >> 48) & 255); \
+        (y)[2] = (unsigned char)(((x) >> 40) & 255); \
+        (y)[3] = (unsigned char)(((x) >> 32) & 255); \
+        (y)[4] = (unsigned char)(((x) >> 24) & 255); \
+        (y)[5] = (unsigned char)(((x) >> 16) & 255); \
+        (y)[6] = (unsigned char)(((x) >> 8) & 255);  \
+        (y)[7] = (unsigned char)((x)&255);           \
+    }
+
+#define LOAD64H(x, y)                                                               \
+    {                                                                               \
+        x = (((ulong64)((y)[0] & 255)) << 56) | (((ulong64)((y)[1] & 255)) << 48) | \
+            (((ulong64)((y)[2] & 255)) << 40) | (((ulong64)((y)[3] & 255)) << 32) | \
+            (((ulong64)((y)[4] & 255)) << 24) | (((ulong64)((y)[5] & 255)) << 16) | \
+            (((ulong64)((y)[6] & 255)) << 8) | (((ulong64)((y)[7] & 255)));         \
+    }
 
 #endif
 
 #ifdef ENDIAN_32BITWORD
 
-#define STORE32L(x, y)        \
-    { ulong32  __t = (x); XMEMCPY(y, &__t, 4); }
-
-#define LOAD32L(x, y)         \
-    XMEMCPY(&(x), y, 4);
-
-#define STORE64L(x, y)                                                                     \
-    { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255);   \
-    (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255);   \
-    (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255);   \
-    (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
-
-#define LOAD64L(x, y)                                                       \
-    { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \
-        (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \
-        (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \
-        (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); }
+#define STORE32L(x, y)       \
+    {                        \
+        ulong32 __t = (x);   \
+        XMEMCPY(y, &__t, 4); \
+    }
+
+#define LOAD32L(x, y) XMEMCPY(&(x), y, 4);
+
+#define STORE64L(x, y)                               \
+    {                                                \
+        (y)[7] = (unsigned char)(((x) >> 56) & 255); \
+        (y)[6] = (unsigned char)(((x) >> 48) & 255); \
+        (y)[5] = (unsigned char)(((x) >> 40) & 255); \
+        (y)[4] = (unsigned char)(((x) >> 32) & 255); \
+        (y)[3] = (unsigned char)(((x) >> 24) & 255); \
+        (y)[2] = (unsigned char)(((x) >> 16) & 255); \
+        (y)[1] = (unsigned char)(((x) >> 8) & 255);  \
+        (y)[0] = (unsigned char)((x)&255);           \
+    }
+
+#define LOAD64L(x, y)                                                               \
+    {                                                                               \
+        x = (((ulong64)((y)[7] & 255)) << 56) | (((ulong64)((y)[6] & 255)) << 48) | \
+            (((ulong64)((y)[5] & 255)) << 40) | (((ulong64)((y)[4] & 255)) << 32) | \
+            (((ulong64)((y)[3] & 255)) << 24) | (((ulong64)((y)[2] & 255)) << 16) | \
+            (((ulong64)((y)[1] & 255)) << 8) | (((ulong64)((y)[0] & 255)));         \
+    }
 
 #else /* 64-bit words then  */
 
-#define STORE32L(x, y)        \
-    { ulong32 __t = (x); XMEMCPY(y, &__t, 4); }
-
-#define LOAD32L(x, y)         \
-    { XMEMCPY(&(x), y, 4); x &= 0xFFFFFFFF; }
-
-#define STORE64L(x, y)        \
-    { ulong64 __t = (x); XMEMCPY(y, &__t, 8); }
-
-#define LOAD64L(x, y)         \
+#define STORE32L(x, y)       \
+    {                        \
+        ulong32 __t = (x);   \
+        XMEMCPY(y, &__t, 4); \
+    }
+
+#define LOAD32L(x, y)        \
+    {                        \
+        XMEMCPY(&(x), y, 4); \
+        x &= 0xFFFFFFFF;     \
+    }
+
+#define STORE64L(x, y)       \
+    {                        \
+        ulong64 __t = (x);   \
+        XMEMCPY(y, &__t, 8); \
+    }
+
+#define LOAD64L(x, y) \
     { XMEMCPY(&(x), y, 8); }
 
 #endif /* ENDIAN_64BITWORD */
@@ -183,67 +243,99 @@ asm __volatile__ (             \
 #endif /* ENDIAN_LITTLE */
 
 #ifdef ENDIAN_BIG
-#define STORE32L(x, y)                                                                     \
-    { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255);   \
-      (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
-
-#define LOAD32L(x, y)                            \
-    { x = ((unsigned long)((y)[3] & 255)<<24) | \
-          ((unsigned long)((y)[2] & 255)<<16) | \
-          ((unsigned long)((y)[1] & 255)<<8)  | \
-          ((unsigned long)((y)[0] & 255)); }
-
-#define STORE64L(x, y)                                                                     \
-    { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255);     \
-      (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255);     \
-      (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255);     \
-      (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); }
-
-#define LOAD64L(x, y)                                                      \
-    { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48) | \
-          (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32) | \
-          (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16) | \
-          (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); }
+#define STORE32L(x, y)                               \
+    {                                                \
+        (y)[3] = (unsigned char)(((x) >> 24) & 255); \
+        (y)[2] = (unsigned char)(((x) >> 16) & 255); \
+        (y)[1] = (unsigned char)(((x) >> 8) & 255);  \
+        (y)[0] = (unsigned char)((x)&255);           \
+    }
+
+#define LOAD32L(x, y)                                                                       \
+    {                                                                                       \
+        x = ((unsigned long)((y)[3] & 255) << 24) | ((unsigned long)((y)[2] & 255) << 16) | \
+            ((unsigned long)((y)[1] & 255) << 8) | ((unsigned long)((y)[0] & 255));         \
+    }
+
+#define STORE64L(x, y)                               \
+    {                                                \
+        (y)[7] = (unsigned char)(((x) >> 56) & 255); \
+        (y)[6] = (unsigned char)(((x) >> 48) & 255); \
+        (y)[5] = (unsigned char)(((x) >> 40) & 255); \
+        (y)[4] = (unsigned char)(((x) >> 32) & 255); \
+        (y)[3] = (unsigned char)(((x) >> 24) & 255); \
+        (y)[2] = (unsigned char)(((x) >> 16) & 255); \
+        (y)[1] = (unsigned char)(((x) >> 8) & 255);  \
+        (y)[0] = (unsigned char)((x)&255);           \
+    }
+
+#define LOAD64L(x, y)                                                               \
+    {                                                                               \
+        x = (((ulong64)((y)[7] & 255)) << 56) | (((ulong64)((y)[6] & 255)) << 48) | \
+            (((ulong64)((y)[5] & 255)) << 40) | (((ulong64)((y)[4] & 255)) << 32) | \
+            (((ulong64)((y)[3] & 255)) << 24) | (((ulong64)((y)[2] & 255)) << 16) | \
+            (((ulong64)((y)[1] & 255)) << 8) | (((ulong64)((y)[0] & 255)));         \
+    }
 
 #ifdef ENDIAN_32BITWORD
 
-#define STORE32H(x, y)        \
-    { ulong32 __t = (x); XMEMCPY(y, &__t, 4); }
-
-#define LOAD32H(x, y)         \
-    XMEMCPY(&(x), y, 4);
-
-#define STORE64H(x, y)                                                                     \
-    { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255);   \
-      (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255);   \
-      (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255);   \
-      (y)[6] = (unsigned char)(((x)>>8)&255);  (y)[7] = (unsigned char)((x)&255); }
-
-#define LOAD64H(x, y)                                                       \
-    { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48)| \
-          (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32)| \
-          (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16)| \
-          (((ulong64)((y)[6] & 255))<<8)| (((ulong64)((y)[7] & 255))); }
+#define STORE32H(x, y)       \
+    {                        \
+        ulong32 __t = (x);   \
+        XMEMCPY(y, &__t, 4); \
+    }
+
+#define LOAD32H(x, y) XMEMCPY(&(x), y, 4);
+
+#define STORE64H(x, y)                               \
+    {                                                \
+        (y)[0] = (unsigned char)(((x) >> 56) & 255); \
+        (y)[1] = (unsigned char)(((x) >> 48) & 255); \
+        (y)[2] = (unsigned char)(((x) >> 40) & 255); \
+        (y)[3] = (unsigned char)(((x) >> 32) & 255); \
+        (y)[4] = (unsigned char)(((x) >> 24) & 255); \
+        (y)[5] = (unsigned char)(((x) >> 16) & 255); \
+        (y)[6] = (unsigned char)(((x) >> 8) & 255);  \
+        (y)[7] = (unsigned char)((x)&255);           \
+    }
+
+#define LOAD64H(x, y)                                                               \
+    {                                                                               \
+        x = (((ulong64)((y)[0] & 255)) << 56) | (((ulong64)((y)[1] & 255)) << 48) | \
+            (((ulong64)((y)[2] & 255)) << 40) | (((ulong64)((y)[3] & 255)) << 32) | \
+            (((ulong64)((y)[4] & 255)) << 24) | (((ulong64)((y)[5] & 255)) << 16) | \
+            (((ulong64)((y)[6] & 255)) << 8) | (((ulong64)((y)[7] & 255)));         \
+    }
 
 #else /* 64-bit words then  */
 
-#define STORE32H(x, y)        \
-    { ulong32 __t = (x); XMEMCPY(y, &__t, 4); }
-
-#define LOAD32H(x, y)         \
-    { XMEMCPY(&(x), y, 4); x &= 0xFFFFFFFF; }
-
-#define STORE64H(x, y)        \
-    { ulong64 __t = (x); XMEMCPY(y, &__t, 8); }
-
-#define LOAD64H(x, y)         \
+#define STORE32H(x, y)       \
+    {                        \
+        ulong32 __t = (x);   \
+        XMEMCPY(y, &__t, 4); \
+    }
+
+#define LOAD32H(x, y)        \
+    {                        \
+        XMEMCPY(&(x), y, 4); \
+        x &= 0xFFFFFFFF;     \
+    }
+
+#define STORE64H(x, y)       \
+    {                        \
+        ulong64 __t = (x);   \
+        XMEMCPY(y, &__t, 8); \
+    }
+
+#define LOAD64H(x, y) \
     { XMEMCPY(&(x), y, 8); }
 
 #endif /* ENDIAN_64BITWORD */
 #endif /* ENDIAN_BIG */
 
-#define BSWAP(x)  ( ((x>>24)&0x000000FFUL) | ((x<<24)&0xFF000000UL)  | \
-                    ((x>>8)&0x0000FF00UL)  | ((x<<8)&0x00FF0000UL) )
+#define BSWAP(x)                                                                           \
+    (((x >> 24) & 0x000000FFUL) | ((x << 24) & 0xFF000000UL) | ((x >> 8) & 0x0000FF00UL) | \
+     ((x << 8) & 0x00FF0000UL))
 
 
 /* 32-bit Rotates */
@@ -251,45 +343,34 @@ asm __volatile__ (             \
 
 /* instrinsic rotate */
 #include <stdlib.h>
-#pragma intrinsic(_lrotr,_lrotl)
-#define ROR(x,n) _lrotr(x,n)
-#define ROL(x,n) _lrotl(x,n)
-#define RORc(x,n) _lrotr(x,n)
-#define ROLc(x,n) _lrotl(x,n)
-
-#elif !defined(__STRICT_ANSI__) && defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && !defined(INTEL_CC) && !defined(LTC_NO_ASM)
-
-static inline unsigned ROL(unsigned word, int i)
-{
-    asm ("roll %%cl,%0"
-        :"=r" (word)
-        :"0" (word),"c" (i));
+#pragma intrinsic(_lrotr, _lrotl)
+#define ROR(x, n) _lrotr(x, n)
+#define ROL(x, n) _lrotl(x, n)
+#define RORc(x, n) _lrotr(x, n)
+#define ROLc(x, n) _lrotl(x, n)
+
+#elif !defined(__STRICT_ANSI__) && defined(__GNUC__) && \
+    (defined(__i386__) || defined(__x86_64__)) && !defined(INTEL_CC) && !defined(LTC_NO_ASM)
+
+static inline unsigned ROL(unsigned word, int i) {
+    asm("roll %%cl,%0" : "=r"(word) : "0"(word), "c"(i));
     return word;
 }
 
-static inline unsigned ROR(unsigned word, int i)
-{
-    asm ("rorl %%cl,%0"
-        :"=r" (word)
-        :"0" (word),"c" (i));
+static inline unsigned ROR(unsigned word, int i) {
+    asm("rorl %%cl,%0" : "=r"(word) : "0"(word), "c"(i));
     return word;
 }
 
 #ifndef LTC_NO_ROLC
 
-static inline unsigned ROLc(unsigned word, const int i)
-{
-    asm ("roll %2,%0"
-        :"=r" (word)
-        :"0" (word),"I" (i));
+static inline unsigned ROLc(unsigned word, const int i) {
+    asm("roll %2,%0" : "=r"(word) : "0"(word), "I"(i));
     return word;
 }
 
-static inline unsigned RORc(unsigned word, const int i)
-{
-    asm ("rorl %2,%0"
-        :"=r" (word)
-        :"0" (word),"I" (i));
+static inline unsigned RORc(unsigned word, const int i) {
+    asm("rorl %2,%0" : "=r"(word) : "0"(word), "I"(i));
     return word;
 }
 
@@ -302,37 +383,25 @@ static inline unsigned RORc(unsigned word, const int i)
 
 #elif !defined(__STRICT_ANSI__) && defined(LTC_PPC32)
 
-static inline unsigned ROL(unsigned word, int i)
-{
-    asm ("rotlw %0,%0,%2"
-        :"=r" (word)
-        :"0" (word),"r" (i));
+static inline unsigned ROL(unsigned word, int i) {
+    asm("rotlw %0,%0,%2" : "=r"(word) : "0"(word), "r"(i));
     return word;
 }
 
-static inline unsigned ROR(unsigned word, int i)
-{
-    asm ("rotlw %0,%0,%2"
-        :"=r" (word)
-        :"0" (word),"r" (32-i));
+static inline unsigned ROR(unsigned word, int i) {
+    asm("rotlw %0,%0,%2" : "=r"(word) : "0"(word), "r"(32 - i));
     return word;
 }
 
 #ifndef LTC_NO_ROLC
 
-static inline unsigned ROLc(unsigned word, const int i)
-{
-    asm ("rotlwi %0,%0,%2"
-        :"=r" (word)
-        :"0" (word),"I" (i));
+static inline unsigned ROLc(unsigned word, const int i) {
+    asm("rotlwi %0,%0,%2" : "=r"(word) : "0"(word), "I"(i));
     return word;
 }
 
-static inline unsigned RORc(unsigned word, const int i)
-{
-    asm ("rotrwi %0,%0,%2"
-        :"=r" (word)
-        :"0" (word),"I" (i));
+static inline unsigned RORc(unsigned word, const int i) {
+    asm("rotrwi %0,%0,%2" : "=r"(word) : "0"(word), "I"(i));
     return word;
 }
 
@@ -347,10 +416,22 @@ static inline unsigned RORc(unsigned word, const int i)
 #else
 
 /* rotates the hard way */
-#define ROL(x, y) ( (((unsigned long)(x)<<(unsigned long)((y)&31)) | (((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)
-#define ROR(x, y) ( ((((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)((y)&31)) | ((unsigned long)(x)<<(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)
-#define ROLc(x, y) ( (((unsigned long)(x)<<(unsigned long)((y)&31)) | (((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)
-#define RORc(x, y) ( ((((unsigned long)(x)&0xFFFFFFFFUL)>>(unsigned long)((y)&31)) | ((unsigned long)(x)<<(unsigned long)(32-((y)&31)))) & 0xFFFFFFFFUL)
+#define ROL(x, y)                                                              \
+    ((((unsigned long)(x) << (unsigned long)((y)&31)) |                        \
+      (((unsigned long)(x)&0xFFFFFFFFUL) >> (unsigned long)(32 - ((y)&31)))) & \
+     0xFFFFFFFFUL)
+#define ROR(x, y)                                                      \
+    (((((unsigned long)(x)&0xFFFFFFFFUL) >> (unsigned long)((y)&31)) | \
+      ((unsigned long)(x) << (unsigned long)(32 - ((y)&31)))) &        \
+     0xFFFFFFFFUL)
+#define ROLc(x, y)                                                             \
+    ((((unsigned long)(x) << (unsigned long)((y)&31)) |                        \
+      (((unsigned long)(x)&0xFFFFFFFFUL) >> (unsigned long)(32 - ((y)&31)))) & \
+     0xFFFFFFFFUL)
+#define RORc(x, y)                                                     \
+    (((((unsigned long)(x)&0xFFFFFFFFUL) >> (unsigned long)((y)&31)) | \
+      ((unsigned long)(x) << (unsigned long)(32 - ((y)&31)))) &        \
+     0xFFFFFFFFUL)
 
 #endif
 
@@ -358,37 +439,25 @@ static inline unsigned RORc(unsigned word, const int i)
 /* 64-bit Rotates */
 #if !defined(__STRICT_ANSI__) && defined(__GNUC__) && defined(__x86_64__) && !defined(LTC_NO_ASM)
 
-static inline unsigned long ROL64(unsigned long word, int i)
-{
-    asm("rolq %%cl,%0"
-        :"=r" (word)
-        :"0" (word),"c" (i));
+static inline unsigned long ROL64(unsigned long word, int i) {
+    asm("rolq %%cl,%0" : "=r"(word) : "0"(word), "c"(i));
     return word;
 }
 
-static inline unsigned long ROR64(unsigned long word, int i)
-{
-    asm("rorq %%cl,%0"
-        :"=r" (word)
-        :"0" (word),"c" (i));
+static inline unsigned long ROR64(unsigned long word, int i) {
+    asm("rorq %%cl,%0" : "=r"(word) : "0"(word), "c"(i));
     return word;
 }
 
 #ifndef LTC_NO_ROLC
 
-static inline unsigned long ROL64c(unsigned long word, const int i)
-{
-    asm("rolq %2,%0"
-        :"=r" (word)
-        :"0" (word),"J" (i));
+static inline unsigned long ROL64c(unsigned long word, const int i) {
+    asm("rolq %2,%0" : "=r"(word) : "0"(word), "J"(i));
     return word;
 }
 
-static inline unsigned long ROR64c(unsigned long word, const int i)
-{
-    asm("rorq %2,%0"
-        :"=r" (word)
-        :"0" (word),"J" (i));
+static inline unsigned long ROR64c(unsigned long word, const int i) {
+    asm("rorq %2,%0" : "=r"(word) : "0"(word), "J"(i));
     return word;
 }
 
@@ -401,37 +470,41 @@ static inline unsigned long ROR64c(unsigned long word, const int i)
 
 #else /* Not x86_64  */
 
-#define ROL64(x, y) \
-    ( (((x)<<((ulong64)(y)&63)) | \
-      (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)64-((y)&63)))) & CONST64(0xFFFFFFFFFFFFFFFF))
+#define ROL64(x, y)                                                      \
+    ((((x) << ((ulong64)(y)&63)) |                                       \
+      (((x)&CONST64(0xFFFFFFFFFFFFFFFF)) >> ((ulong64)64 - ((y)&63)))) & \
+     CONST64(0xFFFFFFFFFFFFFFFF))
 
-#define ROR64(x, y) \
-    ( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \
-      ((x)<<((ulong64)(64-((y)&CONST64(63)))))) & CONST64(0xFFFFFFFFFFFFFFFF))
+#define ROR64(x, y)                                                       \
+    (((((x)&CONST64(0xFFFFFFFFFFFFFFFF)) >> ((ulong64)(y)&CONST64(63))) | \
+      ((x) << ((ulong64)(64 - ((y)&CONST64(63)))))) &                     \
+     CONST64(0xFFFFFFFFFFFFFFFF))
 
-#define ROL64c(x, y) \
-    ( (((x)<<((ulong64)(y)&63)) | \
-      (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)64-((y)&63)))) & CONST64(0xFFFFFFFFFFFFFFFF))
+#define ROL64c(x, y)                                                     \
+    ((((x) << ((ulong64)(y)&63)) |                                       \
+      (((x)&CONST64(0xFFFFFFFFFFFFFFFF)) >> ((ulong64)64 - ((y)&63)))) & \
+     CONST64(0xFFFFFFFFFFFFFFFF))
 
-#define ROR64c(x, y) \
-    ( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \
-      ((x)<<((ulong64)(64-((y)&CONST64(63)))))) & CONST64(0xFFFFFFFFFFFFFFFF))
+#define ROR64c(x, y)                                                      \
+    (((((x)&CONST64(0xFFFFFFFFFFFFFFFF)) >> ((ulong64)(y)&CONST64(63))) | \
+      ((x) << ((ulong64)(64 - ((y)&CONST64(63)))))) &                     \
+     CONST64(0xFFFFFFFFFFFFFFFF))
 
 #endif
 
 #ifndef MAX
-    #define MAX(x, y) ( ((x)>(y))?(x):(y) )
+#define MAX(x, y) (((x) > (y)) ? (x) : (y))
 #endif
 
 #ifndef MIN
-    #define MIN(x, y) ( ((x)<(y))?(x):(y) )
+#define MIN(x, y) (((x) < (y)) ? (x) : (y))
 #endif
 
 /* extract a byte portably */
 #ifdef _MSC_VER
-    #define byte(x, n) ((unsigned char)((x) >> (8 * (n))))
+#define byte(x, n) ((unsigned char)((x) >> (8 * (n))))
 #else
-    #define byte(x, n) (((x) >> (8 * (n))) & 255)
+#define byte(x, n) (((x) >> (8 * (n))) & 255)
 #endif
 
 /* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_macros.h,v $ */
diff --git a/src/mongo/crypto/tom/tomcrypt_misc.h b/src/mongo/crypto/tom/tomcrypt_misc.h
index dc8a0381c07..86559cf9852 100644
--- a/src/mongo/crypto/tom/tomcrypt_misc.h
+++ b/src/mongo/crypto/tom/tomcrypt_misc.h
@@ -15,23 +15,27 @@
 
 /* ---- LTC_BASE64 Routines ---- */
 #ifdef LTC_BASE64
-int base64_encode(const unsigned char *in,  unsigned long len, 
-                        unsigned char *out, unsigned long *outlen);
+int base64_encode(const unsigned char* in,
+                  unsigned long len,
+                  unsigned char* out,
+                  unsigned long* outlen);
 
-int base64_decode(const unsigned char *in,  unsigned long len, 
-                        unsigned char *out, unsigned long *outlen);
+int base64_decode(const unsigned char* in,
+                  unsigned long len,
+                  unsigned char* out,
+                  unsigned long* outlen);
 #endif
 
 /* ---- MEM routines ---- */
-void zeromem(void *dst, size_t len);
+void zeromem(void* dst, size_t len);
 void burn_stack(unsigned long len);
 
-const char *error_to_string(int err);
+const char* error_to_string(int err);
 
-extern const char *crypt_build_settings;
+extern const char* crypt_build_settings;
 
 /* ---- HMM ---- */
-int crypt_fsa(void *mp, ...);
+int crypt_fsa(void* mp, ...);
 
 /* $Source: /cvs/libtom/libtomcrypt/src/headers/tomcrypt_misc.h,v $ */
 /* $Revision: 1.5 $ */