aws-crt 0.1.9 → 0.2.0

data/aws-crt-ffi/crt/aws-lc/crypto/fipsmodule/service_indicator/service_indicator_test.cc

@@ -31,6 +31,7 @@
 #include "../../test/test_util.h"
 #include "../bn/internal.h"
 #include "../rand/internal.h"
+#include "../sha/internal.h"
 
 static const uint8_t kAESKey[16] = {
     'A','W','S','-','L','C','C','r','y','p','t','o',' ','K', 'e','y'};
@@ -361,11 +362,60 @@ static const uint8_t kOutput_sha512[SHA512_DIGEST_LENGTH] = {
     0x46, 0x30, 0x18, 0xc2, 0x05, 0x88, 0x8a, 0x3c, 0x25, 0xcc, 0x06,
     0xf8, 0x73, 0xb9, 0xe4, 0x18, 0xa8, 0xc2, 0xf0, 0xe5};
 
+static const uint8_t kOutput_sha512_224[SHA512_224_DIGEST_LENGTH] = {
+    0xbf, 0xee, 0x89, 0x08, 0x8c, 0x9a, 0x4e, 0xa4, 0x79, 0x22, 0x6e,
+    0x17, 0x9f, 0x41, 0x53, 0x06, 0xc9, 0x1e, 0x58, 0x75, 0x22, 0xfd,
+    0x89, 0x0a, 0xe2, 0xbf, 0x35, 0x8e};
+
 static const uint8_t kOutput_sha512_256[SHA512_256_DIGEST_LENGTH] = {
     0x1a, 0x78, 0x68, 0x6b, 0x69, 0x6d, 0x28, 0x14, 0x6b, 0x37, 0x11,
     0x2d, 0xfb, 0x72, 0x35, 0xfa, 0xc1, 0xc4, 0x5f, 0x5c, 0x49, 0x91,
     0x08, 0x95, 0x0b, 0x0f, 0xc9, 0x88, 0x44, 0x12, 0x01, 0x6a};
 
+static const uint8_t kOutput_sha3_224[SHA3_224_DIGEST_LENGTH] = {
+    0xd4, 0x7e, 0x2d, 0xca, 0xf9, 0x36, 0x7a, 0x73, 0x2f, 0x9b, 0x42, 0x46,
+    0x25, 0x49, 0x29, 0x68, 0xfa, 0x2c, 0xc7, 0xd0, 0xb0, 0x11, 0x1c, 0x86,
+    0xa6, 0xc0, 0xa1, 0x29};
+
+static const uint8_t kOutput_sha3_256[SHA3_256_DIGEST_LENGTH] = {
+    0x4a, 0x95, 0x1c, 0x1e, 0xd1, 0x58, 0x5f, 0xa3, 0xcf, 0x77, 0x24, 0x73,
+    0x7b, 0xd2, 0x28, 0x55, 0x9f, 0xa5, 0xe8, 0xc6, 0x58, 0x99, 0xe3, 0xb1,
+    0x88, 0x17, 0xd6, 0xc4, 0x1d, 0x3e, 0xa8, 0x4c};
+
+static const uint8_t kOutput_sha3_384[SHA3_384_DIGEST_LENGTH] = {
+    0x19, 0x97, 0xad, 0xa6, 0x45, 0x40, 0x3d, 0x10, 0xda, 0xe6, 0xd4, 0xfd,
+    0xe1, 0xd3, 0x2b, 0x1b, 0xd6, 0xdb, 0x0c, 0xdb, 0xca, 0x6f, 0xae, 0x58,
+    0xbf, 0x75, 0x9a, 0xf6, 0x97, 0xc6, 0xb4, 0xb4, 0xbf, 0xef, 0x3c, 0x2d,
+    0xb1, 0xb3, 0x4a, 0x1d, 0xd9, 0x69, 0x58, 0x25, 0x5b, 0xd0, 0xb6, 0xad};
+
+static const uint8_t kOutput_sha3_512[SHA3_512_DIGEST_LENGTH] = {
+    0x36, 0xe5, 0xa2, 0x70, 0xa4, 0xd1, 0xc3, 0x76, 0xc6, 0x44, 0xe6, 0x00,
+    0x49, 0xae, 0x7d, 0x83, 0x21, 0xdc, 0xab, 0x2e, 0xa2, 0xe3, 0x96, 0xc2,
+    0xeb, 0xe6, 0x61, 0x14, 0x95, 0xd6, 0x6a, 0xf2, 0xf0, 0xa0, 0x4e, 0x93,
+    0x14, 0x2f, 0x02, 0x6a, 0xdb, 0xae, 0xbd, 0x76, 0x4e, 0xb9, 0x52, 0x88,
+    0x85, 0x3c, 0x64, 0xa1, 0x56, 0x6f, 0xeb, 0x76, 0x25, 0x9a, 0x4a, 0x44,
+    0x23, 0xf7, 0xcf, 0x46};
+
+// NOTE: SHAKE is a variable-length XOF; this number is chosen somewhat
+//       arbitrarily for testing.
+static const size_t SHAKE_OUTPUT_LENGTH = 64;
+
+static const uint8_t kOutput_shake128[SHAKE_OUTPUT_LENGTH] = {
+    0x22, 0xfe, 0x51, 0xb7, 0x9c, 0x28, 0x1c, 0x0e, 0xfc, 0x66, 0x58, 0x6a,
+    0xa1, 0x60, 0x85, 0x0b, 0xe6, 0xeb, 0x20, 0x0b, 0xdb, 0x0c, 0xe7, 0xfe,
+    0x49, 0x51, 0xcd, 0xc2, 0x92, 0x3f, 0xfc, 0xf8, 0xcb, 0x4b, 0x19, 0xce,
+    0x80, 0x9f, 0x1f, 0xbf, 0x10, 0xf1, 0x74, 0x38, 0x7a, 0x19, 0xd0, 0xca,
+    0x52, 0xf2, 0xf3, 0xd0, 0x77, 0x08, 0xe2, 0x1e, 0x20, 0x2d, 0x57, 0x25,
+    0x8b, 0xd5, 0xca, 0x66};
+
+static const uint8_t kOutput_shake256[SHAKE_OUTPUT_LENGTH] = {
+    0xfc, 0xd1, 0x32, 0xd0, 0x02, 0x43, 0x7c, 0x31, 0xb2, 0x78, 0xdf, 0x34,
+    0x74, 0xc8, 0x9b, 0x77, 0x08, 0x14, 0x9d, 0xde, 0x69, 0x79, 0xb5, 0x58,
+    0x98, 0x01, 0x69, 0xaa, 0x64, 0x11, 0x04, 0xbe, 0xa2, 0x5f, 0xf1, 0x29,
+    0x9b, 0x94, 0x03, 0x4a, 0x1e, 0x82, 0xf0, 0x9e, 0xee, 0x9b, 0xa0, 0xe3,
+    0xe1, 0x5f, 0x9c, 0x13, 0xb7, 0x52, 0xef, 0x3c, 0x96, 0xf3, 0xf8, 0xf3,
+    0x1f, 0x59, 0x7e, 0x41};
+
 static const uint8_t kHMACOutput_sha1[SHA_DIGEST_LENGTH] = {
     0x34, 0xac, 0x50, 0x9b, 0xa9, 0x4c, 0x39, 0xef, 0x45, 0xa0,
     0x6b, 0xdc, 0xfc, 0xbd, 0x3d, 0x42, 0xe8, 0x0a, 0x97, 0x86};
@@ -394,6 +444,11 @@ static const uint8_t kHMACOutput_sha512[SHA512_DIGEST_LENGTH] = {
     0xf6, 0x8f, 0xb2, 0xd5, 0xb2, 0x6e, 0x97, 0x82, 0x25, 0x5a, 0x1e,
     0xbf, 0x9b, 0x99, 0x8c, 0xf0, 0x37, 0xe6, 0x3d, 0x40};
 
+static const uint8_t kHMACOutput_sha512_224[SHA512_224_DIGEST_LENGTH] = {
+    0xb7, 0x55, 0xfb, 0x59, 0x58, 0xa0, 0xf9, 0xa8, 0x94, 0xc2, 0x91,
+    0x6b, 0xd3, 0xfc, 0xa2, 0xbc, 0xd2, 0x91, 0x09, 0xcb, 0x22, 0x0c,
+    0x04, 0xc9, 0x21, 0xc1, 0x96, 0x62};
+
 static const uint8_t kHMACOutput_sha512_256[SHA512_256_DIGEST_LENGTH] = {
     0x9c, 0x95, 0x9c, 0x03, 0xc9, 0x8c, 0x90, 0xee, 0x7a, 0xff, 0xed,
     0x26, 0xba, 0x75, 0x90, 0xd0, 0xb9, 0xd4, 0x09, 0xf5, 0x22, 0xd6,
@@ -1056,6 +1111,14 @@ static const struct DigestTestVector {
         kOutput_sha512,
         AWSLC_APPROVED,
     },
+    {
+        "SHA-512/224",
+        SHA512_224_DIGEST_LENGTH,
+        &EVP_sha512_224,
+        &SHA512_224,
+        kOutput_sha512_224,
+        AWSLC_APPROVED,
+    },
     {
         "SHA-512/256",
         SHA512_256_DIGEST_LENGTH,
@@ -1064,6 +1127,38 @@ static const struct DigestTestVector {
         kOutput_sha512_256,
         AWSLC_APPROVED,
     },
+    {
+        "SHA3-224",
+        SHA3_224_DIGEST_LENGTH,
+        &EVP_sha3_224,
+        &SHA3_224,
+        kOutput_sha3_224,
+        AWSLC_APPROVED,
+    },
+    {
+        "SHA3-256",
+        SHA3_256_DIGEST_LENGTH,
+        &EVP_sha3_256,
+        &SHA3_256,
+        kOutput_sha3_256,
+        AWSLC_APPROVED,
+    },
+    {
+        "SHA3-384",
+        SHA3_384_DIGEST_LENGTH,
+        &EVP_sha3_384,
+        &SHA3_384,
+        kOutput_sha3_384,
+        AWSLC_APPROVED,
+    },
+    {
+        "SHA3-512",
+        SHA3_512_DIGEST_LENGTH,
+        &EVP_sha3_512,
+        &SHA3_512,
+        kOutput_sha3_512,
+        AWSLC_APPROVED,
+    },
 };
 
 class EVPMDServiceIndicatorTest : public TestWithNoErrors<DigestTestVector> {};
@@ -1110,6 +1205,75 @@ TEST_P(EVPMDServiceIndicatorTest, EVP_Digests) {
   EXPECT_EQ(Bytes(test.expected_digest, test.length), Bytes(digest));
 }
 
+static const struct XofTestVector {
+  // name is the name of the digest test.
+  const char *name;
+  // output length to specify in XOF finalization
+  const int length;
+  // func is the digest to test.
+  const EVP_MD *(*func)();
+  // one_shot_func is the convenience one-shot version of the digest.
+  uint8_t *(*one_shot_func)(const uint8_t *, size_t, uint8_t *, size_t);
+  // expected_digest is the expected digest.
+  const uint8_t *expected_digest;
+  // expected to be approved or not.
+  const FIPSStatus expect_approved;
+} kXofTestVectors[] = {
+    {
+        "SHAKE128",
+        SHAKE_OUTPUT_LENGTH,
+        &EVP_shake128,
+        &SHAKE128,
+        kOutput_shake128,
+        AWSLC_APPROVED,
+    },
+    {
+        "SHAKE256",
+        SHAKE_OUTPUT_LENGTH,
+        &EVP_shake256,
+        &SHAKE256,
+        kOutput_shake256,
+        AWSLC_APPROVED,
+    },
+};
+
+class EVPXOFServiceIndicatorTest : public TestWithNoErrors<XofTestVector> {};
+
+INSTANTIATE_TEST_SUITE_P(All, EVPXOFServiceIndicatorTest,
+                         testing::ValuesIn(kXofTestVectors));
+
+TEST_P(EVPXOFServiceIndicatorTest, EVP_Xofs) {
+  const XofTestVector &test = GetParam();
+  SCOPED_TRACE(test.name);
+
+  FIPSStatus approved = AWSLC_NOT_APPROVED;
+  bssl::ScopedEVP_MD_CTX ctx;
+  std::vector<uint8_t> digest(test.length);
+
+  // Test running the EVP_Digest interfaces one by one directly, and check
+  // |EVP_DigestFinalXOF| for approval at the end. |EVP_DigestInit_ex| and
+  // |EVP_DigestUpdate| should not be approved, because the functions do not
+  // indicate that a service has been fully completed yet.
+  CALL_SERVICE_AND_CHECK_APPROVED(approved,
+      ASSERT_TRUE(EVP_DigestInit_ex(ctx.get(), test.func(), nullptr)));
+  EXPECT_EQ(approved, AWSLC_NOT_APPROVED);
+  CALL_SERVICE_AND_CHECK_APPROVED(approved,
+      ASSERT_TRUE(EVP_DigestUpdate(ctx.get(), kPlaintext, sizeof(kPlaintext))));
+  EXPECT_EQ(approved, AWSLC_NOT_APPROVED);
+  EXPECT_TRUE(EVP_MD_flags(ctx->digest) & EVP_MD_FLAG_XOF);
+  CALL_SERVICE_AND_CHECK_APPROVED(approved,
+      ASSERT_TRUE(EVP_DigestFinalXOF(ctx.get(), digest.data(), test.length)));
+  EXPECT_EQ(approved, test.expect_approved);
+  EXPECT_EQ(Bytes(test.expected_digest, test.length), Bytes(digest));
+
+  // Test using the one-shot API for approval.
+  CALL_SERVICE_AND_CHECK_APPROVED(
+      approved,
+      test.one_shot_func(kPlaintext, sizeof(kPlaintext), digest.data(), test.length));
+  EXPECT_EQ(approved, test.expect_approved);
+  EXPECT_EQ(Bytes(test.expected_digest, test.length), Bytes(digest));
+}
+
 static const struct HMACTestVector {
   // func is the hash function for HMAC to test.
   const EVP_MD *(*func)(void);
@@ -1123,6 +1287,7 @@ static const struct HMACTestVector {
     { EVP_sha256, kHMACOutput_sha256, AWSLC_APPROVED },
     { EVP_sha384, kHMACOutput_sha384, AWSLC_APPROVED },
     { EVP_sha512, kHMACOutput_sha512, AWSLC_APPROVED },
+    { EVP_sha512_224, kHMACOutput_sha512_224, AWSLC_APPROVED },
     { EVP_sha512_256, kHMACOutput_sha512_256, AWSLC_APPROVED }
 };
 
@@ -1813,7 +1978,7 @@ TEST(ServiceIndicatorTest, RSAKeyGen) {
     CALL_SERVICE_AND_CHECK_APPROVED(approved,
         EXPECT_TRUE( RSA_generate_key_fips(rsa.get(), bits, nullptr)));
     EXPECT_EQ(approved, AWSLC_APPROVED);
-    EXPECT_EQ(bits, BN_num_bits(rsa->n));
+    EXPECT_EQ(bits, RSA_bits(rsa.get()));
   }
 
   // Test running the EVP_PKEY_keygen interfaces one by one directly, and check
@@ -1881,19 +2046,27 @@ struct RSATestVector kRSATestVectors[] = {
     { 3071, &EVP_sha512, true, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED },
     { 4096, &EVP_md5, false, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED },
 
-    // PKCS1v1.5 with SHA512/256 are not FIPS approved
+    // PKCS1v1.5 with truncated SHA512 are not FIPS approved
+    { 2048, &EVP_sha512_224, false, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED },
+    { 3072, &EVP_sha512_224, false, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED },
+    { 4096, &EVP_sha512_224, false, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED },
     { 2048, &EVP_sha512_256, false, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED },
     { 3072, &EVP_sha512_256, false, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED },
     { 4096, &EVP_sha512_256, false, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED },
 
     // RSA test cases that are approved.
     { 1024, &EVP_sha1, false, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
+    { 1024, &EVP_sha224, false, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
     { 1024, &EVP_sha256, false, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
+    { 1024, &EVP_sha384, false, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
     { 1024, &EVP_sha512, false, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
     { 1024, &EVP_sha1, true, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
+    { 1024, &EVP_sha224, true, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
     { 1024, &EVP_sha256, true, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
+    { 1024, &EVP_sha384, true, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
+    { 1024, &EVP_sha512_256, true, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
     // PSS with hashLen == saltLen is not possible for 1024-bit modulus and
-    // SHA-512.
+    // SHA-512. This means we can't test it here because the API won't work.
 
     { 2048, &EVP_sha1, false, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
     { 2048, &EVP_sha224, false, AWSLC_APPROVED, AWSLC_APPROVED },
@@ -1906,6 +2079,7 @@ struct RSATestVector kRSATestVectors[] = {
     { 2048, &EVP_sha256, true, AWSLC_APPROVED, AWSLC_APPROVED },
     { 2048, &EVP_sha384, true, AWSLC_APPROVED, AWSLC_APPROVED },
     { 2048, &EVP_sha512, true, AWSLC_APPROVED, AWSLC_APPROVED },
+    { 2048, &EVP_sha512_224, true, AWSLC_APPROVED, AWSLC_APPROVED },
     { 2048, &EVP_sha512_256, true, AWSLC_APPROVED, AWSLC_APPROVED },
 
     { 3072, &EVP_sha1, false, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
@@ -1919,6 +2093,7 @@ struct RSATestVector kRSATestVectors[] = {
     { 3072, &EVP_sha256, true, AWSLC_APPROVED, AWSLC_APPROVED },
     { 3072, &EVP_sha384, true, AWSLC_APPROVED, AWSLC_APPROVED },
     { 3072, &EVP_sha512, true, AWSLC_APPROVED, AWSLC_APPROVED },
+    { 3072, &EVP_sha512_224, true, AWSLC_APPROVED, AWSLC_APPROVED },
     { 3072, &EVP_sha512_256, true, AWSLC_APPROVED, AWSLC_APPROVED },
 
     { 4096, &EVP_sha1, false, AWSLC_NOT_APPROVED, AWSLC_APPROVED },
@@ -1932,6 +2107,7 @@ struct RSATestVector kRSATestVectors[] = {
     { 4096, &EVP_sha256, true, AWSLC_APPROVED, AWSLC_APPROVED },
     { 4096, &EVP_sha384, true, AWSLC_APPROVED, AWSLC_APPROVED },
     { 4096, &EVP_sha512, true, AWSLC_APPROVED, AWSLC_APPROVED },
+    { 4096, &EVP_sha512_224, true, AWSLC_APPROVED, AWSLC_APPROVED },
     { 4096, &EVP_sha512_256, true, AWSLC_APPROVED, AWSLC_APPROVED },
 };
 
@@ -2232,6 +2408,8 @@ static const struct ECDSATestVector kECDSATestVectors[] = {
      AWSLC_APPROVED},
     {NID_secp224r1, &EVP_sha512, AWSLC_APPROVED, AWSLC_APPROVED,
      AWSLC_APPROVED},
+    {NID_secp224r1, &EVP_sha512_224, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
+     AWSLC_NOT_APPROVED},
     {NID_secp224r1, &EVP_sha512_256, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
      AWSLC_NOT_APPROVED},
     {NID_secp224r1, &EVP_sha3_224, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
@@ -2253,6 +2431,8 @@ static const struct ECDSATestVector kECDSATestVectors[] = {
      AWSLC_APPROVED},
     {NID_X9_62_prime256v1, &EVP_sha512, AWSLC_APPROVED, AWSLC_APPROVED,
      AWSLC_APPROVED},
+    {NID_X9_62_prime256v1, &EVP_sha512_224, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
+     AWSLC_NOT_APPROVED},
     {NID_X9_62_prime256v1, &EVP_sha512_256, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
      AWSLC_NOT_APPROVED},
     {NID_X9_62_prime256v1, &EVP_sha3_224, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
@@ -2274,6 +2454,8 @@ static const struct ECDSATestVector kECDSATestVectors[] = {
      AWSLC_APPROVED},
     {NID_secp384r1, &EVP_sha512, AWSLC_APPROVED, AWSLC_APPROVED,
      AWSLC_APPROVED},
+    {NID_secp384r1, &EVP_sha512_224, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
+     AWSLC_NOT_APPROVED},
     {NID_secp384r1, &EVP_sha512_256, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
      AWSLC_NOT_APPROVED},
     {NID_secp384r1, &EVP_sha3_224, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
@@ -2295,6 +2477,8 @@ static const struct ECDSATestVector kECDSATestVectors[] = {
      AWSLC_APPROVED},
     {NID_secp521r1, &EVP_sha512, AWSLC_APPROVED, AWSLC_APPROVED,
      AWSLC_APPROVED},
+    {NID_secp521r1, &EVP_sha512_224, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
+     AWSLC_NOT_APPROVED},
     {NID_secp521r1, &EVP_sha512_256, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
      AWSLC_NOT_APPROVED},
     {NID_secp521r1, &EVP_sha3_224, AWSLC_APPROVED, AWSLC_NOT_APPROVED,
@@ -2316,6 +2500,8 @@ static const struct ECDSATestVector kECDSATestVectors[] = {
      AWSLC_NOT_APPROVED},
     {NID_secp256k1, &EVP_sha512, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED,
      AWSLC_NOT_APPROVED},
+    {NID_secp256k1, &EVP_sha512_224, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED,
+     AWSLC_NOT_APPROVED},
     {NID_secp256k1, &EVP_sha512_256, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED,
      AWSLC_NOT_APPROVED},
     {NID_secp256k1, &EVP_sha3_224, AWSLC_NOT_APPROVED, AWSLC_NOT_APPROVED,
@@ -3631,6 +3817,20 @@ TEST(ServiceIndicatorTest, SHA) {
   EXPECT_EQ(Bytes(kOutput_sha512), Bytes(digest));
   EXPECT_EQ(approved, AWSLC_APPROVED);
 
+  digest.resize(SHA512_224_DIGEST_LENGTH);
+  SHA512_CTX sha512_224_ctx;
+  CALL_SERVICE_AND_CHECK_APPROVED(approved,
+      ASSERT_TRUE(SHA512_224_Init(&sha512_224_ctx)));
+  EXPECT_EQ(approved, AWSLC_NOT_APPROVED);
+  CALL_SERVICE_AND_CHECK_APPROVED(approved,
+      ASSERT_TRUE(SHA512_224_Update(&sha512_224_ctx, kPlaintext,
+                                    sizeof(kPlaintext))));
+  EXPECT_EQ(approved, AWSLC_NOT_APPROVED);
+  CALL_SERVICE_AND_CHECK_APPROVED(approved,
+      ASSERT_TRUE(SHA512_224_Final(digest.data(), &sha512_224_ctx)));
+  EXPECT_EQ(Bytes(kOutput_sha512_224), Bytes(digest));
+  EXPECT_EQ(approved, AWSLC_APPROVED);
+
   digest.resize(SHA512_256_DIGEST_LENGTH);
   SHA512_CTX sha512_256_ctx;
   CALL_SERVICE_AND_CHECK_APPROVED(approved,
@@ -4076,7 +4276,7 @@ TEST(ServiceIndicatorTest, DRBG) {
 // Since this is running in FIPS mode it should end in FIPS
 // Update this when the AWS-LC version number is modified
 TEST(ServiceIndicatorTest, AWSLCVersionString) {
-  ASSERT_STREQ(awslc_version_string(), "AWS-LC FIPS 1.16.0");
+  ASSERT_STREQ(awslc_version_string(), "AWS-LC FIPS 1.17.4");
 }
 
 #else
@@ -4119,6 +4319,6 @@ TEST(ServiceIndicatorTest, BasicTest) {
 // Since this is not running in FIPS mode it shouldn't end in FIPS
 // Update this when the AWS-LC version number is modified
 TEST(ServiceIndicatorTest, AWSLCVersionString) {
-  ASSERT_STREQ(awslc_version_string(), "AWS-LC 1.16.0");
+  ASSERT_STREQ(awslc_version_string(), "AWS-LC 1.17.4");
 }
 #endif // AWSLC_FIPS

data/aws-crt-ffi/crt/aws-lc/crypto/fipsmodule/sha/asm/sha1-armv8.pl

@@ -186,7 +186,7 @@ $code.=<<___;
 sha1_block_data_order:
 	// Armv8.3-A PAuth: even though x30 is pushed to stack it is not popped later.
 	AARCH64_VALID_CALL_TARGET
-#if __has_feature(hwaddress_sanitizer) && __clang_major__ >= 10
+#if defined(OPENSSL_HWASAN) && __clang_major__ >= 10
 	adrp	x16,:pg_hi21_nc:OPENSSL_armcap_P
 #else
 	adrp	x16,:pg_hi21:OPENSSL_armcap_P

data/aws-crt-ffi/crt/aws-lc/crypto/fipsmodule/sha/asm/sha512-armv8.pl

@@ -190,7 +190,7 @@ $code.=<<___;
 $func:
 	AARCH64_VALID_CALL_TARGET
 #ifndef	__KERNEL__
-#if __has_feature(hwaddress_sanitizer) && __clang_major__ >= 10
+#if defined(OPENSSL_HWASAN) && __clang_major__ >= 10
 	adrp	x16,:pg_hi21_nc:OPENSSL_armcap_P
 #else
 	adrp	x16,:pg_hi21:OPENSSL_armcap_P

data/aws-crt-ffi/crt/aws-lc/crypto/fipsmodule/sha/internal.h

@@ -126,6 +126,14 @@ OPENSSL_EXPORT uint8_t *SHAKE128(const uint8_t *data, const size_t in_len,
 OPENSSL_EXPORT uint8_t *SHAKE256(const uint8_t *data, const size_t in_len, 
                                  uint8_t *out, size_t out_len);
 
+// SHAKE_Init initializes |ctx| with specified |block_size|, returns 1 on
+// success and 0 on failure. Calls SHA3_Init under the hood.
+OPENSSL_EXPORT int SHAKE_Init(KECCAK1600_CTX *ctx, size_t block_size);
+
+// SHAKE_Final writes |len| bytes of finalized digest to |md|, returns 1 on
+// success and 0 on failure. Calls SHA3_Final under the hood.
+OPENSSL_EXPORT int SHAKE_Final(uint8_t *md, KECCAK1600_CTX *ctx, size_t len);
+
 // SHA3_Reset zeros the bitstate and the amount of processed input.
 OPENSSL_EXPORT void SHA3_Reset(KECCAK1600_CTX *ctx);
 

data/aws-crt-ffi/crt/aws-lc/crypto/fipsmodule/sha/sha3.c

@@ -13,96 +13,116 @@
 
 uint8_t *SHA3_224(const uint8_t *data, size_t len,
                   uint8_t out[SHA3_224_DIGEST_LENGTH]) {
+  FIPS_service_indicator_lock_state();
   KECCAK1600_CTX ctx;
   int ok = (SHA3_Init(&ctx, SHA3_PAD_CHAR, SHA3_224_DIGEST_BITLENGTH) && 
             SHA3_Update(&ctx, data, len) &&
             SHA3_Final(out, &ctx));
 
   OPENSSL_cleanse(&ctx, sizeof(ctx));
+  FIPS_service_indicator_unlock_state();
   if (ok == 0) {
     return NULL;
   }
+  FIPS_service_indicator_update_state();
   return out;
 }
 
 uint8_t *SHA3_256(const uint8_t *data, size_t len,
                   uint8_t out[SHA3_256_DIGEST_LENGTH]) {
+  FIPS_service_indicator_lock_state();
   KECCAK1600_CTX ctx;
   int ok = (SHA3_Init(&ctx, SHA3_PAD_CHAR, SHA3_256_DIGEST_BITLENGTH) && 
             SHA3_Update(&ctx, data, len) &&
             SHA3_Final(out, &ctx));
 
   OPENSSL_cleanse(&ctx, sizeof(ctx));
+  FIPS_service_indicator_unlock_state();
   if (ok == 0) {
     return NULL;
   }
+  FIPS_service_indicator_update_state();
   return out;
 }
 
 uint8_t *SHA3_384(const uint8_t *data, size_t len,
                   uint8_t out[SHA3_384_DIGEST_LENGTH]) {
+  FIPS_service_indicator_lock_state();
   KECCAK1600_CTX ctx;
   int ok = (SHA3_Init(&ctx, SHA3_PAD_CHAR, SHA3_384_DIGEST_BITLENGTH) && 
             SHA3_Update(&ctx, data, len) &&
             SHA3_Final(out, &ctx));
 
   OPENSSL_cleanse(&ctx, sizeof(ctx));
+  FIPS_service_indicator_unlock_state();
   if (ok == 0) {
     return NULL;
   }
+  FIPS_service_indicator_update_state();
   return out;
 }
 
 uint8_t *SHA3_512(const uint8_t *data, size_t len,
                   uint8_t out[SHA3_512_DIGEST_LENGTH]) {
+  FIPS_service_indicator_lock_state();
   KECCAK1600_CTX ctx;
   int ok = (SHA3_Init(&ctx, SHA3_PAD_CHAR, SHA3_512_DIGEST_BITLENGTH) && 
             SHA3_Update(&ctx, data, len) &&
             SHA3_Final(out, &ctx));
 
   OPENSSL_cleanse(&ctx, sizeof(ctx));
+  FIPS_service_indicator_unlock_state();
   if (ok == 0) {
     return NULL;
   }
+  FIPS_service_indicator_update_state();
   return out;
 }
 
 uint8_t *SHAKE128(const uint8_t *data, const size_t in_len, uint8_t *out, size_t out_len) {
+  FIPS_service_indicator_lock_state();
   KECCAK1600_CTX ctx;
-  
-  // The SHAKE block size depends on the security level of the algorithm only
-  // It is independent of the output size
-  ctx.block_size = SHAKE128_BLOCKSIZE;
-
-  int ok = (SHA3_Init(&ctx, SHAKE_PAD_CHAR, out_len) && 
+  int ok = (SHAKE_Init(&ctx, SHAKE128_BLOCKSIZE) &&
             SHA3_Update(&ctx, data, in_len) &&
-            SHA3_Final(out, &ctx));
+            SHAKE_Final(out, &ctx, out_len));
 
   OPENSSL_cleanse(&ctx, sizeof(ctx));
+  FIPS_service_indicator_unlock_state();
   if (ok == 0) {
     return NULL;
   }
+  FIPS_service_indicator_update_state();
   return out;
 }
 
 uint8_t *SHAKE256(const uint8_t *data, const size_t in_len, uint8_t *out, size_t out_len) {
+  FIPS_service_indicator_lock_state();
   KECCAK1600_CTX ctx;
-  
-  // The SHAKE block size depends on the security level of the algorithm only
-  // It is independent of the output size
-  ctx.block_size = SHAKE256_BLOCKSIZE;
-
-  int ok = (SHA3_Init(&ctx, SHAKE_PAD_CHAR, out_len) && 
+  int ok = (SHAKE_Init(&ctx, SHAKE256_BLOCKSIZE) &&
             SHA3_Update(&ctx, data, in_len) &&
-            SHA3_Final(out, &ctx));
-
+            SHAKE_Final(out, &ctx, out_len));
   OPENSSL_cleanse(&ctx, sizeof(ctx));
+  FIPS_service_indicator_unlock_state();
   if (ok == 0) {
     return NULL;
   }
+  FIPS_service_indicator_update_state();
   return out;
 }
 
+int SHAKE_Init(KECCAK1600_CTX *ctx, size_t block_size) {
+  // The SHAKE block size depends on the security level of the algorithm only
+  // It is independent of the output size
+  ctx->block_size = block_size;
+  return SHA3_Init(ctx, SHAKE_PAD_CHAR, 0);
+}
+
+
+int SHAKE_Final(uint8_t *md, KECCAK1600_CTX *ctx, size_t len) {
+  ctx->md_size = len;
+  return SHA3_Final(md, ctx);
+}
+
 void SHA3_Reset(KECCAK1600_CTX *ctx) {
   memset(ctx->A, 0, sizeof(ctx->A));
   ctx->buf_load = 0;
@@ -202,5 +222,7 @@ int SHA3_Final(uint8_t *md, KECCAK1600_CTX *ctx) {
 
   SHA3_Squeeze(ctx->A, md, ctx->md_size, block_size);
 
+  FIPS_service_indicator_update_state();
+
   return 1;
 }