/** Verify a signature
@param hashname [in] String naming the hash
@param keydatalen [in] The length of the public key
@param keydata [in] The public key of the signer
@param sigdatalen [in] The length of the signature data
@param sigdata [in] The signature data
@param filedatalen [in] The length of the file in octets
@param filedata [in] The contents of the file being verified
@param ... [in] Additional len,data pairs until len is 0
@return nonzero on error [or invalid], 0 on success
If
*/
int verify_data(
char *hashname,
unsigned long keydatalen,
unsigned char *keydata,
unsigned long sigdatalen,
unsigned char *sigdata,
unsigned long filedatalen,
const unsigned char *filedata, ...)
{
rsa_key rsakey;
unsigned char rsabuf[2048], md[MAXBLOCKSIZE];
unsigned long rsalen, mdlen;
int stat;
int res;
va_list args;
const unsigned char *dataptr;
unsigned long datalen;
hash_state hs;
struct ltc_hash_descriptor *hd;
int hashid;
heap_start(heap_mem, HEAP_SIZE);
if (strcmp(hashname,"des") == 0) {
symmetric_key skey;
DO(des_setup(keydata, keydatalen, 0, &skey),0x400000);
DO(des_ecb_encrypt(filedata, sigdata, &skey),0x500000);
return res;
}
register_hash(&sha256_desc);
// register_hash(&sha512_desc);
// register_hash(&whirlpool_desc);
register_hash(&rmd160_desc);
register_hash(&md4_desc);
register_hash(<c_md5_desc);
register_hash(&sha1_desc);
ltc_mp = tfm_desc;
hashid = find_hash(hashname);
if ((res = hash_is_valid(hashid)) != CRYPT_OK)
return res;
hd = &hash_descriptor[hashid];
if ((res = hd->init(&hs)) != CRYPT_OK)
return res;
va_start(args, filedata);
dataptr = filedata;
datalen = filedatalen;
for(;;) {
if((res = hd->process(&hs, dataptr, datalen)) != 0)
return res;
if((datalen = va_arg(args, unsigned long)) == 0)
break;
if((dataptr = va_arg(args, unsigned char *)) == NULL)
break;
}
va_end(args);
if (keydatalen == 0) {
res = hd->done(&hs, sigdata);
*keydata = hd->hashsize;
return res+0x100000;
}
if((res = hd->done(&hs, md)) != 0)
return res+0x200000;
mdlen = hd->hashsize;
DO(rsa_import(keydata, keydatalen, &rsakey),0x300000);
DO(rsa_verify_hash(sigdata, sigdatalen, md, mdlen, find_hash(hashname), 8, &stat, &rsakey),0x400000);
rsa_free(&rsakey);
return (stat == 0) ? -1 : 0;
}
void init_heap(void){
heap_start();
FreeBlock *bp = (FreeBlock*) sbrk(ALIGN(sizeof(FreeBlock)));
bp->block_length = 0;
bp->prev = bp;
bp->next = bp;
}
void my_free(void *ptr)
{
FreeBlock *header = (FreeBlock*)((char*)ptr - HEADER_SIZE);
FreeBlock *free_list_head = heap_start();
// Add freed block to the free list just after head
header->next = free_list_head->next;
header->prev = free_list_head;
free_list_head->next = free_list_head->next->prev = header;
}
void *find_fit(size_t length)
{
FreeBlock *bp = heap_start();
FreeBlock *end = bp;
for(bp=bp->next; bp!=end; bp=bp->next){
if(bp->block_length>=length){
bp->next->prev = bp->prev;
bp->prev->next = bp->next;
return bp;
}
}
return NULL;
}
/* service_main */
static VOID WINAPI service_main(DWORD argc, LPTSTR *argv) {
config_t conf;
void* net;
void* threads;
void* pipe;
h_service = RegisterServiceCtrlHandler(LDMSVC_SERVICE_NAME, handler);
if(h_service == NULL) {
return;
}
set_state1(SERVICE_START_PENDING); // SERVICE_START_PENDING
// open the heap
if(!heap_start()) {
dout("Failed to create the heap\n");
set_state2(SERVICE_STOPPED, 1);
return;
}
// parse configuration
if(!config_parse_args(&conf, argc, argv)) {
heap_stop();
set_state2(SERVICE_STOPPED, 1);
return;
}
if(0) {
dout(va("PORT: %u\n", conf.port));
dout(va("PIPE: %s\n", conf.pipe));
dout(va("MAXC: %u\n", conf.maxconn));
}
// open network
if((net = net_start()) == NULL) {
heap_stop();
set_state2(SERVICE_STOPPED, 1);
return;
}
// open the pipe
if((pipe = pipe_start(conf.pipe)) == NULL) {
net_stop(net);
heap_stop();
set_state2(SERVICE_STOPPED, 1);
return;
}
// connect the pipe
if(!pipe_open(pipe)) {
pipe_stop(pipe);
net_stop(net);
heap_stop();
set_state2(SERVICE_STOPPED, 1);
return;
}
// start threads
if((threads = threads_start(net, pipe, conf.maxconn)) == NULL) {
pipe_stop(pipe);
net_stop(net);
heap_stop();
set_state2(SERVICE_STOPPED, 1);
return;
}
set_state1(SERVICE_RUNNING); // SERVICE_RUNNING
while(svc_state == SERVICE_RUNNING) {
if(!net_is_ready(net)) {
net_bind(net, NULL, conf.port);
}
if(!threads_think(threads)) {
break;
}
Sleep(1);
}
set_state1(SERVICE_STOP_PENDING); // SERVICE_STOP_PENDING
// close everything here
threads_stop(threads);
pipe_stop(pipe);
net_stop(net);
heap_stop();
set_state2(SERVICE_STOPPED, 0); // SERVICE_STOPPED
}
