aws-crt 0.1.9 → 0.2.0

data/aws-crt-ffi/crt/aws-lc/ssl/ssl_x509.cc

@@ -981,6 +981,134 @@ int SSL_add1_chain_cert(SSL *ssl, X509 *x509) {
   return ssl_cert_add1_chain_cert(ssl->config->cert.get(), x509);
 }
 
+#define is_flag_set(flags, query) (flags & query)
+
+static int ssl_build_cert_chain(CERT *cert, X509_STORE *cert_store, int flags) {
+  assert(cert_store);
+  if (!ssl_cert_check_cert_private_keys_usage(cert)) {
+    return 0;
+  }
+
+  CERT_PKEY *cert_pkey = &cert->cert_private_keys[cert->cert_private_key_idx];
+  CRYPTO_BUFFER *leaf_buffer =
+      sk_CRYPTO_BUFFER_value(cert_pkey->chain.get(), 0);
+  if (leaf_buffer == nullptr) {
+    OPENSSL_PUT_ERROR(SSL, SSL_R_NO_CERTIFICATE_SET);
+    return 0;
+  }
+  UniquePtr<X509> leaf(X509_parse_from_buffer(leaf_buffer));
+  if (leaf == nullptr) {
+    OPENSSL_PUT_ERROR(SSL, ERR_R_X509_LIB);
+    return 0;
+  }
+
+  UniquePtr<X509_STORE> store(X509_STORE_new());
+  UniquePtr<X509_STORE_CTX> store_ctx(X509_STORE_CTX_new());
+  if (store == nullptr || store_ctx == nullptr) {
+    OPENSSL_PUT_ERROR(SSL, ERR_R_MALLOC_FAILURE);
+    return 0;
+  }
+
+  // Rearranging and check the chain: add everything to a store
+  UniquePtr<STACK_OF(X509)> untrusted(sk_X509_new_null());
+  if (is_flag_set(flags, SSL_BUILD_CHAIN_FLAG_CHECK)) {
+    // Push certs onto |X509_STORE|.
+    for (size_t i = 1; i < sk_CRYPTO_BUFFER_num(cert_pkey->chain.get()); i++) {
+      CRYPTO_BUFFER *buffer = sk_CRYPTO_BUFFER_value(cert_pkey->chain.get(), i);
+      UniquePtr<X509> x509(X509_parse_from_buffer(buffer));
+      if (!x509 || !X509_STORE_add_cert(store.get(), x509.get())) {
+        return 0;
+      }
+    }
+    // Add end-entity certificate too: it might be self-signed.
+    if (!X509_STORE_add_cert(store.get(), leaf.get())) {
+      return 0;
+    }
+  } else {
+    // Use associated |cert_store| from |SSL_CTX|. Reference count added to
+    // avoid double freeing of |X509_STORE|.
+    store.reset(cert_store);
+    X509_STORE_up_ref(cert_store);
+
+    if (is_flag_set(flags, SSL_BUILD_CHAIN_FLAG_UNTRUSTED)) {
+      // Push certs onto untrusted stack.
+      for (size_t i = 1; i < sk_CRYPTO_BUFFER_num(cert_pkey->chain.get());
+           i++) {
+        CRYPTO_BUFFER *buffer =
+            sk_CRYPTO_BUFFER_value(cert_pkey->chain.get(), i);
+        UniquePtr<X509> x509(X509_parse_from_buffer(buffer));
+        if (!x509 || !PushToStack(untrusted.get(), std::move(x509))) {
+          return 0;
+        }
+      }
+    }
+  }
+
+  if (!X509_STORE_CTX_init(store_ctx.get(), store.get(), leaf.get(),
+                           untrusted.get())) {
+    OPENSSL_PUT_ERROR(SSL, ERR_R_X509_LIB);
+    return 0;
+  }
+
+  bool ignore_error = false;
+  if (X509_verify_cert(store_ctx.get()) <= 0) {
+    // Fail if |SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR| is not set.
+    if(!is_flag_set(flags, SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR)) {
+      OPENSSL_PUT_ERROR(SSL, SSL_R_CERTIFICATE_VERIFY_FAILED);
+      ERR_add_error_data(2, "Verify error:",
+                         X509_verify_cert_error_string(
+                             X509_STORE_CTX_get_error(store_ctx.get())));
+      return 0;
+    }
+
+    if (is_flag_set(flags, SSL_BUILD_CHAIN_FLAG_CLEAR_ERROR)) {
+      ERR_clear_error();
+    }
+    ignore_error = true;
+  }
+
+  UniquePtr<STACK_OF(X509)> built_chain(
+      X509_STORE_CTX_get1_chain(store_ctx.get()));
+  // Remove EE certificate from chain.
+  X509_free(sk_X509_shift(built_chain.get()));
+
+  if (is_flag_set(flags, SSL_BUILD_CHAIN_FLAG_NO_ROOT)) {
+    if (sk_X509_num(built_chain.get()) > 0) {
+      // See if last cert is self-signed.
+      if (X509_get_extension_flags(sk_X509_value(
+              built_chain.get(), sk_X509_num(built_chain.get()) - 1)) &
+          EXFLAG_SS) {
+        X509_free(sk_X509_pop(built_chain.get()));
+      }
+    }
+  }
+  if (!ssl_cert_set_chain(cert, built_chain.get())) {
+    return 0;
+  }
+
+  // Anything that has passed successfully up to here is valid.
+  // 2 is used to indicate a verification error has happened, but was ignored
+  // because |SSL_BUILD_CHAIN_FLAG_IGNORE_ERROR| was set.
+  if(ignore_error) {
+    return 2;
+  }
+  return 1;
+}
+
+int SSL_CTX_build_cert_chain(SSL_CTX *ctx, int flags) {
+  check_ssl_ctx_x509_method(ctx);
+  return ssl_build_cert_chain(ctx->cert.get(), ctx->cert_store, flags);
+}
+
+int SSL_build_cert_chain(SSL *ssl, int flags) {
+  check_ssl_x509_method(ssl);
+  if (!ssl->config) {
+    return 0;
+  }
+  return ssl_build_cert_chain(ssl->config->cert.get(), ssl->ctx->cert_store,
+                              flags);
+}
+
 int SSL_CTX_clear_chain_certs(SSL_CTX *ctx) {
   check_ssl_ctx_x509_method(ctx);
   return SSL_CTX_set0_chain(ctx, NULL);

data/aws-crt-ffi/crt/aws-lc/ssl/test/PORTING.md

@@ -20,15 +20,18 @@ The test runner integrates with the TLS stack under test through a
 “shim”: a command line program which encapsulates the stack. By
 default, the shim points to the BoringSSL shim in the same source
 tree, but any program can be supplied via the `-shim-path` flag. The
-runner opens up a server socket and provides the shim with a `-port`
-argument that points to that socket. The shim always connects to the
-runner as a TCP client even when acting as a TLS server. For DTLS,
-there is a small framing layer that gives packet boundaries over
-TCP. The shim can also pass a variety of command line arguments which
-are used to configure the stack under test. These can be found at
+runner opens up a server socket and provides the shim with `-port`, `-shim-id`
+and optional `-ipv6` arguments.
+
+For each connection, the shim should connect to loopback as a TCP client on
+the specified port, using IPv6 if `-ipv6` is specified and IPv4 otherwise.
+It then sends the shim ID as a 64-bit, little-endian integer and proceeds with
+the test. The shim is a TCP client even when testing DTLS or TLS server
+behavior. For DTLS, there is a small framing layer that gives packet boundaries
+over TCP. The shim can also pass a variety of command line arguments
+which are used to configure the stack under test. These can be found at
 `test_config.cc`.
 
-
 The shim reports success by exiting with a `0` error code and failure by
 reporting a non-zero error code and generally sending a textual error
 value to stderr. Many of the tests expect specific error string (such

data/aws-crt-ffi/crt/aws-lc/ssl/test/bssl_shim.cc

@@ -72,15 +72,85 @@ OPENSSL_MSVC_PRAGMA(warning(pop))
 
 
 #if !defined(OPENSSL_WINDOWS)
-static int closesocket(int sock) { return close(sock); }
+using Socket = int;
+#define INVALID_SOCKET (-1)
 
+static int closesocket(int sock) { return close(sock); }
 static void PrintSocketError(const char *func) { perror(func); }
 #else
+using Socket = SOCKET;
+
 static void PrintSocketError(const char *func) {
-  fprintf(stderr, "%s: %d\n", func, WSAGetLastError());
+  int error = WSAGetLastError();
+  char *buffer;
+  DWORD len = FormatMessageA(
+      FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, 0, error, 0,
+      reinterpret_cast<char *>(&buffer), 0, nullptr);
+  std::string msg = "unknown error";
+  if (len > 0) {
+    msg.assign(buffer, len);
+    while (!msg.empty() && (msg.back() == '\r' || msg.back() == '\n')) {
+      msg.resize(msg.size() - 1);
+    }
+  }
+  LocalFree(buffer);
+  fprintf(stderr, "%s: %s (%d)\n", func, msg.c_str(), error);
 }
 #endif
 
+class OwnedSocket {
+ public:
+  OwnedSocket() = default;
+  explicit OwnedSocket(Socket sock) : sock_(sock) {}
+  OwnedSocket(OwnedSocket &&other) { *this = std::move(other); }
+  ~OwnedSocket() { reset(); }
+  OwnedSocket &operator=(OwnedSocket &&other) {
+    if (this != &other) {
+      drain_on_close_ = other.drain_on_close_;
+      reset(other.release());
+    }
+    return *this;
+  }
+
+  bool is_valid() const { return sock_ != INVALID_SOCKET; }
+  void set_drain_on_close(bool drain) { drain_on_close_ = drain; }
+
+  void reset(Socket sock = INVALID_SOCKET) {
+    if (is_valid()) {
+      if (drain_on_close_) {
+#if defined(OPENSSL_WINDOWS)
+        shutdown(sock_, SD_SEND);
+#else
+        shutdown(sock_, SHUT_WR);
+#endif
+        while (true) {
+          char buf[1024];
+          if (recv(sock_, buf, sizeof(buf), 0) <= 0) {
+            break;
+          }
+        }
+        closesocket(sock_);
+      }
+    }
+
+    drain_on_close_ = false;
+    sock_ = sock;
+  }
+
+  Socket get() const { return sock_; }
+
+  Socket release() {
+    Socket sock = sock_;
+    sock_ = INVALID_SOCKET;
+    drain_on_close_ = false;
+    return sock;
+  }
+
+ private:
+  Socket sock_ = INVALID_SOCKET;
+  bool drain_on_close_ = false;
+};
+
 static int Usage(const char *program) {
   fprintf(stderr, "Usage: %s [flags...]\n", program);
   return 1;
@@ -91,83 +161,55 @@ struct Free {
   void operator()(T *buf) { free(buf); }
 };
 
-// Connect returns a new socket connected to localhost on |port| or -1 on
-// error.
-static int Connect(uint16_t port) {
-  for (int af : {AF_INET6, AF_INET}) {
-    int sock = socket(af, SOCK_STREAM, 0);
-    if (sock == -1) {
-      PrintSocketError("socket");
-      return -1;
-    }
-    int nodelay = 1;
-    if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY,
-                   reinterpret_cast<const char *>(&nodelay),
-                   sizeof(nodelay)) != 0) {
-      PrintSocketError("setsockopt");
-      closesocket(sock);
-      return -1;
-    }
-
-    sockaddr_storage ss;
-    OPENSSL_memset(&ss, 0, sizeof(ss));
-    ss.ss_family = af;
-    socklen_t len = 0;
-
-    if (af == AF_INET6) {
-      sockaddr_in6 *sin6 = (sockaddr_in6 *)&ss;
-      len = sizeof(*sin6);
-      sin6->sin6_port = htons(port);
-      if (!inet_pton(AF_INET6, "::1", &sin6->sin6_addr)) {
-        PrintSocketError("inet_pton");
-        closesocket(sock);
-        return -1;
-      }
-    } else if (af == AF_INET) {
-      sockaddr_in *sin = (sockaddr_in *)&ss;
-      len = sizeof(*sin);
-      sin->sin_port = htons(port);
-      if (!inet_pton(AF_INET, "127.0.0.1", &sin->sin_addr)) {
-        PrintSocketError("inet_pton");
-        closesocket(sock);
-        return -1;
-      }
-    }
-
-    if (connect(sock, reinterpret_cast<const sockaddr *>(&ss), len) == 0) {
-      return sock;
+// Connect returns a new socket connected to the runner, or -1 on error.
+static OwnedSocket Connect(const TestConfig *config) {
+  sockaddr_storage addr;
+  socklen_t addr_len = 0;
+  if (config->ipv6) {
+    sockaddr_in6 sin6;
+    OPENSSL_memset(&sin6, 0, sizeof(sin6));
+    sin6.sin6_family = AF_INET6;
+    sin6.sin6_port = htons(config->port);
+    if (!inet_pton(AF_INET6, "::1", &sin6.sin6_addr)) {
+      PrintSocketError("inet_pton");
+      return OwnedSocket();
+    }
+    addr_len = sizeof(sin6);
+    memcpy(&addr, &sin6, addr_len);
+  } else {
+    sockaddr_in sin;
+    OPENSSL_memset(&sin, 0, sizeof(sin));
+    sin.sin_family = AF_INET;
+    sin.sin_port = htons(config->port);
+    if (!inet_pton(AF_INET, "127.0.0.1", &sin.sin_addr)) {
+      PrintSocketError("inet_pton");
+      return OwnedSocket();
     }
-    closesocket(sock);
+    addr_len = sizeof(sin);
+    memcpy(&addr, &sin, addr_len);
   }
 
-  PrintSocketError("connect");
-  return -1;
-}
+  OwnedSocket sock(socket(addr.ss_family, SOCK_STREAM, 0));
+  if (!sock.is_valid()) {
+    PrintSocketError("socket");
+    return OwnedSocket();
+  }
+  int nodelay = 1;
+  if (setsockopt(sock.get(), IPPROTO_TCP, TCP_NODELAY,
+                 reinterpret_cast<const char *>(&nodelay),
+                 sizeof(nodelay)) != 0) {
+    PrintSocketError("setsockopt");
+    return OwnedSocket();
+  }
 
-class SocketCloser {
- public:
-  explicit SocketCloser(int sock) : sock_(sock) {}
-  ~SocketCloser() {
-    // Half-close and drain the socket before releasing it. This seems to be
-    // necessary for graceful shutdown on Windows. It will also avoid write
-    // failures in the test runner.
-#if defined(OPENSSL_WINDOWS)
-    shutdown(sock_, SD_SEND);
-#else
-    shutdown(sock_, SHUT_WR);
-#endif
-    while (true) {
-      char buf[1024];
-      if (recv(sock_, buf, sizeof(buf), 0) <= 0) {
-        break;
-      }
-    }
-    closesocket(sock_);
+  if (connect(sock.get(), reinterpret_cast<const sockaddr *>(&addr),
+              addr_len) != 0) {
+    PrintSocketError("connect");
+    return OwnedSocket();
   }
 
- private:
-  const int sock_;
-};
+  return sock;
+}
 
 static bool TransferSSL(const TestConfig *config, bssl::UniquePtr<SSL> *in,
                         SSL **ssl) {
@@ -801,16 +843,30 @@ static bool DoConnection(bssl::UniquePtr<SSL_SESSION> *out_session,
 #endif
   }
 
-  int sock = Connect(config->port);
-  if (sock == -1) {
+  OwnedSocket sock = Connect(config);
+  if (!sock.is_valid()) {
     return false;
   }
-  SocketCloser closer(sock);
 
-  bssl::UniquePtr<BIO> bio(BIO_new_socket(sock, BIO_NOCLOSE));
+  // Half-close and drain the socket before releasing it. This seems to be
+  // necessary for graceful shutdown on Windows. It will also avoid write
+  // failures in the test runner.
+  sock.set_drain_on_close(true);
+
+  // Windows uses |SOCKET| for socket types, but OpenSSL's API requires casting
+  // them to |int|.
+  bssl::UniquePtr<BIO> bio(
+      BIO_new_socket(static_cast<int>(sock.get()), BIO_NOCLOSE));
   if (!bio) {
     return false;
   }
+
+  uint8_t shim_id[8];
+  CRYPTO_store_u64_le(shim_id, config->shim_id);
+  if (!BIO_write_all(bio.get(), shim_id, sizeof(shim_id))) {
+    return false;
+  }
+
   if (config->is_dtls) {
     bssl::UniquePtr<BIO> packeted = PacketedBioCreate(GetClock());
     if (!packeted) {

data/aws-crt-ffi/crt/aws-lc/ssl/test/handshake_util.cc

@@ -398,9 +398,9 @@ static bool StartHandshaker(ScopedProcess *out, ScopedFD *out_control,
   if (is_resume) {
     args.push_back(kResumeFlag);
   }
-  // config->argv omits argv[0].
-  for (int j = 0; j < config->argc; ++j) {
-    args.push_back(config->argv[j]);
+  // config->handshaker_args omits argv[0].
+  for (const char *arg : config->handshaker_args) {
+    args.push_back(arg);
   }
   args.push_back(nullptr);
 

data/aws-crt-ffi/crt/aws-lc/ssl/test/handshaker.cc

@@ -61,6 +61,8 @@ bool Handshaker(const TestConfig *config, int rfd, int wfd,
   UniquePtr<SSL> ssl =
       config->NewSSL(ctx.get(), /*session=*/nullptr, /*test_state=*/nullptr);
   if (!ssl) {
+    fprintf(stderr, "Error creating SSL object in handshaker.\n");
+    ERR_print_errors_fp(stderr);
     return false;
   }
 
@@ -155,6 +157,8 @@ bool GenerateHandshakeHint(const TestConfig *config,
       config->NewSSL(ctx.get(), /*session=*/nullptr,
                      std::unique_ptr<TestState>(new TestState));
   if (!ssl) {
+    fprintf(stderr, "Error creating SSL object in handshaker.\n");
+    ERR_print_errors_fp(stderr);
     return false;
   }
 

data/aws-crt-ffi/crt/aws-lc/ssl/test/runner/handshake_client.go

@@ -21,6 +21,7 @@ import (
 	"time"
 
 	"boringssl.googlesource.com/boringssl/ssl/test/runner/hpke"
+	"golang.org/x/crypto/cryptobyte"
 )
 
 const echBadPayloadByte = 0xff
@@ -71,9 +72,12 @@ func replaceClientHello(hello *clientHelloMsg, in []byte) (*clientHelloMsg, erro
 	// Replace |newHellos|'s key shares with those of |hello|. For simplicity,
 	// we require their lengths match, which is satisfied by matching the
 	// DefaultCurves setting to the selection in the replacement ClientHello.
-	bb := newByteBuilder()
+	bb := cryptobyte.NewBuilder(nil)
 	hello.marshalKeyShares(bb)
-	keyShares := bb.finish()
+	keyShares, err := bb.Bytes()
+	if err != nil {
+		return nil, err
+	}
 	if len(keyShares) != len(newHello.keySharesRaw) {
 		return nil, errors.New("tls: ClientHello key share length is inconsistent with DefaultCurves setting")
 	}