Coverage Report

Created: 2026-11-20 08:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/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