aws-crt 0.1.9 → 0.2.0

data/aws-crt-ffi/crt/aws-lc/util/fipstools/acvp/acvptool/test/tests.json

@@ -18,6 +18,7 @@
 {"Wrapper": "modulewrapper", "In": "vectors/HMAC-SHA2-256.bz2", "Out": "expected/HMAC-SHA2-256.bz2"},
 {"Wrapper": "modulewrapper", "In": "vectors/HMAC-SHA2-384.bz2", "Out": "expected/HMAC-SHA2-384.bz2"},
 {"Wrapper": "modulewrapper", "In": "vectors/HMAC-SHA2-512.bz2", "Out": "expected/HMAC-SHA2-512.bz2"},
+{"Wrapper": "modulewrapper", "In": "vectors/HMAC-SHA2-512-224.bz2", "Out": "expected/HMAC-SHA2-512-224.bz2"},
 {"Wrapper": "modulewrapper", "In": "vectors/HMAC-SHA2-512-256.bz2", "Out": "expected/HMAC-SHA2-512-256.bz2"},
 {"Wrapper": "testmodulewrapper", "In": "vectors/hmacDRBG.bz2", "Out": "expected/hmacDRBG.bz2"},
 {"Wrapper": "modulewrapper", "In": "vectors/KAS-ECC-SSC.bz2"},

data/aws-crt-ffi/crt/aws-lc/util/fipstools/acvp/modulewrapper/main.cc

@@ -39,6 +39,10 @@ int main(int argc, char **argv) {
     puts("aarch64 (64-bit)");
 #elif defined(OPENSSL_PPC64LE)
     puts("PPC64LE (64-bit)");
+#elif defined(OPENSSL_PPC32BE)
+    puts("PPC32BE (32-bit)");
+#elif defined(OPENSSL_PPC64BE)
+    puts("PPC64BE (64-bit)");
 #else
 #error "FIPS build not supported on this architecture"
 #endif

data/aws-crt-ffi/crt/aws-lc/util/fipstools/acvp/modulewrapper/modulewrapper.cc

@@ -218,6 +218,14 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
         }],
         "performLargeDataTest": [1, 2, 4, 8]
       },
+      {
+        "algorithm": "SHA2-512/224",
+        "revision": "1.0",
+        "messageLength": [{
+          "min": 0, "max": 65528, "increment": 8
+        }],
+        "performLargeDataTest": [1, 2, 4, 8]
+      },
       {
         "algorithm": "SHA2-512/256",
         "revision": "1.0",
@@ -258,6 +266,22 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
           }],
         "performLargeDataTest": [1, 2, 4, 8]
       },
+      {
+        "algorithm": "SHAKE-128",
+        "revision": "2.0",
+        "messageLength": [{
+          "min": 0, "max": 65536, "increment": 8
+          }],
+        "performLargeDataTest": [1, 2, 4, 8]
+      },
+      {
+        "algorithm": "SHAKE-256",
+        "revision": "2.0",
+        "messageLength": [{
+          "min": 0, "max": 65536, "increment": 8
+          }],
+        "performLargeDataTest": [1, 2, 4, 8]
+      },
       {
         "algorithm": "SHA-1",
         "revision": "1.0",
@@ -425,6 +449,16 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
           "min": 32, "max": 512, "increment": 8
         }]
       },
+      {
+        "algorithm": "HMAC-SHA2-512/224",
+        "revision": "1.0",
+        "keyLen": [{
+          "min": 8, "max": 524288, "increment": 8
+        }],
+        "macLen": [{
+          "min": 32, "max": 224, "increment": 8
+        }]
+      },
       {
         "algorithm": "HMAC-SHA2-512/256",
         "revision": "1.0",
@@ -537,6 +571,7 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
             "SHA2-256",
             "SHA2-384",
             "SHA2-512",
+            "SHA2-512/224",
             "SHA2-512/256"
           ]
         }]
@@ -558,6 +593,7 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
             "SHA2-256",
             "SHA2-384",
             "SHA2-512",
+            "SHA2-512/224",
             "SHA2-512/256"
           ]
         }]
@@ -606,6 +642,8 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
               "hashAlg": "SHA2-384"
             }, {
               "hashAlg": "SHA2-512"
+            }, {
+              "hashAlg": "SHA2-512/224"
             }, {
               "hashAlg": "SHA2-512/256"
             }]
@@ -622,6 +660,8 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
               "hashAlg": "SHA2-384"
             }, {
               "hashAlg": "SHA2-512"
+            }, {
+              "hashAlg": "SHA2-512/224"
             }, {
               "hashAlg": "SHA2-512/256"
             }]
@@ -638,6 +678,8 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
               "hashAlg": "SHA2-384"
             }, {
               "hashAlg": "SHA2-512"
+            }, {
+              "hashAlg": "SHA2-512/224"
             }, {
               "hashAlg": "SHA2-512/256"
             }]
@@ -658,6 +700,9 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
             }, {
               "hashAlg": "SHA2-512",
               "saltLen": 64
+            }, {
+              "hashAlg": "SHA2-512/224",
+              "saltLen": 28
             }, {
               "hashAlg": "SHA2-512/256",
               "saltLen": 32
@@ -679,6 +724,9 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
             }, {
               "hashAlg": "SHA2-512",
               "saltLen": 64
+            }, {
+              "hashAlg": "SHA2-512/224",
+              "saltLen": 28
             }, {
               "hashAlg": "SHA2-512/256",
               "saltLen": 32
@@ -700,6 +748,9 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
             }, {
               "hashAlg": "SHA2-512",
               "saltLen": 64
+            }, {
+              "hashAlg": "SHA2-512/224",
+              "saltLen": 28
             }, {
               "hashAlg": "SHA2-512/256",
               "saltLen": 32
@@ -725,6 +776,8 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
               "hashAlg": "SHA2-384"
             }, {
               "hashAlg": "SHA2-512"
+            }, {
+              "hashAlg": "SHA2-512/224"
             }, {
               "hashAlg": "SHA2-512/256"
             }, {
@@ -743,6 +796,8 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
               "hashAlg": "SHA2-384"
             }, {
               "hashAlg": "SHA2-512"
+            }, {
+              "hashAlg": "SHA2-512/224"
             }, {
               "hashAlg": "SHA2-512/256"
             }, {
@@ -761,6 +816,8 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
               "hashAlg": "SHA2-384"
             }, {
               "hashAlg": "SHA2-512"
+            }, {
+              "hashAlg": "SHA2-512/224"
             }, {
               "hashAlg": "SHA2-512/256"
             }, {
@@ -779,6 +836,8 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
               "hashAlg": "SHA2-384"
             }, {
               "hashAlg": "SHA2-512"
+            }, {
+              "hashAlg": "SHA2-512/224"
             }, {
               "hashAlg": "SHA2-512/256"
             }, {
@@ -798,6 +857,9 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
             }, {
               "hashAlg": "SHA2-384",
               "saltLen": 48
+            }, {
+              "hashAlg": "SHA2-512/224",
+              "saltLen": 28
             }, {
               "hashAlg": "SHA2-512/256",
               "saltLen": 32
@@ -822,6 +884,9 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
             }, {
               "hashAlg": "SHA2-512",
               "saltLen": 64
+            }, {
+              "hashAlg": "SHA2-512/224",
+              "saltLen": 28
             }, {
               "hashAlg": "SHA2-512/256",
               "saltLen": 32
@@ -846,6 +911,9 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
             }, {
               "hashAlg": "SHA2-512",
               "saltLen": 64
+            }, {
+              "hashAlg": "SHA2-512/224",
+              "saltLen": 28
             }, {
               "hashAlg": "SHA2-512/256",
               "saltLen": 32
@@ -870,6 +938,9 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
             }, {
               "hashAlg": "SHA2-512",
               "saltLen": 64
+            }, {
+              "hashAlg": "SHA2-512/224",
+              "saltLen": 28
             }, {
               "hashAlg": "SHA2-512/256",
               "saltLen": 32
@@ -910,6 +981,7 @@ static bool GetConfig(const Span<const uint8_t> args[], ReplyCallback write_repl
             "HMAC-SHA2-256",
             "HMAC-SHA2-384",
             "HMAC-SHA2-512",
+            "HMAC-SHA2-512/224",
             "HMAC-SHA2-512/256"
           ],
           "customKeyInLength": 0,
@@ -1062,6 +1134,26 @@ static bool HashSha3(const Span<const uint8_t> args[], ReplyCallback write_reply
   return write_reply({Span<const uint8_t>(digest)});
 }
 
+template <const EVP_MD *(MDFunc)()>
+static bool HashXof(const Span<const uint8_t> args[], ReplyCallback write_reply) {
+  // NOTE: Max outLen in the test vectors is 1024 bits (128 bytes). If that
+  //       changes, we'll need to use a bigger stack-allocated array size here.
+  uint8_t digest[128];
+  const EVP_MD *md = MDFunc();
+  const uint8_t *outlen_bytes = args[1].data();
+  // MD outLen is passed to modulewrapper as a length-4 byte array representing
+  // a little-endian unsigned 32-bit integer.
+  uint32_t md_out_size = 0;
+  md_out_size |= outlen_bytes[3] << 24;
+  md_out_size |= outlen_bytes[2] << 16;
+  md_out_size |= outlen_bytes[1] << 8;
+  md_out_size |= outlen_bytes[0] << 0;
+
+  EVP_Digest(args[0].data(), args[0].size(), digest, &md_out_size, md, NULL);
+
+  return write_reply({Span<const uint8_t>(digest, md_out_size)});
+}
+
 template <uint8_t *(*OneShotHash)(const uint8_t *, size_t, uint8_t *),
           size_t DigestLength>
 static bool HashMCT(const Span<const uint8_t> args[],
@@ -1095,7 +1187,6 @@ static bool HashMCTSha3(const Span<const uint8_t> args[],
   const EVP_MD *evp_md = MDFunc();
   unsigned int md_out_size = DigestLength;
 
-
   // The following logic conforms to the Monte Carlo tests described in
   // https://pages.nist.gov/ACVP/draft-celi-acvp-sha3.html#name-monte-carlo-tests-for-sha3-
   unsigned char md[1001][DigestLength];
@@ -1112,6 +1203,39 @@ static bool HashMCTSha3(const Span<const uint8_t> args[],
       {Span<const uint8_t>(md[1000])});
 }
 
+template <const EVP_MD *(MDFunc)()>
+static bool HashMCTXof(const Span<const uint8_t> args[], ReplyCallback write_reply) {
+  // The spec for SHAKE monte carlo tests is written to be generic between a
+  // minimum and maximum output length, but the vectors obtained from ACVP
+  // allow only 1024 bits. Supporting dynamically sized MCTs would require
+  // passing the min/max output lengths to the modulewrapper, parsing ibid.,
+  // and dynamically allocating and freeing appropriately sized bufffers. To
+  // keep things simple, we defer that complexity until/if needed.
+  //
+  // https://pages.nist.gov/ACVP/draft-celi-acvp-sha3.html#name-shake-monte-carlo-test
+  const unsigned output_len = 1024/8;
+  const unsigned msg_size = 128/8;
+  const size_t array_len = 1001;
+  unsigned char md[array_len][output_len];
+  unsigned char msg[array_len][msg_size];
+
+  // Zero out |md| and |msg| to clear any residual stack garbage before XOF computation
+  for (size_t i = 0; i < array_len; i++) {
+    OPENSSL_cleanse(md[i], sizeof(md[0]) * sizeof(unsigned char));
+    OPENSSL_cleanse(msg[i], sizeof(msg[0]) * sizeof(unsigned char));
+  }
+
+  memcpy(md[0], args[0].data(), msg_size);
+
+  unsigned output_len_mut = output_len;
+  for (size_t i = 1; i < array_len; i++) {
+    memcpy(msg[i], md[i-1], msg_size);
+    EVP_Digest(msg[i], sizeof(msg[i]), md[i], &output_len_mut, MDFunc(), NULL);
+  }
+
+  return write_reply({Span<const uint8_t>(md[1000])});
+}
+
 // The following logic conforms to the Large Data Tests described in
 // https://pages.nist.gov/ACVP/draft-celi-acvp-sha.html#name-large-data-tests-for-sha-1-
 // Which are the same for SHA-1, SHA2, and SHA3
@@ -1893,8 +2017,14 @@ static const EVP_MD *HashFromName(Span<const uint8_t> name) {
     return EVP_sha384();
   } else if (StringEq(name, "SHA2-512")) {
     return EVP_sha512();
+  } else if (StringEq(name, "SHA2-512/224")) {
+    return EVP_sha512_224();
   } else if (StringEq(name, "SHA2-512/256")) {
     return EVP_sha512_256();
+  } else if  (StringEq(name, "SHAKE-128")) {
+    return EVP_shake128();
+  } else if  (StringEq(name, "SHAKE-256")) {
+    return EVP_shake256();
   } else {
     return nullptr;
   }
@@ -2390,26 +2520,33 @@ static struct {
     {"SHA2-256", 1, Hash<SHA256, SHA256_DIGEST_LENGTH>},
     {"SHA2-384", 1, Hash<SHA384, SHA384_DIGEST_LENGTH>},
     {"SHA2-512", 1, Hash<SHA512, SHA512_DIGEST_LENGTH>},
+    {"SHA2-512/224", 1, Hash<SHA512_224, SHA512_224_DIGEST_LENGTH>},
     {"SHA2-512/256", 1, Hash<SHA512_256, SHA512_256_DIGEST_LENGTH>},
     {"SHA3-224", 1, HashSha3<EVP_sha3_224, SHA224_DIGEST_LENGTH>},
     {"SHA3-256", 1, HashSha3<EVP_sha3_256, SHA256_DIGEST_LENGTH>},
     {"SHA3-384", 1, HashSha3<EVP_sha3_384, SHA384_DIGEST_LENGTH>},
     {"SHA3-512", 1, HashSha3<EVP_sha3_512, SHA512_DIGEST_LENGTH>},
+    {"SHAKE-128", 2, HashXof<EVP_shake128>},
+    {"SHAKE-256", 2, HashXof<EVP_shake256>},
     {"SHA-1/MCT", 1, HashMCT<SHA1, SHA_DIGEST_LENGTH>},
     {"SHA2-224/MCT", 1, HashMCT<SHA224, SHA224_DIGEST_LENGTH>},
     {"SHA2-256/MCT", 1, HashMCT<SHA256, SHA256_DIGEST_LENGTH>},
     {"SHA2-384/MCT", 1, HashMCT<SHA384, SHA384_DIGEST_LENGTH>},
     {"SHA2-512/MCT", 1, HashMCT<SHA512, SHA512_DIGEST_LENGTH>},
+    {"SHA2-512/224/MCT", 1, HashMCT<SHA512_224, SHA512_224_DIGEST_LENGTH>},
     {"SHA2-512/256/MCT", 1, HashMCT<SHA512_256, SHA512_256_DIGEST_LENGTH>},
     {"SHA3-224/MCT", 1, HashMCTSha3<EVP_sha3_224, SHA224_DIGEST_LENGTH>},
     {"SHA3-256/MCT", 1, HashMCTSha3<EVP_sha3_256, SHA256_DIGEST_LENGTH>},
     {"SHA3-384/MCT", 1, HashMCTSha3<EVP_sha3_384, SHA384_DIGEST_LENGTH>},
     {"SHA3-512/MCT", 1, HashMCTSha3<EVP_sha3_512, SHA512_DIGEST_LENGTH>},
+    {"SHAKE-128/MCT", 1, HashMCTXof<EVP_shake128>},
+    {"SHAKE-256/MCT", 1, HashMCTXof<EVP_shake256>},
     {"SHA-1/LDT", 2, HashLDT<SHA1, SHA_DIGEST_LENGTH>},
     {"SHA2-224/LDT", 2, HashLDT<SHA224, SHA224_DIGEST_LENGTH>},
     {"SHA2-256/LDT", 2, HashLDT<SHA256, SHA256_DIGEST_LENGTH>},
     {"SHA2-384/LDT", 2, HashLDT<SHA384, SHA384_DIGEST_LENGTH>},
     {"SHA2-512/LDT", 2, HashLDT<SHA512, SHA512_DIGEST_LENGTH>},
+    {"SHA2-512/224/LDT", 2, HashLDT<SHA512_224, SHA512_224_DIGEST_LENGTH>},
     {"SHA2-512/256/LDT", 2, HashLDT<SHA512_256, SHA512_256_DIGEST_LENGTH>},
     {"SHA3-224/LDT", 2, HashLDTSha3<EVP_sha3_224, SHA224_DIGEST_LENGTH>},
     {"SHA3-256/LDT", 2, HashLDTSha3<EVP_sha3_256, SHA256_DIGEST_LENGTH>},
@@ -2440,6 +2577,7 @@ static struct {
     {"HMAC-SHA2-256", 2, HMAC<EVP_sha256>},
     {"HMAC-SHA2-384", 2, HMAC<EVP_sha384>},
     {"HMAC-SHA2-512", 2, HMAC<EVP_sha512>},
+    {"HMAC-SHA2-512/224", 2, HMAC<EVP_sha512_224>},
     {"HMAC-SHA2-512/256", 2, HMAC<EVP_sha512_256>},
     {"ctrDRBG/AES-256", 6, DRBG<false>},
     {"ctrDRBG-reseed/AES-256", 8, DRBG<true>},
@@ -2454,24 +2592,28 @@ static struct {
     {"RSA/sigGen/SHA2-256/pkcs1v1.5", 2, RSASigGen<EVP_sha256, false>},
     {"RSA/sigGen/SHA2-384/pkcs1v1.5", 2, RSASigGen<EVP_sha384, false>},
     {"RSA/sigGen/SHA2-512/pkcs1v1.5", 2, RSASigGen<EVP_sha512, false>},
+    {"RSA/sigGen/SHA2-512/224/pkcs1v1.5", 2, RSASigGen<EVP_sha512_224, false>},
     {"RSA/sigGen/SHA2-512/256/pkcs1v1.5", 2, RSASigGen<EVP_sha512_256, false>},
     {"RSA/sigGen/SHA-1/pkcs1v1.5", 2, RSASigGen<EVP_sha1, false>},
     {"RSA/sigGen/SHA2-224/pss", 2, RSASigGen<EVP_sha224, true>},
     {"RSA/sigGen/SHA2-256/pss", 2, RSASigGen<EVP_sha256, true>},
     {"RSA/sigGen/SHA2-384/pss", 2, RSASigGen<EVP_sha384, true>},
     {"RSA/sigGen/SHA2-512/pss", 2, RSASigGen<EVP_sha512, true>},
+    {"RSA/sigGen/SHA2-512/224/pss", 2, RSASigGen<EVP_sha512_224, true>},
     {"RSA/sigGen/SHA2-512/256/pss", 2, RSASigGen<EVP_sha512_256, true>},
     {"RSA/sigGen/SHA-1/pss", 2, RSASigGen<EVP_sha1, true>},
     {"RSA/sigVer/SHA2-224/pkcs1v1.5", 4, RSASigVer<EVP_sha224, false>},
     {"RSA/sigVer/SHA2-256/pkcs1v1.5", 4, RSASigVer<EVP_sha256, false>},
     {"RSA/sigVer/SHA2-384/pkcs1v1.5", 4, RSASigVer<EVP_sha384, false>},
     {"RSA/sigVer/SHA2-512/pkcs1v1.5", 4, RSASigVer<EVP_sha512, false>},
+    {"RSA/sigVer/SHA2-512/224/pkcs1v1.5", 4, RSASigVer<EVP_sha512_224, false>},
     {"RSA/sigVer/SHA2-512/256/pkcs1v1.5", 4, RSASigVer<EVP_sha512_256, false>},
     {"RSA/sigVer/SHA-1/pkcs1v1.5", 4, RSASigVer<EVP_sha1, false>},
     {"RSA/sigVer/SHA2-224/pss", 4, RSASigVer<EVP_sha224, true>},
     {"RSA/sigVer/SHA2-256/pss", 4, RSASigVer<EVP_sha256, true>},
     {"RSA/sigVer/SHA2-384/pss", 4, RSASigVer<EVP_sha384, true>},
     {"RSA/sigVer/SHA2-512/pss", 4, RSASigVer<EVP_sha512, true>},
+    {"RSA/sigVer/SHA2-512/224/pss", 4, RSASigVer<EVP_sha512_224, true>},
     {"RSA/sigVer/SHA2-512/256/pss", 4, RSASigVer<EVP_sha512_256, true>},
     {"RSA/sigVer/SHA-1/pss", 4, RSASigVer<EVP_sha1, true>},
     {"TLSKDF/1.0/SHA-1", 5, TLSKDF<EVP_md5_sha1>},
@@ -2524,6 +2666,7 @@ static struct {
     {"KDF/Feedback/HMAC-SHA2-256", 3, HKDF_expand<EVP_sha256>},
     {"KDF/Feedback/HMAC-SHA2-384", 3, HKDF_expand<EVP_sha384>},
     {"KDF/Feedback/HMAC-SHA2-512", 3, HKDF_expand<EVP_sha512>},
+    {"KDF/Feedback/HMAC-SHA2-512/224", 3, HKDF_expand<EVP_sha512_224>},
     {"KDF/Feedback/HMAC-SHA2-512/256", 3, HKDF_expand<EVP_sha512_256>},
 };
 

data/aws-crt-ffi/crt/aws-lc/util/fipstools/delocate/delocate.go

@@ -451,6 +451,15 @@ func (d *delocation) loadAarch64Address(statement *node32, targetReg string, sym
 		// If the target happens to be x0 then restore the link register from the
 		// stack and send the saved value of x0 to the zero register.
 		d.output.WriteString("\tldp xzr, lr, [sp], #16\n")
+	} else if targetReg == "x30" {
+		// If the target is x30, restore x0 only because the lr (just an alias
+		// name for x30) register is used as a general-purpose register.
+		// We assume that if the target register is x30 then the routine handles
+		// returning the correct return address to x30 before the routine
+		// returns. One case requiring handling x30 is gcc 11.4 that emitted:
+		//   adrp x30, :got:__stack_chk_guard
+		d.output.WriteString("\tmov " + targetReg + ", x0\n")
+		d.output.WriteString("\tldp x0, xzr, [sp], #16\n")
 	} else {
 		// Otherwise move the result into place and restore registers.
 		d.output.WriteString("\tmov " + targetReg + ", x0\n")
@@ -2154,9 +2163,6 @@ func main() {
 		// preprocessor, but we don't want the compiler complaining that
 		// "argument unused during compilation".
 		cppCommand = append(cppCommand, "-Wno-unused-command-line-argument")
-		// We are preprocessing for assembly output and need to simulate that
-		// environment for arm_arch.h.
-		cppCommand = append(cppCommand, "-D__ASSEMBLER__=1")
 
 		for includePath := range includePaths {
 			cppCommand = append(cppCommand, "-I"+includePath)

data/aws-crt-ffi/crt/aws-lc/util/fipstools/delocate/testdata/aarch64-Basic/in.s

@@ -29,6 +29,10 @@ foo:
 	adrp x1, OPENSSL_armcap_P
 	ldr w2, [x1, :lo12:OPENSSL_armcap_P]
 
+	// armcap to x30
+	adrp x30, OPENSSL_armcap_P
+	ldr w2, [x30, :lo12:OPENSSL_armcap_P]
+
 	// armcap to w0
 	adrp x0, OPENSSL_armcap_P
 	ldr w1, [x1, :lo12:OPENSSL_armcap_P]

data/aws-crt-ffi/crt/aws-lc/util/fipstools/delocate/testdata/aarch64-Basic/out.s

@@ -64,6 +64,17 @@ foo:
 // WAS ldr w2, [x1, :lo12:OPENSSL_armcap_P]
 	ldr	w2, [x1]
 
+	// armcap to x30
+// WAS adrp x30, OPENSSL_armcap_P
+	sub sp, sp, 128
+	stp x0, lr, [sp, #-16]!
+	bl .LOPENSSL_armcap_P_addr
+	mov x30, x0
+	ldp x0, xzr, [sp], #16
+	add sp, sp, 128
+// WAS ldr w2, [x30, :lo12:OPENSSL_armcap_P]
+	ldr	w2, [x30]
+
 	// armcap to w0
 // WAS adrp x0, OPENSSL_armcap_P
 	sub sp, sp, 128

data/aws-crt-ffi/crt/aws-lc/util/fipstools/inject_hash/inject_hash.go

@@ -168,7 +168,6 @@ func doLinux(objectBytes []byte, isStatic bool) ([]byte, []byte, error) {
 	return moduleText, moduleROData, nil
 }
 
-
 func doAppleOS(objectBytes []byte) ([]byte, []byte, error) {
 
 	object, err := macho.NewFile(bytes.NewReader(objectBytes))
@@ -221,6 +220,19 @@ func doAppleOS(objectBytes []byte) ([]byte, []byte, error) {
 			return nil, nil, fmt.Errorf("symbol %q at %x, which is below base of %x\n", symbol.Name, symbol.Value, base)
 		}
 
+		// Skip debugging symbols
+		//
+		// #define	N_STAB	0xe0  /* if any of these bits set, a symbolic debugging entry */
+		//
+		// "Only symbolic debugging entries have some of the N_STAB bits set and if any of these bits are set then it is
+		// a symbolic debugging entry (a stab).  In which case then the values of the n_type field (the entire field)
+		// are given in <mach-o/stab.h>"
+		//
+		// https://github.com/apple-oss-distributions/xnu/blob/main/EXTERNAL_HEADERS/mach-o/nlist.h
+		if symbol.Type&0xe0 != 0 {
+			continue
+		}
+
 		value := symbol.Value - base
 		switch symbol.Name {
 		case "_BORINGSSL_bcm_text_start":
@@ -296,8 +308,6 @@ func doAppleOS(objectBytes []byte) ([]byte, []byte, error) {
 	return moduleText, moduleROData, nil
 }
 
-
-
 func do(outPath, oInput string, arInput string, appleOS bool) error {
 	var objectBytes []byte
 	var isStatic bool
@@ -365,7 +375,6 @@ func do(outPath, oInput string, arInput string, appleOS bool) error {
 		return err
 	}
 
-
 	var zeroKey [64]byte
 	mac := hmac.New(sha256.New, zeroKey[:])
 

data/aws-crt-ffi/crt/aws-lc/util/fipstools/test-break-kat.sh

@@ -40,3 +40,5 @@ for kat in $KATS; do
   rm ./break-kat-bin
 done
 echo "All tests broken as expected"
+
+go run util/fipstools/break-hash.go $TEST_FIPS_BIN ./libcrypto.so

data/aws-crt-ffi/crt/aws-lc/util/testconfig/testconfig.go

@@ -25,7 +25,8 @@ type Test struct {
 	SkipSDE       	bool     `json:"skip_sde"`
 	SkipValgrind 	bool 	 `json:"skip_valgrind"`
 	ValgrindSupp  	[]string `json:"valgrind_supp"`
-	TargetArch  	string 	`json:"target_arch"`
+	TargetArch  	string 	 `json:"target_arch"`
+	Shard           bool     `json:"shard"`
 }
 
 func ParseTestConfig(filename string) ([]Test, error) {

data/aws-crt-ffi/crt/s2n/api/s2n.h

@@ -2127,14 +2127,18 @@ S2N_API extern int s2n_connection_get_client_auth_type(struct s2n_connection *co
 S2N_API extern int s2n_connection_set_client_auth_type(struct s2n_connection *conn, s2n_cert_auth_type client_auth_type);
 
 /**
- * Gets the client certificate chain and places it in the `der_cert_chain_out` buffer. `cert_chain_len` is updated
- * to match the size the chain buffer.
+ * Gets the raw certificate chain received from the client.
  *
- * @warning The buffers share a lifetime with the s2n_connection object.
+ * The retrieved certificate chain has the format described by the TLS 1.2 RFC:
+ * https://datatracker.ietf.org/doc/html/rfc5246#section-7.4.2. Each certificate is a DER-encoded ASN.1 X.509,
+ * prepended by a 3 byte network-endian length value. Note that this format is used regardless of the connection's
+ * protocol version.
+ *
+ * @warning The buffer pointed to by `cert_chain_out` shares its lifetime with the s2n_connection object.
  *
  * @param conn A pointer to the s2n_connection object
- * @param der_cert_chain_out A uint8_t pointer. This will be updated to point to the client certificate chain.
- * @param cert_chain_len A pointer to a uint32_t. This will be updated to match the size of the buffer `der_cert_chain_out` points to.
+ * @param cert_chain_out A pointer that's set to the client certificate chain.
+ * @param cert_chain_len A pointer that's set to the size of the `cert_chain_out` buffer.
  * @returns S2N_SUCCESS on success. S2N_FAILURE on failure
  */
 S2N_API extern int s2n_connection_get_client_cert_chain(struct s2n_connection *conn, uint8_t **der_cert_chain_out, uint32_t *cert_chain_len);

data/aws-crt-ffi/crt/s2n/bindings/rust/bench/benches/handshake.rs

@@ -6,8 +6,8 @@ use bench::OpenSslConnection;
 #[cfg(feature = "rustls")]
 use bench::RustlsConnection;
 use bench::{
-    CipherSuite, ConnectedBuffer, CryptoConfig, HandshakeType, KXGroup, Mode, S2NConnection,
-    SigType, TlsConnPair, TlsConnection, PROFILER_FREQUENCY,
+    harness::TlsBenchConfig, CipherSuite, ConnectedBuffer, CryptoConfig, HandshakeType, KXGroup,
+    Mode, S2NConnection, SigType, TlsConnPair, TlsConnection, PROFILER_FREQUENCY,
 };
 use criterion::{
     criterion_group, criterion_main, measurement::WallTime, BatchSize, BenchmarkGroup, Criterion,
@@ -16,16 +16,19 @@ use pprof::criterion::{Output, PProfProfiler};
 use std::error::Error;
 use strum::IntoEnumIterator;
 
-fn bench_handshake_for_library<T: TlsConnection>(
+fn bench_handshake_for_library<T>(
     bench_group: &mut BenchmarkGroup<WallTime>,
     handshake_type: HandshakeType,
     kx_group: KXGroup,
     sig_type: SigType,
-) {
+) where
+    T: TlsConnection,
+    T::Config: TlsBenchConfig,
+{
     // make configs before benching to reuse
     let crypto_config = CryptoConfig::new(CipherSuite::default(), kx_group, sig_type);
-    let client_config = T::make_config(Mode::Client, crypto_config, handshake_type);
-    let server_config = T::make_config(Mode::Server, crypto_config, handshake_type);
+    let client_config = T::Config::make_config(Mode::Client, crypto_config, handshake_type);
+    let server_config = T::Config::make_config(Mode::Server, crypto_config, handshake_type);
 
     // generate all harnesses (TlsConnPair structs) beforehand so that benchmarks
     // only include negotiation and not config/connection initialization

data/aws-crt-ffi/crt/s2n/bindings/rust/bench/benches/resumption.rs

@@ -1,25 +1,25 @@
 use bench::{
-    CipherSuite, CryptoConfig, HandshakeType, KXGroup, S2NConnection, SigType, TlsConnPair,
-    TlsConnection,
+    harness::TlsBenchConfig, CipherSuite, CryptoConfig, HandshakeType, KXGroup, S2NConnection,
+    SigType, TlsConnPair, TlsConnection,
 };
 use criterion::{
     criterion_group, criterion_main, measurement::WallTime, BatchSize, BenchmarkGroup, Criterion,
 };
 
-fn bench_handshake_pair<T: TlsConnection>(
-    bench_group: &mut BenchmarkGroup<WallTime>,
-    sig_type: SigType,
-) {
+fn bench_handshake_pair<T>(bench_group: &mut BenchmarkGroup<WallTime>, sig_type: SigType)
+where
+    T: TlsConnection,
+    T::Config: TlsBenchConfig,
+{
     // generate all harnesses (TlsConnPair structs) beforehand so that benchmarks
     // only include negotiation and not config/connection initialization
     for handshake in [HandshakeType::Resumption, HandshakeType::ServerAuth] {
         bench_group.bench_function(format!("{:?}-{}", handshake, T::name()), |b| {
             b.iter_batched_ref(
                 || {
-                    TlsConnPair::<T, T>::new(
+                    TlsConnPair::<T, T>::new_bench_pair(
                         CryptoConfig::new(CipherSuite::default(), KXGroup::default(), sig_type),
                         handshake,
-                        Default::default(),
                     )
                 },
                 |conn_pair_res| {
@@ -33,18 +33,18 @@ fn bench_handshake_pair<T: TlsConnection>(
     }
 }
 
-fn bench_handshake_server_1rtt<T: TlsConnection>(
-    bench_group: &mut BenchmarkGroup<WallTime>,
-    sig_type: SigType,
-) {
+fn bench_handshake_server_1rtt<T>(bench_group: &mut BenchmarkGroup<WallTime>, sig_type: SigType)
+where
+    T: TlsConnection,
+    T::Config: TlsBenchConfig,
+{
     for handshake in [HandshakeType::Resumption, HandshakeType::ServerAuth] {
         bench_group.bench_function(format!("{:?}-{}", handshake, T::name()), |b| {
             b.iter_batched_ref(
                 || {
-                    let pair = TlsConnPair::<T, T>::new(
+                    let pair = TlsConnPair::<T, T>::new_bench_pair(
                         CryptoConfig::new(CipherSuite::default(), KXGroup::default(), sig_type),
                         handshake,
-                        Default::default(),
                     )
                     .unwrap();
                     let (mut c, s) = pair.split();