int vce_tcpcontext_init_world( void ) { if( vce_limit.max_tcpcontext > 0 ){ vce_tcpcontext_mi = vce_init_array( sizeof( tcpcontext ), vce_limit.max_tcpcontext, "tcpctx" ); if( vce_tcpcontext_mi < 0 ) return SET_LAST_ERROR(VCE_EARRAY); } return SET_LAST_ERROR(VCE_NOERROR); }
int vce_protocol_parser_text( conn_t ct ) { conn *c = (conn*) ct.p; int datalen, ret = 0; char *data; int i; vce_sbuf_get_buffer( &c->rb, &data, &datalen ); if( datalen < 1 ) return SET_LAST_ERROR(0); // Do I have enough characters to compose a line? for(i=0;i<datalen;i++){ if( data[i] == '\r' && data[i+1] == '\n' && (i<(datalen-1))){ if( c->pcallback ){ ret = c->pcallback( ct, data, i ); } vce_sbuf_shrink( &c->rb, NULL, i+2 ); SET_LAST_ERROR(0); return ret; } else if( data[i] == '\n' ){ if( c->pcallback ){ ret = c->pcallback( ct, data, i ); } vce_sbuf_shrink( &c->rb, NULL, i+1 ); SET_LAST_ERROR(0); return ret; } } return 0; }
/* set */ int vce_set_variable_length_specifier( char *out, int outmax, unsigned int len_upper, unsigned int len_lower ) { if( len_upper == 0 ){ if( len_lower <= 0xfc ){ if(out){ if( outmax < 1 ) return SET_LAST_ERROR(VCE_EFULL); out[0] = (unsigned char)len_lower; } return 1; } else { if(out){ if( outmax < (1+4) ) return SET_LAST_ERROR(VCE_EFULL); out[0] = 0xfd; SET_32BIT_INT(out+1, len_lower); } return 1+4; } } else { if(out){ if( outmax < (1+8) ) return SET_LAST_ERROR(VCE_EFULL); out[0] = 0xfe; SET_32BIT_INT(out+1,len_upper); SET_32BIT_INT(out+1+4,len_lower); } return 1 + 8; } /* not reached */ return SET_LAST_ERROR(VCE_EBUG); }
int vce_protocol_parser_bin16( conn_t ct ) { conn *c = ( conn *) ct.p; int datalen, contentlen, ret=0; char *data; vce_sbuf_get_buffer( &c->rb, &data, &datalen ); if( datalen < 2 ) return SET_LAST_ERROR(0); contentlen = GET_16BIT_INT( data ) & 0xffff; // Limitting length of the record. if(c->maxlen_record>=1 && contentlen > c->maxlen_record ) { if(c->maxlen_warning) { if(c->maxlen_warning(ct)<0) return SET_LAST_ERROR(VCE_EPROTO_TOOLONG); } else { return SET_LAST_ERROR(VCE_EPROTO_TOOLONG); } } if( datalen < ( 2 + contentlen ) ) return SET_LAST_ERROR(0); if( c->pcallback ){ ret = c->pcallback( ct, data + 2, contentlen ); } vce_sbuf_shrink( &c->rb, NULL, contentlen + 2 ); SET_LAST_ERROR(0); return ret; }
/* String array. Format: [VARLEN(string num)][ STRING ][ STRING ]... STRING : [VARLEN][data] eachmax : Max length of each strings. If you have longer strings than this, it gives error. This function doesn't truncate string. No null terminator. */ int vce_binary_push_nb_stra( char *out, int ofs, int maxlen, const char * const *stra, int num, int eachmax ) { int headlen,i,total_l; char lenwork[10]; if(num<0)return SET_LAST_ERROR(VCE_EINVAL); headlen = vce_set_variable_length_specifier( lenwork,sizeof(lenwork), 0,num); if( (ofs+headlen) > maxlen ) return SET_LAST_ERROR(VCE_EFULL); memcpy( out + ofs, lenwork, headlen ); total_l = ofs + headlen; for(i=0;i<num;i++){ char slenwork[10]; char sheadlen; int sl = vce_strlenmax( stra[i], eachmax ); if( sl <0 ) return SET_LAST_ERROR(VCE_EFULL); sheadlen = vce_set_variable_length_specifier( slenwork, sizeof(slenwork), 0,sl); if( (total_l+sheadlen+sl) >= maxlen ) return SET_LAST_ERROR(VCE_EFULL); memcpy( out + total_l , slenwork, sheadlen ); memcpy( out + total_l + sheadlen , stra[i], sl ); total_l += sheadlen + sl; } SET_LAST_ERROR(VCE_NOERROR); return total_l; }
int vce_protocol_unparser_bin16( conn_t ct, char *data , int len ) { int totallen; char work[2]; int wable; if( !vce_conn_is_valid(ct) ) return SET_LAST_ERROR(VCE_EINVAL); if( len > BIN16DATA_MAX ) return SET_LAST_ERROR(VCE_ELONGINPUT); totallen = 2 + len ; wable = vce_conn_writable(ct); if( wable < 0 ) return SET_LAST_ERROR(wable); if( totallen > wable ){ return SET_LAST_ERROR( VCE_EWBFULL ); } // write twice, but never get error (checking by writable() function beforehand // header first SET_16BIT_INT( work, len ); vce_conn_write( ct, work, 2 ); // content second vce_conn_write( ct, data, len ); SET_LAST_ERROR(0); return len+2; }
//============================================================ // Loads the PKCS#11 driver and // tests if the driver loaded correctly // Returns 0 for ok otherwise error code //============================================================ int loadAndTestDriver(const char* driver, LIBHANDLE* pLibrary, CK_SLOT_ID* slotids, int slots, CK_ULONG slot) { CK_TOKEN_INFO tokinfo; CK_SLOT_INFO slotinfo; CK_ULONG idlen, i, ok; CK_RV rv; int err = ERR_OK; // initialize *pLibrary = NULL; memset(slotids, 0, sizeof(CK_SLOT_ID) * slots); // try to load the driver *pLibrary = initPKCS11Library(driver); if(!(*pLibrary)) SET_LAST_ERROR_RETURN_CODE(ERR_PKCS_LIB_LOAD); idlen = slots; rv = GetSlotIds(slotids, &idlen); ddocDebug(3, "loadAndTestDriver", "RV: %d slots: %ld", (int)rv, (long)idlen); if (rv != CKR_OK) { err = ERR_PKCS_SLOT_LIST; SET_LAST_ERROR(err); } if ((slot < 0) || (slot >= idlen)) { err = ERR_PKCS_WRONG_SLOT; SET_LAST_ERROR(err); } // it's useful to test DLL load status this way: ok = 0; for(i = 0; i < idlen; i++) { rv = GetSlotInfo(&slotinfo, slotids[i]); if(slotinfo.flags & CKF_TOKEN_PRESENT) { ddocDebug(3, "loadAndTestDriver", "Read Token: %ld", (long)i); rv = GetTokenInfo(&tokinfo, slotids[i]); // if !CKR_OK test tokinfo.label[31] = 0; ddocDebug(3, "loadAndTestDriver", "RV: %d Token: %s", (int)rv, tokinfo.label); if(rv != CKR_OK) slotids[i] = INVALID_SLOTIID; // set bad slotids to 0 else ok++; // count the good slots } else { slotids[i] = INVALID_SLOTIID; // no tokne in this slot } } // fill other slotid's with invalid slotid for(i = idlen; i < (CK_ULONG)slots; i++) slotids[i] = INVALID_SLOTIID; if(ok < slot) { err = ERR_PKCS_CARD_READ; // if not enough good slots SET_LAST_ERROR(err); } // in case of error try to unload the module and notify caller if (err) { if (*pLibrary) closePKCS11Library(*pLibrary, 0); *pLibrary = NULL; } return err; }
//============================================================ // Locates and reads users certificate from smartcard // slot - number of the slot for decryption key. On ID card allways 0 // ppCert - address for newly allocated certificate pointer // return error code or ERR_OK //============================================================ EXP_OPTION int findUsersCertificate(int slot, X509** ppCert) { int err = ERR_OK, l1, l2; LIBHANDLE pLibrary = 0; CK_RV rv = 0; CK_SLOT_ID slotids[20], slId; CK_OBJECT_HANDLE hCert; CK_SESSION_HANDLE hSession = 0; CK_ULONG certLen; CK_BYTE certData[2048]; char driver[100]; *ppCert = 0; snprintf(driver, sizeof(driver), "DIGIDOC_DRIVER_%d_FILE", ConfigItem_lookup_int("DIGIDOC_DEFAULT_DRIVER", 1)); ddocDebug(3, "findUsersCertificate", "Slot: %d Driver nr: %d - %s", slot, ConfigItem_lookup_int("DIGIDOC_DEFAULT_DRIVER", 1), ConfigItem_lookup(driver)); err = loadAndTestDriver(ConfigItem_lookup(driver), &pLibrary, (CK_SLOT_ID*)slotids, 20, (CK_ULONG)slot); if(err) return err; // find the right slotid for(l1 = l2 = 0; l1 < 20; l1++) { if(slotids[l1] != INVALID_SLOTIID) { if(l2 == slot) slId = slotids[l1]; l2++; } } // open session hSession = OpenSession(slId, NULL); if (hSession == CK_INVALID_HANDLE) { SET_LAST_ERROR(ERR_PKCS_LOGIN); return ERR_PKCS_LOGIN; } ddocDebug(3, "findUsersCertificate", "OpenSession ok, hSession = %d", (int)hSession); // get cert memset(certData, 0, sizeof(certData)); certLen = sizeof(certData); hCert = LocateCertificate(hSession, certData, &certLen, 0, 0, 0); ddocDebug(3, "findUsersCertificate", "hCert = %d, len: %d", (int)hCert, certLen); if (hCert == (CK_OBJECT_HANDLE)-1) { err = ERR_PKCS_CERT_LOC; SET_LAST_ERROR(err); } // set cert data if(certLen) err = ddocDecodeX509Data(ppCert, certData, certLen); ddocDebug(3, "findUsersCertificate", "RV: %d, cert: %s", (int)rv, (*ppCert ? "OK" : "NULL")); if(hSession) closePKCS11Library(pLibrary, hSession); return err; }
int vce_binary_push_nb_ia8( char *out, int ofs, int maxlen, const void *ia, int num ) { int headlen,i; char lenwork[10]; if(num<0)return SET_LAST_ERROR(VCE_EINVAL); headlen = vce_set_variable_length_specifier( lenwork,sizeof(lenwork), 0,num ); if( ( ofs + headlen + num*8 ) > maxlen ) return SET_LAST_ERROR(VCE_EFULL); for(i=0;i<num;i++){ SET_64BIT_INT( out + ofs + headlen + i*8, ((VCEI64*)ia)[i]); } memcpy( out + ofs, lenwork, headlen ); SET_LAST_ERROR(VCE_NOERROR); return ofs + headlen + num*8; }
int vce_binary_pop_nb_ia8( const char *src, int len, int ofs, VCEI64 *out, int *outlen ) { int headlen, available = len - ofs , i; unsigned int lu,ll; headlen = vce_get_variable_length_specifier( src + ofs, available, &lu, &ll ); if( headlen < 0 ) return SET_LAST_ERROR(headlen); if( lu ) return SET_LAST_ERROR(VCE_ESUPPORT); if( (headlen+ll*8) > available ) return SET_LAST_ERROR(VCE_ETOOSHORT); if( ll > *outlen ) return SET_LAST_ERROR(VCE_EFULL); for(i=0;i<ll;i++){ out[i] = GET_64BIT_INT( src +ofs + headlen + i*8 ); } *outlen = ll; SET_LAST_ERROR(VCE_NOERROR); return ofs + headlen + ll*8; }
// get signers first name EXP_OPTION int getSignerFirstName(const SignatureInfo* pSigInfo, char* buf) { int err = ERR_OK, l1; X509* cert; char buf1[500], *p, *p2, *p1; RETURN_IF_NULL_PARAM(pSigInfo); RETURN_IF_NULL_PARAM(buf); cert = getSignCertData(pSigInfo); if (!cert) SET_LAST_ERROR_RETURN_CODE(ERR_CERT_INVALID); l1 = sizeof(buf1); err = getCertSubjectName(cert, buf1, &l1); if (err != ERR_OK) SET_LAST_ERROR_RETURN_CODE(err); p = strstr(buf1, "CN="); if (p) { p1 = strchr(p, ','); if(!p1) p1 = strchr(p, '/'); if (p1) { p1 += 1; p2 = strchr(p1, ','); if(!p2) p2 = strchr(p1, '/'); if(p2) { strncpy(buf, p1, p2-p1); buf[p2-p1] = 0; err = ERR_OK; } } } if (err != ERR_OK) SET_LAST_ERROR(err); return err; }
// get signers id-code EXP_OPTION int getSignerCode(const SignatureInfo* pSigInfo, char* buf) { int err, l1; X509* cert; char buf1[500], *p; RETURN_IF_NULL_PARAM(pSigInfo); RETURN_IF_NULL_PARAM(buf); cert = getSignCertData(pSigInfo); if (!cert) SET_LAST_ERROR_RETURN_CODE(ERR_CERT_INVALID); l1 = sizeof(buf1); err = getCertSubjectName(cert, buf1, &l1); if (err != ERR_OK) SET_LAST_ERROR_RETURN_CODE(err); err = ERR_CERT_READ; p = strstr(buf1, "CN="); if (p) { p = strchr(p, ','); if(p) { p = strchr(p+1, ','); if(p) { strncpy(buf, p+1, 11); buf[11] = 0; err = ERR_OK; } } else { // no comma -> no id-code ! buf[0] = 0; // is this really an error ? err = ERR_WRONG_CERT; } } if (err != ERR_OK) SET_LAST_ERROR(err); return err; }
EXP_OPTION int getSignerCN(const SignatureInfo* pSigInfo, char* buf, int bUTF8) { int err = ERR_OK, l1; X509* cert; char buf1[500], *p, *p2, buf2[500]; RETURN_IF_NULL_PARAM(pSigInfo); RETURN_IF_NULL_PARAM(buf); cert = getSignCertData(pSigInfo); if (!cert) SET_LAST_ERROR_RETURN_CODE(ERR_CERT_INVALID); l1 = sizeof(buf1); err = getCertSubjectName(cert, buf1, &l1); if (err != ERR_OK) SET_LAST_ERROR_RETURN_CODE(err); if(!bUTF8) { l1 = sizeof(buf2); utf82ascii(buf1, buf2, &l1); strncpy(buf1, buf2, sizeof(buf1)); } err = ERR_CERT_READ; p = strstr(buf1, "CN="); if (p) { p += 3; p2 = strchr(p, '/'); if(!p2) p2 = p + strlen(p); if (p2) { strncpy(buf, p, p2-p); buf[p2-p] = 0; err = ERR_OK; } } if (err != ERR_OK) SET_LAST_ERROR(err); return err; }
//-------------------------------------------------- // Calculates files SHA1 digest // szFileName - file name // nDigestType - digest type. Supports only SHA1 (0) // pDigestBuf - buffer to store the digest // nDigestLen - buffer size, must be at least 20 // will be updated by actual digest length // returns error code or ERR_OK for success //-------------------------------------------------- EXP_OPTION int calculateDigest(const byte* data, int nDataLen, int nDigestType, byte* pDigestBuf, int* nDigestLen) { int err = ERR_OK; RETURN_IF_NULL_PARAM(data); RETURN_IF_NULL_PARAM(pDigestBuf); RETURN_IF_NULL_PARAM(nDigestLen); memset(pDigestBuf, 0, *nDigestLen); if(nDigestType == DIGEST_SHA1) { if(*nDigestLen >= SHA_DIGEST_LENGTH) { *nDigestLen = SHA_DIGEST_LENGTH; SHA1(data, nDataLen, pDigestBuf); } }//AM 22.04.08 else if(nDigestType == DIGEST_SHA256) { if(*nDigestLen >= SHA256_DIGEST_LENGTH) { *nDigestLen = SHA256_DIGEST_LENGTH; SHA256(data, nDataLen, pDigestBuf); } else err = ERR_DIGEST_LEN; } else err = ERR_UNSUPPORTED_DIGEST; if (err != ERR_OK) SET_LAST_ERROR(err); return err; }
//============================================================ // Reads in an OCSP Response file in DER format // szFileName - OCSP response file name //============================================================ int ReadOCSPResponse(OCSP_RESPONSE **newOCSP_RESPONSE, const char* szFileName) { BIO *bin = NULL; OCSP_RESPONSE *resp = NULL; int err = ERR_OK; ddocDebug(4, "ReadOCSPResponse", "File: %s", szFileName); RETURN_IF_NULL_PARAM(newOCSP_RESPONSE); RETURN_IF_NULL_PARAM(szFileName); if((bin = BIO_new_file(szFileName, "rb")) != NULL) { ddocDebug(4, "ReadOCSPResponse", "File opened"); resp = d2i_OCSP_RESPONSE_bio(bin, NULL); BIO_free(bin); if (resp == NULL) { err = ERR_OCSP_WRONG_VERSION; } } else { ddocDebug(4, "ReadOCSPResponse", "Cannot read file:%s", szFileName); err =ERR_FILE_READ; } if (err != ERR_OK) SET_LAST_ERROR(err); *newOCSP_RESPONSE = resp; return err; }
int vce_binary_pop_nb_ia1( const char *src, int len, int ofs, char *out, int *outlen ) { int headlen, available = len - ofs; unsigned int lu,ll; headlen = vce_get_variable_length_specifier( src + ofs, available, &lu,&ll ); if( headlen < 0 ) return SET_LAST_ERROR(headlen); if( lu ) return SET_LAST_ERROR(VCE_ESUPPORT); if( (headlen+ll) > available ) return SET_LAST_ERROR(VCE_ETOOSHORT); if( ll > *outlen ) return SET_LAST_ERROR(VCE_EFULL); memcpy( out, src + ofs + headlen, ll ); *outlen = ll; SET_LAST_ERROR(VCE_NOERROR); return ofs + headlen + ll; }
int vce_tcpcontext_get_next_conn_serial() { vce_conn_serial++; if( vce_conn_serial == 0 ){ vce_conn_serial = 1; } SET_LAST_ERROR(VCE_NOERROR); return vce_conn_serial; }
int vce_finalize( void ) { int e = 0; if( vce_tcpcontext_fin_world() < 0 ) e = 1; if( vce_conn_fin_world() < 0 ) e = 1; if( vce_array_fin_world() < 0 ) e = 1; VCEFREE( vce_sendbuf_work ); VCEFREE( vce_recvbuf_work ); VCE_ERROUT_V0( NOTE_VCE_FINALIZED ); if( e ) { return SET_LAST_ERROR(VCE_EFINALIZE); } else { return SET_LAST_ERROR(0); } }
int vce_protocol_unparser_text( conn_t ct, char *data, int len ) { int totallen = len + 1; int rest = vce_conn_writable( ct ); if( !vce_conn_is_valid(ct) ) return SET_LAST_ERROR(VCE_EINVAL); // Do I have room to store newline? if( rest < 0 ) return SET_LAST_ERROR(rest); if( rest < totallen ) return SET_LAST_ERROR(VCE_EWBFULL); // write body and newline vce_conn_write( ct, data, len ); vce_conn_write( ct, "\n", 1 ); return totallen; }
int vce_protocol_parser_bin32( conn_t ct ) { conn *c = ( conn * ) ct.p; int datalen , ret = 0; unsigned int contentlen; char *data; vce_sbuf_get_buffer( &c->rb, &data, &datalen ); if( datalen < 4 ) return SET_LAST_ERROR(0); if( datalen > BIN32DATA_MAX ) return SET_LAST_ERROR(VCE_EPROTO_TOOLONG); contentlen = GET_32BIT_INT( data ) & 0xffffffff; if( contentlen > BIN32DATA_MAX ) return SET_LAST_ERROR(VCE_EPROTO_TOOLONG); if( datalen < ( 4 + contentlen ) ) return SET_LAST_ERROR(0); if( c->pcallback ){ ret = c->pcallback( ct, data + 4, contentlen ); } vce_sbuf_shrink( &c->rb, NULL, contentlen + 4 ); SET_LAST_ERROR(0); return ret; }
BOOL APIENTRY GetConsoleDisplayMode( OUT LPDWORD lpModeFlags ) /*++ Description: This routine returns the display mode of the console. Parameters: lpModeFlags - pointer to store display mode in. Return value: TRUE - The operation was successful. FALSE/NULL - The operation failed. Extended error status is available using GetLastError. --*/ { CONSOLE_API_MSG m; PCONSOLE_GETDISPLAYMODE_MSG a = &m.u.GetConsoleDisplayMode; a->ConsoleHandle = GET_CONSOLE_HANDLE; CsrClientCallServer( (PCSR_API_MSG)&m, NULL, CSR_MAKE_API_NUMBER( CONSRV_SERVERDLL_INDEX, ConsolepGetDisplayMode ), sizeof( *a ) ); if (!NT_SUCCESS( m.ReturnValue)) { SET_LAST_NT_ERROR(m.ReturnValue); return FALSE; } else { try { *lpModeFlags = a->ModeFlags; } except( EXCEPTION_EXECUTE_HANDLER ) { SET_LAST_ERROR(ERROR_INVALID_ACCESS); return FALSE; } return TRUE; } }
//-------------------------------------------------- // Decodes a single hex digit // h - hex digit // return binary value //-------------------------------------------------- byte h2b(char h) { int i; for(i = 0; i < 16; i++) { if(g_hexChars[i] == h || g_hexChars[i] == toupper(h)) return (byte)i; } // if not found then return an error ddocDebug(1, "h2b", "Invalid hex byte: %c", h); SET_LAST_ERROR(ERR_BAD_PARAM); return 0; // MSTERN: incorrect, VS - yes return -1 if not found. This is an error code }
/* get */ int vce_get_variable_length_specifier( const char *src, int srcmax, unsigned int *len_upper, unsigned int *len_lower ) { unsigned char top; if( srcmax < 1 ) return SET_LAST_ERROR(VCE_ETOOSHORT); top = src[0]; if( top <= 0xfc ){ *len_upper = 0; *len_lower = GET_8BIT_INT( src ) & 0xff; return 1; } else if( top == 0xfd ){ if( srcmax < (1+4)) return SET_LAST_ERROR(VCE_ETOOSHORT); *len_upper = 0; *len_lower = GET_32BIT_INT( src+1); return 1+4; } else if( top == 0xfe ){ if( srcmax < (1+8)) return SET_LAST_ERROR(VCE_ETOOSHORT); *len_upper = GET_32BIT_INT(src+1); *len_lower = GET_32BIT_INT(src+1+4); return 1+8; return SET_LAST_ERROR(VCE_NOERROR); } else if( top == 0xff ){ *len_lower = *len_upper = 0; return SET_LAST_ERROR(VCE_ESUPPORT); } /* not reached */ return SET_LAST_ERROR(VCE_EBUG); }
int vce_binary_pop_nb_stra( const char *src, int len, int ofs, char **out, int *strnum, int eachmax ) { int headlen, available = len - ofs; int i,total_l; unsigned int lu,ll; headlen = vce_get_variable_length_specifier( src + ofs, available, &lu, &ll ); if( headlen < 0 ) return SET_LAST_ERROR(headlen); if( lu ) return SET_LAST_ERROR(VCE_ESUPPORT); if( *strnum < ll ){ return SET_LAST_ERROR(VCE_EFULL); } total_l = ofs + headlen; for(i=0;i<ll;i++){ unsigned int slu, sll; int sheadlen; sheadlen = vce_get_variable_length_specifier( src + total_l, len - total_l, &slu, &sll ); if( slu ) return SET_LAST_ERROR(VCE_ESUPPORT); if( sll > (eachmax-1) ){ return SET_LAST_ERROR(VCE_EFULL); } memcpy( out[i], src + total_l + sheadlen, sll ); out[i][sll] = 0; /* null byte */ total_l += sheadlen + sll; } *strnum = ll; SET_LAST_ERROR(VCE_NOERROR); return total_l; }
int vce_initialize( void ) { int ret; if( vce_socket_library_ok == 0 ) { if( vce_socket_lib_os_init() == 0 ) { vce_socket_library_ok = 1; } } vce_update_time(); // fixed size of send/recv buffer. vce_sendbuf_work = (char*) VCEMALLOC( vce_limit.sendbuf_work_size ); vce_recvbuf_work = (char*) VCEMALLOC( vce_limit.recvbuf_work_size ); if( !vce_sendbuf_work || !vce_recvbuf_work ) { if( vce_sendbuf_work ) VCEFREE( vce_sendbuf_work ); if( vce_recvbuf_work ) VCEFREE( vce_recvbuf_work ); return SET_LAST_ERROR(VCE_EMEM); } if( (ret = vce_array_init_world()) < 0 ) { return SET_LAST_ERROR(ret); } if( (ret = vce_conn_init_world()) < 0 ) { vce_array_fin_world(); return SET_LAST_ERROR(ret); } if( ( ret = vce_tcpcontext_init_world())<0) { vce_conn_fin_world(); vce_array_fin_world(); return SET_LAST_ERROR(ret); } vce_usage_set_boot_time( vce_global_time ); return SET_LAST_ERROR(0); }
int vce_protocol_unparser_bin32( conn_t ct, char *data, int len ) { int totallen,wable; char work[4]; if( !vce_conn_is_valid(ct) ) return SET_LAST_ERROR(VCE_EINVAL); if( len > BIN32DATA_MAX ) return SET_LAST_ERROR(VCE_ELONGINPUT); totallen = 4 + len; wable = vce_conn_writable(ct); if( wable < 0 ) return SET_LAST_ERROR(wable); if( totallen > wable ){ return SET_LAST_ERROR(VCE_EWBFULL); } SET_32BIT_INT(work, len); vce_conn_write( ct, work, 4 ); vce_conn_write( ct, data, len ); SET_LAST_ERROR(0); return len+4; }
int vce_protocol_parser_through( conn_t ct ) { conn *c = (conn*) ct.p; char *data; int datalen , ret = 0; vce_sbuf_get_buffer( &c->rb, &data, &datalen ); if( datalen > 0 ){ ret = c->pcallback( ct, data , datalen ); } vce_sbuf_shrink( &c->rb, NULL, datalen ); SET_LAST_ERROR(0); return ret; }
//-------------------------------------------------- // Calculates files SHA1-RSA signature // szFileName - file name // nDigestType - digest type. Supports only SHA1 (0) // pSigBuf - buffer to store the signature // nSigLen - buffer size, must be at least 128 // will be updated by actual signature length // keyfile - name of the private key file // passwd - private key password // returns error code or ERR_OK for success //-------------------------------------------------- EXP_OPTION int calculateFileSignature(const char* szFileName, int nDigestType, byte* pSigBuf, int* nSigLen, const char *keyfile, const char* passwd) { int err = ERR_OK; EVP_MD_CTX ctx; byte buf[FILE_BUFSIZE]; int i; FILE *f = NULL; EVP_PKEY* pkey = NULL; RETURN_IF_NULL_PARAM(szFileName); RETURN_IF_NULL_PARAM(pSigBuf); RETURN_IF_NULL_PARAM(nSigLen); RETURN_IF_NULL_PARAM(keyfile); RETURN_IF_NULL_PARAM(passwd); memset(pSigBuf, 0, *nSigLen); if(nDigestType == DIGEST_SHA1) { if(*nSigLen >= SIGNATURE_LEN) { if((err = ReadPrivateKey(&pkey, keyfile, passwd, FILE_FORMAT_PEM)) == ERR_OK) { if((f = fopen(szFileName,"rb")) != NULL) { EVP_SignInit(&ctx, EVP_sha1()); for (;;) { i = fread(buf, sizeof(char), FILE_BUFSIZE, f); if (i <= 0) break; EVP_SignUpdate (&ctx, buf, (unsigned long)i); } err = EVP_SignFinal(&ctx, pSigBuf, (unsigned int*)nSigLen, pkey); if(err == ERR_LIB_NONE) err = ERR_OK; fclose(f); EVP_PKEY_free(pkey); } // if - fopen else err = ERR_FILE_READ; } else err = ERR_PRIVKEY_READ; } else err = ERR_SIGNATURE_LEN; } else err = ERR_UNSUPPORTED_DIGEST; if (err != ERR_OK) SET_LAST_ERROR(err); return err; }
BOOL RemoveCtrlHandler( IN PHANDLER_ROUTINE HandlerRoutine ) /*++ Routine Description: This routine removes a ctrl handler from the process's list. Arguments: HandlerRoutine - pointer to ctrl handler. Return Value: TRUE - success. --*/ { ULONG i; // // NULL handler routine is not stored in table. It is // used to temporarily inhibit ^C event handling. Removing // this handler allows normal processing to occur // if ( !HandlerRoutine ) { NtCurrentPeb()->ProcessParameters->ConsoleFlags = 0; return TRUE; } for (i=0; i<HandlerListLength; i++) { if (*(HandlerList+i) == HandlerRoutine) { if (i < (HandlerListLength-1)) { memmove(&HandlerList[i],&HandlerList[i+1],sizeof(PHANDLER_ROUTINE) * (HandlerListLength - i - 1)); } HandlerListLength -= 1; return TRUE; } } SET_LAST_ERROR(ERROR_INVALID_PARAMETER); return FALSE; }
void vce_tcpcontext_cleanup( tcpcontext_t tp ) { tcpcontext *t = ( tcpcontext * ) tp; vce_conn_close_tcpcontext_all( (tcpcontext_t) tp ); if( t->is_server ) vce_socket_close( t->mainsock ); vce_end_array( t->rbmaster_mi ); vce_end_array( t->erbmaster_mi ); vce_end_array( t->wbmaster_mi ); vce_end_array( t->ewbmaster_mi ); vce_end_array( t->statebuf_mi ); vce_free_array_object( vce_tcpcontext_mi , t ); vce_usage_increment_tcpcontext_cleanup(); SET_LAST_ERROR(VCE_NOERROR); }