aws-crt 0.1.5 → 0.1.6

data/aws-crt-ffi/crt/aws-c-auth/source/aws_imds_client.c

@@ -16,6 +16,8 @@
 #include <aws/io/socket.h>
 #include <ctype.h>
 
+#include <aws/common/json.h>
+
 #if defined(_MSC_VER)
 #    pragma warning(disable : 4204)
 #    pragma warning(disable : 4232)
@@ -1059,32 +1061,46 @@ on_finish:
   "InstanceProfileId" : "AIPAQOHATHEGTGNQ5THQB"
 }
  */
-static int s_parse_iam_profile(cJSON *document_root, struct aws_imds_iam_profile *dest) {
+static int s_parse_iam_profile(struct aws_json_value *document_root, struct aws_imds_iam_profile *dest) {
 
     bool success = false;
 
-    cJSON *last_updated = cJSON_GetObjectItemCaseSensitive(document_root, "LastUpdated");
-    if (!cJSON_IsString(last_updated) || (last_updated->valuestring == NULL)) {
+    struct aws_byte_cursor last_updated_cursor;
+    struct aws_json_value *last_updated =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("LastUpdated"));
+    if (last_updated == NULL) {
+        last_updated = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("lastupdated"));
+    }
+    if (!aws_json_value_is_string(last_updated) ||
+        (aws_json_value_get_string(last_updated, &last_updated_cursor) == AWS_OP_ERR)) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse LastUpdated from Json document for iam profile.");
         goto done;
     }
 
-    cJSON *profile_arn = cJSON_GetObjectItemCaseSensitive(document_root, "InstanceProfileArn");
-    if (!cJSON_IsString(profile_arn) || (profile_arn->valuestring == NULL)) {
+    struct aws_byte_cursor profile_arn_cursor;
+    struct aws_json_value *profile_arn =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("InstanceProfileArn"));
+    if (profile_arn == NULL) {
+        profile_arn = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("instanceprofilearn"));
+    }
+    if (!aws_json_value_is_string(profile_arn) ||
+        (aws_json_value_get_string(profile_arn, &profile_arn_cursor) == AWS_OP_ERR)) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse InstanceProfileArn from Json document for iam profile.");
         goto done;
     }
 
-    cJSON *profile_id = cJSON_GetObjectItemCaseSensitive(document_root, "InstanceProfileId");
-    if (!cJSON_IsString(profile_id) || (profile_id->valuestring == NULL)) {
+    struct aws_byte_cursor profile_id_cursor;
+    struct aws_json_value *profile_id =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("InstanceProfileId"));
+    if (profile_id == NULL) {
+        profile_id = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("instanceprofileid"));
+    }
+    if (!aws_json_value_is_string(profile_id) ||
+        (aws_json_value_get_string(profile_id, &profile_id_cursor) == AWS_OP_ERR)) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse InstanceProfileId from Json document for iam profile.");
         goto done;
     }
 
-    struct aws_byte_cursor last_updated_cursor = aws_byte_cursor_from_c_str(last_updated->valuestring);
-    struct aws_byte_cursor profile_arn_cursor = aws_byte_cursor_from_c_str(profile_arn->valuestring);
-    struct aws_byte_cursor profile_id_cursor = aws_byte_cursor_from_c_str(profile_id->valuestring);
-
     if (last_updated_cursor.len == 0 || profile_arn_cursor.len == 0 || profile_id_cursor.len == 0) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Parsed an unexpected Json document fro iam profile.");
         goto done;
@@ -1107,7 +1123,7 @@ done:
 
 static void s_process_iam_profile(const struct aws_byte_buf *resource, int error_code, void *user_data) {
     struct imds_get_iam_user_data *wrapped_user_data = user_data;
-    cJSON *document_root = NULL;
+    struct aws_json_value *document_root = NULL;
     struct aws_imds_iam_profile iam;
     AWS_ZERO_STRUCT(iam);
 
@@ -1126,7 +1142,8 @@ static void s_process_iam_profile(const struct aws_byte_buf *resource, int error
         goto on_finish;
     }
 
-    document_root = cJSON_Parse((const char *)json_data.buffer);
+    struct aws_byte_cursor json_data_cursor = aws_byte_cursor_from_buf(&json_data);
+    document_root = aws_json_value_new_from_string(aws_default_allocator(), json_data_cursor);
     if (document_root == NULL) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse document as Json document for iam profile.");
         goto on_finish;
@@ -1141,7 +1158,7 @@ on_finish:
     aws_byte_buf_clean_up_secure(&json_data);
     aws_mem_release(wrapped_user_data->allocator, wrapped_user_data);
     if (document_root != NULL) {
-        cJSON_Delete(document_root);
+        aws_json_value_destroy(document_root);
     }
 }
 
@@ -1164,108 +1181,228 @@ on_finish:
   "version" : "2017-09-30"
   }
  */
-static int s_parse_instance_info(cJSON *document_root, struct aws_imds_instance_info *dest) {
+static int s_parse_instance_info(struct aws_json_value *document_root, struct aws_imds_instance_info *dest) {
 
     bool success = false;
-    cJSON *account_id = cJSON_GetObjectItemCaseSensitive(document_root, "accountId");
-    if (!cJSON_IsString(account_id) || (account_id->valuestring == NULL)) {
+
+    struct aws_byte_cursor account_id_cursor;
+    struct aws_json_value *account_id =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("accountId"));
+    if (account_id == NULL) {
+        account_id = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("accountid"));
+        if (account_id == NULL) {
+            account_id = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("AccountId"));
+        }
+    }
+    if (!aws_json_value_is_string(account_id) ||
+        (aws_json_value_get_string(account_id, &account_id_cursor) == AWS_OP_ERR)) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse accountId from Json document for ec2 instance info.");
         goto done;
     }
-    dest->account_id = aws_byte_cursor_from_c_str(account_id->valuestring);
+    dest->account_id = account_id_cursor;
 
-    cJSON *architecture = cJSON_GetObjectItemCaseSensitive(document_root, "architecture");
-    if (!cJSON_IsString(architecture) || (architecture->valuestring == NULL)) {
+    struct aws_byte_cursor architecture_cursor;
+    struct aws_json_value *architecture =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("architecture"));
+    if (architecture == NULL) {
+        architecture = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("Architecture"));
+    }
+    if (!aws_json_value_is_string(architecture) ||
+        (aws_json_value_get_string(architecture, &architecture_cursor) == AWS_OP_ERR)) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse architecture from Json document for ec2 instance info.");
         goto done;
     }
-    dest->architecture = aws_byte_cursor_from_c_str(architecture->valuestring);
-
-    cJSON *availability_zone = cJSON_GetObjectItemCaseSensitive(document_root, "availabilityZone");
-    if (!cJSON_IsString(availability_zone) || (availability_zone->valuestring == NULL)) {
+    dest->architecture = architecture_cursor;
+
+    struct aws_byte_cursor availability_zone_cursor;
+    struct aws_json_value *availability_zone =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("availabilityZone"));
+    if (availability_zone == NULL) {
+        availability_zone =
+            aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("availabilityzone"));
+        if (availability_zone == NULL) {
+            availability_zone =
+                aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("AvailabilityZone"));
+        }
+    }
+    if (!aws_json_value_is_string(availability_zone) ||
+        (aws_json_value_get_string(availability_zone, &availability_zone_cursor) == AWS_OP_ERR)) {
         AWS_LOGF_ERROR(
             AWS_LS_IMDS_CLIENT, "Failed to parse availabilityZone from Json document for ec2 instance info.");
         goto done;
     }
-    dest->availability_zone = aws_byte_cursor_from_c_str(availability_zone->valuestring);
+    dest->availability_zone = availability_zone_cursor;
 
-    cJSON *billing_products = cJSON_GetObjectItemCaseSensitive(document_root, "billingProducts");
-    if (cJSON_IsArray(billing_products)) {
-        cJSON *element;
-        cJSON_ArrayForEach(element, billing_products) {
-            if (cJSON_IsString(element) && (element->valuestring != NULL)) {
-                struct aws_byte_cursor item = aws_byte_cursor_from_c_str(element->valuestring);
+    struct aws_byte_cursor billing_products_cursor;
+    struct aws_json_value *billing_products =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("billingProducts"));
+    if (billing_products == NULL) {
+        billing_products = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("billingproducts"));
+        if (billing_products == NULL) {
+            billing_products =
+                aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("BillingProducts"));
+        }
+    }
+    if (aws_json_value_is_array(billing_products)) {
+        struct aws_json_value *element;
+        for (size_t i = 0; i < aws_json_get_array_size(billing_products); i++) {
+            element = aws_json_get_array_element(billing_products, i);
+            if (aws_json_value_is_string(element) &&
+                aws_json_value_get_string(element, &billing_products_cursor) != AWS_OP_ERR) {
+                struct aws_byte_cursor item = billing_products_cursor;
                 aws_array_list_push_back(&dest->billing_products, (const void *)&item);
             }
         }
     }
 
-    cJSON *marketplace_product_codes = cJSON_GetObjectItemCaseSensitive(document_root, "marketplaceProductCodes");
-    if (cJSON_IsArray(marketplace_product_codes)) {
-        cJSON *element;
-        cJSON_ArrayForEach(element, marketplace_product_codes) {
-            if (cJSON_IsString(element) && (element->valuestring != NULL)) {
-                struct aws_byte_cursor item = aws_byte_cursor_from_c_str(element->valuestring);
-                aws_array_list_push_back(&dest->marketplace_product_codes, (const void *)&item);
+    struct aws_byte_cursor marketplace_product_codes_cursor;
+    struct aws_json_value *marketplace_product_codes =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("marketplaceProductCodes"));
+    if (marketplace_product_codes == NULL) {
+        marketplace_product_codes =
+            aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("marketplaceproductcodes"));
+        if (marketplace_product_codes == NULL) {
+            marketplace_product_codes =
+                aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("MarketplaceProductCodes"));
+        }
+    }
+    if (aws_json_value_is_array(marketplace_product_codes)) {
+        struct aws_json_value *element;
+        for (size_t i = 0; i < aws_json_get_array_size(marketplace_product_codes); i++) {
+            element = aws_json_get_array_element(marketplace_product_codes, i);
+            if (aws_json_value_is_string(element) &&
+                aws_json_value_get_string(element, &marketplace_product_codes_cursor) != AWS_OP_ERR) {
+                struct aws_byte_cursor item = marketplace_product_codes_cursor;
+                aws_array_list_push_back(&dest->billing_products, (const void *)&item);
             }
         }
     }
 
-    cJSON *image_id = cJSON_GetObjectItemCaseSensitive(document_root, "imageId");
-    if (cJSON_IsString(image_id) && (image_id->valuestring != NULL)) {
-        dest->image_id = aws_byte_cursor_from_c_str(image_id->valuestring);
+    struct aws_byte_cursor image_id_cursor;
+    struct aws_json_value *image_id =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("imageId"));
+    if (image_id == NULL) {
+        image_id = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("imageid"));
+        if (image_id == NULL) {
+            image_id = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("ImageId"));
+        }
+    }
+    if (aws_json_value_is_string(image_id) && (aws_json_value_get_string(image_id, &image_id_cursor) != AWS_OP_ERR)) {
+        dest->image_id = image_id_cursor;
     }
 
-    cJSON *instance_id = cJSON_GetObjectItemCaseSensitive(document_root, "instanceId");
-    if (!cJSON_IsString(instance_id) || (instance_id->valuestring == NULL)) {
+    struct aws_byte_cursor instance_id_cursor;
+    struct aws_json_value *instance_id =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("instanceId"));
+    if (instance_id == NULL) {
+        instance_id = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("instanceid"));
+        if (instance_id == NULL) {
+            instance_id = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("InstanceId"));
+        }
+    }
+    if (!aws_json_value_is_string(instance_id) ||
+        (aws_json_value_get_string(instance_id, &instance_id_cursor) == AWS_OP_ERR)) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse instanceId from Json document for ec2 instance info.");
         goto done;
     }
-    dest->instance_id = aws_byte_cursor_from_c_str(instance_id->valuestring);
+    dest->instance_id = instance_id_cursor;
 
-    cJSON *instance_type = cJSON_GetObjectItemCaseSensitive(document_root, "instanceType");
-    if (!cJSON_IsString(instance_type) || (instance_type->valuestring == NULL)) {
+    struct aws_byte_cursor instance_type_cursor;
+    struct aws_json_value *instance_type =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("instanceType"));
+    if (instance_type == NULL) {
+        instance_type = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("instancetype"));
+        if (instance_type == NULL) {
+            instance_type = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("InstanceType"));
+        }
+    }
+    if (!aws_json_value_is_string(instance_type) ||
+        (aws_json_value_get_string(instance_type, &instance_type_cursor) == AWS_OP_ERR)) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse instanceType from Json document for ec2 instance info.");
         goto done;
     }
-    dest->instance_type = aws_byte_cursor_from_c_str(instance_type->valuestring);
+    dest->instance_type = instance_type_cursor;
 
-    cJSON *kernel_id = cJSON_GetObjectItemCaseSensitive(document_root, "kernelId");
-    if (cJSON_IsString(kernel_id) && (kernel_id->valuestring != NULL)) {
-        dest->kernel_id = aws_byte_cursor_from_c_str(kernel_id->valuestring);
+    struct aws_byte_cursor kernel_id_cursor;
+    struct aws_json_value *kernel_id =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("kernelId"));
+    if (kernel_id == NULL) {
+        kernel_id = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("kernelid"));
+        if (kernel_id == NULL) {
+            kernel_id = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("KernelId"));
+        }
+    }
+    if (aws_json_value_is_string(kernel_id) &&
+        (aws_json_value_get_string(kernel_id, &kernel_id_cursor) != AWS_OP_ERR)) {
+        dest->kernel_id = kernel_id_cursor;
     }
 
-    cJSON *private_ip = cJSON_GetObjectItemCaseSensitive(document_root, "privateIp");
-    if (cJSON_IsString(private_ip) && (private_ip->valuestring != NULL)) {
-        dest->private_ip = aws_byte_cursor_from_c_str(private_ip->valuestring);
+    struct aws_byte_cursor private_ip_cursor;
+    struct aws_json_value *private_ip =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("privateIp"));
+    if (private_ip == NULL) {
+        private_ip = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("privateip"));
+        if (private_ip == NULL) {
+            private_ip = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("PrivateIp"));
+        }
+    }
+    if (aws_json_value_is_string(private_ip) &&
+        (aws_json_value_get_string(private_ip, &private_ip_cursor) != AWS_OP_ERR)) {
+        dest->private_ip = private_ip_cursor;
     }
 
-    cJSON *ramdisk_id = cJSON_GetObjectItemCaseSensitive(document_root, "ramdiskId");
-    if (cJSON_IsString(ramdisk_id) && (ramdisk_id->valuestring != NULL)) {
-        dest->ramdisk_id = aws_byte_cursor_from_c_str(ramdisk_id->valuestring);
+    struct aws_byte_cursor ramdisk_id_cursor;
+    struct aws_json_value *ramdisk_id =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("ramdiskId"));
+    if (ramdisk_id == NULL) {
+        ramdisk_id = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("ramdiskid"));
+        if (ramdisk_id == NULL) {
+            ramdisk_id = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("RamdiskId"));
+        }
+    }
+    if (aws_json_value_is_string(ramdisk_id) &&
+        (aws_json_value_get_string(ramdisk_id, &ramdisk_id_cursor) != AWS_OP_ERR)) {
+        dest->ramdisk_id = ramdisk_id_cursor;
     }
 
-    cJSON *region = cJSON_GetObjectItemCaseSensitive(document_root, "region");
-    if (!cJSON_IsString(region) || (region->valuestring == NULL)) {
+    struct aws_byte_cursor region_cursor;
+    struct aws_json_value *region = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("region"));
+    if (region == NULL) {
+        region = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("Region"));
+    }
+    if (!aws_json_value_is_string(region) || (aws_json_value_get_string(region, &region_cursor) == AWS_OP_ERR)) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse region from Json document for ec2 instance info.");
         goto done;
     }
-    dest->region = aws_byte_cursor_from_c_str(region->valuestring);
+    dest->region = region_cursor;
 
-    cJSON *version = cJSON_GetObjectItemCaseSensitive(document_root, "version");
-    if (!cJSON_IsString(version) || (version->valuestring == NULL)) {
+    struct aws_byte_cursor version_cursor;
+    struct aws_json_value *version =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("version"));
+    if (version == NULL) {
+        version = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("Version"));
+    }
+    if (!aws_json_value_is_string(version) || (aws_json_value_get_string(version, &version_cursor) == AWS_OP_ERR)) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse version from Json document for ec2 instance info.");
         goto done;
     }
-    dest->version = aws_byte_cursor_from_c_str(version->valuestring);
+    dest->version = version_cursor;
 
-    cJSON *pending_time = cJSON_GetObjectItemCaseSensitive(document_root, "pendingTime");
-    if (!cJSON_IsString(pending_time) || (pending_time->valuestring == NULL)) {
+    struct aws_byte_cursor pending_time_cursor;
+    struct aws_json_value *pending_time =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("pendingTime"));
+    if (pending_time == NULL) {
+        pending_time = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("pendingtime"));
+        if (pending_time == NULL) {
+            pending_time = aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("PendingTime"));
+        }
+    }
+    if (!aws_json_value_is_string(pending_time) ||
+        (aws_json_value_get_string(pending_time, &pending_time_cursor) == AWS_OP_ERR)) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse pendingTime from Json document for ec2 instance info.");
         goto done;
     }
 
-    struct aws_byte_cursor pending_time_cursor = aws_byte_cursor_from_c_str(pending_time->valuestring);
     if (aws_date_time_init_from_str_cursor(&dest->pending_time, &pending_time_cursor, AWS_DATE_FORMAT_ISO_8601)) {
         AWS_LOGF_ERROR(
             AWS_LS_IMDS_CLIENT, "pendingTime in instance info Json document is not a valid ISO_8601 date string.");
@@ -1285,7 +1422,7 @@ static void s_process_instance_info(const struct aws_byte_buf *resource, int err
     struct aws_byte_buf json_data;
     AWS_ZERO_STRUCT(json_data);
 
-    cJSON *document_root = NULL;
+    struct aws_json_value *document_root = NULL;
 
     if (aws_array_list_init_dynamic(
             &instance_info.billing_products, wrapped_user_data->allocator, 10, sizeof(struct aws_byte_cursor))) {
@@ -1312,7 +1449,8 @@ static void s_process_instance_info(const struct aws_byte_buf *resource, int err
         goto on_finish;
     }
 
-    document_root = cJSON_Parse((const char *)json_data.buffer);
+    struct aws_byte_cursor json_data_cursor = aws_byte_cursor_from_buf(&json_data);
+    document_root = aws_json_value_new_from_string(aws_default_allocator(), json_data_cursor);
     if (document_root == NULL) {
         AWS_LOGF_ERROR(AWS_LS_IMDS_CLIENT, "Failed to parse document as Json document for ec2 instance info.");
         goto on_finish;
@@ -1329,7 +1467,7 @@ on_finish:
     aws_byte_buf_clean_up_secure(&json_data);
     aws_mem_release(wrapped_user_data->allocator, wrapped_user_data);
     if (document_root != NULL) {
-        cJSON_Delete(document_root);
+        aws_json_value_destroy(document_root);
     }
 }
 

data/aws-crt-ffi/crt/aws-c-auth/source/aws_signing.c

@@ -130,6 +130,11 @@ int aws_signing_init_signing_tables(struct aws_allocator *allocator) {
         return AWS_OP_ERR;
     }
 
+    s_connection_header_name = aws_byte_cursor_from_c_str("expect");
+    if (aws_hash_table_put(&s_skipped_headers, &s_connection_header_name, NULL, NULL)) {
+        return AWS_OP_ERR;
+    }
+
     s_sec_websocket_key_header_name = aws_byte_cursor_from_c_str("sec-websocket-key");
     if (aws_hash_table_put(&s_skipped_headers, &s_sec_websocket_key_header_name, NULL, NULL)) {
         return AWS_OP_ERR;

data/aws-crt-ffi/crt/aws-c-auth/source/credentials_provider_cached.c

@@ -101,6 +101,10 @@ static void s_cached_credentials_provider_get_credentials_async_callback(
             credentials_expiration_timepoint_seconds = aws_credentials_get_expiration_timepoint_seconds(credentials);
         }
 
+        /*
+         * If the sourced credentials have an explicit expiration time, we should always use that time
+         * rather than the much cruder, mechanical refresh setting on the caching wrapper.
+         */
         if (credentials_expiration_timepoint_seconds < UINT64_MAX) {
             uint64_t system_now = 0;
             if (!impl->system_clock_fn(&system_now)) {
@@ -109,17 +113,13 @@ static void s_cached_credentials_provider_get_credentials_async_callback(
                     aws_timestamp_convert(system_now, AWS_TIMESTAMP_NANOS, AWS_TIMESTAMP_SECS, NULL);
                 if (credentials_expiration_timepoint_seconds >=
                     system_now_seconds + REFRESH_CREDENTIALS_EARLY_DURATION_SECONDS) {
-                    uint64_t early_refresh_time_ns = high_res_now;
-                    early_refresh_time_ns += aws_timestamp_convert(
+                    next_refresh_time_in_ns = high_res_now;
+                    next_refresh_time_in_ns += aws_timestamp_convert(
                         credentials_expiration_timepoint_seconds - system_now_seconds -
                             REFRESH_CREDENTIALS_EARLY_DURATION_SECONDS,
                         AWS_TIMESTAMP_SECS,
                         AWS_TIMESTAMP_NANOS,
                         NULL);
-
-                    if (early_refresh_time_ns < next_refresh_time_in_ns) {
-                        next_refresh_time_in_ns = early_refresh_time_ns;
-                    }
                 }
             }
         }

data/aws-crt-ffi/crt/aws-c-auth/source/credentials_provider_default_chain.c

@@ -273,6 +273,7 @@ struct aws_credentials_provider *aws_credentials_provider_new_chain_default(
     struct aws_tls_ctx *tls_ctx = NULL;
     struct aws_credentials_provider *environment_provider = NULL;
     struct aws_credentials_provider *profile_provider = NULL;
+    struct aws_credentials_provider *sts_provider = NULL;
     struct aws_credentials_provider *ecs_or_imds_provider = NULL;
     struct aws_credentials_provider *chain_provider = NULL;
     struct aws_credentials_provider *cached_provider = NULL;
@@ -304,7 +305,7 @@ struct aws_credentials_provider *aws_credentials_provider_new_chain_default(
 #endif /* BYO_CRYPTO */
     }
 
-    enum { providers_size = 3 };
+    enum { providers_size = 4 };
     struct aws_credentials_provider *providers[providers_size];
     AWS_ZERO_ARRAY(providers);
     size_t index = 0;
@@ -330,6 +331,18 @@ struct aws_credentials_provider *aws_credentials_provider_new_chain_default(
         aws_atomic_fetch_add(&impl->shutdowns_remaining, 1);
     }
 
+    struct aws_credentials_provider_sts_web_identity_options sts_options;
+    AWS_ZERO_STRUCT(sts_options);
+    sts_options.bootstrap = options->bootstrap;
+    sts_options.tls_ctx = tls_ctx;
+    sts_options.shutdown_options = sub_provider_shutdown_options;
+    sts_provider = aws_credentials_provider_new_sts_web_identity(allocator, &sts_options);
+    if (sts_provider != NULL) {
+        providers[index++] = sts_provider;
+        /* 1 shutdown call from the web identity provider's shutdown */
+        aws_atomic_fetch_add(&impl->shutdowns_remaining, 1);
+    }
+
     ecs_or_imds_provider = s_aws_credentials_provider_new_ecs_or_imds(
         allocator, &sub_provider_shutdown_options, options->bootstrap, tls_ctx);
     if (ecs_or_imds_provider != NULL) {
@@ -355,6 +368,7 @@ struct aws_credentials_provider *aws_credentials_provider_new_chain_default(
      */
     aws_credentials_provider_release(environment_provider);
     aws_credentials_provider_release(profile_provider);
+    aws_credentials_provider_release(sts_provider);
     aws_credentials_provider_release(ecs_or_imds_provider);
 
     struct aws_credentials_provider_cached_options cached_options = {
@@ -395,6 +409,7 @@ on_error:
     } else {
         aws_credentials_provider_release(ecs_or_imds_provider);
         aws_credentials_provider_release(profile_provider);
+        aws_credentials_provider_release(sts_provider);
         aws_credentials_provider_release(environment_provider);
     }
 

data/aws-crt-ffi/crt/aws-c-auth/source/credentials_provider_ecs.c

@@ -5,7 +5,6 @@
 
 #include <aws/auth/credentials.h>
 
-#include <aws/auth/external/cJSON.h>
 #include <aws/auth/private/credentials_utils.h>
 #include <aws/common/clock.h>
 #include <aws/common/date_time.h>

data/aws-crt-ffi/crt/aws-c-auth/source/credentials_provider_process.c

@@ -4,7 +4,6 @@
  */
 
 #include <aws/auth/credentials.h>
-#include <aws/auth/external/cJSON.h>
 #include <aws/auth/private/aws_profile.h>
 #include <aws/auth/private/credentials_utils.h>
 #include <aws/common/clock.h>

data/aws-crt-ffi/crt/aws-c-auth/source/credentials_provider_sts_web_identity.c

@@ -5,7 +5,6 @@
 
 #include <aws/auth/credentials.h>
 
-#include <aws/auth/external/cJSON.h>
 #include <aws/auth/private/aws_profile.h>
 #include <aws/auth/private/credentials_utils.h>
 #include <aws/common/clock.h>

data/aws-crt-ffi/crt/aws-c-auth/source/credentials_provider_x509.c

@@ -5,7 +5,6 @@
 
 #include <aws/auth/credentials.h>
 
-#include <aws/auth/external/cJSON.h>
 #include <aws/auth/private/credentials_utils.h>
 #include <aws/common/clock.h>
 #include <aws/common/date_time.h>
@@ -19,6 +18,8 @@
 #include <aws/io/tls_channel_handler.h>
 #include <aws/io/uri.h>
 
+#include <aws/common/json.h>
+
 #if defined(_MSC_VER)
 #    pragma warning(disable : 4204)
 #    pragma warning(disable : 4232)
@@ -146,13 +147,14 @@ static struct aws_credentials *s_parse_credentials_from_iot_core_document(
     struct aws_byte_buf *document) {
 
     struct aws_credentials *credentials = NULL;
-    cJSON *document_root = NULL;
+    struct aws_json_value *document_root = NULL;
 
     if (aws_byte_buf_append_null_terminator(document)) {
         goto done;
     }
 
-    document_root = cJSON_Parse((const char *)document->buffer);
+    struct aws_byte_cursor document_cursor = aws_byte_cursor_from_buf(document);
+    document_root = aws_json_value_new_from_string(allocator, document_cursor);
     if (document_root == NULL) {
         AWS_LOGF_ERROR(AWS_LS_AUTH_CREDENTIALS_PROVIDER, "Failed to parse IoT Core response as Json document.");
         goto done;
@@ -161,8 +163,9 @@ static struct aws_credentials *s_parse_credentials_from_iot_core_document(
     /*
      * pull out the root "Credentials" components
      */
-    cJSON *creds = cJSON_GetObjectItem(document_root, "credentials");
-    if (!cJSON_IsObject(creds)) {
+    struct aws_json_value *creds =
+        aws_json_value_get_from_object(document_root, aws_byte_cursor_from_c_str("credentials"));
+    if (!aws_json_value_is_object(creds)) {
         AWS_LOGF_ERROR(AWS_LS_AUTH_CREDENTIALS_PROVIDER, "Failed to parse credentials from IoT Core response.");
         goto done;
     }
@@ -176,7 +179,7 @@ static struct aws_credentials *s_parse_credentials_from_iot_core_document(
         .expiration_required = false,
     };
 
-    credentials = aws_parse_credentials_from_cjson_object(allocator, creds, &parse_options);
+    credentials = aws_parse_credentials_from_aws_json_object(allocator, creds, &parse_options);
     if (!credentials) {
         AWS_LOGF_ERROR(AWS_LS_AUTH_CREDENTIALS_PROVIDER, "X509 credentials provider failed to parse credentials");
     }
@@ -184,7 +187,7 @@ static struct aws_credentials *s_parse_credentials_from_iot_core_document(
 done:
 
     if (document_root != NULL) {
-        cJSON_Delete(document_root);
+        aws_json_value_destroy(document_root);
     }
 
     return credentials;