[thirdparty/openssl.git] / crypto / o_str.c

/*
 * Copyright 2003-2017 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#include "e_os.h"
#include <limits.h>
#include <openssl/crypto.h>
#include "internal/cryptlib.h"

#define DEFAULT_SEPARATOR ':'
#define CH_ZERO '\0'

char *CRYPTO_strdup(const char *str, const char* file, int line)
{
    char *ret;

    if (str == NULL)
        return NULL;
    ret = CRYPTO_malloc(strlen(str) + 1, file, line);
    if (ret != NULL)
        strcpy(ret, str);
    return ret;
}

char *CRYPTO_strndup(const char *str, size_t s, const char* file, int line)
{
    size_t maxlen;
    char *ret;

    if (str == NULL)
        return NULL;

    maxlen = OPENSSL_strnlen(str, s);

    ret = CRYPTO_malloc(maxlen + 1, file, line);
    if (ret) {
        memcpy(ret, str, maxlen);
        ret[maxlen] = CH_ZERO;
    }
    return ret;
}

void *CRYPTO_memdup(const void *data, size_t siz, const char* file, int line)
{
    void *ret;

    if (data == NULL || siz >= INT_MAX)
        return NULL;

    ret = CRYPTO_malloc(siz, file, line);
    if (ret == NULL) {
        CRYPTOerr(CRYPTO_F_CRYPTO_MEMDUP, ERR_R_MALLOC_FAILURE);
        return NULL;
    }
    return memcpy(ret, data, siz);
}

size_t OPENSSL_strnlen(const char *str, size_t maxlen)
{
    const char *p;

    for (p = str; maxlen-- != 0 && *p != CH_ZERO; ++p) ;

    return p - str;
}

size_t OPENSSL_strlcpy(char *dst, const char *src, size_t size)
{
    size_t l = 0;
    for (; size > 1 && *src; size--) {
        *dst++ = *src++;
        l++;
    }
    if (size)
        *dst = CH_ZERO;
    return l + strlen(src);
}

size_t OPENSSL_strlcat(char *dst, const char *src, size_t size)
{
    size_t l = 0;
    for (; size > 0 && *dst; size--, dst++)
        l++;
    return l + OPENSSL_strlcpy(dst, src, size);
}

int OPENSSL_hexchar2int(unsigned char c)
{
#ifdef CHARSET_EBCDIC
    c = os_toebcdic[c];
#endif

    switch (c) {
    case '0':
        return 0;
    case '1':
        return 1;
    case '2':
        return 2;
    case '3':
        return 3;
    case '4':
          return 4;
    case '5':
          return 5;
    case '6':
          return 6;
    case '7':
          return 7;
    case '8':
          return 8;
    case '9':
          return 9;
    case 'a': case 'A':
          return 0x0A;
    case 'b': case 'B':
          return 0x0B;
    case 'c': case 'C':
          return 0x0C;
    case 'd': case 'D':
          return 0x0D;
    case 'e': case 'E':
          return 0x0E;
    case 'f': case 'F':
          return 0x0F;
    }
    return -1;
}

static int hexstr2buf_sep(unsigned char *buf, size_t buf_n, size_t *buflen,
                          const char *str, const char sep)
{
    unsigned char *q;
    unsigned char ch, cl;
    int chi, cli;
    const unsigned char *p;
    size_t cnt;

    for (p = (const unsigned char *)str, q = buf, cnt = 0; *p; ) {
        ch = *p++;
        /* A separator of CH_ZERO means there is no separator */
        if (ch == sep && sep != CH_ZERO)
            continue;
        cl = *p++;
        if (!cl) {
            CRYPTOerr(0, CRYPTO_R_ODD_NUMBER_OF_DIGITS);
            return 0;
        }
        cli = OPENSSL_hexchar2int(cl);
        chi = OPENSSL_hexchar2int(ch);
        if (cli < 0 || chi < 0) {
            CRYPTOerr(0, CRYPTO_R_ILLEGAL_HEX_DIGIT);
            return 0;
        }
        cnt++;
        if (q != NULL) {
            if (cnt > buf_n) {
                CRYPTOerr(0, CRYPTO_R_TOO_SMALL_BUFFER);
                return 0;
            }
            *q++ = (unsigned char)((chi << 4) | cli);
        }
    }

    if (buflen != NULL)
        *buflen = cnt;
    return 1;
}

/*
 * Given a string of hex digits convert to a buffer
 */
int OPENSSL_hexstr2buf_ex(unsigned char *buf, size_t buf_n, size_t *buflen,
                          const char *str)
{
    return hexstr2buf_sep(buf, buf_n, buflen, str, DEFAULT_SEPARATOR);
}

unsigned char *openssl_hexstr2buf_sep(const char *str, long *buflen,
                                      const char sep)
{
    unsigned char *buf;
    size_t buf_n, tmp_buflen;

    buf_n = strlen(str) >> 1;
    if ((buf = OPENSSL_malloc(buf_n)) == NULL) {
        CRYPTOerr(0, ERR_R_MALLOC_FAILURE);
        return NULL;
    }

    if (buflen != NULL)
        *buflen = 0;
    tmp_buflen = 0;
    if (hexstr2buf_sep(buf, buf_n, &tmp_buflen, str, sep)) {
        if (buflen != NULL)
            *buflen = (long)tmp_buflen;
        return buf;
    }
    OPENSSL_free(buf);
    return NULL;
}

unsigned char *OPENSSL_hexstr2buf(const char *str, long *buflen)
{
    return openssl_hexstr2buf_sep(str, buflen, DEFAULT_SEPARATOR);
}

static int buf2hexstr_sep(char *str, size_t str_n, size_t *strlen,
                          const unsigned char *buf, size_t buflen,
                          const char sep)
{
    static const char hexdig[] = "0123456789ABCDEF";
    const unsigned char *p;
    char *q;
    size_t i;
    int has_sep = (sep != CH_ZERO);
    size_t len = has_sep ? buflen * 3 : 1 + buflen * 2;

    if (strlen != NULL)
        *strlen = len;
    if (str == NULL)
        return 1;

    if (str_n < (unsigned long)len) {
        CRYPTOerr(0, CRYPTO_R_TOO_SMALL_BUFFER);
        return 0;
    }

    q = str;
    for (i = 0, p = buf; i < buflen; i++, p++) {
        *q++ = hexdig[(*p >> 4) & 0xf];
        *q++ = hexdig[*p & 0xf];
        if (has_sep)
            *q++ = sep;
    }
    if (has_sep)
        --q;
    *q = CH_ZERO;

#ifdef CHARSET_EBCDIC
    ebcdic2ascii(str, str, q - str - 1);
#endif
    return 1;
}

int OPENSSL_buf2hexstr_ex(char *str, size_t str_n, size_t *strlen,
                          const unsigned char *buf, size_t buflen)
{
    return buf2hexstr_sep(str, str_n, strlen, buf, buflen, DEFAULT_SEPARATOR);
}

char *openssl_buf2hexstr_sep(const unsigned char *buf, long buflen, char sep)
{
    char *tmp;
    size_t tmp_n;

    if (buflen == 0)
        return OPENSSL_zalloc(1);

    tmp_n = (sep != CH_ZERO) ? buflen * 3 : 1 + buflen * 2;
    if ((tmp = OPENSSL_malloc(tmp_n)) == NULL) {
        CRYPTOerr(0, ERR_R_MALLOC_FAILURE);
        return NULL;
    }

    if (buf2hexstr_sep(tmp, tmp_n, NULL, buf, buflen, sep))
        return tmp;
    OPENSSL_free(tmp);
    return NULL;
}


/*
 * Given a buffer of length 'len' return a OPENSSL_malloc'ed string with its
 * hex representation @@@ (Contents of buffer are always kept in ASCII, also
 * on EBCDIC machines)
 */
char *OPENSSL_buf2hexstr(const unsigned char *buf, long buflen)
{
    return openssl_buf2hexstr_sep(buf, buflen, ':');
}

int openssl_strerror_r(int errnum, char *buf, size_t buflen)
{
#if defined(_MSC_VER) && _MSC_VER>=1400
    return !strerror_s(buf, buflen, errnum);
#elif defined(_GNU_SOURCE)
    char *err;

    /*
     * GNU strerror_r may not actually set buf.
     * It can return a pointer to some (immutable) static string in which case
     * buf is left unused.
     */
    err = strerror_r(errnum, buf, buflen);
    if (err == NULL || buflen == 0)
        return 0;
    /*
     * If err is statically allocated, err != buf and we need to copy the data.
     * If err points somewhere inside buf, OPENSSL_strlcpy can handle this,
     * since src and dest are not annotated with __restrict and the function
     * reads src byte for byte and writes to dest.
     * If err == buf we do not have to copy anything.
     */
    if (err != buf)
        OPENSSL_strlcpy(buf, err, buflen);
    return 1;
#elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) || \
      (defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)
    /*
     * We can use "real" strerror_r. The OpenSSL version differs in that it
     * gives 1 on success and 0 on failure for consistency with other OpenSSL
     * functions. Real strerror_r does it the other way around
     */
    return !strerror_r(errnum, buf, buflen);
#else
    char *err;

    /* Fall back to non-thread safe strerror()...its all we can do */
    if (buflen < 2)
        return 0;
    err = strerror(errnum);
    /* Can this ever happen? */
    if (err == NULL)
        return 0;
    OPENSSL_strlcpy(buf, err, buflen);
    return 1;
#endif
}
Commit	Line	Data
0f113f3e	1	/*
a1df06b3	2	* Copyright 2003-2017 The OpenSSL Project Authors. All Rights Reserved.
e6fa67fa	3	*
0e9725bc	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
62867571 RS	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
e6fa67fa RL	8	*/
e6fa67fa RL	9
bef7a815	10	#include "e_os.h"
07016a8a	11	#include <limits.h>
7644a9ae RS	12	#include <openssl/crypto.h>
7644a9ae RS	13	#include "internal/cryptlib.h"
7644a9ae	14
f32af93c SL	15	#define DEFAULT_SEPARATOR ':'
	16	#define CH_ZERO '\0'
	17
037439c4 MC	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);
f32af93c	43	ret[maxlen] = CH_ZERO;
037439c4 MC	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
7644a9ae RS	63	size_t OPENSSL_strnlen(const char *str, size_t maxlen)
	64	{
	65	const char *p;
	66
f32af93c	67	for (p = str; maxlen-- != 0 && *p != CH_ZERO; ++p) ;
7644a9ae RS	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)
f32af93c	80	*dst = CH_ZERO;
7644a9ae RS	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	}
14f051a0 RS	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
f32af93c SL	135	static int hexstr2buf_sep(unsigned char buf, size_t buf_n, size_t buflen,
f32af93c SL	136	const char *str, const char sep)
037439c4	137	{
82bd7c2c	138	unsigned char *q;
037439c4 MC	139	unsigned char ch, cl;
	140	int chi, cli;
	141	const unsigned char *p;
82bd7c2c	142	size_t cnt;
037439c4	143
82bd7c2c	144	for (p = (const unsigned char )str, q = buf, cnt = 0; p; ) {
037439c4	145	ch = *p++;
f32af93c SL	146	/* A separator of CH_ZERO means there is no separator */
f32af93c SL	147	if (ch == sep && sep != CH_ZERO)
037439c4 MC	148	continue;
	149	cl = *p++;
	150	if (!cl) {
f32af93c	151	CRYPTOerr(0, CRYPTO_R_ODD_NUMBER_OF_DIGITS);
82bd7c2c	152	return 0;
037439c4 MC	153	}
	154	cli = OPENSSL_hexchar2int(cl);
	155	chi = OPENSSL_hexchar2int(ch);
	156	if (cli < 0 \|\| chi < 0) {
f32af93c	157	CRYPTOerr(0, CRYPTO_R_ILLEGAL_HEX_DIGIT);
82bd7c2c RL	158	return 0;
	159	}
	160	cnt++;
	161	if (q != NULL) {
	162	if (cnt > buf_n) {
f32af93c	163	CRYPTOerr(0, CRYPTO_R_TOO_SMALL_BUFFER);
82bd7c2c RL	164	return 0;
	165	}
	166	*q++ = (unsigned char)((chi << 4) \| cli);
037439c4	167	}
037439c4 MC	168	}
037439c4 MC	169
82bd7c2c RL	170	if (buflen != NULL)
	171	*buflen = cnt;
	172	return 1;
037439c4 MC	173	}
037439c4 MC	174
f32af93c SL	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)
82bd7c2c RL	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) {
f32af93c	192	CRYPTOerr(0, ERR_R_MALLOC_FAILURE);
82bd7c2c RL	193	return NULL;
	194	}
	195
	196	if (buflen != NULL)
	197	*buflen = 0;
	198	tmp_buflen = 0;
f32af93c	199	if (hexstr2buf_sep(buf, buf_n, &tmp_buflen, str, sep)) {
82bd7c2c RL	200	if (buflen != NULL)
	201	*buflen = (long)tmp_buflen;
	202	return buf;
	203	}
	204	OPENSSL_free(buf);
	205	return NULL;
	206	}
	207
f32af93c SL	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)
037439c4 MC	216	{
037439c4 MC	217	static const char hexdig[] = "0123456789ABCDEF";
037439c4	218	const unsigned char *p;
82bd7c2c RL	219	char *q;
82bd7c2c RL	220	size_t i;
f32af93c SL	221	int has_sep = (sep != CH_ZERO);
f32af93c SL	222	size_t len = has_sep ? buflen * 3 : 1 + buflen * 2;
037439c4	223
82bd7c2c	224	if (strlen != NULL)
f32af93c	225	*strlen = len;
82bd7c2c RL	226	if (str == NULL)
82bd7c2c RL	227	return 1;
037439c4	228
f32af93c SL	229	if (str_n < (unsigned long)len) {
f32af93c SL	230	CRYPTOerr(0, CRYPTO_R_TOO_SMALL_BUFFER);
82bd7c2c	231	return 0;
037439c4	232	}
82bd7c2c RL	233
	234	q = str;
	235	for (i = 0, p = buf; i < buflen; i++, p++) {
037439c4 MC	236	q++ = hexdig[(p >> 4) & 0xf];
037439c4 MC	237	q++ = hexdig[p & 0xf];
f32af93c SL	238	if (has_sep)
f32af93c SL	239	*q++ = sep;
037439c4	240	}
f32af93c SL	241	if (has_sep)
	242	--q;
	243	*q = CH_ZERO;
	244
037439c4	245	#ifdef CHARSET_EBCDIC
82bd7c2c	246	ebcdic2ascii(str, str, q - str - 1);
037439c4	247	#endif
82bd7c2c RL	248	return 1;
	249	}
	250
f32af93c SL	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)
82bd7c2c RL	258	{
	259	char *tmp;
	260	size_t tmp_n;
	261
	262	if (buflen == 0)
	263	return OPENSSL_zalloc(1);
	264
f32af93c	265	tmp_n = (sep != CH_ZERO) ? buflen * 3 : 1 + buflen * 2;
82bd7c2c	266	if ((tmp = OPENSSL_malloc(tmp_n)) == NULL) {
f32af93c	267	CRYPTOerr(0, ERR_R_MALLOC_FAILURE);
82bd7c2c RL	268	return NULL;
82bd7c2c RL	269	}
037439c4	270
f32af93c	271	if (buf2hexstr_sep(tmp, tmp_n, NULL, buf, buflen, sep))
82bd7c2c RL	272	return tmp;
	273	OPENSSL_free(tmp);
	274	return NULL;
037439c4 MC	275	}
037439c4 MC	276
f32af93c SL	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
7d37818d MC	288	int openssl_strerror_r(int errnum, char *buf, size_t buflen)
7d37818d MC	289	{
43c4116c AP	290	#if defined(_MSC_VER) && _MSC_VER>=1400
43c4116c AP	291	return !strerror_s(buf, buflen, errnum);
efdb2d6c	292	#elif defined(_GNU_SOURCE)
e3b35d2b VC	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);
e7a4682d	301	if (err == NULL \|\| buflen == 0)
e3b35d2b VC	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;
01b76c2c BE	313	#elif (defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112L) \|\| \
01b76c2c BE	314	(defined(_XOPEN_SOURCE) && _XOPEN_SOURCE >= 600)
7d37818d MC	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;
e3b35d2b	323
7d37818d MC	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;
e3b35d2b	331	OPENSSL_strlcpy(buf, err, buflen);
7d37818d MC	332	return 1;
	333	#endif
	334	}