Coverage Report

Created: 2025-06-13 06:58

/src/openssl31/crypto/evp/bio_enc.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 1995-2021 The OpenSSL Project Authors. All Rights Reserved.
3
 *
4
 * Licensed under the Apache License 2.0 (the "License").  You may not use
5
 * this file except in compliance with the License.  You can obtain a copy
6
 * in the file LICENSE in the source distribution or at
7
 * https://www.openssl.org/source/license.html
8
 */
9
10
#define OPENSSL_SUPPRESS_DEPRECATED /* for BIO_get_callback */
11
12
#include <stdio.h>
13
#include <errno.h>
14
#include "internal/cryptlib.h"
15
#include <openssl/buffer.h>
16
#include <openssl/evp.h>
17
#include "internal/bio.h"
18
19
static int enc_write(BIO *h, const char *buf, int num);
20
static int enc_read(BIO *h, char *buf, int size);
21
static long enc_ctrl(BIO *h, int cmd, long arg1, void *arg2);
22
static int enc_new(BIO *h);
23
static int enc_free(BIO *data);
24
static long enc_callback_ctrl(BIO *h, int cmd, BIO_info_cb *fps);
25
0
#define ENC_BLOCK_SIZE  (1024*4)
26
0
#define ENC_MIN_CHUNK   (256)
27
0
#define BUF_OFFSET      (ENC_MIN_CHUNK + EVP_MAX_BLOCK_LENGTH)
28
29
typedef struct enc_struct {
30
    int buf_len;
31
    int buf_off;
32
    int cont;                   /* <= 0 when finished */
33
    int finished;
34
    int ok;                     /* bad decrypt */
35
    EVP_CIPHER_CTX *cipher;
36
    unsigned char *read_start, *read_end;
37
    /*
38
     * buf is larger than ENC_BLOCK_SIZE because EVP_DecryptUpdate can return
39
     * up to a block more data than is presented to it
40
     */
41
    unsigned char buf[BUF_OFFSET + ENC_BLOCK_SIZE];
42
} BIO_ENC_CTX;
43
44
static const BIO_METHOD methods_enc = {
45
    BIO_TYPE_CIPHER,
46
    "cipher",
47
    bwrite_conv,
48
    enc_write,
49
    bread_conv,
50
    enc_read,
51
    NULL,                       /* enc_puts, */
52
    NULL,                       /* enc_gets, */
53
    enc_ctrl,
54
    enc_new,
55
    enc_free,
56
    enc_callback_ctrl,
57
};
58
59
const BIO_METHOD *BIO_f_cipher(void)
60
0
{
61
0
    return &methods_enc;
62
0
}
63
64
static int enc_new(BIO *bi)
65
0
{
66
0
    BIO_ENC_CTX *ctx;
67
68
0
    if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
69
0
        ERR_raise(ERR_LIB_EVP, ERR_R_MALLOC_FAILURE);
70
0
        return 0;
71
0
    }
72
73
0
    ctx->cipher = EVP_CIPHER_CTX_new();
74
0
    if (ctx->cipher == NULL) {
75
0
        OPENSSL_free(ctx);
76
0
        return 0;
77
0
    }
78
0
    ctx->cont = 1;
79
0
    ctx->ok = 1;
80
0
    ctx->read_end = ctx->read_start = &(ctx->buf[BUF_OFFSET]);
81
0
    BIO_set_data(bi, ctx);
82
0
    BIO_set_init(bi, 1);
83
84
0
    return 1;
85
0
}
86
87
static int enc_free(BIO *a)
88
0
{
89
0
    BIO_ENC_CTX *b;
90
91
0
    if (a == NULL)
92
0
        return 0;
93
94
0
    b = BIO_get_data(a);
95
0
    if (b == NULL)
96
0
        return 0;
97
98
0
    EVP_CIPHER_CTX_free(b->cipher);
99
0
    OPENSSL_clear_free(b, sizeof(BIO_ENC_CTX));
100
0
    BIO_set_data(a, NULL);
101
0
    BIO_set_init(a, 0);
102
103
0
    return 1;
104
0
}
105
106
static int enc_read(BIO *b, char *out, int outl)
107
0
{
108
0
    int ret = 0, i, blocksize;
109
0
    BIO_ENC_CTX *ctx;
110
0
    BIO *next;
111
112
0
    if (out == NULL)
113
0
        return 0;
114
0
    ctx = BIO_get_data(b);
115
116
0
    next = BIO_next(b);
117
0
    if ((ctx == NULL) || (next == NULL))
118
0
        return 0;
119
120
    /* First check if there are bytes decoded/encoded */
121
0
    if (ctx->buf_len > 0) {
122
0
        i = ctx->buf_len - ctx->buf_off;
123
0
        if (i > outl)
124
0
            i = outl;
125
0
        memcpy(out, &(ctx->buf[ctx->buf_off]), i);
126
0
        ret = i;
127
0
        out += i;
128
0
        outl -= i;
129
0
        ctx->buf_off += i;
130
0
        if (ctx->buf_len == ctx->buf_off) {
131
0
            ctx->buf_len = 0;
132
0
            ctx->buf_off = 0;
133
0
        }
134
0
    }
135
136
0
    blocksize = EVP_CIPHER_CTX_get_block_size(ctx->cipher);
137
0
    if (blocksize == 1)
138
0
        blocksize = 0;
139
140
    /*
141
     * At this point, we have room of outl bytes and an empty buffer, so we
142
     * should read in some more.
143
     */
144
145
0
    while (outl > 0) {
146
0
        if (ctx->cont <= 0)
147
0
            break;
148
149
0
        if (ctx->read_start == ctx->read_end) { /* time to read more data */
150
0
            ctx->read_end = ctx->read_start = &(ctx->buf[BUF_OFFSET]);
151
0
            i = BIO_read(next, ctx->read_start, ENC_BLOCK_SIZE);
152
0
            if (i > 0)
153
0
                ctx->read_end += i;
154
0
        } else {
155
0
            i = ctx->read_end - ctx->read_start;
156
0
        }
157
158
0
        if (i <= 0) {
159
            /* Should be continue next time we are called? */
160
0
            if (!BIO_should_retry(next)) {
161
0
                ctx->cont = i;
162
0
                i = EVP_CipherFinal_ex(ctx->cipher,
163
0
                                       ctx->buf, &(ctx->buf_len));
164
0
                ctx->ok = i;
165
0
                ctx->buf_off = 0;
166
0
            } else {
167
0
                ret = (ret == 0) ? i : ret;
168
0
                break;
169
0
            }
170
0
        } else {
171
0
            if (outl > ENC_MIN_CHUNK) {
172
                /*
173
                 * Depending on flags block cipher decrypt can write
174
                 * one extra block and then back off, i.e. output buffer
175
                 * has to accommodate extra block...
176
                 */
177
0
                int j = outl - blocksize, buf_len;
178
179
0
                if (!EVP_CipherUpdate(ctx->cipher,
180
0
                                      (unsigned char *)out, &buf_len,
181
0
                                      ctx->read_start, i > j ? j : i)) {
182
0
                    BIO_clear_retry_flags(b);
183
0
                    return 0;
184
0
                }
185
0
                ret += buf_len;
186
0
                out += buf_len;
187
0
                outl -= buf_len;
188
189
0
                if ((i -= j) <= 0) {
190
0
                    ctx->read_start = ctx->read_end;
191
0
                    continue;
192
0
                }
193
0
                ctx->read_start += j;
194
0
            }
195
0
            if (i > ENC_MIN_CHUNK)
196
0
                i = ENC_MIN_CHUNK;
197
0
            if (!EVP_CipherUpdate(ctx->cipher,
198
0
                                  ctx->buf, &ctx->buf_len,
199
0
                                  ctx->read_start, i)) {
200
0
                BIO_clear_retry_flags(b);
201
0
                ctx->ok = 0;
202
0
                return 0;
203
0
            }
204
0
            ctx->read_start += i;
205
0
            ctx->cont = 1;
206
            /*
207
             * Note: it is possible for EVP_CipherUpdate to decrypt zero
208
             * bytes because this is or looks like the final block: if this
209
             * happens we should retry and either read more data or decrypt
210
             * the final block
211
             */
212
0
            if (ctx->buf_len == 0)
213
0
                continue;
214
0
        }
215
216
0
        if (ctx->buf_len <= outl)
217
0
            i = ctx->buf_len;
218
0
        else
219
0
            i = outl;
220
0
        if (i <= 0)
221
0
            break;
222
0
        memcpy(out, ctx->buf, i);
223
0
        ret += i;
224
0
        ctx->buf_off = i;
225
0
        outl -= i;
226
0
        out += i;
227
0
    }
228
229
0
    BIO_clear_retry_flags(b);
230
0
    BIO_copy_next_retry(b);
231
0
    return ((ret == 0) ? ctx->cont : ret);
232
0
}
233
234
static int enc_write(BIO *b, const char *in, int inl)
235
0
{
236
0
    int ret = 0, n, i;
237
0
    BIO_ENC_CTX *ctx;
238
0
    BIO *next;
239
240
0
    ctx = BIO_get_data(b);
241
0
    next = BIO_next(b);
242
0
    if ((ctx == NULL) || (next == NULL))
243
0
        return 0;
244
245
0
    ret = inl;
246
247
0
    BIO_clear_retry_flags(b);
248
0
    n = ctx->buf_len - ctx->buf_off;
249
0
    while (n > 0) {
250
0
        i = BIO_write(next, &(ctx->buf[ctx->buf_off]), n);
251
0
        if (i <= 0) {
252
0
            BIO_copy_next_retry(b);
253
0
            return i;
254
0
        }
255
0
        ctx->buf_off += i;
256
0
        n -= i;
257
0
    }
258
    /* at this point all pending data has been written */
259
260
0
    if ((in == NULL) || (inl <= 0))
261
0
        return 0;
262
263
0
    ctx->buf_off = 0;
264
0
    while (inl > 0) {
265
0
        n = (inl > ENC_BLOCK_SIZE) ? ENC_BLOCK_SIZE : inl;
266
0
        if (!EVP_CipherUpdate(ctx->cipher,
267
0
                              ctx->buf, &ctx->buf_len,
268
0
                              (const unsigned char *)in, n)) {
269
0
            BIO_clear_retry_flags(b);
270
0
            ctx->ok = 0;
271
0
            return 0;
272
0
        }
273
0
        inl -= n;
274
0
        in += n;
275
276
0
        ctx->buf_off = 0;
277
0
        n = ctx->buf_len;
278
0
        while (n > 0) {
279
0
            i = BIO_write(next, &(ctx->buf[ctx->buf_off]), n);
280
0
            if (i <= 0) {
281
0
                BIO_copy_next_retry(b);
282
0
                return (ret == inl) ? i : ret - inl;
283
0
            }
284
0
            n -= i;
285
0
            ctx->buf_off += i;
286
0
        }
287
0
        ctx->buf_len = 0;
288
0
        ctx->buf_off = 0;
289
0
    }
290
0
    BIO_copy_next_retry(b);
291
0
    return ret;
292
0
}
293
294
static long enc_ctrl(BIO *b, int cmd, long num, void *ptr)
295
0
{
296
0
    BIO *dbio;
297
0
    BIO_ENC_CTX *ctx, *dctx;
298
0
    long ret = 1;
299
0
    int i;
300
0
    EVP_CIPHER_CTX **c_ctx;
301
0
    BIO *next;
302
0
    int pend;
303
304
0
    ctx = BIO_get_data(b);
305
0
    next = BIO_next(b);
306
0
    if (ctx == NULL)
307
0
        return 0;
308
309
0
    switch (cmd) {
310
0
    case BIO_CTRL_RESET:
311
0
        ctx->ok = 1;
312
0
        ctx->finished = 0;
313
0
        if (!EVP_CipherInit_ex(ctx->cipher, NULL, NULL, NULL, NULL,
314
0
                               EVP_CIPHER_CTX_is_encrypting(ctx->cipher)))
315
0
            return 0;
316
0
        ret = BIO_ctrl(next, cmd, num, ptr);
317
0
        break;
318
0
    case BIO_CTRL_EOF:         /* More to read */
319
0
        if (ctx->cont <= 0)
320
0
            ret = 1;
321
0
        else
322
0
            ret = BIO_ctrl(next, cmd, num, ptr);
323
0
        break;
324
0
    case BIO_CTRL_WPENDING:
325
0
        ret = ctx->buf_len - ctx->buf_off;
326
0
        if (ret <= 0)
327
0
            ret = BIO_ctrl(next, cmd, num, ptr);
328
0
        break;
329
0
    case BIO_CTRL_PENDING:     /* More to read in buffer */
330
0
        ret = ctx->buf_len - ctx->buf_off;
331
0
        if (ret <= 0)
332
0
            ret = BIO_ctrl(next, cmd, num, ptr);
333
0
        break;
334
0
    case BIO_CTRL_FLUSH:
335
        /* do a final write */
336
0
 again:
337
0
        while (ctx->buf_len != ctx->buf_off) {
338
0
            pend = ctx->buf_len - ctx->buf_off;
339
0
            i = enc_write(b, NULL, 0);
340
            /*
341
             * i should never be > 0 here because we didn't ask to write any
342
             * new data. We stop if we get an error or we failed to make any
343
             * progress writing pending data.
344
             */
345
0
            if (i < 0 || (ctx->buf_len - ctx->buf_off) == pend)
346
0
                return i;
347
0
        }
348
349
0
        if (!ctx->finished) {
350
0
            ctx->finished = 1;
351
0
            ctx->buf_off = 0;
352
0
            ret = EVP_CipherFinal_ex(ctx->cipher,
353
0
                                     (unsigned char *)ctx->buf,
354
0
                                     &(ctx->buf_len));
355
0
            ctx->ok = (int)ret;
356
0
            if (ret <= 0)
357
0
                break;
358
359
            /* push out the bytes */
360
0
            goto again;
361
0
        }
362
363
        /* Finally flush the underlying BIO */
364
0
        ret = BIO_ctrl(next, cmd, num, ptr);
365
0
        break;
366
0
    case BIO_C_GET_CIPHER_STATUS:
367
0
        ret = (long)ctx->ok;
368
0
        break;
369
0
    case BIO_C_DO_STATE_MACHINE:
370
0
        BIO_clear_retry_flags(b);
371
0
        ret = BIO_ctrl(next, cmd, num, ptr);
372
0
        BIO_copy_next_retry(b);
373
0
        break;
374
0
    case BIO_C_GET_CIPHER_CTX:
375
0
        c_ctx = (EVP_CIPHER_CTX **)ptr;
376
0
        *c_ctx = ctx->cipher;
377
0
        BIO_set_init(b, 1);
378
0
        break;
379
0
    case BIO_CTRL_DUP:
380
0
        dbio = (BIO *)ptr;
381
0
        dctx = BIO_get_data(dbio);
382
0
        dctx->cipher = EVP_CIPHER_CTX_new();
383
0
        if (dctx->cipher == NULL)
384
0
            return 0;
385
0
        ret = EVP_CIPHER_CTX_copy(dctx->cipher, ctx->cipher);
386
0
        if (ret)
387
0
            BIO_set_init(dbio, 1);
388
0
        break;
389
0
    default:
390
0
        ret = BIO_ctrl(next, cmd, num, ptr);
391
0
        break;
392
0
    }
393
0
    return ret;
394
0
}
395
396
static long enc_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
397
0
{
398
0
    BIO *next = BIO_next(b);
399
400
0
    if (next == NULL)
401
0
        return 0;
402
403
0
    return BIO_callback_ctrl(next, cmd, fp);
404
0
}
405
406
int BIO_set_cipher(BIO *b, const EVP_CIPHER *c, const unsigned char *k,
407
                   const unsigned char *i, int e)
408
0
{
409
0
    BIO_ENC_CTX *ctx;
410
0
    BIO_callback_fn_ex callback_ex;
411
0
#ifndef OPENSSL_NO_DEPRECATED_3_0
412
0
    long (*callback) (struct bio_st *, int, const char *, int, long, long) = NULL;
413
0
#endif
414
415
0
    ctx = BIO_get_data(b);
416
0
    if (ctx == NULL)
417
0
        return 0;
418
419
0
    if ((callback_ex = BIO_get_callback_ex(b)) != NULL) {
420
0
        if (callback_ex(b, BIO_CB_CTRL, (const char *)c, 0, BIO_CTRL_SET,
421
0
                        e, 1, NULL) <= 0)
422
0
            return 0;
423
0
    }
424
0
#ifndef OPENSSL_NO_DEPRECATED_3_0
425
0
    else {
426
0
        callback = BIO_get_callback(b);
427
428
0
        if ((callback != NULL) &&
429
0
            (callback(b, BIO_CB_CTRL, (const char *)c, BIO_CTRL_SET, e,
430
0
                      0L) <= 0))
431
0
            return 0;
432
0
    }
433
0
#endif
434
435
0
    BIO_set_init(b, 1);
436
437
0
    if (!EVP_CipherInit_ex(ctx->cipher, c, NULL, k, i, e))
438
0
        return 0;
439
440
0
    if (callback_ex != NULL)
441
0
        return callback_ex(b, BIO_CB_CTRL | BIO_CB_RETURN, (const char *)c, 0,
442
0
                           BIO_CTRL_SET, e, 1, NULL);
443
0
#ifndef OPENSSL_NO_DEPRECATED_3_0
444
0
    else if (callback != NULL)
445
0
        return callback(b, BIO_CB_CTRL, (const char *)c, BIO_CTRL_SET, e, 1L);
446
0
#endif
447
0
    return 1;
448
0
}