BOOL ssl_parse_certificate_internal(void * bytes, size_t size, void* pwd, void* x509CertData) { char *name,*subject; X509CertData* x509 = (X509CertData*)x509CertData; X509* x = ssl_parse_certificate(bytes, size, (LPCSTR)pwd, NULL); if (x == NULL) { TINYCLR_SSL_PRINTF("Unable to load certificate\n"); ERR_print_errors_fp(OPENSSL_TYPE__FILE_STDERR); return FALSE; } name=X509_NAME_oneline(X509_get_issuer_name(x),NULL,0); subject=X509_NAME_oneline(X509_get_subject_name(x),NULL,0); TINYCLR_SSL_STRNCPY(x509->Issuer, name, TINYCLR_SSL_STRLEN(name)); TINYCLR_SSL_STRNCPY(x509->Subject, subject, TINYCLR_SSL_STRLEN(subject)); ssl_get_ASN1_UTCTIME(X509_get_notBefore(x), &x509->EffectiveDate); ssl_get_ASN1_UTCTIME(X509_get_notAfter(x), &x509->ExpirationDate); #if defined(DEBUG) || defined(_DEBUG) TINYCLR_SSL_PRINTF("\n Issuer: "); TINYCLR_SSL_PRINTF(name); TINYCLR_SSL_PRINTF("\n",1); TINYCLR_SSL_PRINTF(" Validity\n"); TINYCLR_SSL_PRINTF(" Not Before: "); TINYCLR_SSL_PRINTF("%s %2d %02d:%02d:%02d %d%s", mon[x509->EffectiveDate.month-1], x509->EffectiveDate.day, x509->EffectiveDate.hour, x509->EffectiveDate.minute, x509->EffectiveDate.second, x509->EffectiveDate.year, (x509->EffectiveDate.tzOffset)?" GMT":""); TINYCLR_SSL_PRINTF("\n Not After : "); TINYCLR_SSL_PRINTF("%s %2d %02d:%02d:%02d %d%s", mon[x509->ExpirationDate.month-1], x509->ExpirationDate.day, x509->ExpirationDate.hour, x509->ExpirationDate.minute, x509->ExpirationDate.second, x509->ExpirationDate.year, (x509->ExpirationDate.tzOffset)?" GMT":""); TINYCLR_SSL_PRINTF("\n"); TINYCLR_SSL_PRINTF(" Subject: "); TINYCLR_SSL_PRINTF(subject); TINYCLR_SSL_PRINTF("\n"); #endif OPENSSL_free(name); OPENSSL_free(subject); X509_free(x); return TRUE; }
const char *LP_find_file(LP_DIR_CTX **ctx, const char *directory) { struct dirent *direntry = NULL; if (ctx == NULL || directory == NULL) { errno = EINVAL; return 0; } errno = 0; if (*ctx == NULL) { *ctx = (LP_DIR_CTX *)malloc(sizeof(LP_DIR_CTX)); if (*ctx == NULL) { errno = ENOMEM; return 0; } TINYCLR_SSL_MEMSET(*ctx, '\0', sizeof(LP_DIR_CTX)); (*ctx)->dir = opendir(directory); if ((*ctx)->dir == NULL) { int save_errno = errno; /* Probably not needed, but I'm paranoid */ free(*ctx); *ctx = NULL; errno = save_errno; return 0; } } direntry = readdir((*ctx)->dir); if (direntry == NULL) { return 0; } TINYCLR_SSL_STRNCPY((*ctx)->entry_name, direntry->d_name, sizeof((*ctx)->entry_name) - 1); (*ctx)->entry_name[sizeof((*ctx)->entry_name) - 1] = '\0'; return (*ctx)->entry_name; }
static char *win32_joiner(DSO *dso, const struct file_st *file_split) { int len = 0, offset = 0; char *result = NULL; const char *start; if(!file_split) { DSOerr(DSO_F_WIN32_JOINER, ERR_R_PASSED_NULL_PARAMETER); return(NULL); } if(file_split->node) { len += 2 + file_split->nodelen; /* 2 for starting \\ */ if(file_split->predir || file_split->dir || file_split->file) len++; /* 1 for ending \ */ } else if(file_split->device) { len += file_split->devicelen + 1; /* 1 for ending : */ } len += file_split->predirlen; if(file_split->predir && (file_split->dir || file_split->file)) { len++; /* 1 for ending \ */ } len += file_split->dirlen; if(file_split->dir && file_split->file) { len++; /* 1 for ending \ */ } len += file_split->filelen; if(!len) { DSOerr(DSO_F_WIN32_JOINER, DSO_R_EMPTY_FILE_STRUCTURE); return(NULL); } result = OPENSSL_malloc(len + 1); if (!result) { DSOerr(DSO_F_WIN32_JOINER, ERR_R_MALLOC_FAILURE); return(NULL); } if(file_split->node) { TINYCLR_SSL_STRCPY(&result[offset], "\\\\"); offset += 2; TINYCLR_SSL_STRNCPY(&result[offset], file_split->node, file_split->nodelen); offset += file_split->nodelen; if(file_split->predir || file_split->dir || file_split->file) { result[offset] = '\\'; offset++; } } else if(file_split->device) { TINYCLR_SSL_STRNCPY(&result[offset], file_split->device, file_split->devicelen); offset += file_split->devicelen; result[offset] = ':'; offset++; } start = file_split->predir; while(file_split->predirlen > (start - file_split->predir)) { const char *end = openssl_strnchr(start, '/', file_split->predirlen - (start - file_split->predir)); if(!end) end = start + file_split->predirlen - (start - file_split->predir); TINYCLR_SSL_STRNCPY(&result[offset], start, end - start); offset += (int)(end - start); result[offset] = '\\'; offset++; start = end + 1; } #if 0 /* Not needed, since the directory converter above already appeneded a backslash */ if(file_split->predir && (file_split->dir || file_split->file)) { result[offset] = '\\'; offset++; } #endif start = file_split->dir; while(file_split->dirlen > (start - file_split->dir)) { const char *end = openssl_strnchr(start, '/', file_split->dirlen - (start - file_split->dir)); if(!end) end = start + file_split->dirlen - (start - file_split->dir); TINYCLR_SSL_STRNCPY(&result[offset], start, end - start); offset += (int)(end - start); result[offset] = '\\'; offset++; start = end + 1; } #if 0 /* Not needed, since the directory converter above already appeneded a backslash */ if(file_split->dir && file_split->file) { result[offset] = '\\'; offset++; } #endif TINYCLR_SSL_STRNCPY(&result[offset], file_split->file, file_split->filelen); offset += file_split->filelen; result[offset] = '\0'; return(result); }
const char *LP_find_file(LP_DIR_CTX **ctx, const char *directory) { if (ctx == NULL || directory == NULL) { errno = EINVAL; return 0; } errno = 0; if (*ctx == NULL) { *ctx = (LP_DIR_CTX *)OPENSSL_malloc(sizeof(LP_DIR_CTX)); if (*ctx == NULL) { errno = ENOMEM; return 0; } TINYCLR_SSL_MEMSET(*ctx, '\0', sizeof(LP_DIR_CTX)); if (sizeof(TCHAR) != sizeof(char)) { TCHAR *wdir = NULL; /* len_0 denotes string length *with* trailing 0 */ size_t index = 0,len_0 = TINYCLR_SSL_STRLEN(directory) + 1; wdir = (TCHAR *)OPENSSL_malloc(len_0 * sizeof(TCHAR)); if (wdir == NULL) { OPENSSL_free(*ctx); *ctx = NULL; errno = ENOMEM; return 0; } #ifdef LP_MULTIBYTE_AVAILABLE if (!MultiByteToWideChar(CP_ACP, 0, directory, len_0, (WCHAR *)wdir, len_0)) #endif for (index = 0; index < len_0; index++) wdir[index] = (TCHAR)directory[index]; (*ctx)->handle = FindFirstFile(wdir, &(*ctx)->ctx); OPENSSL_free(wdir); } else (*ctx)->handle = FindFirstFile((TCHAR *)directory, &(*ctx)->ctx); if ((*ctx)->handle == INVALID_HANDLE_VALUE) { OPENSSL_free(*ctx); *ctx = NULL; errno = EINVAL; return 0; } } else { if (FindNextFile((*ctx)->handle, &(*ctx)->ctx) == FALSE) { return 0; } } if (sizeof(TCHAR) != sizeof(char)) { TCHAR *wdir = (*ctx)->ctx.cFileName; size_t index, len_0 = 0; while (wdir[len_0] && len_0 < (sizeof((*ctx)->entry_name) - 1)) len_0++; len_0++; #ifdef LP_MULTIBYTE_AVAILABLE if (!WideCharToMultiByte(CP_ACP, 0, (WCHAR *)wdir, len_0, (*ctx)->entry_name, sizeof((*ctx)->entry_name), NULL, 0)) #endif for (index = 0; index < len_0; index++) (*ctx)->entry_name[index] = (char)wdir[index]; } else TINYCLR_SSL_STRNCPY((*ctx)->entry_name, (const char *)(*ctx)->ctx.cFileName, sizeof((*ctx)->entry_name)-1); (*ctx)->entry_name[sizeof((*ctx)->entry_name)-1] = '\0'; return (*ctx)->entry_name; }
const char *LP_find_file(LP_DIR_CTX **ctx, const char *directory) { int status; char *p, *r; size_t l; unsigned long flags = 0; #ifdef NAML$C_MAXRSS flags |= LIB$M_FIL_LONG_NAMES; #endif if (ctx == NULL || directory == NULL) { errno = EINVAL; return 0; } errno = 0; if (*ctx == NULL) { size_t filespeclen = TINYCLR_SSL_STRLEN(directory); char *filespec = NULL; /* MUST be a VMS directory specification! Let's estimate if it is. */ if (directory[filespeclen-1] != ']' && directory[filespeclen-1] != '>' && directory[filespeclen-1] != ':') { errno = EINVAL; return 0; } filespeclen += 4; /* "*.*;" */ if (filespeclen > #ifdef NAML$C_MAXRSS NAML$C_MAXRSS #else 255 #endif ) { errno = ENAMETOOLONG; return 0; } *ctx = (LP_DIR_CTX *)OPENSSL_malloc(sizeof(LP_DIR_CTX)); if (*ctx == NULL) { errno = ENOMEM; return 0; } TINYCLR_SSL_MEMSET(*ctx, '\0', sizeof(LP_DIR_CTX)); TINYCLR_SSL_STRCPY((*ctx)->filespec,directory); TINYCLR_SSL_STRCAT((*ctx)->filespec,"*.*;"); (*ctx)->filespec_dsc.dsc$w_length = filespeclen; (*ctx)->filespec_dsc.dsc$b_dtype = DSC$K_DTYPE_T; (*ctx)->filespec_dsc.dsc$b_class = DSC$K_CLASS_S; (*ctx)->filespec_dsc.dsc$a_pointer = (*ctx)->filespec; (*ctx)->result_dsc.dsc$w_length = 0; (*ctx)->result_dsc.dsc$b_dtype = DSC$K_DTYPE_T; (*ctx)->result_dsc.dsc$b_class = DSC$K_CLASS_D; (*ctx)->result_dsc.dsc$a_pointer = 0; } (*ctx)->result_dsc.dsc$w_length = 0; (*ctx)->result_dsc.dsc$b_dtype = DSC$K_DTYPE_T; (*ctx)->result_dsc.dsc$b_class = DSC$K_CLASS_D; (*ctx)->result_dsc.dsc$a_pointer = 0; status = lib$find_file(&(*ctx)->filespec_dsc, &(*ctx)->result_dsc, &(*ctx)->VMS_context, 0, 0, 0, &flags); if (status == RMS$_NMF) { errno = 0; vaxc$errno = status; return NULL; } if(!$VMS_STATUS_SUCCESS(status)) { errno = EVMSERR; vaxc$errno = status; return NULL; } /* Quick, cheap and dirty way to discard any device and directory, since we only want file names */ l = (*ctx)->result_dsc.dsc$w_length; p = (*ctx)->result_dsc.dsc$a_pointer; r = p; for (; *p; p++) { if (*p == '^' && p[1] != '\0') /* Take care of ODS-5 escapes */ { p++; } else if (*p == ':' || *p == '>' || *p == ']') { l -= p + 1 - r; r = p + 1; } else if (*p == ';') { l = p - r; break; } } TINYCLR_SSL_STRNCPY((*ctx)->result, r, l); (*ctx)->result[l] = '\0'; str$free1_dx(&(*ctx)->result_dsc); return (*ctx)->result; }
char *X509_NAME_oneline(X509_NAME *a, char *buf, int len) { X509_NAME_ENTRY *ne; int i; int n,lold,l,l1,l2,num,j,type; const char *s; char *p; unsigned char *q; BUF_MEM *b=NULL; static const char hex[17]="0123456789ABCDEF"; int gs_doit[4]; char tmp_buf[80]; #ifdef CHARSET_EBCDIC char ebcdic_buf[1024]; #endif if (buf == NULL) { if ((b=BUF_MEM_new()) == NULL) goto err; if (!BUF_MEM_grow(b,200)) goto err; b->data[0]='\0'; len=200; } if (a == NULL) { if(b) { buf=b->data; OPENSSL_free(b); } TINYCLR_SSL_STRNCPY(buf,"NO X509_NAME",len); buf[len-1]='\0'; return buf; } len--; /* space for '\0' */ l=0; for (i=0; i<sk_X509_NAME_ENTRY_num(a->entries); i++) { ne=sk_X509_NAME_ENTRY_value(a->entries,i); n=OBJ_obj2nid(ne->object); if ((n == NID_undef) || ((s=OBJ_nid2sn(n)) == NULL)) { i2t_ASN1_OBJECT(tmp_buf,sizeof(tmp_buf),ne->object); s=tmp_buf; } l1=TINYCLR_SSL_STRLEN(s); type=ne->value->type; num=ne->value->length; q=ne->value->data; #ifdef CHARSET_EBCDIC if (type == V_ASN1_GENERALSTRING || type == V_ASN1_VISIBLESTRING || type == V_ASN1_PRINTABLESTRING || type == V_ASN1_TELETEXSTRING || type == V_ASN1_VISIBLESTRING || type == V_ASN1_IA5STRING) { ascii2ebcdic(ebcdic_buf, q, (num > sizeof ebcdic_buf) ? sizeof ebcdic_buf : num); q=ebcdic_buf; } #endif if ((type == V_ASN1_GENERALSTRING) && ((num%4) == 0)) { gs_doit[0]=gs_doit[1]=gs_doit[2]=gs_doit[3]=0; for (j=0; j<num; j++) if (q[j] != 0) gs_doit[j&3]=1; if (gs_doit[0]|gs_doit[1]|gs_doit[2]) gs_doit[0]=gs_doit[1]=gs_doit[2]=gs_doit[3]=1; else { gs_doit[0]=gs_doit[1]=gs_doit[2]=0; gs_doit[3]=1; } } else gs_doit[0]=gs_doit[1]=gs_doit[2]=gs_doit[3]=1; for (l2=j=0; j<num; j++) { if (!gs_doit[j&3]) continue; l2++; #ifndef CHARSET_EBCDIC if ((q[j] < ' ') || (q[j] > '~')) l2+=3; #else if ((os_toascii[q[j]] < os_toascii[' ']) || (os_toascii[q[j]] > os_toascii['~'])) l2+=3; #endif } lold=l; l+=1+l1+1+l2; if (b != NULL) { if (!BUF_MEM_grow(b,l+1)) goto err; p= &(b->data[lold]); } else if (l > len) { break; } else p= &(buf[lold]); *(p++)='/'; TINYCLR_SSL_MEMCPY(p,s,(unsigned int)l1); p+=l1; *(p++)='='; #ifndef CHARSET_EBCDIC /* q was assigned above already. */ q=ne->value->data; #endif for (j=0; j<num; j++) { if (!gs_doit[j&3]) continue; #ifndef CHARSET_EBCDIC n=q[j]; if ((n < ' ') || (n > '~')) { *(p++)='\\'; *(p++)='x'; *(p++)=hex[(n>>4)&0x0f]; *(p++)=hex[n&0x0f]; } else *(p++)=n; #else n=os_toascii[q[j]]; if ((n < os_toascii[' ']) || (n > os_toascii['~'])) { *(p++)='\\'; *(p++)='x'; *(p++)=hex[(n>>4)&0x0f]; *(p++)=hex[n&0x0f]; }