/src/openssl/crypto/o_str.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright 2003-2017 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 "e_os.h" |
11 | | #include <limits.h> |
12 | | #include <openssl/crypto.h> |
13 | | #include "internal/cryptlib.h" |
14 | | |
15 | | char *CRYPTO_strdup(const char *str, const char* file, int line) |
16 | 112k | { |
17 | 112k | char *ret; |
18 | | |
19 | 112k | if (str == NULL) |
20 | 0 | return NULL; |
21 | 112k | ret = CRYPTO_malloc(strlen(str) + 1, file, line); |
22 | 112k | if (ret != NULL) |
23 | 112k | strcpy(ret, str); |
24 | 112k | return ret; |
25 | 112k | } |
26 | | |
27 | | char *CRYPTO_strndup(const char *str, size_t s, const char* file, int line) |
28 | 0 | { |
29 | 0 | size_t maxlen; |
30 | 0 | char *ret; |
31 | |
|
32 | 0 | if (str == NULL) |
33 | 0 | return NULL; |
34 | | |
35 | 0 | maxlen = OPENSSL_strnlen(str, s); |
36 | |
|
37 | 0 | ret = CRYPTO_malloc(maxlen + 1, file, line); |
38 | 0 | if (ret) { |
39 | 0 | memcpy(ret, str, maxlen); |
40 | 0 | ret[maxlen] = '\0'; |
41 | 0 | } |
42 | 0 | return ret; |
43 | 0 | } |
44 | | |
45 | | void *CRYPTO_memdup(const void *data, size_t siz, const char* file, int line) |
46 | 230k | { |
47 | 230k | void *ret; |
48 | | |
49 | 230k | if (data == NULL || siz >= INT_MAX) |
50 | 0 | return NULL; |
51 | | |
52 | 230k | ret = CRYPTO_malloc(siz, file, line); |
53 | 230k | if (ret == NULL) { |
54 | 0 | CRYPTOerr(CRYPTO_F_CRYPTO_MEMDUP, ERR_R_MALLOC_FAILURE); |
55 | 0 | return NULL; |
56 | 0 | } |
57 | 230k | return memcpy(ret, data, siz); |
58 | 230k | } |
59 | | |
60 | | size_t OPENSSL_strnlen(const char *str, size_t maxlen) |
61 | 5.63M | { |
62 | 5.63M | const char *p; |
63 | | |
64 | 17.4M | for (p = str; maxlen-- != 0 && *p != '\0'; ++p) ; |
65 | | |
66 | 5.63M | return p - str; |
67 | 5.63M | } |
68 | | |
69 | | size_t OPENSSL_strlcpy(char *dst, const char *src, size_t size) |
70 | 10.6M | { |
71 | 10.6M | size_t l = 0; |
72 | 77.4M | for (; size > 1 && *src; size--) { |
73 | 66.8M | *dst++ = *src++; |
74 | 66.8M | l++; |
75 | 66.8M | } |
76 | 10.6M | if (size) |
77 | 10.6M | *dst = '\0'; |
78 | 10.6M | return l + strlen(src); |
79 | 10.6M | } |
80 | | |
81 | | size_t OPENSSL_strlcat(char *dst, const char *src, size_t size) |
82 | 8.94M | { |
83 | 8.94M | size_t l = 0; |
84 | 43.0M | for (; size > 0 && *dst; size--, dst++) |
85 | 34.1M | l++; |
86 | 8.94M | return l + OPENSSL_strlcpy(dst, src, size); |
87 | 8.94M | } |
88 | | |
89 | | int OPENSSL_hexchar2int(unsigned char c) |
90 | 0 | { |
91 | | #ifdef CHARSET_EBCDIC |
92 | | c = os_toebcdic[c]; |
93 | | #endif |
94 | |
|
95 | 0 | switch (c) { |
96 | 0 | case '0': |
97 | 0 | return 0; |
98 | 0 | case '1': |
99 | 0 | return 1; |
100 | 0 | case '2': |
101 | 0 | return 2; |
102 | 0 | case '3': |
103 | 0 | return 3; |
104 | 0 | case '4': |
105 | 0 | return 4; |
106 | 0 | case '5': |
107 | 0 | return 5; |
108 | 0 | case '6': |
109 | 0 | return 6; |
110 | 0 | case '7': |
111 | 0 | return 7; |
112 | 0 | case '8': |
113 | 0 | return 8; |
114 | 0 | case '9': |
115 | 0 | return 9; |
116 | 0 | case 'a': case 'A': |
117 | 0 | return 0x0A; |
118 | 0 | case 'b': case 'B': |
119 | 0 | return 0x0B; |
120 | 0 | case 'c': case 'C': |
121 | 0 | return 0x0C; |
122 | 0 | case 'd': case 'D': |
123 | 0 | return 0x0D; |
124 | 0 | case 'e': case 'E': |
125 | 0 | return 0x0E; |
126 | 0 | case 'f': case 'F': |
127 | 0 | return 0x0F; |
128 | 0 | } |
129 | 0 | return -1; |
130 | 0 | } |
131 | | |
132 | | /* |
133 | | * Give a string of hex digits convert to a buffer |
134 | | */ |
135 | | int OPENSSL_hexstr2buf_ex(unsigned char *buf, size_t buf_n, size_t *buflen, |
136 | | const char *str) |
137 | 0 | { |
138 | 0 | unsigned char *q; |
139 | 0 | unsigned char ch, cl; |
140 | 0 | int chi, cli; |
141 | 0 | const unsigned char *p; |
142 | 0 | size_t cnt; |
143 | |
|
144 | 0 | for (p = (const unsigned char *)str, q = buf, cnt = 0; *p; ) { |
145 | 0 | ch = *p++; |
146 | 0 | if (ch == ':') |
147 | 0 | continue; |
148 | 0 | cl = *p++; |
149 | 0 | if (!cl) { |
150 | 0 | CRYPTOerr(CRYPTO_F_OPENSSL_HEXSTR2BUF_EX, |
151 | 0 | CRYPTO_R_ODD_NUMBER_OF_DIGITS); |
152 | 0 | return 0; |
153 | 0 | } |
154 | 0 | cli = OPENSSL_hexchar2int(cl); |
155 | 0 | chi = OPENSSL_hexchar2int(ch); |
156 | 0 | if (cli < 0 || chi < 0) { |
157 | 0 | CRYPTOerr(CRYPTO_F_OPENSSL_HEXSTR2BUF_EX, |
158 | 0 | CRYPTO_R_ILLEGAL_HEX_DIGIT); |
159 | 0 | return 0; |
160 | 0 | } |
161 | 0 | cnt++; |
162 | 0 | if (q != NULL) { |
163 | 0 | if (cnt > buf_n) { |
164 | 0 | CRYPTOerr(CRYPTO_F_OPENSSL_HEXSTR2BUF_EX, |
165 | 0 | CRYPTO_R_TOO_SMALL_BUFFER); |
166 | 0 | return 0; |
167 | 0 | } |
168 | 0 | *q++ = (unsigned char)((chi << 4) | cli); |
169 | 0 | } |
170 | 0 | } |
171 | | |
172 | 0 | if (buflen != NULL) |
173 | 0 | *buflen = cnt; |
174 | 0 | return 1; |
175 | 0 | } |
176 | | |
177 | | unsigned char *OPENSSL_hexstr2buf(const char *str, long *buflen) |
178 | 0 | { |
179 | 0 | unsigned char *buf; |
180 | 0 | size_t buf_n, tmp_buflen; |
181 | |
|
182 | 0 | buf_n = strlen(str) >> 1; |
183 | 0 | if ((buf = OPENSSL_malloc(buf_n)) == NULL) { |
184 | 0 | CRYPTOerr(CRYPTO_F_OPENSSL_HEXSTR2BUF, ERR_R_MALLOC_FAILURE); |
185 | 0 | return NULL; |
186 | 0 | } |
187 | | |
188 | 0 | if (buflen != NULL) |
189 | 0 | *buflen = 0; |
190 | 0 | tmp_buflen = 0; |
191 | 0 | if (OPENSSL_hexstr2buf_ex(buf, buf_n, &tmp_buflen, str)) { |
192 | 0 | if (buflen != NULL) |
193 | 0 | *buflen = (long)tmp_buflen; |
194 | 0 | return buf; |
195 | 0 | } |
196 | 0 | OPENSSL_free(buf); |
197 | 0 | return NULL; |
198 | 0 | } |
199 | | |
200 | | int OPENSSL_buf2hexstr_ex(char *str, size_t str_n, size_t *strlen, |
201 | | const unsigned char *buf, size_t buflen) |
202 | 64.9k | { |
203 | 64.9k | static const char hexdig[] = "0123456789ABCDEF"; |
204 | 64.9k | const unsigned char *p; |
205 | 64.9k | char *q; |
206 | 64.9k | size_t i; |
207 | | |
208 | 64.9k | if (strlen != NULL) |
209 | 0 | *strlen = buflen * 3; |
210 | 64.9k | if (str == NULL) |
211 | 0 | return 1; |
212 | | |
213 | 64.9k | if (str_n < (unsigned long)buflen * 3) { |
214 | 0 | CRYPTOerr(CRYPTO_F_OPENSSL_BUF2HEXSTR_EX, CRYPTO_R_TOO_SMALL_BUFFER); |
215 | 0 | return 0; |
216 | 0 | } |
217 | | |
218 | 64.9k | q = str; |
219 | 657k | for (i = 0, p = buf; i < buflen; i++, p++) { |
220 | 592k | *q++ = hexdig[(*p >> 4) & 0xf]; |
221 | 592k | *q++ = hexdig[*p & 0xf]; |
222 | 592k | *q++ = ':'; |
223 | 592k | } |
224 | 64.9k | q[-1] = 0; |
225 | | #ifdef CHARSET_EBCDIC |
226 | | ebcdic2ascii(str, str, q - str - 1); |
227 | | #endif |
228 | 64.9k | return 1; |
229 | 64.9k | } |
230 | | |
231 | | /* |
232 | | * Given a buffer of length 'len' return a OPENSSL_malloc'ed string with its |
233 | | * hex representation @@@ (Contents of buffer are always kept in ASCII, also |
234 | | * on EBCDIC machines) |
235 | | */ |
236 | | char *OPENSSL_buf2hexstr(const unsigned char *buf, long buflen) |
237 | 65.0k | { |
238 | 65.0k | char *tmp; |
239 | 65.0k | size_t tmp_n; |
240 | | |
241 | 65.0k | if (buflen == 0) |
242 | 160 | return OPENSSL_zalloc(1); |
243 | | |
244 | 64.9k | tmp_n = buflen * 3; |
245 | 64.9k | if ((tmp = OPENSSL_malloc(tmp_n)) == NULL) { |
246 | 0 | CRYPTOerr(CRYPTO_F_OPENSSL_BUF2HEXSTR, ERR_R_MALLOC_FAILURE); |
247 | 0 | return NULL; |
248 | 0 | } |
249 | | |
250 | 64.9k | if (OPENSSL_buf2hexstr_ex(tmp, tmp_n, NULL, buf, buflen)) |
251 | 64.9k | return tmp; |
252 | 0 | OPENSSL_free(tmp); |
253 | 0 | return NULL; |
254 | 64.9k | } |
255 | | |
256 | | int openssl_strerror_r(int errnum, char *buf, size_t buflen) |
257 | 328k | { |
258 | | #if defined(_MSC_VER) && _MSC_VER>=1400 |
259 | | return !strerror_s(buf, buflen, errnum); |
260 | | #elif defined(_GNU_SOURCE) |
261 | | char *err; |
262 | | |
263 | | /* |
264 | | * GNU strerror_r may not actually set buf. |
265 | | * It can return a pointer to some (immutable) static string in which case |
266 | | * buf is left unused. |
267 | | */ |
268 | | err = strerror_r(errnum, buf, buflen); |
269 | | if (err == NULL || buflen == 0) |
270 | | return 0; |
271 | | /* |
272 | | * If err is statically allocated, err != buf and we need to copy the data. |
273 | | * If err points somewhere inside buf, OPENSSL_strlcpy can handle this, |
274 | | * since src and dest are not annotated with __restrict and the function |
275 | | * reads src byte for byte and writes to dest. |
276 | | * If err == buf we do not have to copy anything. |
277 | | */ |
278 | | if (err != buf) |
279 | | OPENSSL_strlcpy(buf, err, buflen); |
280 | | return 1; |
281 | | #elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || \ |
282 | | (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600) |
283 | | /* |
284 | | * We can use "real" strerror_r. The OpenSSL version differs in that it |
285 | | * gives 1 on success and 0 on failure for consistency with other OpenSSL |
286 | | * functions. Real strerror_r does it the other way around |
287 | | */ |
288 | 328k | return !strerror_r(errnum, buf, buflen); |
289 | | #else |
290 | | char *err; |
291 | | |
292 | | /* Fall back to non-thread safe strerror()...its all we can do */ |
293 | | if (buflen < 2) |
294 | | return 0; |
295 | | err = strerror(errnum); |
296 | | /* Can this ever happen? */ |
297 | | if (err == NULL) |
298 | | return 0; |
299 | | OPENSSL_strlcpy(buf, err, buflen); |
300 | | return 1; |
301 | | #endif |
302 | 328k | } |