1 //
2 //
3 // Copyright 2018 gRPC authors.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 //
18
19 #include "src/core/lib/iomgr/port.h"
20
21 // This test won't work except with posix sockets enabled
22 #ifdef GRPC_POSIX_SOCKET_TCP
23
24 #include <arpa/inet.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <sys/socket.h>
28 #include <unistd.h>
29
30 #include <string>
31
32 #include <openssl/err.h>
33 #include <openssl/ssl.h>
34
35 #include "absl/strings/str_cat.h"
36
37 #include <grpc/grpc.h>
38 #include <grpc/grpc_security.h>
39 #include <grpc/support/alloc.h>
40 #include <grpc/support/log.h>
41
42 #include "src/core/lib/gprpp/crash.h"
43 #include "src/core/lib/gprpp/thd.h"
44 #include "test/core/util/port.h"
45 #include "test/core/util/test_config.h"
46 #include "test/core/util/tls_utils.h"
47
48 #define SSL_CERT_PATH "src/core/tsi/test_creds/server1.pem"
49 #define SSL_KEY_PATH "src/core/tsi/test_creds/server1.key"
50 #define SSL_CA_PATH "src/core/tsi/test_creds/ca.pem"
51
52 // Simple gRPC server. This listens until client_handshake_complete occurs.
53 static gpr_event client_handshake_complete;
54
server_thread(void * arg)55 static void server_thread(void* arg) {
56 const int port = *static_cast<int*>(arg);
57
58 // Load key pair and establish server SSL credentials.
59 std::string ca_cert = grpc_core::testing::GetFileContents(SSL_CA_PATH);
60 std::string cert = grpc_core::testing::GetFileContents(SSL_CERT_PATH);
61 std::string key = grpc_core::testing::GetFileContents(SSL_KEY_PATH);
62
63 grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
64 pem_key_cert_pair.private_key = key.c_str();
65 pem_key_cert_pair.cert_chain = cert.c_str();
66 grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
67 ca_cert.c_str(), &pem_key_cert_pair, 1, 0, nullptr);
68
69 // Start server listening on local port.
70 std::string addr = absl::StrCat("127.0.0.1:", port);
71 grpc_server* server = grpc_server_create(nullptr, nullptr);
72 GPR_ASSERT(grpc_server_add_http2_port(server, addr.c_str(), ssl_creds));
73
74 grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
75
76 grpc_server_register_completion_queue(server, cq, nullptr);
77 grpc_server_start(server);
78
79 // Wait a bounded number of time until client_handshake_complete is set,
80 // sleeping between polls. The total time spent (deadline * retries)
81 // should be strictly greater than the client retry limit so that the
82 // client will always timeout first.
83 int retries = 60;
84 while (!gpr_event_get(&client_handshake_complete) && retries-- > 0) {
85 const gpr_timespec cq_deadline = grpc_timeout_seconds_to_deadline(1);
86 grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, nullptr);
87 GPR_ASSERT(ev.type == GRPC_QUEUE_TIMEOUT);
88 }
89
90 gpr_log(GPR_INFO, "Shutting down server");
91 grpc_server_shutdown_and_notify(server, cq, nullptr);
92 grpc_server_cancel_all_calls(server);
93 grpc_completion_queue_shutdown(cq);
94
95 const gpr_timespec cq_deadline = grpc_timeout_seconds_to_deadline(60);
96 grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, nullptr);
97 GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
98
99 grpc_server_destroy(server);
100 grpc_completion_queue_destroy(cq);
101 grpc_server_credentials_release(ssl_creds);
102 }
103
104 // This test launches a minimal TLS grpc server on a separate thread and then
105 // establishes a TLS handshake via the core library to the server. The client
106 // uses the supplied verify options.
verify_peer_options_test(verify_peer_options * verify_options)107 static bool verify_peer_options_test(verify_peer_options* verify_options) {
108 bool success = true;
109
110 grpc_init();
111 int port = grpc_pick_unused_port_or_die();
112 gpr_event_init(&client_handshake_complete);
113
114 // Load key pair and establish client SSL credentials.
115 // NOTE: we intentionally load the credential files before starting
116 // the server thread because loading the file can experience trouble
117 // when two threads attempt to load the same file concurrently
118 // and server thread also reads the same files as soon as it starts.
119 // See https://github.com/grpc/grpc/issues/23503 for details.
120 std::string ca_cert = grpc_core::testing::GetFileContents(SSL_CA_PATH);
121 std::string cert = grpc_core::testing::GetFileContents(SSL_CERT_PATH);
122 std::string key = grpc_core::testing::GetFileContents(SSL_KEY_PATH);
123
124 grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
125 pem_key_cert_pair.private_key = key.c_str();
126 pem_key_cert_pair.cert_chain = cert.c_str();
127 grpc_channel_credentials* ssl_creds = grpc_ssl_credentials_create(
128 ca_cert.c_str(), &pem_key_cert_pair, verify_options, nullptr);
129
130 // Launch the gRPC server thread.
131 bool ok;
132 grpc_core::Thread thd("grpc_client_ssl_test", server_thread, &port, &ok);
133 GPR_ASSERT(ok);
134 thd.Start();
135
136 // Establish a channel pointing at the TLS server. Since the gRPC runtime is
137 // lazy, this won't necessarily establish a connection yet.
138 std::string target = absl::StrCat("127.0.0.1:", port);
139 grpc_arg ssl_name_override = {
140 GRPC_ARG_STRING,
141 const_cast<char*>(GRPC_SSL_TARGET_NAME_OVERRIDE_ARG),
142 {const_cast<char*>("foo.test.google.fr")}};
143 grpc_channel_args grpc_args;
144 grpc_args.num_args = 1;
145 grpc_args.args = &ssl_name_override;
146 grpc_channel* channel =
147 grpc_channel_create(target.c_str(), ssl_creds, &grpc_args);
148 GPR_ASSERT(channel);
149
150 // Initially the channel will be idle, the
151 // grpc_channel_check_connectivity_state triggers an attempt to connect.
152 GPR_ASSERT(grpc_channel_check_connectivity_state(
153 channel, 1 /* try_to_connect */) == GRPC_CHANNEL_IDLE);
154
155 // Wait a bounded number of times for the channel to be ready. When the
156 // channel is ready, the initial TLS handshake will have successfully
157 // completed. The total time spent on the client side (retries * deadline)
158 // should be greater than the server side time limit.
159 int retries = 10;
160 grpc_connectivity_state state = GRPC_CHANNEL_IDLE;
161 grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
162
163 while (state != GRPC_CHANNEL_READY && retries-- > 0) {
164 grpc_channel_watch_connectivity_state(
165 channel, state, grpc_timeout_seconds_to_deadline(3), cq, nullptr);
166 gpr_timespec cq_deadline = grpc_timeout_seconds_to_deadline(5);
167 grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, nullptr);
168 GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
169 state =
170 grpc_channel_check_connectivity_state(channel, 0 /* try_to_connect */);
171 }
172 grpc_completion_queue_destroy(cq);
173 if (retries < 0) {
174 success = false;
175 }
176
177 grpc_channel_destroy(channel);
178 grpc_channel_credentials_release(ssl_creds);
179
180 // Now that the client is completely cleaned up, trigger the server to
181 // shutdown
182 gpr_event_set(&client_handshake_complete, &client_handshake_complete);
183 // Wait for the server to completely shutdown
184 thd.Join();
185
186 grpc_shutdown();
187
188 return success;
189 }
190
191 static int callback_return_value = 0;
192 static char callback_target_host[4096];
193 static char callback_target_pem[4096];
194 static void* callback_userdata = nullptr;
195 static void* destruct_userdata = nullptr;
196
verify_callback(const char * target_host,const char * target_pem,void * userdata)197 static int verify_callback(const char* target_host, const char* target_pem,
198 void* userdata) {
199 if (target_host != nullptr) {
200 snprintf(callback_target_host, sizeof(callback_target_host), "%s",
201 target_host);
202 } else {
203 callback_target_host[0] = '\0';
204 }
205 if (target_pem != nullptr) {
206 snprintf(callback_target_pem, sizeof(callback_target_pem), "%s",
207 target_pem);
208 } else {
209 callback_target_pem[0] = '\0';
210 }
211 callback_userdata = userdata;
212 return callback_return_value;
213 }
214
verify_destruct(void * userdata)215 static void verify_destruct(void* userdata) { destruct_userdata = userdata; }
216
main(int argc,char * argv[])217 int main(int argc, char* argv[]) {
218 grpc::testing::TestEnvironment env(&argc, argv);
219 grpc_init();
220
221 int userdata = 42;
222 verify_peer_options verify_options;
223
224 // Load the server's cert so that we can assert it gets passed to the callback
225 std::string server_cert = grpc_core::testing::GetFileContents(SSL_CERT_PATH);
226
227 // Running with all-null values should have no effect
228 verify_options.verify_peer_callback = nullptr;
229 verify_options.verify_peer_callback_userdata = nullptr;
230 verify_options.verify_peer_destruct = nullptr;
231 GPR_ASSERT(verify_peer_options_test(&verify_options));
232 GPR_ASSERT(strlen(callback_target_host) == 0);
233 GPR_ASSERT(strlen(callback_target_pem) == 0);
234 GPR_ASSERT(callback_userdata == nullptr);
235 GPR_ASSERT(destruct_userdata == nullptr);
236
237 // Running with the callbacks and verify we get the expected values
238 verify_options.verify_peer_callback = verify_callback;
239 verify_options.verify_peer_callback_userdata = static_cast<void*>(&userdata);
240 verify_options.verify_peer_destruct = verify_destruct;
241 GPR_ASSERT(verify_peer_options_test(&verify_options));
242 GPR_ASSERT(strcmp(callback_target_host, "foo.test.google.fr") == 0);
243 GPR_ASSERT(strcmp(callback_target_pem, server_cert.c_str()) == 0);
244 GPR_ASSERT(callback_userdata == static_cast<void*>(&userdata));
245 GPR_ASSERT(destruct_userdata == static_cast<void*>(&userdata));
246
247 // If the callback returns non-zero, initializing the channel should fail.
248 callback_return_value = 1;
249 GPR_ASSERT(!verify_peer_options_test(&verify_options));
250
251 grpc_shutdown();
252 return 0;
253 }
254
255 #else // GRPC_POSIX_SOCKET_TCP
256
main(int argc,char ** argv)257 int main(int argc, char** argv) { return 1; }
258
259 #endif // GRPC_POSIX_SOCKET_TCP
260