static int append_buf(char **buf, int *size, const char *s) { if (*buf == NULL) { *size = 256; *buf = app_malloc(*size, "engine buffer"); **buf = '\0'; } if (strlen(*buf) + strlen(s) >= (unsigned int)*size) { char *tmp; *size += 256; tmp = OPENSSL_realloc(*buf, *size); if (tmp == NULL) { OPENSSL_free(*buf); *buf = NULL; return 0; } *buf = tmp; } if (**buf != '\0') OPENSSL_strlcat(*buf, ", ", *size); OPENSSL_strlcat(*buf, s, *size); return 1; }
char *UI_construct_prompt(UI *ui, const char *object_desc, const char *object_name) { char *prompt = NULL; if (ui->meth->ui_construct_prompt != NULL) prompt = ui->meth->ui_construct_prompt(ui, object_desc, object_name); else { char prompt1[] = "Enter "; char prompt2[] = " for "; char prompt3[] = ":"; int len = 0; if (object_desc == NULL) return NULL; len = sizeof(prompt1) - 1 + strlen(object_desc); if (object_name != NULL) len += sizeof(prompt2) - 1 + strlen(object_name); len += sizeof(prompt3) - 1; prompt = OPENSSL_malloc(len + 1); if (prompt == NULL) return NULL; OPENSSL_strlcpy(prompt, prompt1, len + 1); OPENSSL_strlcat(prompt, object_desc, len + 1); if (object_name != NULL) { OPENSSL_strlcat(prompt, prompt2, len + 1); OPENSSL_strlcat(prompt, object_name, len + 1); } OPENSSL_strlcat(prompt, prompt3, len + 1); } return prompt; }
/* * Get next file from the directory path. * Returns BIO of the next file to read and updates dirctx. */ static BIO *get_next_file(const char *path, OPENSSL_DIR_CTX **dirctx) { const char *filename; while ((filename = OPENSSL_DIR_read(dirctx, path)) != NULL) { size_t namelen; namelen = strlen(filename); if ((namelen > 5 && strcasecmp(filename + namelen - 5, ".conf") == 0) || (namelen > 4 && strcasecmp(filename + namelen - 4, ".cnf") == 0)) { size_t newlen; char *newpath; BIO *bio; newlen = strlen(path) + namelen + 2; newpath = OPENSSL_zalloc(newlen); if (newpath == NULL) { CONFerr(CONF_F_GET_NEXT_FILE, ERR_R_MALLOC_FAILURE); break; } #ifdef OPENSSL_SYS_VMS /* * If the given path isn't clear VMS syntax, * we treat it as on Unix. */ { size_t pathlen = strlen(path); if (path[pathlen - 1] == ']' || path[pathlen - 1] == '>' || path[pathlen - 1] == ':') { /* Clear VMS directory syntax, just copy as is */ OPENSSL_strlcpy(newpath, path, newlen); } } #endif if (newpath[0] == '\0') { OPENSSL_strlcpy(newpath, path, newlen); OPENSSL_strlcat(newpath, "/", newlen); } OPENSSL_strlcat(newpath, filename, newlen); bio = BIO_new_file(newpath, "r"); OPENSSL_free(newpath); /* Errors when opening files are non-fatal. */ if (bio != NULL) return bio; } } OPENSSL_DIR_end(dirctx); *dirctx = NULL; return NULL; }
const char *RAND_file_name(char *buf, size_t size) { char *s = NULL; #ifdef __OpenBSD__ struct stat sb; #endif if (OPENSSL_issetugid() == 0) s = getenv("RANDFILE"); if (s != NULL && *s && strlen(s) + 1 < size) { if (OPENSSL_strlcpy(buf, s, size) >= size) return NULL; } else { if (OPENSSL_issetugid() == 0) s = getenv("HOME"); #ifdef DEFAULT_HOME if (s == NULL) { s = DEFAULT_HOME; } #endif if (s && *s && strlen(s) + strlen(RFILE) + 2 < size) { OPENSSL_strlcpy(buf, s, size); #ifndef OPENSSL_SYS_VMS OPENSSL_strlcat(buf, "/", size); #endif OPENSSL_strlcat(buf, RFILE, size); } else buf[0] = '\0'; /* no file name */ } #ifdef __OpenBSD__ /* * given that all random loads just fail if the file can't be seen on a * stat, we stat the file we're returning, if it fails, use /dev/arandom * instead. this allows the user to use their own source for good random * data, but defaults to something hopefully decent if that isn't * available. */ if (!buf[0]) if (OPENSSL_strlcpy(buf, "/dev/arandom", size) >= size) { return (NULL); } if (stat(buf, &sb) == -1) if (OPENSSL_strlcpy(buf, "/dev/arandom", size) >= size) { return (NULL); } #endif return (buf); }
void ERR_add_error_vdata(int num, va_list args) { int i, n, s; char *str, *p, *a; s = 80; if ((str = OPENSSL_malloc(s + 1)) == NULL) { /* ERRerr(ERR_F_ERR_ADD_ERROR_VDATA, ERR_R_MALLOC_FAILURE); */ return; } str[0] = '\0'; n = 0; for (i = 0; i < num; i++) { a = va_arg(args, char *); if (a == NULL) a = "<NULL>"; n += strlen(a); if (n > s) { s = n + 20; p = OPENSSL_realloc(str, s + 1); if (p == NULL) { OPENSSL_free(str); return; } str = p; } OPENSSL_strlcat(str, a, (size_t)s + 1); } if (!err_set_error_data_int(str, ERR_TXT_MALLOCED | ERR_TXT_STRING)) OPENSSL_free(str); }
void ERR_add_error_vdata(int num, va_list args) { int i, n, s; char *str, *p, *a; s = 80; str = OPENSSL_malloc(s + 1); if (str == NULL) return; str[0] = '\0'; n = 0; for (i = 0; i < num; i++) { a = va_arg(args, char *); /* ignore NULLs, thanks to Bob Beck <*****@*****.**> */ if (a != NULL) { n += strlen(a); if (n > s) { s = n + 20; p = OPENSSL_realloc(str, s + 1); if (p == NULL) { OPENSSL_free(str); return; } str = p; } OPENSSL_strlcat(str, a, (size_t)s + 1); } } ERR_set_error_data(str, ERR_TXT_MALLOCED | ERR_TXT_STRING); }
void ERR_add_error_vdata(int num, va_list args) { int i, n, s; char *str, *p, *a; s = 80; str = OPENSSL_malloc(s + 1); if (str == NULL) return; str[0] = '\0'; n = 0; for (i = 0; i < num; i++) { a = va_arg(args, char *); if (a == NULL) a = "<NULL>"; n += strlen(a); if (n > s) { s = n + 20; p = OPENSSL_realloc(str, s + 1); if (p == NULL) { OPENSSL_free(str); return; } str = p; } OPENSSL_strlcat(str, a, (size_t)s + 1); } ERR_set_error_data(str, ERR_TXT_MALLOCED | ERR_TXT_STRING); }
void PEM_proc_type(char *buf, int type) { const char *str; if (type == PEM_TYPE_ENCRYPTED) str = "ENCRYPTED"; else if (type == PEM_TYPE_MIC_CLEAR) str = "MIC-CLEAR"; else if (type == PEM_TYPE_MIC_ONLY) str = "MIC-ONLY"; else str = "BAD-TYPE"; OPENSSL_strlcat(buf, "Proc-Type: 4,", PEM_BUFSIZE); OPENSSL_strlcat(buf, str, PEM_BUFSIZE); OPENSSL_strlcat(buf, "\n", PEM_BUFSIZE); }
static char *mk_file_path(const char *dir, const char *file) { #ifndef OPENSSL_SYS_VMS const char *sep = "/"; #else const char *sep = ""; #endif size_t len = strlen(dir) + strlen(sep) + strlen(file) + 1; char *full_file = OPENSSL_zalloc(len); if (full_file != NULL) { OPENSSL_strlcpy(full_file, dir, len); OPENSSL_strlcat(full_file, sep, len); OPENSSL_strlcat(full_file, file, len); } return full_file; }
static char *mk_file_path(const char *dir, const char *file) { char *full_file = NULL; size_t full_file_l = 0; const char *sep = ""; #ifndef OPENSSL_SYS_VMS sep = "/"; #endif full_file_l = strlen(dir) + strlen(sep) + strlen(file) + 1; full_file = OPENSSL_zalloc(full_file_l); if (full_file != NULL) { OPENSSL_strlcpy(full_file, dir, full_file_l); OPENSSL_strlcat(full_file, sep, full_file_l); OPENSSL_strlcat(full_file, file, full_file_l); } return full_file; }
void PEM_dek_info(char *buf, const char *type, int len, char *str) { static const unsigned char map[17] = "0123456789ABCDEF"; long i; int j; OPENSSL_strlcat(buf, "DEK-Info: ", PEM_BUFSIZE); OPENSSL_strlcat(buf, type, PEM_BUFSIZE); OPENSSL_strlcat(buf, ",", PEM_BUFSIZE); j = strlen(buf); if (j + (len * 2) + 1 > PEM_BUFSIZE) return; for (i = 0; i < len; i++) { buf[j + i * 2] = map[(str[i] >> 4) & 0x0f]; buf[j + i * 2 + 1] = map[(str[i]) & 0x0f]; } buf[j + i * 2] = '\n'; buf[j + i * 2 + 1] = '\0'; }
static int file_name_to_uri(OSSL_STORE_LOADER_CTX *ctx, const char *name, char **data) { assert(name != NULL); assert(data != NULL); { const char *pathsep = ends_with_dirsep(ctx->_.dir.uri) ? "" : "/"; long calculated_length = strlen(ctx->_.dir.uri) + strlen(pathsep) + strlen(name) + 1 /* \0 */; *data = OPENSSL_zalloc(calculated_length); if (*data == NULL) { OSSL_STOREerr(OSSL_STORE_F_FILE_NAME_TO_URI, ERR_R_MALLOC_FAILURE); return 0; } OPENSSL_strlcat(*data, ctx->_.dir.uri, calculated_length); OPENSSL_strlcat(*data, pathsep, calculated_length); OPENSSL_strlcat(*data, name, calculated_length); } return 1; }
/* Convert an ASN1_TIME structure to GeneralizedTime */ ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(const ASN1_TIME *t, ASN1_GENERALIZEDTIME **out) { ASN1_GENERALIZEDTIME *ret = NULL; char *str; int newlen; if (!ASN1_TIME_check(t)) return NULL; if (out == NULL || *out == NULL) { if ((ret = ASN1_GENERALIZEDTIME_new()) == NULL) goto err; } else ret = *out; /* If already GeneralizedTime just copy across */ if (t->type == V_ASN1_GENERALIZEDTIME) { if (!ASN1_STRING_set(ret, t->data, t->length)) goto err; goto done; } /* grow the string */ if (!ASN1_STRING_set(ret, NULL, t->length + 2)) goto err; /* ASN1_STRING_set() allocated 'len + 1' bytes. */ newlen = t->length + 2 + 1; str = (char *)ret->data; /* Work out the century and prepend */ if (t->data[0] >= '5') OPENSSL_strlcpy(str, "19", newlen); else OPENSSL_strlcpy(str, "20", newlen); OPENSSL_strlcat(str, (const char *)t->data, newlen); done: if (out != NULL && *out == NULL) *out = ret; return ret; err: if (out == NULL || *out != ret) ASN1_GENERALIZEDTIME_free(ret); return NULL; }
static ASN1_INTEGER *x509_load_serial(char *CAfile, char *serialfile, int create) { char *buf = NULL, *p; ASN1_INTEGER *bs = NULL; BIGNUM *serial = NULL; size_t len; len = ((serialfile == NULL) ? (strlen(CAfile) + strlen(POSTFIX) + 1) : (strlen(serialfile))) + 1; buf = app_malloc(len, "serial# buffer"); if (serialfile == NULL) { OPENSSL_strlcpy(buf, CAfile, len); for (p = buf; *p; p++) if (*p == '.') { *p = '\0'; break; } OPENSSL_strlcat(buf, POSTFIX, len); } else OPENSSL_strlcpy(buf, serialfile, len); serial = load_serial(buf, create, NULL); if (serial == NULL) goto end; if (!BN_add_word(serial, 1)) { BIO_printf(bio_err, "add_word failure\n"); goto end; } if (!save_serial(buf, NULL, serial, &bs)) goto end; end: OPENSSL_free(buf); BN_free(serial); return bs; }
const char *RAND_file_name(char *buf, size_t size) { char *s = NULL; int use_randfile = 1; #ifdef __OpenBSD__ struct stat sb; #endif #if defined(_WIN32) && defined(CP_UTF8) DWORD len; WCHAR *var, *val; if ((var = L"RANDFILE", len = GetEnvironmentVariableW(var, NULL, 0)) == 0 && (var = L"HOME", use_randfile = 0, len = GetEnvironmentVariableW(var, NULL, 0)) == 0 && (var = L"USERPROFILE", len = GetEnvironmentVariableW(var, NULL, 0)) == 0) { var = L"SYSTEMROOT", len = GetEnvironmentVariableW(var, NULL, 0); } if (len != 0) { int sz; val = _alloca(len * sizeof(WCHAR)); if (GetEnvironmentVariableW(var, val, len) < len && (sz = WideCharToMultiByte(CP_UTF8, 0, val, -1, NULL, 0, NULL, NULL)) != 0) { s = _alloca(sz); if (WideCharToMultiByte(CP_UTF8, 0, val, -1, s, sz, NULL, NULL) == 0) s = NULL; } } #else if (OPENSSL_issetugid() != 0) { use_randfile = 0; } else { s = getenv("RANDFILE"); if (s == NULL || *s == '\0') { use_randfile = 0; s = getenv("HOME"); } } #endif #ifdef DEFAULT_HOME if (!use_randfile && s == NULL) { s = DEFAULT_HOME; } #endif if (s != NULL && *s) { size_t len = strlen(s); if (use_randfile && len + 1 < size) { if (OPENSSL_strlcpy(buf, s, size) >= size) return NULL; } else if (len + strlen(RFILE) + 2 < size) { OPENSSL_strlcpy(buf, s, size); #ifndef OPENSSL_SYS_VMS OPENSSL_strlcat(buf, "/", size); #endif OPENSSL_strlcat(buf, RFILE, size); } } else { buf[0] = '\0'; /* no file name */ } #ifdef __OpenBSD__ /* * given that all random loads just fail if the file can't be seen on a * stat, we stat the file we're returning, if it fails, use /dev/arandom * instead. this allows the user to use their own source for good random * data, but defaults to something hopefully decent if that isn't * available. */ if (!buf[0] || stat(buf, &sb) == -1) if (OPENSSL_strlcpy(buf, "/dev/arandom", size) >= size) { return NULL; } #endif return buf[0] ? buf : NULL; }
static long file_ctrl(BIO *b, int cmd, long num, void *ptr) { long ret = 1; FILE *fp = (FILE *)b->ptr; FILE **fpp; char p[4]; int st; switch (cmd) { case BIO_C_FILE_SEEK: case BIO_CTRL_RESET: if (b->flags & BIO_FLAGS_UPLINK) ret = (long)UP_fseek(b->ptr, num, 0); else ret = (long)fseek(fp, num, 0); break; case BIO_CTRL_EOF: if (b->flags & BIO_FLAGS_UPLINK) ret = (long)UP_feof(fp); else ret = (long)feof(fp); break; case BIO_C_FILE_TELL: case BIO_CTRL_INFO: if (b->flags & BIO_FLAGS_UPLINK) ret = UP_ftell(b->ptr); else ret = ftell(fp); break; case BIO_C_SET_FILE_PTR: file_free(b); b->shutdown = (int)num & BIO_CLOSE; b->ptr = ptr; b->init = 1; # if BIO_FLAGS_UPLINK!=0 # if defined(__MINGW32__) && defined(__MSVCRT__) && !defined(_IOB_ENTRIES) # define _IOB_ENTRIES 20 # endif /* Safety net to catch purely internal BIO_set_fp calls */ # if defined(_MSC_VER) && _MSC_VER>=1900 if (ptr == stdin || ptr == stdout || ptr == stderr) BIO_clear_flags(b, BIO_FLAGS_UPLINK); # elif defined(_IOB_ENTRIES) if ((size_t)ptr >= (size_t)stdin && (size_t)ptr < (size_t)(stdin + _IOB_ENTRIES)) BIO_clear_flags(b, BIO_FLAGS_UPLINK); # endif # endif # ifdef UP_fsetmod if (b->flags & BIO_FLAGS_UPLINK) UP_fsetmod(b->ptr, (char)((num & BIO_FP_TEXT) ? 't' : 'b')); else # endif { # if defined(OPENSSL_SYS_WINDOWS) int fd = _fileno((FILE *)ptr); if (num & BIO_FP_TEXT) _setmode(fd, _O_TEXT); else _setmode(fd, _O_BINARY); # elif defined(OPENSSL_SYS_MSDOS) int fd = fileno((FILE *)ptr); /* Set correct text/binary mode */ if (num & BIO_FP_TEXT) _setmode(fd, _O_TEXT); /* Dangerous to set stdin/stdout to raw (unless redirected) */ else { if (fd == STDIN_FILENO || fd == STDOUT_FILENO) { if (isatty(fd) <= 0) _setmode(fd, _O_BINARY); } else _setmode(fd, _O_BINARY); } # elif defined(OPENSSL_SYS_WIN32_CYGWIN) int fd = fileno((FILE *)ptr); if (!(num & BIO_FP_TEXT)) setmode(fd, O_BINARY); # endif } break; case BIO_C_SET_FILENAME: file_free(b); b->shutdown = (int)num & BIO_CLOSE; if (num & BIO_FP_APPEND) { if (num & BIO_FP_READ) OPENSSL_strlcpy(p, "a+", sizeof(p)); else OPENSSL_strlcpy(p, "a", sizeof(p)); } else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE)) OPENSSL_strlcpy(p, "r+", sizeof(p)); else if (num & BIO_FP_WRITE) OPENSSL_strlcpy(p, "w", sizeof(p)); else if (num & BIO_FP_READ) OPENSSL_strlcpy(p, "r", sizeof(p)); else { BIOerr(BIO_F_FILE_CTRL, BIO_R_BAD_FOPEN_MODE); ret = 0; break; } # if defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_WINDOWS) if (!(num & BIO_FP_TEXT)) OPENSSL_strlcat(p, "b", sizeof(p)); else OPENSSL_strlcat(p, "t", sizeof(p)); # elif defined(OPENSSL_SYS_WIN32_CYGWIN) if (!(num & BIO_FP_TEXT)) OPENSSL_strlcat(p, "b", sizeof(p)); # endif fp = openssl_fopen(ptr, p); if (fp == NULL) { SYSerr(SYS_F_FOPEN, get_last_sys_error()); ERR_add_error_data(5, "fopen('", ptr, "','", p, "')"); BIOerr(BIO_F_FILE_CTRL, ERR_R_SYS_LIB); ret = 0; break; } b->ptr = fp; b->init = 1; BIO_clear_flags(b, BIO_FLAGS_UPLINK); /* we did fopen -> we disengage * UPLINK */ break; case BIO_C_GET_FILE_PTR: /* the ptr parameter is actually a FILE ** in this case. */ if (ptr != NULL) { fpp = (FILE **)ptr; *fpp = (FILE *)b->ptr; } break; case BIO_CTRL_GET_CLOSE: ret = (long)b->shutdown; break; case BIO_CTRL_SET_CLOSE: b->shutdown = (int)num; break; case BIO_CTRL_FLUSH: st = b->flags & BIO_FLAGS_UPLINK ? UP_fflush(b->ptr) : fflush((FILE *)b->ptr); if (st == EOF) { SYSerr(SYS_F_FFLUSH, get_last_sys_error()); ERR_add_error_data(1, "fflush()"); BIOerr(BIO_F_FILE_CTRL, ERR_R_SYS_LIB); ret = 0; } break; case BIO_CTRL_DUP: ret = 1; break; case BIO_CTRL_WPENDING: case BIO_CTRL_PENDING: case BIO_CTRL_PUSH: case BIO_CTRL_POP: default: ret = 0; break; } return ret; }