Create verify_peer_options when creating ssl credentials in order to expose a verification callback option.

These options are not yet exposed to languages outside of core.

3 files changed, 295 insertions, 2 deletions

diff --git a/test/core/handshake/BUILD b/test/core/handshake/BUILD
index a3276b9343..712cd59197 100644
--- a/test/core/handshake/BUILD
+++ b/test/core/handshake/BUILD
@@ -82,3 +82,21 @@ grpc_cc_test(
         "//test/core/util:grpc_test_util",
     ],
 )
+
+grpc_cc_test(
+    name = "handshake_verify_peer_options",
+    srcs = ["verify_peer_options.cc"],
+    language = "C++",
+    data = [
+        "//src/core/tsi/test_creds:ca.pem",
+        "//src/core/tsi/test_creds:server1.key",
+        "//src/core/tsi/test_creds:server1.pem",
+    ],
+    deps = [
+        "//:gpr",
+        "//:grpc",
+        "//test/core/util:gpr_test_util",
+        "//test/core/util:grpc_test_util",
+    ],
+)
+
diff --git a/test/core/handshake/client_ssl.cc b/test/core/handshake/client_ssl.cc
index 8ac763ac4b..467df6e229 100644
--- a/test/core/handshake/client_ssl.cc
+++ b/test/core/handshake/client_ssl.cc
@@ -251,8 +251,8 @@ static bool client_ssl_test(char* server_alpn_preferred) {
       reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
   pem_key_cert_pair.cert_chain =
       reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
-  grpc_channel_credentials* ssl_creds =
-      grpc_ssl_credentials_create(ca_cert, &pem_key_cert_pair, nullptr);
+  grpc_channel_credentials* ssl_creds = grpc_ssl_credentials_create(
+      ca_cert, &pem_key_cert_pair, nullptr, nullptr);
 
   // Establish a channel pointing at the TLS server. Since the gRPC runtime is
   // lazy, this won't necessarily establish a connection yet.
diff --git a/test/core/handshake/verify_peer_options.cc b/test/core/handshake/verify_peer_options.cc
new file mode 100644
index 0000000000..86c524b4a5
--- /dev/null
+++ b/test/core/handshake/verify_peer_options.cc
@@ -0,0 +1,275 @@
+/*
+ *
+ * Copyright 2018 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/iomgr/port.h"
+
+// This test won't work except with posix sockets enabled
+#ifdef GRPC_POSIX_SOCKET
+
+#include <arpa/inet.h>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+
+#include "src/core/lib/gprpp/thd.h"
+#include "src/core/lib/iomgr/load_file.h"
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+
+#define SSL_CERT_PATH "src/core/tsi/test_creds/server1.pem"
+#define SSL_KEY_PATH "src/core/tsi/test_creds/server1.key"
+#define SSL_CA_PATH "src/core/tsi/test_creds/ca.pem"
+
+// Simple gRPC server. This listens until client_handshake_complete occurs.
+static gpr_event client_handshake_complete;
+
+static void server_thread(void* arg) {
+  const int port = *static_cast<int*>(arg);
+
+  // Load key pair and establish server SSL credentials.
+  grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
+  grpc_slice ca_slice, cert_slice, key_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SSL_CA_PATH, 1, &ca_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SSL_CERT_PATH, 1, &cert_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SSL_KEY_PATH, 1, &key_slice)));
+  const char* ca_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
+  pem_key_cert_pair.private_key =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+  pem_key_cert_pair.cert_chain =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+  grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
+      ca_cert, &pem_key_cert_pair, 1, 0, nullptr);
+
+  // Start server listening on local port.
+  char* addr;
+  gpr_asprintf(&addr, "127.0.0.1:%d", port);
+  grpc_server* server = grpc_server_create(nullptr, nullptr);
+  GPR_ASSERT(grpc_server_add_secure_http2_port(server, addr, ssl_creds));
+  free(addr);
+
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
+
+  grpc_server_register_completion_queue(server, cq, nullptr);
+  grpc_server_start(server);
+
+  // Wait a bounded number of time until client_handshake_complete is set,
+  // sleeping between polls. The total time spent (deadline * retries)
+  // should be strictly greater than the client retry limit so that the
+  // client will always timeout first.
+  int retries = 60;
+  while (!gpr_event_get(&client_handshake_complete) && retries-- > 0) {
+    const gpr_timespec cq_deadline = grpc_timeout_seconds_to_deadline(1);
+    grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, nullptr);
+    GPR_ASSERT(ev.type == GRPC_QUEUE_TIMEOUT);
+  }
+
+  gpr_log(GPR_INFO, "Shutting down server");
+  grpc_server_shutdown_and_notify(server, cq, nullptr);
+  grpc_server_cancel_all_calls(server);
+  grpc_completion_queue_shutdown(cq);
+
+  const gpr_timespec cq_deadline = grpc_timeout_seconds_to_deadline(60);
+  grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, nullptr);
+  GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
+
+  grpc_server_destroy(server);
+  grpc_completion_queue_destroy(cq);
+  grpc_server_credentials_release(ssl_creds);
+  grpc_slice_unref(cert_slice);
+  grpc_slice_unref(key_slice);
+  grpc_slice_unref(ca_slice);
+}
+
+// This test launches a minimal TLS grpc server on a separate thread and then
+// establishes a TLS handshake via the core library to the server. The client
+// uses the supplied verify options.
+static bool verify_peer_options_test(verify_peer_options* verify_options) {
+  bool success = true;
+
+  grpc_init();
+  int port = grpc_pick_unused_port_or_die();
+  gpr_event_init(&client_handshake_complete);
+
+  // Launch the gRPC server thread.
+  bool ok;
+  grpc_core::Thread thd("grpc_client_ssl_test", server_thread, &port, &ok);
+  GPR_ASSERT(ok);
+  thd.Start();
+
+  // Load key pair and establish client SSL credentials.
+  grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
+  grpc_slice ca_slice, cert_slice, key_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SSL_CA_PATH, 1, &ca_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SSL_CERT_PATH, 1, &cert_slice)));
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SSL_KEY_PATH, 1, &key_slice)));
+  const char* ca_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
+  pem_key_cert_pair.private_key =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
+  pem_key_cert_pair.cert_chain =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+  grpc_channel_credentials* ssl_creds = grpc_ssl_credentials_create(
+      ca_cert, &pem_key_cert_pair, verify_options, nullptr);
+
+  // Establish a channel pointing at the TLS server. Since the gRPC runtime is
+  // lazy, this won't necessarily establish a connection yet.
+  char* target;
+  gpr_asprintf(&target, "127.0.0.1:%d", port);
+  grpc_arg ssl_name_override = {
+      GRPC_ARG_STRING,
+      const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
+      {const_cast<char*>("foo.test.google.fr")}};
+  grpc_channel_args grpc_args;
+  grpc_args.num_args = 1;
+  grpc_args.args = &ssl_name_override;
+  grpc_channel* channel =
+      grpc_secure_channel_create(ssl_creds, target, &grpc_args, nullptr);
+  GPR_ASSERT(channel);
+  gpr_free(target);
+
+  // Initially the channel will be idle, the
+  // grpc_channel_check_connectivity_state triggers an attempt to connect.
+  GPR_ASSERT(grpc_channel_check_connectivity_state(
+                 channel, 1 /* try_to_connect */) == GRPC_CHANNEL_IDLE);
+
+  // Wait a bounded number of times for the channel to be ready. When the
+  // channel is ready, the initial TLS handshake will have successfully
+  // completed. The total time spent on the client side (retries * deadline)
+  // should be greater than the server side time limit.
+  int retries = 10;
+  grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
+  grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
+
+  while (state != GRPC_CHANNEL_READY && retries-- > 0) {
+    grpc_channel_watch_connectivity_state(
+        channel, state, grpc_timeout_seconds_to_deadline(3), cq, nullptr);
+    gpr_timespec cq_deadline = grpc_timeout_seconds_to_deadline(5);
+    grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, nullptr);
+    GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
+    state =
+        grpc_channel_check_connectivity_state(channel, 0 /* try_to_connect */);
+  }
+  grpc_completion_queue_destroy(cq);
+  if (retries < 0) {
+    success = false;
+  }
+
+  grpc_channel_destroy(channel);
+  grpc_channel_credentials_release(ssl_creds);
+  grpc_slice_unref(cert_slice);
+  grpc_slice_unref(key_slice);
+  grpc_slice_unref(ca_slice);
+
+  // Now that the client is completely cleaned up, trigger the server to
+  // shutdown
+  gpr_event_set(&client_handshake_complete, &client_handshake_complete);
+  // Wait for the server to completely shutdown
+  thd.Join();
+
+  grpc_shutdown();
+
+  return success;
+}
+
+static int callback_return_value = 0;
+static char callback_target_host[4096];
+static char callback_target_pem[4096];
+static void* callback_userdata = nullptr;
+static void* destruct_userdata = nullptr;
+
+static int verify_callback(const char* target_host, const char* target_pem,
+                           void* userdata) {
+  if (target_host != nullptr) {
+    snprintf(callback_target_host, sizeof(callback_target_host), "%s",
+             target_host);
+  } else {
+    callback_target_host[0] = '\0';
+  }
+  if (target_pem != nullptr) {
+    snprintf(callback_target_pem, sizeof(callback_target_pem), "%s",
+             target_pem);
+  } else {
+    callback_target_pem[0] = '\0';
+  }
+  callback_userdata = userdata;
+  return callback_return_value;
+}
+
+static void verify_destruct(void* userdata) { destruct_userdata = userdata; }
+
+int main(int argc, char* argv[]) {
+  int userdata = 42;
+  verify_peer_options verify_options;
+
+  // Load the server's cert so that we can assert it gets passed to the callback
+  grpc_slice cert_slice;
+  GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
+                               grpc_load_file(SSL_CERT_PATH, 1, &cert_slice)));
+  const char* server_cert =
+      reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
+
+  // Running with all-null values should have no effect
+  verify_options.verify_peer_callback = nullptr;
+  verify_options.verify_peer_callback_userdata = nullptr;
+  verify_options.verify_peer_destruct = nullptr;
+  GPR_ASSERT(verify_peer_options_test(&verify_options));
+  GPR_ASSERT(strlen(callback_target_host) == 0);
+  GPR_ASSERT(strlen(callback_target_pem) == 0);
+  GPR_ASSERT(callback_userdata == nullptr);
+  GPR_ASSERT(destruct_userdata == nullptr);
+
+  // Running with the callbacks and verify we get the expected values
+  verify_options.verify_peer_callback = verify_callback;
+  verify_options.verify_peer_callback_userdata = static_cast<void*>(&userdata);
+  verify_options.verify_peer_destruct = verify_destruct;
+  GPR_ASSERT(verify_peer_options_test(&verify_options));
+  GPR_ASSERT(strcmp(callback_target_host, "foo.test.google.fr") == 0);
+  GPR_ASSERT(strcmp(callback_target_pem, server_cert) == 0);
+  GPR_ASSERT(callback_userdata == static_cast<void*>(&userdata));
+  GPR_ASSERT(destruct_userdata == static_cast<void*>(&userdata));
+
+  // If the callback returns non-zero, initializing the channel should fail.
+  callback_return_value = 1;
+  GPR_ASSERT(!verify_peer_options_test(&verify_options));
+
+  grpc_slice_unref(cert_slice);
+
+  return 0;
+}
+
+#else /* GRPC_POSIX_SOCKET */
+
+int main(int argc, char** argv) { return 1; }
+
+#endif /* GRPC_POSIX_SOCKET */