/src/qemu/crypto/tlssession.c
Line | Count | Source |
1 | | /* |
2 | | * QEMU crypto TLS session support |
3 | | * |
4 | | * Copyright (c) 2015 Red Hat, Inc. |
5 | | * |
6 | | * This library is free software; you can redistribute it and/or |
7 | | * modify it under the terms of the GNU Lesser General Public |
8 | | * License as published by the Free Software Foundation; either |
9 | | * version 2.1 of the License, or (at your option) any later version. |
10 | | * |
11 | | * This library is distributed in the hope that it will be useful, |
12 | | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 | | * Lesser General Public License for more details. |
15 | | * |
16 | | * You should have received a copy of the GNU Lesser General Public |
17 | | * License along with this library; if not, see <http://www.gnu.org/licenses/>. |
18 | | * |
19 | | */ |
20 | | |
21 | | #include "qemu/osdep.h" |
22 | | #include "crypto/tlssession.h" |
23 | | #include "crypto/tlscredsanon.h" |
24 | | #include "crypto/tlscredspsk.h" |
25 | | #include "crypto/tlscredsx509.h" |
26 | | #include "qapi/error.h" |
27 | | #include "authz/base.h" |
28 | | #include "tlscredspriv.h" |
29 | | #include "trace.h" |
30 | | |
31 | | #ifdef CONFIG_GNUTLS |
32 | | |
33 | | |
34 | | #include <gnutls/x509.h> |
35 | | |
36 | | |
37 | | struct QCryptoTLSSession { |
38 | | QCryptoTLSCreds *creds; |
39 | | QCryptoTLSCredsBox *credsbox; |
40 | | gnutls_session_t handle; |
41 | | char *hostname; |
42 | | char *authzid; |
43 | | bool handshakeComplete; |
44 | | QCryptoTLSSessionWriteFunc writeFunc; |
45 | | QCryptoTLSSessionReadFunc readFunc; |
46 | | void *opaque; |
47 | | char *peername; |
48 | | |
49 | | /* |
50 | | * Allow concurrent reads and writes, so track |
51 | | * errors separately |
52 | | */ |
53 | | Error *rerr; |
54 | | Error *werr; |
55 | | }; |
56 | | |
57 | | |
58 | | void |
59 | | qcrypto_tls_session_free(QCryptoTLSSession *session) |
60 | | { |
61 | | if (!session) { |
62 | | return; |
63 | | } |
64 | | |
65 | | error_free(session->rerr); |
66 | | error_free(session->werr); |
67 | | |
68 | | gnutls_deinit(session->handle); |
69 | | g_free(session->hostname); |
70 | | g_free(session->peername); |
71 | | g_free(session->authzid); |
72 | | qcrypto_tls_creds_box_unref(session->credsbox); |
73 | | object_unref(OBJECT(session->creds)); |
74 | | g_free(session); |
75 | | } |
76 | | |
77 | | |
78 | | static ssize_t |
79 | | qcrypto_tls_session_push(void *opaque, const void *buf, size_t len) |
80 | | { |
81 | | QCryptoTLSSession *session = opaque; |
82 | | ssize_t ret; |
83 | | |
84 | | if (!session->writeFunc) { |
85 | | errno = EIO; |
86 | | return -1; |
87 | | }; |
88 | | |
89 | | error_free(session->werr); |
90 | | session->werr = NULL; |
91 | | |
92 | | ret = session->writeFunc(buf, len, session->opaque, &session->werr); |
93 | | if (ret == QCRYPTO_TLS_SESSION_ERR_BLOCK) { |
94 | | errno = EAGAIN; |
95 | | return -1; |
96 | | } else if (ret < 0) { |
97 | | errno = EIO; |
98 | | return -1; |
99 | | } else { |
100 | | return ret; |
101 | | } |
102 | | } |
103 | | |
104 | | |
105 | | static ssize_t |
106 | | qcrypto_tls_session_pull(void *opaque, void *buf, size_t len) |
107 | | { |
108 | | QCryptoTLSSession *session = opaque; |
109 | | ssize_t ret; |
110 | | |
111 | | if (!session->readFunc) { |
112 | | errno = EIO; |
113 | | return -1; |
114 | | }; |
115 | | |
116 | | error_free(session->rerr); |
117 | | session->rerr = NULL; |
118 | | |
119 | | ret = session->readFunc(buf, len, session->opaque, &session->rerr); |
120 | | if (ret == QCRYPTO_TLS_SESSION_ERR_BLOCK) { |
121 | | errno = EAGAIN; |
122 | | return -1; |
123 | | } else if (ret < 0) { |
124 | | errno = EIO; |
125 | | return -1; |
126 | | } else { |
127 | | return ret; |
128 | | } |
129 | | } |
130 | | |
131 | | QCryptoTLSSession * |
132 | | qcrypto_tls_session_new(QCryptoTLSCreds *creds, |
133 | | const char *hostname, |
134 | | const char *authzid, |
135 | | QCryptoTLSCredsEndpoint endpoint, |
136 | | Error **errp) |
137 | | { |
138 | | QCryptoTLSSession *session; |
139 | | int ret; |
140 | | g_autofree char *prio = NULL; |
141 | | |
142 | | session = g_new0(QCryptoTLSSession, 1); |
143 | | trace_qcrypto_tls_session_new( |
144 | | session, creds, hostname ? hostname : "<none>", |
145 | | authzid ? authzid : "<none>", endpoint); |
146 | | |
147 | | if (hostname) { |
148 | | session->hostname = g_strdup(hostname); |
149 | | } |
150 | | if (authzid) { |
151 | | session->authzid = g_strdup(authzid); |
152 | | } |
153 | | session->creds = creds; |
154 | | object_ref(OBJECT(creds)); |
155 | | |
156 | | if (creds->endpoint != endpoint) { |
157 | | error_setg(errp, "Credentials endpoint doesn't match session"); |
158 | | goto error; |
159 | | } |
160 | | |
161 | | if (endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) { |
162 | | ret = gnutls_init(&session->handle, GNUTLS_SERVER); |
163 | | } else { |
164 | | ret = gnutls_init(&session->handle, GNUTLS_CLIENT); |
165 | | } |
166 | | if (ret < 0) { |
167 | | error_setg(errp, "Cannot initialize TLS session: %s", |
168 | | gnutls_strerror(ret)); |
169 | | goto error; |
170 | | } |
171 | | |
172 | | prio = qcrypto_tls_creds_get_priority(creds); |
173 | | ret = gnutls_priority_set_direct(session->handle, prio, NULL); |
174 | | if (ret < 0) { |
175 | | error_setg(errp, "Unable to set TLS session priority %s: %s", |
176 | | prio, gnutls_strerror(ret)); |
177 | | goto error; |
178 | | } |
179 | | |
180 | | ret = gnutls_credentials_set(session->handle, |
181 | | creds->box->type, |
182 | | creds->box->data.any); |
183 | | if (ret < 0) { |
184 | | error_setg(errp, "Cannot set session credentials: %s", |
185 | | gnutls_strerror(ret)); |
186 | | goto error; |
187 | | } |
188 | | |
189 | | /* |
190 | | * creds->box->data.any must be kept alive for as long |
191 | | * as the gnutls_session_t is alive, so acquire a ref |
192 | | */ |
193 | | qcrypto_tls_creds_box_ref(creds->box); |
194 | | session->credsbox = creds->box; |
195 | | |
196 | | if (object_dynamic_cast(OBJECT(creds), |
197 | | TYPE_QCRYPTO_TLS_CREDS_X509) && |
198 | | creds->endpoint == QCRYPTO_TLS_CREDS_ENDPOINT_SERVER) { |
199 | | /* |
200 | | * This requests, but does not enforce a client cert. |
201 | | * The cert checking code later does enforcement |
202 | | */ |
203 | | gnutls_certificate_server_set_request(session->handle, |
204 | | GNUTLS_CERT_REQUEST); |
205 | | } |
206 | | |
207 | | gnutls_transport_set_ptr(session->handle, session); |
208 | | gnutls_transport_set_push_function(session->handle, |
209 | | qcrypto_tls_session_push); |
210 | | gnutls_transport_set_pull_function(session->handle, |
211 | | qcrypto_tls_session_pull); |
212 | | |
213 | | return session; |
214 | | |
215 | | error: |
216 | | qcrypto_tls_session_free(session); |
217 | | return NULL; |
218 | | } |
219 | | |
220 | | static int |
221 | | qcrypto_tls_session_check_certificate(QCryptoTLSSession *session, |
222 | | Error **errp) |
223 | | { |
224 | | int ret; |
225 | | unsigned int status; |
226 | | const gnutls_datum_t *certs; |
227 | | unsigned int nCerts, i; |
228 | | time_t now; |
229 | | gnutls_x509_crt_t cert = NULL; |
230 | | Error *err = NULL; |
231 | | |
232 | | now = time(NULL); |
233 | | if (now == ((time_t)-1)) { |
234 | | error_setg_errno(errp, errno, "Cannot get current time"); |
235 | | return -1; |
236 | | } |
237 | | |
238 | | ret = gnutls_certificate_verify_peers2(session->handle, &status); |
239 | | if (ret < 0) { |
240 | | error_setg(errp, "Verify failed: %s", gnutls_strerror(ret)); |
241 | | return -1; |
242 | | } |
243 | | |
244 | | if (status != 0) { |
245 | | const char *reason = "Invalid certificate"; |
246 | | |
247 | | if (status & GNUTLS_CERT_INVALID) { |
248 | | reason = "The certificate is not trusted"; |
249 | | } |
250 | | |
251 | | if (status & GNUTLS_CERT_SIGNER_NOT_FOUND) { |
252 | | reason = "The certificate hasn't got a known issuer"; |
253 | | } |
254 | | |
255 | | if (status & GNUTLS_CERT_REVOKED) { |
256 | | reason = "The certificate has been revoked"; |
257 | | } |
258 | | |
259 | | if (status & GNUTLS_CERT_INSECURE_ALGORITHM) { |
260 | | reason = "The certificate uses an insecure algorithm"; |
261 | | } |
262 | | |
263 | | error_setg(errp, "%s", reason); |
264 | | return -1; |
265 | | } |
266 | | |
267 | | certs = gnutls_certificate_get_peers(session->handle, &nCerts); |
268 | | if (!certs) { |
269 | | error_setg(errp, "No certificate peers"); |
270 | | return -1; |
271 | | } |
272 | | |
273 | | for (i = 0; i < nCerts; i++) { |
274 | | ret = gnutls_x509_crt_init(&cert); |
275 | | if (ret < 0) { |
276 | | error_setg(errp, "Cannot initialize certificate: %s", |
277 | | gnutls_strerror(ret)); |
278 | | return -1; |
279 | | } |
280 | | |
281 | | ret = gnutls_x509_crt_import(cert, &certs[i], GNUTLS_X509_FMT_DER); |
282 | | if (ret < 0) { |
283 | | error_setg(errp, "Cannot import certificate: %s", |
284 | | gnutls_strerror(ret)); |
285 | | goto error; |
286 | | } |
287 | | |
288 | | if (gnutls_x509_crt_get_expiration_time(cert) < now) { |
289 | | error_setg(errp, "The certificate has expired"); |
290 | | goto error; |
291 | | } |
292 | | |
293 | | if (gnutls_x509_crt_get_activation_time(cert) > now) { |
294 | | error_setg(errp, "The certificate is not yet activated"); |
295 | | goto error; |
296 | | } |
297 | | |
298 | | if (gnutls_x509_crt_get_activation_time(cert) > now) { |
299 | | error_setg(errp, "The certificate is not yet activated"); |
300 | | goto error; |
301 | | } |
302 | | |
303 | | if (i == 0) { |
304 | | gnutls_datum_t dname = {}; |
305 | | ret = gnutls_x509_crt_get_dn2(cert, &dname); |
306 | | if (ret < 0) { |
307 | | error_setg(errp, "Cannot get client distinguished name: %s", |
308 | | gnutls_strerror(ret)); |
309 | | goto error; |
310 | | } |
311 | | session->peername = (char *)g_steal_pointer(&dname.data); |
312 | | trace_qcrypto_tls_session_check_x509_dn(session, session->peername); |
313 | | if (session->authzid) { |
314 | | bool allow; |
315 | | |
316 | | allow = qauthz_is_allowed_by_id(session->authzid, |
317 | | session->peername, &err); |
318 | | if (err) { |
319 | | error_propagate(errp, err); |
320 | | goto error; |
321 | | } |
322 | | if (!allow) { |
323 | | error_setg(errp, "TLS x509 authz check for %s is denied", |
324 | | session->peername); |
325 | | goto error; |
326 | | } |
327 | | } |
328 | | if (session->hostname) { |
329 | | if (!gnutls_x509_crt_check_hostname(cert, session->hostname)) { |
330 | | error_setg(errp, |
331 | | "Certificate does not match the hostname %s", |
332 | | session->hostname); |
333 | | goto error; |
334 | | } |
335 | | } else { |
336 | | if (session->creds->endpoint == |
337 | | QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT) { |
338 | | error_setg(errp, "No hostname for certificate validation"); |
339 | | goto error; |
340 | | } |
341 | | } |
342 | | } |
343 | | |
344 | | gnutls_x509_crt_deinit(cert); |
345 | | } |
346 | | |
347 | | return 0; |
348 | | |
349 | | error: |
350 | | gnutls_x509_crt_deinit(cert); |
351 | | return -1; |
352 | | } |
353 | | |
354 | | |
355 | | int |
356 | | qcrypto_tls_session_check_credentials(QCryptoTLSSession *session, |
357 | | Error **errp) |
358 | | { |
359 | | if (object_dynamic_cast(OBJECT(session->creds), |
360 | | TYPE_QCRYPTO_TLS_CREDS_ANON)) { |
361 | | trace_qcrypto_tls_session_check_creds(session, "nop"); |
362 | | return 0; |
363 | | } else if (object_dynamic_cast(OBJECT(session->creds), |
364 | | TYPE_QCRYPTO_TLS_CREDS_PSK)) { |
365 | | trace_qcrypto_tls_session_check_creds(session, "nop"); |
366 | | return 0; |
367 | | } else if (object_dynamic_cast(OBJECT(session->creds), |
368 | | TYPE_QCRYPTO_TLS_CREDS_X509)) { |
369 | | if (session->creds->verifyPeer) { |
370 | | int ret = qcrypto_tls_session_check_certificate(session, |
371 | | errp); |
372 | | trace_qcrypto_tls_session_check_creds(session, |
373 | | ret == 0 ? "pass" : "fail"); |
374 | | return ret; |
375 | | } else { |
376 | | trace_qcrypto_tls_session_check_creds(session, "skip"); |
377 | | return 0; |
378 | | } |
379 | | } else { |
380 | | trace_qcrypto_tls_session_check_creds(session, "error"); |
381 | | error_setg(errp, "Unexpected credential type %s", |
382 | | object_get_typename(OBJECT(session->creds))); |
383 | | return -1; |
384 | | } |
385 | | } |
386 | | |
387 | | |
388 | | void |
389 | | qcrypto_tls_session_set_callbacks(QCryptoTLSSession *session, |
390 | | QCryptoTLSSessionWriteFunc writeFunc, |
391 | | QCryptoTLSSessionReadFunc readFunc, |
392 | | void *opaque) |
393 | | { |
394 | | session->writeFunc = writeFunc; |
395 | | session->readFunc = readFunc; |
396 | | session->opaque = opaque; |
397 | | } |
398 | | |
399 | | |
400 | | ssize_t |
401 | | qcrypto_tls_session_write(QCryptoTLSSession *session, |
402 | | const char *buf, |
403 | | size_t len, |
404 | | Error **errp) |
405 | | { |
406 | | ssize_t ret = gnutls_record_send(session->handle, buf, len); |
407 | | |
408 | | if (ret < 0) { |
409 | | if (ret == GNUTLS_E_AGAIN) { |
410 | | return QCRYPTO_TLS_SESSION_ERR_BLOCK; |
411 | | } else { |
412 | | if (session->werr) { |
413 | | error_propagate(errp, session->werr); |
414 | | session->werr = NULL; |
415 | | } else { |
416 | | error_setg(errp, |
417 | | "Cannot write to TLS channel: %s", |
418 | | gnutls_strerror(ret)); |
419 | | } |
420 | | return -1; |
421 | | } |
422 | | } |
423 | | |
424 | | return ret; |
425 | | } |
426 | | |
427 | | |
428 | | ssize_t |
429 | | qcrypto_tls_session_read(QCryptoTLSSession *session, |
430 | | char *buf, |
431 | | size_t len, |
432 | | Error **errp) |
433 | | { |
434 | | ssize_t ret = gnutls_record_recv(session->handle, buf, len); |
435 | | |
436 | | if (ret < 0) { |
437 | | if (ret == GNUTLS_E_AGAIN) { |
438 | | return QCRYPTO_TLS_SESSION_ERR_BLOCK; |
439 | | } else { |
440 | | if (session->rerr) { |
441 | | error_propagate(errp, session->rerr); |
442 | | session->rerr = NULL; |
443 | | } else { |
444 | | error_setg(errp, |
445 | | "Cannot read from TLS channel: %s", |
446 | | gnutls_strerror(ret)); |
447 | | } |
448 | | if (ret == GNUTLS_E_PREMATURE_TERMINATION) { |
449 | | return QCRYPTO_TLS_SESSION_PREMATURE_TERMINATION; |
450 | | } else { |
451 | | return -1; |
452 | | } |
453 | | } |
454 | | } |
455 | | |
456 | | return ret; |
457 | | } |
458 | | |
459 | | |
460 | | void qcrypto_tls_session_write_cork(QCryptoTLSSession *sess) |
461 | | { |
462 | | gnutls_record_cork(sess->handle); |
463 | | } |
464 | | |
465 | | |
466 | | ssize_t qcrypto_tls_session_write_uncork(QCryptoTLSSession *sess, |
467 | | Error **errp) |
468 | | { |
469 | | int ret; |
470 | | ret = gnutls_record_uncork(sess->handle, 0); |
471 | | if (ret == GNUTLS_E_AGAIN || |
472 | | ret == GNUTLS_E_INTERRUPTED) { |
473 | | ret = gnutls_record_check_corked(sess->handle); |
474 | | if (ret < 0) { |
475 | | error_setg(errp, |
476 | | "Cannot query pending TLS output: %s", |
477 | | gnutls_strerror(ret)); |
478 | | return -1; |
479 | | } |
480 | | |
481 | | return ret; |
482 | | } else if (ret < 0) { |
483 | | error_setg(errp, |
484 | | "Cannot uncork TLS output: %s", |
485 | | gnutls_strerror(ret)); |
486 | | return -1; |
487 | | } |
488 | | |
489 | | return 0; |
490 | | } |
491 | | |
492 | | |
493 | | size_t |
494 | | qcrypto_tls_session_check_pending(QCryptoTLSSession *session) |
495 | | { |
496 | | return gnutls_record_check_pending(session->handle); |
497 | | } |
498 | | |
499 | | |
500 | | int |
501 | | qcrypto_tls_session_handshake(QCryptoTLSSession *session, |
502 | | Error **errp) |
503 | | { |
504 | | int ret = gnutls_handshake(session->handle); |
505 | | if (!ret) { |
506 | | session->handshakeComplete = true; |
507 | | return QCRYPTO_TLS_HANDSHAKE_COMPLETE; |
508 | | } |
509 | | |
510 | | if (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) { |
511 | | int direction = gnutls_record_get_direction(session->handle); |
512 | | return direction ? QCRYPTO_TLS_HANDSHAKE_SENDING : |
513 | | QCRYPTO_TLS_HANDSHAKE_RECVING; |
514 | | } |
515 | | |
516 | | if (session->rerr || session->werr) { |
517 | | error_setg(errp, "TLS handshake failed: %s: %s", |
518 | | gnutls_strerror(ret), |
519 | | error_get_pretty(session->rerr ? |
520 | | session->rerr : session->werr)); |
521 | | } else { |
522 | | error_setg(errp, "TLS handshake failed: %s", |
523 | | gnutls_strerror(ret)); |
524 | | } |
525 | | |
526 | | error_free(session->rerr); |
527 | | error_free(session->werr); |
528 | | session->rerr = session->werr = NULL; |
529 | | |
530 | | return -1; |
531 | | } |
532 | | |
533 | | |
534 | | int |
535 | | qcrypto_tls_session_bye(QCryptoTLSSession *session, Error **errp) |
536 | | { |
537 | | int ret; |
538 | | |
539 | | if (!session->handshakeComplete) { |
540 | | return 0; |
541 | | } |
542 | | |
543 | | ret = gnutls_bye(session->handle, GNUTLS_SHUT_WR); |
544 | | |
545 | | if (!ret) { |
546 | | return QCRYPTO_TLS_BYE_COMPLETE; |
547 | | } |
548 | | |
549 | | if (ret == GNUTLS_E_INTERRUPTED || ret == GNUTLS_E_AGAIN) { |
550 | | int direction = gnutls_record_get_direction(session->handle); |
551 | | return direction ? QCRYPTO_TLS_BYE_SENDING : QCRYPTO_TLS_BYE_RECVING; |
552 | | } |
553 | | |
554 | | if (session->rerr || session->werr) { |
555 | | error_setg(errp, "TLS termination failed: %s: %s", gnutls_strerror(ret), |
556 | | error_get_pretty(session->rerr ? |
557 | | session->rerr : session->werr)); |
558 | | } else { |
559 | | error_setg(errp, "TLS termination failed: %s", gnutls_strerror(ret)); |
560 | | } |
561 | | |
562 | | error_free(session->rerr); |
563 | | error_free(session->werr); |
564 | | session->rerr = session->werr = NULL; |
565 | | |
566 | | return -1; |
567 | | } |
568 | | |
569 | | int |
570 | | qcrypto_tls_session_get_key_size(QCryptoTLSSession *session, |
571 | | Error **errp) |
572 | | { |
573 | | gnutls_cipher_algorithm_t cipher; |
574 | | int ssf; |
575 | | |
576 | | cipher = gnutls_cipher_get(session->handle); |
577 | | ssf = gnutls_cipher_get_key_size(cipher); |
578 | | if (!ssf) { |
579 | | error_setg(errp, "Cannot get TLS cipher key size"); |
580 | | return -1; |
581 | | } |
582 | | return ssf; |
583 | | } |
584 | | |
585 | | |
586 | | char * |
587 | | qcrypto_tls_session_get_peer_name(QCryptoTLSSession *session) |
588 | | { |
589 | | if (session->peername) { |
590 | | return g_strdup(session->peername); |
591 | | } |
592 | | return NULL; |
593 | | } |
594 | | |
595 | | |
596 | | #else /* ! CONFIG_GNUTLS */ |
597 | | |
598 | | |
599 | | QCryptoTLSSession * |
600 | | qcrypto_tls_session_new(QCryptoTLSCreds *creds G_GNUC_UNUSED, |
601 | | const char *hostname G_GNUC_UNUSED, |
602 | | const char *authzid G_GNUC_UNUSED, |
603 | | QCryptoTLSCredsEndpoint endpoint G_GNUC_UNUSED, |
604 | | Error **errp) |
605 | 0 | { |
606 | 0 | error_setg(errp, "TLS requires GNUTLS support"); |
607 | 0 | return NULL; |
608 | 0 | } |
609 | | |
610 | | |
611 | | void |
612 | | qcrypto_tls_session_free(QCryptoTLSSession *sess G_GNUC_UNUSED) |
613 | 0 | { |
614 | 0 | } |
615 | | |
616 | | |
617 | | int |
618 | | qcrypto_tls_session_check_credentials(QCryptoTLSSession *sess G_GNUC_UNUSED, |
619 | | Error **errp) |
620 | 0 | { |
621 | 0 | error_setg(errp, "TLS requires GNUTLS support"); |
622 | 0 | return -1; |
623 | 0 | } |
624 | | |
625 | | |
626 | | void |
627 | | qcrypto_tls_session_set_callbacks( |
628 | | QCryptoTLSSession *sess G_GNUC_UNUSED, |
629 | | QCryptoTLSSessionWriteFunc writeFunc G_GNUC_UNUSED, |
630 | | QCryptoTLSSessionReadFunc readFunc G_GNUC_UNUSED, |
631 | | void *opaque G_GNUC_UNUSED) |
632 | 0 | { |
633 | 0 | } |
634 | | |
635 | | |
636 | | ssize_t |
637 | | qcrypto_tls_session_write(QCryptoTLSSession *sess, |
638 | | const char *buf, |
639 | | size_t len, |
640 | | Error **errp) |
641 | 0 | { |
642 | 0 | error_setg(errp, "TLS requires GNUTLS support"); |
643 | 0 | return -1; |
644 | 0 | } |
645 | | |
646 | | |
647 | | ssize_t |
648 | | qcrypto_tls_session_read(QCryptoTLSSession *sess, |
649 | | char *buf, |
650 | | size_t len, |
651 | | Error **errp) |
652 | 0 | { |
653 | 0 | error_setg(errp, "TLS requires GNUTLS support"); |
654 | 0 | return -1; |
655 | 0 | } |
656 | | |
657 | | |
658 | | size_t |
659 | | qcrypto_tls_session_check_pending(QCryptoTLSSession *session) |
660 | 0 | { |
661 | 0 | return 0; |
662 | 0 | } |
663 | | |
664 | | |
665 | | int |
666 | | qcrypto_tls_session_handshake(QCryptoTLSSession *sess, |
667 | | Error **errp) |
668 | 0 | { |
669 | 0 | error_setg(errp, "TLS requires GNUTLS support"); |
670 | 0 | return -1; |
671 | 0 | } |
672 | | |
673 | | |
674 | | int |
675 | | qcrypto_tls_session_bye(QCryptoTLSSession *session, Error **errp) |
676 | 0 | { |
677 | 0 | return QCRYPTO_TLS_BYE_COMPLETE; |
678 | 0 | } |
679 | | |
680 | | |
681 | | int |
682 | | qcrypto_tls_session_get_key_size(QCryptoTLSSession *sess, |
683 | | Error **errp) |
684 | 0 | { |
685 | 0 | error_setg(errp, "TLS requires GNUTLS support"); |
686 | 0 | return -1; |
687 | 0 | } |
688 | | |
689 | | |
690 | | char * |
691 | | qcrypto_tls_session_get_peer_name(QCryptoTLSSession *sess) |
692 | 0 | { |
693 | 0 | return NULL; |
694 | 0 | } |
695 | | |
696 | | void qcrypto_tls_session_write_cork(QCryptoTLSSession *sess) |
697 | 0 | { |
698 | 0 | } |
699 | | |
700 | | |
701 | | ssize_t qcrypto_tls_session_write_uncork(QCryptoTLSSession *sess, |
702 | | Error **errp) |
703 | 0 | { |
704 | 0 | error_setg(errp, "TLS requires GNUTLS support"); |
705 | 0 | return -1; |
706 | 0 | } |
707 | | |
708 | | #endif |