1 /*
2 *
3 * Copyright 2016 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 "test/core/handshake/server_ssl_common.h"
20
21 #include <arpa/inet.h>
22 #include <openssl/err.h>
23 #include <openssl/ssl.h>
24 #include <string.h>
25 #include <sys/socket.h>
26 #include <unistd.h>
27
28 #include <string>
29
30 #include "absl/strings/str_cat.h"
31
32 #include <grpc/grpc.h>
33 #include <grpc/grpc_security.h>
34 #include <grpc/support/alloc.h>
35 #include <grpc/support/log.h>
36 #include <grpc/support/sync.h>
37
38 #include "src/core/lib/gprpp/sync.h"
39 #include "src/core/lib/gprpp/thd.h"
40 #include "src/core/lib/iomgr/load_file.h"
41 #include "test/core/util/port.h"
42 #include "test/core/util/test_config.h"
43
44 #define SSL_CERT_PATH "src/core/tsi/test_creds/server1.pem"
45 #define SSL_KEY_PATH "src/core/tsi/test_creds/server1.key"
46 #define SSL_CA_PATH "src/core/tsi/test_creds/ca.pem"
47
48 namespace {
49
50 // Handshake completed signal to server thread.
51 gpr_event client_handshake_complete;
52
create_socket(int port)53 int create_socket(int port) {
54 int s;
55 struct sockaddr_in addr;
56
57 addr.sin_family = AF_INET;
58 addr.sin_port = htons(static_cast<uint16_t>(port));
59 addr.sin_addr.s_addr = htonl(INADDR_ANY);
60
61 s = socket(AF_INET, SOCK_STREAM, 0);
62 if (s < 0) {
63 perror("Unable to create socket");
64 return -1;
65 }
66
67 if (connect(s, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)) < 0) {
68 perror("Unable to connect");
69 return -1;
70 }
71
72 return s;
73 }
74
75 class ServerInfo {
76 public:
ServerInfo(int p)77 explicit ServerInfo(int p) : port_(p) {}
78
port() const79 int port() const { return port_; }
80
Activate()81 void Activate() {
82 grpc_core::MutexLock lock(&mu_);
83 ready_ = true;
84 cv_.Signal();
85 }
86
Await()87 void Await() {
88 grpc_core::MutexLock lock(&mu_);
89 cv_.WaitUntil(&mu_, [this] { return ready_; });
90 }
91
92 private:
93 const int port_;
94 grpc_core::Mutex mu_;
95 grpc_core::CondVar cv_;
96 bool ready_ = false;
97 };
98
99 // Simple gRPC server. This listens until client_handshake_complete occurs.
server_thread(void * arg)100 void server_thread(void* arg) {
101 ServerInfo* s = static_cast<ServerInfo*>(arg);
102 const int port = s->port();
103
104 // Load key pair and establish server SSL credentials.
105 grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
106 grpc_slice ca_slice, cert_slice, key_slice;
107 GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
108 grpc_load_file(SSL_CA_PATH, 1, &ca_slice)));
109 GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
110 grpc_load_file(SSL_CERT_PATH, 1, &cert_slice)));
111 GPR_ASSERT(GRPC_LOG_IF_ERROR("load_file",
112 grpc_load_file(SSL_KEY_PATH, 1, &key_slice)));
113 const char* ca_cert =
114 reinterpret_cast<const char*> GRPC_SLICE_START_PTR(ca_slice);
115 pem_key_cert_pair.private_key =
116 reinterpret_cast<const char*> GRPC_SLICE_START_PTR(key_slice);
117 pem_key_cert_pair.cert_chain =
118 reinterpret_cast<const char*> GRPC_SLICE_START_PTR(cert_slice);
119 grpc_server_credentials* ssl_creds = grpc_ssl_server_credentials_create(
120 ca_cert, &pem_key_cert_pair, 1, 0, nullptr);
121
122 // Start server listening on local port.
123 std::string addr = absl::StrCat("127.0.0.1:", port);
124 grpc_server* server = grpc_server_create(nullptr, nullptr);
125 GPR_ASSERT(
126 grpc_server_add_secure_http2_port(server, addr.c_str(), ssl_creds));
127
128 grpc_completion_queue* cq = grpc_completion_queue_create_for_next(nullptr);
129
130 grpc_server_register_completion_queue(server, cq, nullptr);
131 grpc_server_start(server);
132
133 // Notify the other side that it is now ok to start working since SSL is
134 // definitely already started.
135 s->Activate();
136
137 // Wait a bounded number of time until client_handshake_complete is set,
138 // sleeping between polls.
139 int retries = 10;
140 while (!gpr_event_get(&client_handshake_complete) && retries-- > 0) {
141 const gpr_timespec cq_deadline = grpc_timeout_seconds_to_deadline(1);
142 grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, nullptr);
143 GPR_ASSERT(ev.type == GRPC_QUEUE_TIMEOUT);
144 }
145
146 gpr_log(GPR_INFO, "Shutting down server");
147 grpc_server_shutdown_and_notify(server, cq, nullptr);
148 grpc_completion_queue_shutdown(cq);
149
150 const gpr_timespec cq_deadline = grpc_timeout_seconds_to_deadline(5);
151 grpc_event ev = grpc_completion_queue_next(cq, cq_deadline, nullptr);
152 GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
153
154 grpc_server_destroy(server);
155 grpc_completion_queue_destroy(cq);
156 grpc_server_credentials_release(ssl_creds);
157 grpc_slice_unref(cert_slice);
158 grpc_slice_unref(key_slice);
159 grpc_slice_unref(ca_slice);
160 }
161
162 } // namespace
163
164 // This test launches a gRPC server on a separate thread and then establishes a
165 // TLS handshake via a minimal TLS client. The TLS client has configurable (via
166 // alpn_list) ALPN settings and can probe at the supported ALPN preferences
167 // using this (via alpn_expected).
server_ssl_test(const char * alpn_list[],unsigned int alpn_list_len,const char * alpn_expected)168 bool server_ssl_test(const char* alpn_list[], unsigned int alpn_list_len,
169 const char* alpn_expected) {
170 bool success = true;
171
172 grpc_init();
173 ServerInfo s(grpc_pick_unused_port_or_die());
174 gpr_event_init(&client_handshake_complete);
175
176 // Launch the gRPC server thread.
177 bool ok;
178 grpc_core::Thread thd("grpc_ssl_test", server_thread, &s, &ok);
179 GPR_ASSERT(ok);
180 thd.Start();
181
182 // The work in server_thread will cause the SSL initialization to take place
183 // so long as we wait for it to reach beyond the point of adding a secure
184 // server port.
185 s.Await();
186
187 const SSL_METHOD* method = TLSv1_2_client_method();
188 SSL_CTX* ctx = SSL_CTX_new(method);
189 if (!ctx) {
190 perror("Unable to create SSL context");
191 ERR_print_errors_fp(stderr);
192 abort();
193 }
194
195 // Load key pair.
196 if (SSL_CTX_use_certificate_file(ctx, SSL_CERT_PATH, SSL_FILETYPE_PEM) < 0) {
197 ERR_print_errors_fp(stderr);
198 abort();
199 }
200 if (SSL_CTX_use_PrivateKey_file(ctx, SSL_KEY_PATH, SSL_FILETYPE_PEM) < 0) {
201 ERR_print_errors_fp(stderr);
202 abort();
203 }
204
205 // Set the cipher list to match the one expressed in
206 // src/core/tsi/ssl_transport_security.c.
207 const char* cipher_list =
208 "ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES256-"
209 "SHA384:ECDHE-RSA-AES256-GCM-SHA384";
210 if (!SSL_CTX_set_cipher_list(ctx, cipher_list)) {
211 ERR_print_errors_fp(stderr);
212 gpr_log(GPR_ERROR, "Couldn't set server cipher list.");
213 abort();
214 }
215
216 // Configure ALPN list the client will send to the server. This must match the
217 // wire format, see documentation for SSL_CTX_set_alpn_protos.
218 unsigned int alpn_protos_len = alpn_list_len;
219 for (unsigned int i = 0; i < alpn_list_len; ++i) {
220 alpn_protos_len += static_cast<unsigned int>(strlen(alpn_list[i]));
221 }
222 unsigned char* alpn_protos =
223 static_cast<unsigned char*>(gpr_malloc(alpn_protos_len));
224 unsigned char* p = alpn_protos;
225 for (unsigned int i = 0; i < alpn_list_len; ++i) {
226 const uint8_t len = static_cast<uint8_t>(strlen(alpn_list[i]));
227 *p++ = len;
228 memcpy(p, alpn_list[i], len);
229 p += len;
230 }
231 GPR_ASSERT(SSL_CTX_set_alpn_protos(ctx, alpn_protos, alpn_protos_len) == 0);
232
233 // Try and connect to server. We allow a bounded number of retries as we might
234 // be racing with the server setup on its separate thread.
235 int retries = 10;
236 int sock = -1;
237 while (sock == -1 && retries-- > 0) {
238 sock = create_socket(s.port());
239 if (sock < 0) {
240 sleep(1);
241 }
242 }
243 GPR_ASSERT(sock > 0);
244 gpr_log(GPR_INFO, "Connected to server on port %d", s.port());
245
246 // Establish a SSL* and connect at SSL layer.
247 SSL* ssl = SSL_new(ctx);
248 GPR_ASSERT(ssl);
249 SSL_set_fd(ssl, sock);
250 if (SSL_connect(ssl) <= 0) {
251 ERR_print_errors_fp(stderr);
252 gpr_log(GPR_ERROR, "Handshake failed.");
253 success = false;
254 } else {
255 gpr_log(GPR_INFO, "Handshake successful.");
256 // Validate ALPN preferred by server matches alpn_expected.
257 const unsigned char* alpn_selected;
258 unsigned int alpn_selected_len;
259 SSL_get0_alpn_selected(ssl, &alpn_selected, &alpn_selected_len);
260 if (strlen(alpn_expected) != alpn_selected_len ||
261 strncmp(reinterpret_cast<const char*>(alpn_selected), alpn_expected,
262 alpn_selected_len) != 0) {
263 gpr_log(GPR_ERROR, "Unexpected ALPN protocol preference");
264 success = false;
265 }
266 }
267 gpr_event_set(&client_handshake_complete, &client_handshake_complete);
268
269 SSL_free(ssl);
270 gpr_free(alpn_protos);
271 SSL_CTX_free(ctx);
272 EVP_cleanup();
273 close(sock);
274
275 thd.Join();
276
277 grpc_shutdown();
278
279 return success;
280 }
281