aws-crt 0.1.5 → 0.1.6

data/aws-crt-ffi/crt/aws-c-io/tests/resources/ec_unittests.crt

@@ -0,0 +1,15 @@
+-----BEGIN CERTIFICATE-----
+MIICYDCCAgagAwIBAgIJAMhHikin3AYVMAoGCCqGSM49BAMCMIGaMQswCQYDVQQG
+EwJVUzETMBEGA1UECAwKV2FzaGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEPMA0G
+A1UECgwGQW1hem9uMQ0wCwYDVQQLDARTREtzMRIwEAYDVQQDDAlsb2NhbGhvc3Qx
+MDAuBgkqhkiG9w0BCQEWIWF3cy1zZGstY29tbW9uLXJ1bnRpbWVAYW1hem9uLmNv
+bTAeFw0yMjAyMDgxODA4NTJaFw0yNDA1MTIxODA4NTJaMIGaMQswCQYDVQQGEwJV
+UzETMBEGA1UECAwKV2FzaGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEPMA0GA1UE
+CgwGQW1hem9uMQ0wCwYDVQQLDARTREtzMRIwEAYDVQQDDAlsb2NhbGhvc3QxMDAu
+BgkqhkiG9w0BCQEWIWF3cy1zZGstY29tbW9uLXJ1bnRpbWVAYW1hem9uLmNvbTBZ
+MBMGByqGSM49AgEGCCqGSM49AwEHA0IABCOVOKo+/0+07kUwDp6BQ+6vqYcQhkgL
+Lj1hnKyRgsK9Na62vyb48RR62eGVau8x/u4hRNUzcQFQZT+k3YGQdLijMzAxMBMG
+A1UdJQQMMAoGCCsGAQUFBwMBMBoGA1UdEQQTMBGCCWxvY2FsaG9zdIcEfwAAATAK
+BggqhkjOPQQDAgNIADBFAiBV/D57WihCxkW6RllW8va1TAkDFoCFQZ0ZBIFuD2OA
+/AIhANSK917av7vJszNr63czldt33YSNjMikb2fhiZkzqROj
+-----END CERTIFICATE-----

data/aws-crt-ffi/crt/aws-c-io/tests/resources/ec_unittests.key

@@ -0,0 +1,5 @@
+-----BEGIN EC PRIVATE KEY-----
+MHcCAQEEILPwDoMGFMzvhek7rPPqeL0Ns2cuNAJ9w+am7/L8BDxqoAoGCCqGSM49
+AwEHoUQDQgAEI5U4qj7/T7TuRTAOnoFD7q+phxCGSAsuPWGcrJGCwr01rra/Jvjx
+FHrZ4ZVq7zH+7iFE1TNxAVBlP6TdgZB0uA==
+-----END EC PRIVATE KEY-----

data/aws-crt-ffi/crt/aws-c-io/tests/resources/ec_unittests.p8

@@ -0,0 +1,5 @@
+-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgs/AOgwYUzO+F6Tus
+8+p4vQ2zZy40An3D5qbv8vwEPGqhRANCAAQjlTiqPv9PtO5FMA6egUPur6mHEIZI
+Cy49YZyskYLCvTWutr8m+PEUetnhlWrvMf7uIUTVM3EBUGU/pN2BkHS4
+-----END PRIVATE KEY-----

data/aws-crt-ffi/crt/aws-c-io/tests/resources/generateCerts.sh

@@ -14,11 +14,15 @@ set -e
 # unittests.crt:      self-signed certificate
 # unittests.p8:       private key, pkcs#8 syntax
 # unittests.p12:      pkcs#12 file bundling the certificate and private key. Password is "1234"
+# ec_unittests.crt:   elliptic curve self-signed certificate
+# ec_unittests.p8:    elliptic curve private key, pkcs#8 syntax
+# ec_unittests.p12:   elliptic curve pkcs#12 file bundling the certificate and private key. Password is "1234"
 
 # Create directory for use with certificate generation
-mkdir certGeneration
+mkdir -p certGeneration
 # Copy files needed to generate new certificates
 cp unittests.key certGeneration/unittests.key
+cp ec_unittests.key certGeneration/ec_unittests.key
 cp unittests.conf certGeneration/unittests.conf
 cp ca_root.cnf certGeneration/ca_root.cnf
 cd certGeneration
@@ -58,24 +62,27 @@ yes | openssl ca -config ca_root.cnf \
 # Generate a certificate chain containing the ca_root and server certificates
 cat server.crt ca_root.crt > server_chain.crt
 
-openssl req -x509 -new \
-            -key unittests.key \
+# Generate other unittest certificate variations
+for base in unittests ec_unittests; do
+  openssl req -x509 -new \
+            -key $base.key \
             -config unittests.conf \
-            -out unittests.crt \
+            -out $base.crt \
             -days 824
 
-openssl pkcs8 -topk8 \
-            -out unittests.p8 \
-            -in unittests.key \
+  openssl pkcs8 -topk8 \
+            -out $base.p8 \
+            -in $base.key \
             -nocrypt
 
-openssl pkcs12 -export \
-            -out unittests.p12 \
-            -inkey unittests.key \
-            -in unittests.crt \
+  openssl pkcs12 -export \
+            -out $base.p12 \
+            -inkey $base.key \
+            -in $base.crt \
             -password pass:1234
+done
 
-# Copy the generated certificates and keys to the resouces folder
+# Copy the generated certificates and keys to the resources folder
 cd ..
 cp certGeneration/ca_root.crt ./ca_root.crt
 cp certGeneration/server.crt ./server.crt
@@ -83,9 +90,11 @@ cp certGeneration/server.key ./server.key
 cp certGeneration/server_chain.crt ./server_chain.crt
 cp certGeneration/server.crt ./server.crt
 
-cp certGeneration/unittests.crt ./unittests.crt
-cp certGeneration/unittests.p8 ./unittests.p8
-cp certGeneration/unittests.p12 ./unittests.p12
+for base in unittests ec_unittests; do
+  cp certGeneration/$base.crt ./$base.crt
+  cp certGeneration/$base.p8 ./$base.p8
+  cp certGeneration/$base.p12 ./$base.p12
+done
 
 # Clean up the certGeneration folder
 rm -r certGeneration

data/aws-crt-ffi/crt/aws-c-io/tests/socket_test.c

@@ -237,6 +237,11 @@ static int s_test_socket_ex(
 
     ASSERT_SUCCESS(aws_socket_bind(&listener, endpoint));
 
+    struct aws_socket_endpoint bound_endpoint;
+    ASSERT_SUCCESS(aws_socket_get_bound_address(&listener, &bound_endpoint));
+    ASSERT_INT_EQUALS(endpoint->port, bound_endpoint.port);
+    ASSERT_STR_EQUALS(endpoint->address, bound_endpoint.address);
+
     if (options->type == AWS_SOCKET_STREAM) {
         ASSERT_SUCCESS(aws_socket_listen(&listener, 1024));
         ASSERT_SUCCESS(aws_socket_start_accept(&listener, event_loop, s_local_listener_incoming, &listener_args));
@@ -409,6 +414,7 @@ static int s_test_local_socket_communication(struct aws_allocator *allocator, vo
     uint64_t timestamp = 0;
     ASSERT_SUCCESS(aws_sys_clock_get_ticks(&timestamp));
     struct aws_socket_endpoint endpoint;
+    AWS_ZERO_STRUCT(endpoint);
 
     snprintf(endpoint.address, sizeof(endpoint.address), LOCAL_SOCK_TEST_PATTERN, (long long unsigned)timestamp);
 
@@ -865,6 +871,71 @@ static int s_test_incoming_duplicate_tcp_bind_errors(struct aws_allocator *alloc
 
 AWS_TEST_CASE(incoming_duplicate_tcp_bind_errors, s_test_incoming_duplicate_tcp_bind_errors)
 
+/* Ensure that binding to port 0 results in OS assigning a port */
+static int s_test_bind_on_zero_port(
+    struct aws_allocator *allocator,
+    enum aws_socket_type sock_type,
+    enum aws_socket_domain sock_domain,
+    const char *address) {
+
+    struct aws_event_loop *event_loop = aws_event_loop_new_default(allocator, aws_high_res_clock_get_ticks);
+
+    ASSERT_NOT_NULL(event_loop, "Event loop creation failed with error: %s", aws_error_debug_str(aws_last_error()));
+    ASSERT_SUCCESS(aws_event_loop_run(event_loop));
+
+    struct aws_socket_options options;
+    AWS_ZERO_STRUCT(options);
+    options.connect_timeout_ms = 1000;
+    options.type = sock_type;
+    options.domain = sock_domain;
+
+    struct aws_socket_endpoint endpoint = {
+        .port = 0 /* important: must be 0 for this test */,
+    };
+    strncpy(endpoint.address, address, sizeof(endpoint.address));
+
+    struct aws_socket incoming;
+    ASSERT_SUCCESS(aws_socket_init(&incoming, allocator, &options));
+
+    /* ensure address query fails if socket isn't bound yet */
+    struct aws_socket_endpoint local_address1;
+    ASSERT_FAILS(aws_socket_get_bound_address(&incoming, &local_address1));
+
+    ASSERT_SUCCESS(aws_socket_bind(&incoming, &endpoint));
+
+    ASSERT_SUCCESS(aws_socket_get_bound_address(&incoming, &local_address1));
+
+    if (sock_type != AWS_SOCKET_DGRAM) {
+        ASSERT_SUCCESS(aws_socket_listen(&incoming, 1024));
+    }
+
+    ASSERT_TRUE(local_address1.port > 0);
+    ASSERT_STR_EQUALS(address, local_address1.address);
+
+    /* ensure that querying again gets the same results */
+    struct aws_socket_endpoint local_address2;
+    ASSERT_SUCCESS(aws_socket_get_bound_address(&incoming, &local_address2));
+    ASSERT_INT_EQUALS(local_address1.port, local_address2.port);
+    ASSERT_STR_EQUALS(local_address1.address, local_address2.address);
+
+    aws_socket_close(&incoming);
+    aws_socket_clean_up(&incoming);
+    aws_event_loop_destroy(event_loop);
+    return 0;
+}
+
+static int s_bind_on_zero_port_tcp_ipv4(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    return s_test_bind_on_zero_port(allocator, AWS_SOCKET_STREAM, AWS_SOCKET_IPV4, "127.0.0.1");
+}
+AWS_TEST_CASE(bind_on_zero_port_tcp_ipv4, s_bind_on_zero_port_tcp_ipv4)
+
+static int s_bind_on_zero_port_udp_ipv4(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    return s_test_bind_on_zero_port(allocator, AWS_SOCKET_DGRAM, AWS_SOCKET_IPV4, "127.0.0.1");
+}
+AWS_TEST_CASE(bind_on_zero_port_udp_ipv4, s_bind_on_zero_port_udp_ipv4)
+
 static int s_test_incoming_udp_sock_errors(struct aws_allocator *allocator, void *ctx) {
     (void)ctx;
     if (!s_test_running_as_root(allocator)) {
@@ -1581,7 +1652,7 @@ static int s_local_socket_pipe_connected_race(struct aws_allocator *allocator, v
     uint64_t timestamp = 0;
     ASSERT_SUCCESS(aws_sys_clock_get_ticks(&timestamp));
     struct aws_socket_endpoint endpoint;
-
+    AWS_ZERO_STRUCT(endpoint);
     snprintf(endpoint.address, sizeof(endpoint.address), LOCAL_SOCK_TEST_PATTERN, (long long unsigned)timestamp);
 
     struct aws_socket listener;

data/aws-crt-ffi/crt/s2n/CMakeLists.txt

@@ -341,7 +341,7 @@ set_target_properties(${PROJECT_NAME} PROPERTIES LINKER_LANGUAGE C)
 set(CMAKE_C_FLAGS_DEBUGOPT "")
 
 target_compile_options(${PROJECT_NAME} PRIVATE -pedantic -std=gnu99 -Wall -Wimplicit -Wunused -Wcomment -Wchar-subscripts
-        -Wuninitialized -Wshadow -Wcast-qual -Wcast-align -Wwrite-strings -Wno-deprecated-declarations -Wno-unknown-pragmas -Wformat-security
+        -Wuninitialized -Wshadow -Wcast-align -Wwrite-strings -Wno-deprecated-declarations -Wno-unknown-pragmas -Wformat-security
         -Wno-missing-braces -Wa,--noexecstack
 )
 
@@ -477,6 +477,11 @@ endif()
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules")
 
+if (NOT $ENV{S2N_LIBCRYPTO} STREQUAL "awslc")
+    # add cast-qual back in for non AWS-LC
+    target_compile_options(${PROJECT_NAME} PRIVATE -Wcast-qual)
+endif()
+
 #work around target differences
 if (TARGET crypto)
     message(STATUS "S2N found target: crypto")

data/aws-crt-ffi/crt/s2n/bindings/rust/Cargo.toml

@@ -4,6 +4,7 @@ members = [
     "integration",
     "s2n-tls",
     "s2n-tls-sys",
+    "s2n-tls-tokio",
 ]
 
 [profile.release]

data/aws-crt-ffi/crt/s2n/bindings/rust/generate/src/main.rs

@@ -1,7 +1,6 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-use bindgen::CodegenConfig;
 use std::{
     collections::BTreeSet,
     io,
@@ -13,44 +12,51 @@ fn main() {
     let out_dir = std::env::args().nth(1).expect("missing sys dir");
     let out_dir = Path::new(&out_dir);
 
-    gen_bindings("#include <s2n.h>", &out_dir.join("lib"))
-        .allowlist_type("s2n_.*")
-        .allowlist_function("s2n_.*")
-        .allowlist_var("s2n_.*")
-        .generate()
-        .unwrap()
-        .write_to_file(out_dir.join("src/api.rs"))
-        .unwrap();
-
-    gen_bindings("#include \"tls/s2n_quic_support.h\"", &out_dir.join("lib"))
-        .allowlist_function("s2n_.*quic.*")
-        .allowlist_function("s2n_.*secret_callback.*")
-        .blocklist_type("s2n_config")
-        .blocklist_type("s2n_connection")
-        .raw_line("use crate::api::*;\n")
-        .generate()
-        .unwrap()
-        .write_to_file(out_dir.join("src/quic.rs"))
-        .unwrap();
-
-    gen_bindings("#include \"tls/s2n_internal.h\"", &out_dir.join("lib"))
-        .allowlist_function("s2n_.*")
-        .blocklist_type("s2n_config")
-        .blocklist_type("s2n_connection")
-        .raw_line("use crate::api::*;\n")
-        .generate()
-        .unwrap()
-        .write_to_file(out_dir.join("src/internal.rs"))
-        .unwrap();
-
     let functions = FunctionCallbacks::default();
 
-    gen_bindings("#include <s2n.h>", &out_dir.join("lib"))
-        .allowlist_function("s2n_.*")
-        .with_codegen_config(CodegenConfig::FUNCTIONS)
-        .parse_callbacks(Box::new(functions.clone()))
-        .generate()
-        .unwrap();
+    gen_bindings(
+        "#include <s2n.h>",
+        &out_dir.join("lib"),
+        functions.with_feature(None),
+    )
+    .allowlist_type("s2n_.*")
+    .allowlist_function("s2n_.*")
+    .allowlist_var("s2n_.*")
+    .generate()
+    .unwrap()
+    .write_to_file(out_dir.join("src/api.rs"))
+    .unwrap();
+
+    gen_bindings(
+        "#include \"tls/s2n_quic_support.h\"",
+        &out_dir.join("lib"),
+        functions.with_feature(Some("quic")),
+    )
+    .allowlist_function("s2n_.*quic.*")
+    .allowlist_function("s2n_.*secret_callback.*")
+    .allowlist_function("s2n_error_get_alert")
+    .blocklist_type("s2n_config")
+    .blocklist_type("s2n_connection")
+    .raw_line("use crate::api::*;\n")
+    .generate()
+    .unwrap()
+    .write_to_file(out_dir.join("src/quic.rs"))
+    .unwrap();
+
+    gen_bindings(
+        "#include \"tls/s2n_internal.h\"",
+        &out_dir.join("lib"),
+        functions.with_feature(Some("internal")),
+    )
+    // any new internal functions need to be added here
+    .allowlist_function("s2n_.*")
+    .blocklist_type("s2n_config")
+    .blocklist_type("s2n_connection")
+    .raw_line("use crate::api::*;\n")
+    .generate()
+    .unwrap()
+    .write_to_file(out_dir.join("src/internal.rs"))
+    .unwrap();
 
     functions.tests(&out_dir.join("src/tests.rs")).unwrap();
 
@@ -68,7 +74,7 @@ const PRELUDE: &str = r#"
 use libc::{iovec, FILE};
 "#;
 
-fn gen_bindings(entry: &str, s2n_dir: &Path) -> bindgen::Builder {
+fn gen_bindings(entry: &str, s2n_dir: &Path, functions: FunctionCallbacks) -> bindgen::Builder {
     let builder = bindgen::Builder::default()
         .use_core()
         .layout_tests(true)
@@ -91,7 +97,7 @@ fn gen_bindings(entry: &str, s2n_dir: &Path) -> bindgen::Builder {
         .raw_line(COPYRIGHT)
         .raw_line(PRELUDE)
         .ctypes_prefix("::libc")
-        .parse_callbacks(Box::new(S2nCallbacks::default()))
+        .parse_callbacks(Box::new(functions))
         .clang_arg(format!("-I{}/api", s2n_dir.display()))
         .clang_arg(format!("-I{}", s2n_dir.display()));
     builder
@@ -120,51 +126,21 @@ fn gen_files(input: &Path, out: &Path) -> io::Result<()> {
     Ok(())
 }
 
-#[derive(Debug, Default)]
-struct S2nCallbacks;
-
-impl bindgen::callbacks::ParseCallbacks for S2nCallbacks {
-    fn enum_variant_name(
-        &self,
-        _enum_name: Option<&str>,
-        variant_name: &str,
-        _variant_value: bindgen::callbacks::EnumVariantValue,
-    ) -> Option<String> {
-        if !variant_name.starts_with("S2N_") {
-            return None;
-        }
-
-        let variant_name = variant_name
-            .trim_start_matches("S2N_ERR_T_")
-            .trim_start_matches("S2N_EXTENSION_")
-            // keep the LEN_ so it's a valid identifier
-            .trim_start_matches("S2N_TLS_MAX_FRAG_")
-            .trim_start_matches("S2N_ALERT_")
-            .trim_start_matches("S2N_CT_SUPPORT_")
-            .trim_start_matches("S2N_STATUS_REQUEST_")
-            .trim_start_matches("S2N_CERT_AUTH_")
-            .trim_start_matches("S2N_CLIENT_HELLO_CB_")
-            .trim_start_matches("S2N_TLS_SIGNATURE_")
-            .trim_start_matches("S2N_TLS_HASH_")
-            .trim_start_matches("S2N_PSK_HMAC_")
-            .trim_start_matches("S2N_PSK_MODE_")
-            .trim_start_matches("S2N_ASYNC_PKEY_VALIDATION_")
-            .trim_start_matches("S2N_ASYNC_")
-            .trim_start_matches("S2N_EARLY_DATA_STATUS_")
-            // match everything else
-            .trim_start_matches("S2N_");
-
-        Some(variant_name.to_owned())
-    }
-}
+type SharedBTreeSet<T> = Arc<Mutex<BTreeSet<T>>>;
 
 #[derive(Clone, Debug, Default)]
 struct FunctionCallbacks {
-    types: Arc<Mutex<BTreeSet<String>>>,
-    functions: Arc<Mutex<BTreeSet<String>>>,
+    feature: Arc<Mutex<Option<&'static str>>>,
+    types: SharedBTreeSet<String>,
+    functions: SharedBTreeSet<(Option<&'static str>, String)>,
 }
 
 impl FunctionCallbacks {
+    fn with_feature(&self, feature: Option<&'static str>) -> Self {
+        *self.feature.lock().unwrap() = feature;
+        self.clone()
+    }
+
     fn tests(&self, out: &Path) -> io::Result<()> {
         use io::Write;
         let functions = self.functions.lock().unwrap();
@@ -180,6 +156,7 @@ impl FunctionCallbacks {
                 "s2n_cache_retrieve_callback",
                 "s2n_cache_store_callback",
                 "s2n_cert",
+                "s2n_cert_public_key",
                 "s2n_cert_chain_and_key",
                 "s2n_cert_private_key",
                 "s2n_cert_tiebreak_callback",
@@ -206,6 +183,7 @@ impl FunctionCallbacks {
                 "s2n_rand_mix_callback",
                 "s2n_rand_seed_callback",
                 "s2n_recv_fn",
+                "s2n_secret_cb",
                 "s2n_send_fn",
                 "s2n_session_ticket",
                 "s2n_session_ticket_fn",
@@ -221,8 +199,24 @@ impl FunctionCallbacks {
         let mut o = io::BufWriter::new(&mut tests);
 
         writeln!(o, "{}", COPYRIGHT)?;
-        for function in functions.difference(&types) {
+        for (feature, function) in functions.iter() {
+            // don't generate tests for types
+            if types.contains(function) {
+                continue;
+            }
+
+            // don't generate a test if it's enabled without a feature
+            if feature.is_some() && functions.contains(&(None, function.to_string())) {
+                continue;
+            }
+
             writeln!(o, "#[test]")?;
+
+            // if the function is behind a feature, gate it with `cfg`
+            if let Some(feature) = feature {
+                writeln!(o, "#[cfg(feature = {:?})]", feature)?;
+            };
+
             writeln!(o, "fn {} () {{", function)?;
             writeln!(o, "    let ptr = crate::{} as *const ();", function)?;
             writeln!(o, "    assert!(!ptr.is_null());")?;
@@ -238,19 +232,48 @@ impl bindgen::callbacks::ParseCallbacks for FunctionCallbacks {
     fn enum_variant_name(
         &self,
         name: Option<&str>,
-        _original_variant_name: &str,
+        variant_name: &str,
         _variant_value: bindgen::callbacks::EnumVariantValue,
     ) -> Option<String> {
         let name = name.unwrap_or("");
         if name.starts_with("s2n_") {
             self.types.lock().unwrap().insert(name.to_owned());
         }
-        None
+
+        if !variant_name.starts_with("S2N_") {
+            return None;
+        }
+
+        let variant_name = variant_name
+            .trim_start_matches("S2N_ERR_T_")
+            .trim_start_matches("S2N_EXTENSION_")
+            // keep the LEN_ so it's a valid identifier
+            .trim_start_matches("S2N_TLS_MAX_FRAG_")
+            .trim_start_matches("S2N_ALERT_")
+            .trim_start_matches("S2N_CT_SUPPORT_")
+            .trim_start_matches("S2N_STATUS_REQUEST_")
+            .trim_start_matches("S2N_CERT_AUTH_")
+            .trim_start_matches("S2N_CLIENT_HELLO_CB_")
+            .trim_start_matches("S2N_TLS_SIGNATURE_")
+            .trim_start_matches("S2N_TLS_HASH_")
+            .trim_start_matches("S2N_PSK_HMAC_")
+            .trim_start_matches("S2N_PSK_MODE_")
+            .trim_start_matches("S2N_ASYNC_PKEY_VALIDATION_")
+            .trim_start_matches("S2N_ASYNC_")
+            .trim_start_matches("S2N_EARLY_DATA_STATUS_")
+            // match everything else
+            .trim_start_matches("S2N_");
+
+        Some(variant_name.to_owned())
     }
 
     fn item_name(&self, name: &str) -> Option<String> {
         if name.starts_with("s2n_") {
-            self.functions.lock().unwrap().insert(name.to_owned());
+            let feature = *self.feature.lock().unwrap();
+            self.functions
+                .lock()
+                .unwrap()
+                .insert((feature, name.to_owned()));
         }
         None
     }

data/aws-crt-ffi/crt/s2n/bindings/rust/generate.sh

@@ -32,6 +32,7 @@ cd s2n-tls-sys \
   && cargo test \
   && cargo test --release \
   && cargo test --features quic \
+  && cargo test --features internal \
   && cd ..
 
 cd integration \

data/aws-crt-ffi/crt/s2n/bindings/rust/s2n-tls/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "s2n-tls"
 description = "A C99 implementation of the TLS/SSL protocols"
-version = "0.0.4"
+version = "0.0.5"
 authors = ["AWS s2n"]
 edition = "2018"
 repository = "https://github.com/aws/s2n-tls"
@@ -17,7 +17,7 @@ testing = ["errno", "bytes"]
 bytes = { version = "1", optional = true }
 errno = { version = "0.2", optional = true }
 libc = "0.2"
-s2n-tls-sys = { version = "=0.0.4", path = "../s2n-tls-sys", features = ["internal"] }
+s2n-tls-sys = { version = "=0.0.5", path = "../s2n-tls-sys", features = ["internal"] }
 
 [dev-dependencies]
 bytes = { version = "1" }

data/aws-crt-ffi/crt/s2n/bindings/rust/s2n-tls/src/raw/config.rs

@@ -9,7 +9,7 @@ use crate::raw::{
 use core::{convert::TryInto, ptr::NonNull, task::Poll};
 use s2n_tls_sys::*;
 use std::{
-    ffi::{c_void, CStr, CString},
+    ffi::{c_void, CString},
     mem::ManuallyDrop,
     sync::atomic::{AtomicUsize, Ordering},
 };

data/aws-crt-ffi/crt/s2n/bindings/rust/s2n-tls-sys/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "s2n-tls-sys"
 description = "A C99 implementation of the TLS/SSL protocols"
-version = "0.0.4"
+version = "0.0.5"
 authors = ["AWS s2n"]
 edition = "2018"
 links = "s2n-tls"