static int parse_readbuf(char *cmd, char **dest, size_t *rlen)
{
unsigned int s=0;
char cmdtmp='\0';
if(readbuflen>=5)
{
if((sscanf(readbuf, "%c%04X", &cmdtmp, &s))!=2)
{
logp("sscanf of '%s' failed in parse_readbuf\n",
readbuf);
truncate_buf(&readbuf, &readbuflen);
return -1;
}
}
if(readbuflen>=s+5)
{
*cmd=cmdtmp;
if(!(*dest=(char *)malloc(s+1)))
{
logp("out of memory in parse_readbuf\n");
truncate_buf(&readbuf, &readbuflen);
return -1;
}
if(!(memcpy(*dest, readbuf+5, s)))
{
logp("memcpy failed in parse_readbuf\n");
truncate_buf(&readbuf, &readbuflen);
return -1;
}
(*dest)[s]='\0';
if(!(memmove(readbuf, readbuf+s+5, readbuflen-s-5)))
{
logp("memmove failed in parse_readbuf\n");
truncate_buf(&readbuf, &readbuflen);
return -1;
}
readbuflen-=s+5;
*rlen=s;
}
return 0;
}
static int async_alloc_buf(char **buf, size_t *buflen, size_t bufmaxsize)
{
if(!*buf)
{
if(!(*buf=(char *)malloc(bufmaxsize)))
{
logp("out of memory in async_alloc_buf\n");
return -1;
}
truncate_buf(buf, buflen);
}
return 0;
}
static int async_alloc_buf(char **buf, size_t *buflen, size_t bufmaxsize)
{
if(!*buf)
{
if(!(*buf=(char *)malloc(bufmaxsize)))
{
log_out_of_memory(__FUNCTION__);
return -1;
}
truncate_buf(buf, buflen);
}
return 0;
}
static int do_read(int *read_blocked_on_write)
{
ssize_t r;
ERR_clear_error();
r=SSL_read(ssl, readbuf+readbuflen, readbufmaxsize-readbuflen);
switch(SSL_get_error(ssl, r))
{
case SSL_ERROR_NONE:
//logp("read: %d\n", r);
readbuflen+=r;
readbuf[readbuflen]='\0';
break;
case SSL_ERROR_ZERO_RETURN:
/* end of data */
//logp("zero return!\n");
SSL_shutdown(ssl);
truncate_buf(&readbuf, &readbuflen);
return -1;
case SSL_ERROR_WANT_READ:
break;
case SSL_ERROR_WANT_WRITE:
*read_blocked_on_write=1;
break;
case SSL_ERROR_SYSCALL:
if(errno == EAGAIN || errno == EINTR)
break;
logp("Got SSL_ERROR_SYSCALL in read, errno=%d (%s)\n",
errno, strerror(errno));
// Fall through to read problem
default:
logp("SSL read problem\n");
truncate_buf(&readbuf, &readbuflen);
return -1;
}
return 0;
}
int main (int argc, char* argv[]) {
//Entradas
FILE* file=fopen(argv[1],"rb");
//Calcula tamanho do arquivo
int tam=tamanho(file);
//Calcula quantidade de blocos
if(tam%512){
tam+=512-tam%512;
}
tam/=4;
//buffer de leitura
unsigned char buf[512];
//block de entrada 512B
unsigned long long int in[64+25];
//block de saida 128B
unsigned long long int out[16];
//Memoria necessaria para arvora 1/4 do tamanho do arquivo (mais complemento do block)
unsigned char data[tam];
//Variaveis usadas
int bytes,i,index=0;
//Inicialização do md6
hashState state;
Init(&state, 0);
// Set default parameters:
state.config.keylen = 0; // implies key is nil
memset(state.config.key, 0, MAX_KEYLEN);
state.config.max_level = 64;
state.config.digest_size = atoi(argv[2]); // This must be specified!
state.config.rounds = 40 + (state.config.digest_size / 4);
//Base da arvore
if(tam>128){
while((bytes=fread(buf,sizeof(char),512,file))){
if(bytes!=512){
//Block parcial
for(i=bytes;i<512;i++){
buf[i]=0x0;
}
memcpy(&(in[25]),buf,512);
reverse_buffer_byte_order(&(in[25]),64);
initialize_buf(in, &(state.config),
0, 4096-(bytes*8), (uint8)(1), index);
}else {
//Block completo
memcpy(&(in[25]),buf,512);
reverse_buffer_byte_order(&(in[25]),64);
initialize_buf(in, &(state.config),
0, 0, (uint8)(1), index);
}
f(in,out,state.config.rounds);
memcpy(&(data[index*128]),out,128);
index++;
}
//i = quantidade de blocks de saida 128B
i=tam/128;
//Level atual
int current_level=2;
//Resto da arvore
while(i>4){
int current_index, current_blocks_num;
for(current_index=0,current_blocks_num=i/4;current_index<current_blocks_num;current_index++){
//Block completo
memcpy(&(in[25]),&(data[current_index*512]),512);
initialize_buf(in, &(state.config),
0, 0, (uint8)(current_level), current_index);
f(in,out,state.config.rounds);
memcpy(&(data[current_index*128]),out,128);
}
if(i%4){
//Block parcial
memcpy(&(in[25]),&(data[current_index*512]),(i%4)*128);
int j;
for(j=(i%4)*16+25;j<89;j++)
in[j]=0x0;
initialize_buf(in, &(state.config),
0, 4096-(i%4)*1024, (uint8)(current_level), current_index);
f(in,out,state.config.rounds);
memcpy(&(data[current_index*128]),out,128);
current_index++;
}
//Nova quantidade de blocks de saida 128B
i=ceil(i/4.0);
//Subir um level
current_level++;
}
//Ultima compressão
if(i%4){
//Block parcial
memcpy(&(in[25]),data,(i%4)*128);
int j;
for(j=(i%4)*16+25;j<89;j++)
in[j]=0x0;
initialize_buf(in, &(state.config),
1, 4096-(i%4)*1024, (uint8)(current_level), 0);
f(in,out,state.config.rounds);
memcpy(&(data[0]),out,128);
} else {
//Block completo
memcpy(&(in[25]),data,512);
initialize_buf(in, &(state.config),
1, 0, (uint8)(current_level), 0);
f(in,out,state.config.rounds);
memcpy(data,out,128);
}
} else {
bytes=fread(buf,sizeof(char),512,file);
if(bytes!=512){
//Block parcial
for(i=bytes;i<512;i++){
buf[i]=0x0;
}
memcpy(&(in[25]),buf,512);
reverse_buffer_byte_order(&(in[25]),64);
initialize_buf(in, &(state.config),
1, 4096-(bytes*8), (uint8)(1), 0);
}else {
//Block completo
memcpy(&(in[25]),buf,512);
reverse_buffer_byte_order(&(in[25]),64);
initialize_buf(in, &(state.config),
1, 0, (uint8)(1), 0);
}
f(in,out,state.config.rounds);
}
printf("digest (%d bits): \n",state.config.digest_size);
truncate_buf(out,state.config.digest_size,16);
reverse_buffer_byte_order(out,16);
print_output(out,state.config.digest_size);
}
