crypto/o_str.c

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