xref: /openssl/crypto/buffer/buffer.c (revision e077455e)
1 /*
2  * Copyright 1995-2020 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 #include <stdio.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/buffer.h>
13 
14 /*
15  * LIMIT_BEFORE_EXPANSION is the maximum n such that (n+3)/3*4 < 2**31. That
16  * function is applied in several functions in this file and this limit
17  * ensures that the result fits in an int.
18  */
19 #define LIMIT_BEFORE_EXPANSION 0x5ffffffc
20 
BUF_MEM_new_ex(unsigned long flags)21 BUF_MEM *BUF_MEM_new_ex(unsigned long flags)
22 {
23     BUF_MEM *ret;
24 
25     ret = BUF_MEM_new();
26     if (ret != NULL)
27         ret->flags = flags;
28     return ret;
29 }
30 
BUF_MEM_new(void)31 BUF_MEM *BUF_MEM_new(void)
32 {
33     BUF_MEM *ret;
34 
35     ret = OPENSSL_zalloc(sizeof(*ret));
36     if (ret == NULL)
37         return NULL;
38     return ret;
39 }
40 
BUF_MEM_free(BUF_MEM * a)41 void BUF_MEM_free(BUF_MEM *a)
42 {
43     if (a == NULL)
44         return;
45     if (a->data != NULL) {
46         if (a->flags & BUF_MEM_FLAG_SECURE)
47             OPENSSL_secure_clear_free(a->data, a->max);
48         else
49             OPENSSL_clear_free(a->data, a->max);
50     }
51     OPENSSL_free(a);
52 }
53 
54 /* Allocate a block of secure memory; copy over old data if there
55  * was any, and then free it. */
sec_alloc_realloc(BUF_MEM * str,size_t len)56 static char *sec_alloc_realloc(BUF_MEM *str, size_t len)
57 {
58     char *ret;
59 
60     ret = OPENSSL_secure_malloc(len);
61     if (str->data != NULL) {
62         if (ret != NULL) {
63             memcpy(ret, str->data, str->length);
64             OPENSSL_secure_clear_free(str->data, str->length);
65             str->data = NULL;
66         }
67     }
68     return ret;
69 }
70 
BUF_MEM_grow(BUF_MEM * str,size_t len)71 size_t BUF_MEM_grow(BUF_MEM *str, size_t len)
72 {
73     char *ret;
74     size_t n;
75 
76     if (str->length >= len) {
77         str->length = len;
78         return len;
79     }
80     if (str->max >= len) {
81         if (str->data != NULL)
82             memset(&str->data[str->length], 0, len - str->length);
83         str->length = len;
84         return len;
85     }
86     /* This limit is sufficient to ensure (len+3)/3*4 < 2**31 */
87     if (len > LIMIT_BEFORE_EXPANSION) {
88         ERR_raise(ERR_LIB_BUF, ERR_R_PASSED_INVALID_ARGUMENT);
89         return 0;
90     }
91     n = (len + 3) / 3 * 4;
92     if ((str->flags & BUF_MEM_FLAG_SECURE))
93         ret = sec_alloc_realloc(str, n);
94     else
95         ret = OPENSSL_realloc(str->data, n);
96     if (ret == NULL) {
97         len = 0;
98     } else {
99         str->data = ret;
100         str->max = n;
101         memset(&str->data[str->length], 0, len - str->length);
102         str->length = len;
103     }
104     return len;
105 }
106 
BUF_MEM_grow_clean(BUF_MEM * str,size_t len)107 size_t BUF_MEM_grow_clean(BUF_MEM *str, size_t len)
108 {
109     char *ret;
110     size_t n;
111 
112     if (str->length >= len) {
113         if (str->data != NULL)
114             memset(&str->data[len], 0, str->length - len);
115         str->length = len;
116         return len;
117     }
118     if (str->max >= len) {
119         memset(&str->data[str->length], 0, len - str->length);
120         str->length = len;
121         return len;
122     }
123     /* This limit is sufficient to ensure (len+3)/3*4 < 2**31 */
124     if (len > LIMIT_BEFORE_EXPANSION) {
125         ERR_raise(ERR_LIB_BUF, ERR_R_PASSED_INVALID_ARGUMENT);
126         return 0;
127     }
128     n = (len + 3) / 3 * 4;
129     if ((str->flags & BUF_MEM_FLAG_SECURE))
130         ret = sec_alloc_realloc(str, n);
131     else
132         ret = OPENSSL_clear_realloc(str->data, str->max, n);
133     if (ret == NULL) {
134         len = 0;
135     } else {
136         str->data = ret;
137         str->max = n;
138         memset(&str->data[str->length], 0, len - str->length);
139         str->length = len;
140     }
141     return len;
142 }
143 
BUF_reverse(unsigned char * out,const unsigned char * in,size_t size)144 void BUF_reverse(unsigned char *out, const unsigned char *in, size_t size)
145 {
146     size_t i;
147     if (in) {
148         out += size - 1;
149         for (i = 0; i < size; i++)
150             *out-- = *in++;
151     } else {
152         unsigned char *q;
153         char c;
154         q = out + size - 1;
155         for (i = 0; i < size / 2; i++) {
156             c = *q;
157             *q-- = *out;
158             *out++ = c;
159         }
160     }
161 }
162