crypto/o_str.c

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