crypto/o_str.c

   1 /*
   2  * Copyright 2003-2017 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (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 #include "internal/o_str.h"
  15
  16 int OPENSSL_memcmp(const void *v1, const void *v2, size_t n)
  17 {
  18     const unsigned char *c1 = v1, *c2 = v2;
  19     int ret = 0;
  20
  21     while (n && (ret = *c1 - *c2) == 0)
  22         n--, c1++, c2++;
  23
  24     return ret;
  25 }
  26
  27 char *CRYPTO_strdup(const char *str, const char* file, int line)
  28 {
  29     char *ret;
  30     size_t size;
  31
  32     if (str == NULL)
  33         return NULL;
  34     size = strlen(str) + 1;
  35     ret = CRYPTO_malloc(size, file, line);
  36     if (ret != NULL)
  37         memcpy(ret, str, size);
  38     return ret;
  39 }
  40
  41 char *CRYPTO_strndup(const char *str, size_t s, const char* file, int line)
  42 {
  43     size_t maxlen;
  44     char *ret;
  45
  46     if (str == NULL)
  47         return NULL;
  48
  49     maxlen = OPENSSL_strnlen(str, s);
  50
  51     ret = CRYPTO_malloc(maxlen + 1, file, line);
  52     if (ret) {
  53         memcpy(ret, str, maxlen);
  54         ret[maxlen] = '\0';
  55     }
  56     return ret;
  57 }
  58
  59 void *CRYPTO_memdup(const void *data, size_t siz, const char* file, int line)
  60 {
  61     void *ret;
  62
  63     if (data == NULL || siz >= INT_MAX)
  64         return NULL;
  65
  66     ret = CRYPTO_malloc(siz, file, line);
  67     if (ret == NULL) {
  68         CRYPTOerr(CRYPTO_F_CRYPTO_MEMDUP, ERR_R_MALLOC_FAILURE);
  69         return NULL;
  70     }
  71     return memcpy(ret, data, siz);
  72 }
  73
  74 size_t OPENSSL_strnlen(const char *str, size_t maxlen)
  75 {
  76     const char *p;
  77
  78     for (p = str; maxlen-- != 0 && *p != '\0'; ++p) ;
  79
  80     return p - str;
  81 }
  82
  83 size_t OPENSSL_strlcpy(char *dst, const char *src, size_t size)
  84 {
  85     size_t l = 0;
  86     for (; size > 1 && *src; size--) {
  87         *dst++ = *src++;
  88         l++;
  89     }
  90     if (size)
  91         *dst = '\0';
  92     return l + strlen(src);
  93 }
  94
  95 size_t OPENSSL_strlcat(char *dst, const char *src, size_t size)
  96 {
  97     size_t l = 0;
  98     for (; size > 0 && *dst; size--, dst++)
  99         l++;
 100     return l + OPENSSL_strlcpy(dst, src, size);
 101 }
 102
 103 int OPENSSL_hexchar2int(unsigned char c)
 104 {
 105 #ifdef CHARSET_EBCDIC
 106     c = os_toebcdic[c];
 107 #endif
 108
 109     switch (c) {
 110     case '0':
 111         return 0;
 112     case '1':
 113         return 1;
 114     case '2':
 115         return 2;
 116     case '3':
 117         return 3;
 118     case '4':
 119           return 4;
 120     case '5':
 121           return 5;
 122     case '6':
 123           return 6;
 124     case '7':
 125           return 7;
 126     case '8':
 127           return 8;
 128     case '9':
 129           return 9;
 130     case 'a': case 'A':
 131           return 0x0A;
 132     case 'b': case 'B':
 133           return 0x0B;
 134     case 'c': case 'C':
 135           return 0x0C;
 136     case 'd': case 'D':
 137           return 0x0D;
 138     case 'e': case 'E':
 139           return 0x0E;
 140     case 'f': case 'F':
 141           return 0x0F;
 142     }
 143     return -1;
 144 }
 145
 146 /*
 147  * Give a string of hex digits convert to a buffer
 148  */
 149 unsigned char *OPENSSL_hexstr2buf(const char *str, long *len)
 150 {
 151     unsigned char *hexbuf, *q;
 152     unsigned char ch, cl;
 153     int chi, cli;
 154     const unsigned char *p;
 155     size_t s;
 156
 157     s = strlen(str);
 158     if ((hexbuf = OPENSSL_malloc(s >> 1)) == NULL) {
 159         CRYPTOerr(CRYPTO_F_OPENSSL_HEXSTR2BUF, ERR_R_MALLOC_FAILURE);
 160         return NULL;
 161     }
 162     for (p = (const unsigned char *)str, q = hexbuf; *p; ) {
 163         ch = *p++;
 164         if (ch == ':')
 165             continue;
 166         cl = *p++;
 167         if (!cl) {
 168             CRYPTOerr(CRYPTO_F_OPENSSL_HEXSTR2BUF,
 169                       CRYPTO_R_ODD_NUMBER_OF_DIGITS);
 170             OPENSSL_free(hexbuf);
 171             return NULL;
 172         }
 173         cli = OPENSSL_hexchar2int(cl);
 174         chi = OPENSSL_hexchar2int(ch);
 175         if (cli < 0 || chi < 0) {
 176             OPENSSL_free(hexbuf);
 177             CRYPTOerr(CRYPTO_F_OPENSSL_HEXSTR2BUF, CRYPTO_R_ILLEGAL_HEX_DIGIT);
 178             return NULL;
 179         }
 180         *q++ = (unsigned char)((chi << 4) | cli);
 181     }
 182
 183     if (len)
 184         *len = q - hexbuf;
 185     return hexbuf;
 186 }
 187
 188 /*
 189  * Given a buffer of length 'len' return a OPENSSL_malloc'ed string with its
 190  * hex representation @@@ (Contents of buffer are always kept in ASCII, also
 191  * on EBCDIC machines)
 192  */
 193 char *OPENSSL_buf2hexstr(const unsigned char *buffer, long len)
 194 {
 195     static const char hexdig[] = "0123456789ABCDEF";
 196     char *tmp, *q;
 197     const unsigned char *p;
 198     int i;
 199
 200     if (len == 0)
 201     {
 202         return OPENSSL_zalloc(1);
 203     }
 204
 205     if ((tmp = OPENSSL_malloc(len * 3)) == NULL) {
 206         CRYPTOerr(CRYPTO_F_OPENSSL_BUF2HEXSTR, ERR_R_MALLOC_FAILURE);
 207         return NULL;
 208     }
 209     q = tmp;
 210     for (i = 0, p = buffer; i < len; i++, p++) {
 211         *q++ = hexdig[(*p >> 4) & 0xf];
 212         *q++ = hexdig[*p & 0xf];
 213         *q++ = ':';
 214     }
 215     q[-1] = 0;
 216 #ifdef CHARSET_EBCDIC
 217     ebcdic2ascii(tmp, tmp, q - tmp - 1);
 218 #endif
 219
 220     return tmp;
 221 }
 222
 223 int openssl_strerror_r(int errnum, char *buf, size_t buflen)
 224 {
 225 #if defined(_MSC_VER) && _MSC_VER>=1400
 226     return !strerror_s(buf, buflen, errnum);
 227 #elif defined(_GNU_SOURCE)
 228     return strerror_r(errnum, buf, buflen) != NULL;
 229 #elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || \
 230       (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)
 231     /*
 232      * We can use "real" strerror_r. The OpenSSL version differs in that it
 233      * gives 1 on success and 0 on failure for consistency with other OpenSSL
 234      * functions. Real strerror_r does it the other way around
 235      */
 236     return !strerror_r(errnum, buf, buflen);
 237 #else
 238     char *err;
 239     /* Fall back to non-thread safe strerror()...its all we can do */
 240     if (buflen < 2)
 241         return 0;
 242     err = strerror(errnum);
 243     /* Can this ever happen? */
 244     if (err == NULL)
 245         return 0;
 246     strncpy(buf, err, buflen - 1);
 247     buf[buflen - 1] = '\0';
 248     return 1;
 249 #endif
 250 }