示例#1
0
文件: random.c 项目: Akanoa/PRI
void hash_given_data( void* data, size_t data_size) {
MHASH td;
byte _res[20];
int i;

	td = mhash_init( MHASH_SHA1);
	if (td==MHASH_FAILED) {
		err_quit(_("mhash_init() failed."));
	}

	/* also hash the pool
	 */
	mhash( td, rnd_pool, 20);
	
	mhash(td, data, data_size);

	mhash_deinit( td, _res);

	/* addition may do as well as xor
	 */
	for(i=0;i<20;i++) rnd_pool[i] ^= _res[i];


	/* Step 1 was completed. The pool was updated.
	 */
	 
}
示例#2
0
int conf_input_wrapper(char* buf, int max_size, FILE* in)
{
  int retval=0;
  int c=0;
  char* tmp=NULL;
  void* key=NULL;
  int keylen=0;

  /* FIXME Add support for gzipped config. :) */
#ifdef WITH_MHASH
  /* Read a character at a time until we are doing md */
  if(conf->do_configmd){
    retval=fread(buf,1,max_size,in);
  }else {
    c=fgetc(in);
    retval= (c==EOF) ? 0 : (buf[0] = c,1);
  }
#else
  retval=fread(buf,1,max_size,in);
#endif 

#ifdef WITH_MHASH    
  if(conf->do_configmd||conf->config_check){
    if(((conf->do_configmd==1)&&conf->config_check)||!conf->confmd){
      if(conf->do_configmd==1){
	conf->do_configmd+=1;
      }
      if((key=get_conf_key())!=NULL){
	keylen=get_conf_key_len();
	
	if( (conf->confmd=
	     mhash_hmac_init(conf->confhmactype,
			     key,
			     keylen,
			     mhash_get_hash_pblock(conf->confhmactype)))==
	    MHASH_FAILED){
	  error(0, "mhash_hmac_init() failed for %i for config check. Aborting\n",
		conf->confhmactype);
	  exit(EXIT_FAILURE);
	}
      } else {
	conf->do_configmd=0;
	return retval;
      }
    }
    /* FIXME This does not handle the case that @@end_config is on 
       buffer boundary. */
    if((tmp=strnstr(buf,"@@end_config",retval))!=NULL){
      /* We have end of config don't feed the last line to mhash */
      mhash(conf->confmd,(void*)buf,tmp-buf);
    } else {
      mhash(conf->confmd,(void*)buf,retval);
    }
  }
#endif
  return retval;
}
示例#3
0
int
rasqal_digest_buffer(rasqal_digest_type type, const unsigned char *output,
                     const unsigned char * const input, size_t len)
{
  hashid hash_type;
  unsigned int output_len;
  MHASH m;
  
  if(type > RASQAL_DIGEST_LAST)
    return -1;
  
  hash_type = rasqal_digest_to_hashid[type];
  if(hash_type == (hashid)-1)
    return -1;
  
  output_len = mhash_get_block_size(hash_type);
  if(!input)
    return output_len;
  
  m = mhash_init(hash_type);
  if(m == MHASH_FAILED)
    return -1;

  mhash(m, (const void *)input, len);
  
  mhash_deinit(m, (void*)output);

  return output_len;
}
示例#4
0
static void
digest_update(PX_MD * h, const uint8 *data, unsigned dlen)
{
	MHASH		mh = (MHASH) h->p.ptr;

	mhash(mh, data, dlen);
}
示例#5
0
文件: Stats.cpp 项目: AnumQ/protein
/* create md5 hash from input string
 * returns NULL on failure
 * user must free returned string
 */
char *
Stats::Md5Hash(const char *thread)
{
    MHASH td;
    char *tmpcstr;
    int i;
    unsigned char *hash;
    char *rethash;

    td = mhash_init(MHASH_MD5);
    if (td == MHASH_FAILED)
        return NULL;

    if (thread==NULL)
        return NULL;

    mhash(td, thread, strlen(thread));
    //mhash_deinit(td, hash);
    hash = (unsigned char*) mhash_end(td);

    rethash = (char*) calloc(mhash_get_block_size(MHASH_MD5)*2+1, sizeof(char));
    for (i = 0; i < mhash_get_block_size(MHASH_MD5); i++) {
        sprintf(&rethash[i*2], "%.2x", hash[i]);
    }

    return rethash;
}
示例#6
0
文件: auth.c 项目: ClusterLabs/booth
/* test HMAC
 */
int verify_hmac(const void *data, size_t datalen,
	hashid hid, unsigned char *hmac, char *key, int keylen)
{
	MHASH td;
	unsigned char *our_hmac = NULL;
	int rc = -1;

	td = mhash_hmac_init(hid, key, keylen,
		mhash_get_hash_pblock(hid));
	if (!td)
		return -1;

	our_hmac = malloc(mhash_get_block_size(hid));
	if (!our_hmac)
		return -1;

	(void)mhash(td, data, datalen);
	if (mhash_hmac_deinit(td, our_hmac))
		goto out_free;

	rc = memcmp(our_hmac, hmac, mhash_get_block_size(hid));

out_free:
	if (our_hmac)
		free(our_hmac);
	return rc;
}
示例#7
0
int checkhash(unsigned char *data, size_t datalen, char *checkhash) {
    char keyword[100];

    memcpy(together + pos, data, datalen);
    pos += datalen;

    mhash_keygen((keygenid)0, (hashid)10, 10, keyword, 100, (void *)"aaaa", 3,  key, keylen);

    MHASH hash = mhash_hmac_init((hashid)10, keyword, 100, mhash_get_hash_pblock((hashid)10));

    mhash(hash, data, datalen);
    void *mac = mhash_hmac_end(hash);

    char hash_printed[1000] = "0x";
    for (int j = 0; j < mhash_get_block_size((hashid)10); j++) {
        unsigned char *m = (unsigned char *)mac;
        char r[3];
        snprintf(r, 3, "%.2x", m[j]);
        strcat(hash_printed, r);
    }

    printf("%s\n", hash_printed);

    return strcmp(hash_printed, checkhash) == 0;
}
示例#8
0
文件: md.c 项目: IFGHou/AIDE
int update_md(struct md_container* md,void* data,ssize_t size) {
  int i;
    
  error(255,"update_md called\n");

#ifdef _PARAMETER_CHECK_
  if (md==NULL||data==NULL) {
    return RETFAIL;
  }
#endif

#ifdef WITH_MHASH
  
  for(i=0;i<=HASH_MHASH_COUNT;i++) {
    if (md->mhash_mdh[i]!=MHASH_FAILED) {
      mhash (md->mhash_mdh[i], data, size);
    }
  }
  
#endif /* WITH_MHASH */
#ifdef WITH_GCRYPT
	gcry_md_write(md->mdh, data, size);
#endif
  return RETOK;
}
示例#9
0
/*
**! method: Mhash.hash feed(string data)
**!    alt: Mhash.hash update(string data)
**!  Update the current hash context with data.
**!  update() is here for compatibility reasons with Crypto.md5.
**! arg: string data
**!  The data to update the context with.
**! returns:
**!  The current hash object.
**! name: feed - Update the current hash context.
*/
void f_hash_feed(INT32 args) 
{
  if(THIS->hash == NULL) {
    if(THIS->type != -1) {
      free_hash();
      THIS->hash = mhash_init(THIS->type);
      if(THIS->hash == MHASH_FAILED) {
	THIS->hash = NULL;
	Pike_error("Failed to initialize hash.\n");
      }
    } else
      Pike_error("Hash is uninitialized. Use Mhash.Hash()->set_type() to select hash type.\n");
  }
  if(args == 1) {
    if(Pike_sp[-args].type != T_STRING) {
      Pike_error("Invalid argument 1. Expected string.\n");
    }
    mhash(THIS->hash, Pike_sp[-args].u.string->str,
	  Pike_sp[-args].u.string->len << Pike_sp[-args].u.string->size_shift);
  } else {
    Pike_error("Invalid number of arguments to Mhash.Hash->feed(), expected 1.\n");
  }
  pop_n_elems(args);
  push_object(this_object());
}
示例#10
0
文件: hash.c 项目: davidvaz/yap-cmake
static hashnode* hash_lookup(hashtable table,ulong  key){
  
  table->last_node = BUCKET(table,mhash(table,key)); /* set a pointer to the first bucket */
  while ( table->last_node != NULL ) {
    if( table->last_node->value==key) return table->last_node;
    table->last_node = table->last_node->next;
  }
  return NULL;
}
示例#11
0
void checksum_block(char *buf, int len, unsigned char *digest)
{
	td = mhash_init(HASH_FUNC);
	if (td == MHASH_FAILED)
		abort();

	mhash(td, buf, len);
	mhash_deinit(td, digest);
}
示例#12
0
文件: state.c 项目: ysm001/slim
/* 膜memを用いて状態sのハッシュ値を計算する.
 * canonicalをTRUEで入力した場合, バイナリストリングの設定まで行う */
void state_calc_hash(State *s, LmnMembrane *mem, BOOL canonical)
{
  if (canonical) {
    state_set_binstr(s, lmn_mem_encode(mem));
    s->hash = binstr_hash(state_binstr(s));
    set_encoded(s);
  } else {
    s->hash = mhash(mem);
  }
}
/*
 * ******************************************* 
 *  Function: get_crc 
 *
 *  Description: gets the crc of a packet   
 *   
 *  Parameters : 
 *     buffer - link layer buffer 
 *     len    - length of buffer 
 *  
 * ******************************************* 
 */
uint32_t get_crc(void *buffer , int len)
{
     
	MHASH td;
	uint32_t crc;
	td = mhash_init(MHASH_CRC32);
        mhash(td,buffer,len); 
        mhash_deinit(td,&crc);
	return crc; 
 

}
示例#14
0
char * compute_hash(FILE* file)
{
	MHASH td;
	unsigned char buffer;
	unsigned char hash[16];
	
	td = mhash_init (MHASH_MD5);
	
	while (fread (&buffer, 1, 1, file) == 1)
    {
		mhash (td, &buffer, 1);
    }
	mhash_deinit (td, hash);
	return hash;
}
示例#15
0
文件: vdetelweb.c 项目: aissat/vde2
int sha1passwdok(const char *pw) {
	unsigned char out[mhash_get_block_size(MHASH_SHA1)];
	char outstr[mhash_get_block_size(MHASH_SHA1)*2+1];
	int i;
	MHASH td;
	td=mhash_init(MHASH_SHA1);
	mhash(td, pw, strlen(pw));
	mhash_deinit(td, out);
	for (i=0; i<mhash_get_block_size(MHASH_SHA1); i++) {
		outstr[2*i]=hex[out[i] >> 4];
		outstr[2*i+1]=hex[out[i] & 0xf];
	}
	outstr[2*i]=0;
	return (memcmp(outstr,passwd,mhash_get_block_size(MHASH_SHA1))==0);
}
示例#16
0
int ddfs_calculate_hash(char * dst, char * src, int len) {
	//memcpy(dst, src, DDFS_HASH_LEN);
	//return 0;

    /*
	md5_state_t state;
	md5_init(&state);
	md5_append(&state, src , len);
	md5_finish(&state, dst);
    */

    MHASH td = mhash_init(MHASH_TIGER);
    mhash(td, src, len);
    mhash_deinit(td, dst);
	return 0;

}
示例#17
0
static int MD4BlockChecksum( void *buffer, int length )
{
	MHASH	mh;
	int		digest[ 4 ], checksum;
	
	
	/* make md4 hash */
	mh = mhash_init( MHASH_MD4 );
	if( !mh )
		Error( "Unable to initialize MD4 hash context" );
	mhash( mh, buffer, length );
	mhash_deinit( mh, digest );
	
	/* xor the bits and return */
	checksum = digest[ 0 ] ^ digest[ 1 ] ^ digest[ 2 ] ^ digest[ 3 ];
	return checksum;
}
示例#18
0
static const char *
vmod_hmac_sha256(const struct vrt_ctx *ctx,
	const char *key,size_t lkey, const char *msg,size_t lmsg,bool raw)
{
	hashid hash = MHASH_SHA256;
	size_t blocksize = mhash_get_block_size(hash);

	char *p;
	char *ptmp;
	p    = WS_Alloc(ctx->ws, blocksize * 2 + 1);
	ptmp = p;

	
	unsigned char *mac;
	unsigned u;
	u = WS_Reserve(ctx->ws, 0);
	assert(u > blocksize);
	mac = (unsigned char*)ctx->ws->f;
	
	int i;
	MHASH td;

	assert(msg);
	assert(key);

	assert(mhash_get_hash_pblock(hash) > 0);

	td = mhash_hmac_init(hash, (void *) key, lkey,
		mhash_get_hash_pblock(hash));
	mhash(td, msg, lmsg);
	mhash_hmac_deinit(td,mac);
	if(raw){
		WS_Release(ctx->ws, blocksize);
		return (char *)mac;
	}
	WS_Release(ctx->ws, 0);
	
	for (i = 0; i<blocksize;i++) {
		sprintf(ptmp,"%.2x",mac[i]);
		ptmp+=2;
	}
	return p;
}
示例#19
0
static const char *
vmod_hash_sha256(const struct vrt_ctx *ctx, const char *msg)
{
	MHASH td;
	hashid hash = MHASH_SHA256;
	unsigned char h[mhash_get_block_size(hash)];
	int i;
	char *p;
	char *ptmp;
	td = mhash_init(hash);
	mhash(td, msg, strlen(msg));
	mhash_deinit(td, h);
	p = WS_Alloc(ctx->ws,mhash_get_block_size(hash)*2 + 1);
	ptmp = p;
	for (i = 0; i<mhash_get_block_size(hash);i++) {
		sprintf(ptmp,"%.2x",h[i]);
		ptmp+=2;
	}
	return p;
}
示例#20
0
文件: auth.c 项目: ClusterLabs/booth
/* calculate the HMAC of the message in data and store it in result
 * it is up to the caller to make sure that there's enough space
 * at result for the MAC
 */
int calc_hmac(const void *data, size_t datalen,
	hashid hid, unsigned char *result, char *key, int keylen)
{
	MHASH td;
	size_t block_size;

	block_size = mhash_get_hash_pblock(hid);
	if (!block_size)
		return -1;

	td = mhash_hmac_init(hid, key, keylen, block_size);
	if (!td)
		return -1;

	(void)mhash(td, data, datalen);
	if (mhash_hmac_deinit(td, result))
		return -1;

	return 0;
}
示例#21
0
std::string
MD5::md5_file(const std::string& filename)
{
  unsigned char hash[16]; /* enough size for MD5 */
  MHASH td = mhash_init(MHASH_MD5);
  if (td == MHASH_FAILED) 
  {
    throw std::runtime_error("Failed to init MHash");
  }
  else
  {  
    const unsigned int buf_size = 32768;
    char buf[buf_size];
    std::ifstream in(filename.c_str(), std::ios::in | std::ios::binary); 
    if (!in)
    {
      throw std::runtime_error("MD5::md5_file(): Couldn't open file " + filename);
    }
    else
    {
    
      while(!in.eof())
      {
        in.read(buf, buf_size);
        mhash(td, buf, in.gcount());
      }

      in.close();
    
      mhash_deinit(td, hash);

      // Convert to string representation
      std::ostringstream out;
      for (int i = 0; i < 16; i++)
        out << std::setfill('0') << std::setw(2) << std::hex << int(hash[i]);

      return out.str();  
    }
  }
}
示例#22
0
int main(void)         {
  MHASH td;
  unsigned char buffer;
  unsigned char *hash;  

  td = mhash_init(MHASH_MD5);  

  if (td == MHASH_FAILED) exit(1);  

  while (fread(&buffer, 1, 1, stdin) == 1) {
    mhash(td, &buffer, 1);
  }
  hash = (unsigned char *) mhash_end(td);
 
  printf("Hash:");
  for (unsigned int i = 0; i < mhash_get_block_size(MHASH_MD5); ++i) {
    printf("%.2x", hash[i]);
  }
  printf("\n");
  
  exit(0);
}
示例#23
0
std::string
MD5::md5_string(const std::string& str)
{
  unsigned char hash[16]; /* enough size for MD5 */
  MHASH td = mhash_init(MHASH_MD5);
  if (td == MHASH_FAILED)
  {
    throw std::runtime_error("MD5::md5_string(): Failed to init MHash");
  }
  else
  {  
    mhash(td, str.c_str(), str.length());
  
    mhash_deinit(td, hash);

    // Convert to string representation
    std::ostringstream out;
    for (int i = 0; i < 16; i++) 
      out << std::setfill('0') << std::setw(2) << std::hex << int(hash[i]);

    return out.str();
  }
}
示例#24
0
uw_Basis_string uw_Hash_sha512(uw_context ctx, uw_Basis_string str) {
  uw_Basis_string hash;
  MHASH td;
  int i;
  unsigned char *buf;

  td = mhash_init(MHASH_SHA512);

  if (td == MHASH_FAILED) 
    uw_error(ctx, FATAL, "uw_Hash_sha512: mhash_init(MHASH_SHA512) failed.");
  
  buf = uw_malloc(ctx, mhash_get_block_size(MHASH_SHA512));
  hash = uw_malloc(ctx, (mhash_get_block_size(MHASH_SHA512) * 2) + 1);

  mhash(td, str, uw_Basis_strlen(ctx, str));
  buf = mhash_end(td);

  for(i = 0; i < mhash_get_block_size(MHASH_SHA512); i++) {
    sprintf((hash + 2*i), "%02x", buf[i]);
  }
  hash[2 * i] = '\0';

  return hash;
}
示例#25
0
std::string hashMD5 (const char* in) {

  MHASH td;
  unsigned char* p;
  unsigned char *hash;

  td = mhash_init(MHASH_MD5);  

  if (td == MHASH_FAILED) exit(1);  

  for (p = (unsigned char*) in; *p != 0; ++p)
    mhash(td, p, 1);

  hash = (unsigned char *) mhash_end(td);

  std::ostringstream sout;
  sout.unsetf(std::ios::dec); sout.setf(std::ios::hex);
  sout.fill('0');
  for (unsigned int i = 0; i < mhash_get_block_size(MHASH_MD5); i++) {
    sout.width(2); sout << (unsigned int) hash[i];
  }
  
  return sout.str();
}
int main(int argc, char * argv[])
{
	FILE *fp;
	FILE *fp2;
	struct hostent *hp;
	struct sockaddr_in sin;
	char *host; 
	char hashrcv[MAX_LINE];
	char command[10];
	char file_c[10000000];
	char buf[MAX_LINE];
	int length_s[1];
	int length;
	int s;
	int port;
	int len;
	int r_val;
	double rtt;
	double throughput;
	double fsize;
	struct tm * timeinfo;
	struct timeval tb, ta;
	clock_t start_t, end_t, total_t;
	int fd;
	unsigned char buffer;
	unsigned char *computedHash;
	unsigned char *hash;
	unsigned char send_hash[4096];
	int leng = 0;
	int i;
	MHASH td;
	
	// Check if the arguments are appropriate
	if (argc==3)
	{
		host = argv[1];
		port = atoi(argv[2]);
	}
	else
	{
		fprintf(stderr, "usage: simplex-talk host\n");
		exit(1);
	}

	// convert to IP
	hp = gethostbyname(host);
	if (!hp)
	{
		fprintf(stderr, "simplex-talk: unknown host: %s\n", host);
		exit(1);
	}
	
	// Fill in Socket
	bzero((char *)&sin, sizeof(sin));
	sin.sin_family = AF_INET;
	bcopy(hp->h_addr, (char*)&sin.sin_addr, hp->h_length);
	sin.sin_port = htons(port);
	
	// Exit if socket can't be created
	if ((s=socket(PF_INET, SOCK_STREAM, 0)) < 0)
	{
		perror("simplex-talk: socket");
		exit(1);
	}
	
	// Exit if Connection refused
	if (connect(s, (struct sockaddr *)&sin, sizeof(sin)) < 0)
	{
		perror("simplex-talk: connect");
		close(s);
		exit(1);
	}
	
	while (1) 
	{
		bzero((char*)&buf, sizeof(buf));
		bzero((char*)&command, sizeof(command));
		printf("Please enter command--REQ, UPL, LIS, DEL, XIT: ");
		fgets(command, 50, stdin);
		command[strlen(command) - 1] = '\0';
		if (strcmp(command, "REQ") == 0) {
			if (send(s,command,strlen(command) + 1,0)==-1)
			{
				perror("client send error!");
				exit (1);
			} 
			printf("Enter name of file to download from server: ");
			fgets(buf, 50, stdin);
			
			// send name of file to server
			if (send(s, buf, strlen(buf) + 1, 0) == -1) 
			{
				perror("client send error!");
				exit(1);
			}
			buf[strlen(buf) - 1] = '\0';
	
			// Receive the size
			recv(s,length_s,sizeof(length_s), 0);
	
			// if -1, file doesn't exist and exit
			if (length_s[0] == -1)
			{
				perror("File does not exist\n");
				continue;
			}
	
			// File exists=>Receive file hash from server
			else
			{
				recv(s, hashrcv, 33, 0);			
				fp = fopen(buf, "w");			// open requested file to write
      				if (fp == NULL)
      				{
      					exit(1);
      				}
		
				// prepare to receive blocks from the file
				// set remain_data = size of the file
		   		int remain_data = length_s[0];
				int datarcv = 5000;
		
				// if file size is less than default receiving block size
				// set equal to size
				if (remain_data < datarcv) {
					datarcv = remain_data;
				}

				// get time of day before file is received
				gettimeofday(&tb, NULL);
	
				// receive file from server
				bzero((char*)&file_c, sizeof(file_c));
      				while (recv(s, file_c, datarcv, 0) > 0 && (remain_data > 0))
      				{
                			fwrite(file_c, sizeof(char), datarcv, fp);
					bzero((char*)&file_c, sizeof(file_c));
                			remain_data -= datarcv;
					if (remain_data < datarcv) {
						datarcv = remain_data;
					}
					if (remain_data <= 0) break;
      				}
				gettimeofday(&ta, NULL); // time of day after

				int fileSize;
				rewind(fp);
				fclose(fp);
		
				// open file received	
				fp2 = fopen(buf, "r");
		
				// Compute hash
				bzero((char*)&buffer, sizeof(buffer));
				bzero((char*)&computedHash, sizeof(computedHash));
				bzero((char*)&send_hash, sizeof(send_hash));
      				td = mhash_init(MHASH_MD5);
      				if (td == MHASH_FAILED) exit(1);
     	 			while (fread(&buffer, 1, 1, fp2) == 1) {
      					mhash(td, &buffer, 1);
      				}

      				computedHash = mhash_end(td);
				leng = 0;
      				// Fill in computed hash into send_hash
      				for (i = 0; i < mhash_get_block_size(MHASH_MD5); i++) {
            				leng += sprintf(send_hash+leng,"%.2x", computedHash[i]);
      				}
					
				// If the hashes do not match exit
				if ( strcmp(send_hash, hashrcv) != 0) {
					perror("The hash Received does not match the computed hash!\n");
					exit(1);
				}

				// Compute Round trip time
				rtt = ((ta.tv_sec - tb.tv_sec)*1000000L +ta.tv_usec) -tb.tv_usec; 
				rtt /= 1000000;
			}
	
			fsize = (double) length_s[0]/1000000;		// Size in Mb
			throughput = fsize/rtt;						// Throughput 
			printf("%d bytes transferred in %lf seconds.\nThroughput: %lf Megabytes/sec.\nFile MD5sum: %s\n", length_s[0], rtt, throughput, hashrcv);
		} else if (strcmp(command, "DEL") == 0) {
			int fexists;
			if (send(s,command,strlen(command) + 1,0)==-1)
			{
				perror("client send error!");
				exit (1);
			}
			printf("Enter name of file to delete: ");
			fgets(buf, 40, stdin);
		
			// send name of file to server
			if (send(s, buf, strlen(buf) + 1, 0) == -1) {
				perror("client send error!");
				exit(1);
			}
			buf[strlen(buf) - 1] = '\0';
			//printf("buf to delete is %s\n", buf);
			recv(s, &fexists, 4, 0);
			if (fexists) {
				while (1) {
					printf("'Yes' to delete, 'No' to ignore. ");
					bzero((char*)&buf, sizeof(buf));
					fgets(buf, sizeof(buf), stdin);
					buf[strlen(buf) - 1] = '\0';
					if (!strcmp(buf, "Yes")) {
						send(s, buf, strlen(buf) + 1, 0);
						break;
					} else if (!strcmp(buf, "No")) {
						send(s, buf, strlen(buf) + 1, 0);
						break;
					} else {
						continue;
					}
				}
			} else {
				printf("The file does not exist on the server\n");
				continue;
			}
		} else if (!strcmp(command, "UPL")) {
		// ********* UPlOAD ****************
			int ack;
			if (send(s,command,strlen(command) + 1,0)==-1)
			{
				perror("client send error!");
				exit (1);
			}
			while (1) {
				printf("Enter name of file to upload to server: ");
				fgets(buf, 40, stdin);
				buf[strlen(buf) - 1] = '\0';
			
				fp = fopen(buf, "r");
				if (fp != NULL) {
					break;
				}
			}

	
			// send name of file to server
			if (send(s, buf, strlen(buf) + 1, 0) == -1) {
				perror("client send error!");
				exit(1);
			}
			// receive acknowledgement
			recv(s, &ack, 4, 0);
	
			// break if acknowledge is 0
			if (!ack) {
				printf("Server acknowledges 0 because it already has the file\n");
				continue;
			}
		
			// COMPUTE AND SEND FILE SIZE 
			int ex[1];
			//fseek(fp, 0L, SEEK_END);
			//ex[0] = ftell(fp);	
			struct stat st;
			stat(buf, &st);
			int sz = st.st_size;
			ex[0] = sz;
			char *file_c = malloc( ex[0] + 4096 );
			send(s,ex,sizeof(ex),0);
				
			// CALCULATE AND SEND MD5 HASH 
			fp2 = fopen(buf, "r");
			if (fp2 == NULL ) {
				printf("fp2 is NULL: \n", buf);
			}
        		td = mhash_init(MHASH_MD5);
        		if (td == MHASH_FAILED) exit(1);
        		while (fread(&buffer, 1, 1, fp2) == 1) {
                		mhash(td, &buffer, 1);
        		}
        		hash = mhash_end(td);
			bzero((char*)&send_hash, sizeof(send_hash));
			length = 0;
        		for (i = 0; i < mhash_get_block_size(MHASH_MD5); i++) {
               			length += sprintf(send_hash+length,"%.2x", hash[i]);
        		}
			//printf("SENDING HASH: %s\n", send_hash);
			send(s, send_hash, strlen(send_hash)+1, 0);
		
			// READ CONTENTS OF FILE //		
			rewind(fp);	
			fread(file_c, 1, ex[0], fp);		
			//printf("size is %d\n", ex[0]);	

			// SEND FILE TO SERVER /
	 		int offset = 0;
		  	int sent_bytes = 5000;
        		int remain_data = ex[0];
			if (remain_data < sent_bytes) {		// send as one packet
				sent_bytes = remain_data;
			}
        		while (((send(s, file_c + offset,sent_bytes,0)) > 0) && (remain_data > 0))
        		{
                		remain_data -= sent_bytes;
                		offset += sent_bytes;	// keeping track of sent and remaining data
					if (remain_data < sent_bytes) {
						sent_bytes = remain_data;
					}	
        		}
			char results[200];
			recv(s, results, 200, 0);
			printf("%s\n", results);		
		} else if (strcmp(command, "LIS") == 0)
		{
			char files[30];
                        if (send(s,command,strlen(command) + 1,0)==-1)
                        {
                                perror("client send error!");
                                exit (1);
                        }
			while (recv(s, files, sizeof(files), 0) > 0)
			{
				if (strcmp(files, "end") != 0)
				{
					printf("%s\n",files);
		//			bzero((char*)files, sizeof(files));
				}
				else
					break;
			}	
		} else if (strcmp(command, "XIT") == 0) {
			break;
		} else {
			printf("Not a valid command!\n");
			continue;
		}
	} // end while
	printf("Session closed\n");
	close (s);
}
示例#27
0
文件: md.c 项目: IFGHou/AIDE
int close_md(struct md_container* md) {
  int i;
#ifdef _PARAMETER_CHECK_
  if (md==NULL) {
    return RETFAIL;
  }
#endif
  error(255,"close_md called \n");
#ifdef WITH_MHASH
  for(i=0;i<=HASH_MHASH_COUNT;i++) {
    if (md->mhash_mdh[i]!=MHASH_FAILED) {
      mhash (md->mhash_mdh[i], NULL, 0);
    }  
  }
#endif /* WITH_MHASH */
#ifdef WITH_GCRYPT
  gcry_md_final(md->mdh); 
  /* Let's flush the buffers */

#define get_libgcrypt_hash(a,b,c,d) \
  if(md->calc_attr&a&HASH_USE_GCRYPT){\
		error(255,"Getting hash %i\n",b);\
    memcpy(md->c,gcry_md_read(md->mdh,b),d);\
  }

  get_libgcrypt_hash(DB_MD5,GCRY_MD_MD5,md5,HASH_MD5_LEN);
  get_libgcrypt_hash(DB_SHA1,GCRY_MD_SHA1,sha1,HASH_SHA1_LEN);
  get_libgcrypt_hash(DB_TIGER,GCRY_MD_TIGER,tiger,HASH_TIGER_LEN);
  get_libgcrypt_hash(DB_RMD160,GCRY_MD_RMD160,rmd160,HASH_RMD160_LEN);
  get_libgcrypt_hash(DB_SHA256,GCRY_MD_SHA256,sha256,HASH_SHA256_LEN);
  get_libgcrypt_hash(DB_SHA512,GCRY_MD_SHA512,sha512,HASH_SHA512_LEN);
  get_libgcrypt_hash(DB_CRC32,GCRY_MD_CRC32,crc32,HASH_CRC32_LEN);
  
  /*.    There might be more hashes in the library. Add those here..   */
  
  gcry_md_reset(md->mdh);
#endif  

#ifdef WITH_MHASH
#define get_mhash_hash(b,c) \
  if(md->mhash_mdh[b]!=MHASH_FAILED){ \
    mhash_deinit(md->mhash_mdh[b],(void*)md->c); \
  }
  
  get_mhash_hash(MHASH_MD5,md5);
  get_mhash_hash(MHASH_SHA1,sha1);
  get_mhash_hash(MHASH_TIGER,tiger);
  get_mhash_hash(MHASH_RMD160,rmd160);
  get_mhash_hash(MHASH_CRC32,crc32);
  get_mhash_hash(MHASH_HAVAL,haval);
  get_mhash_hash(MHASH_GOST,gost);
  get_mhash_hash(MHASH_CRC32B,crc32b);
  get_mhash_hash(MHASH_SHA256,sha256);
  get_mhash_hash(MHASH_SHA512,sha512);
#ifdef HAVE_MHASH_WHIRLPOOL
  get_mhash_hash(MHASH_WHIRLPOOL,whirlpool);
#endif
  
  /*
    There might be more hashes in the library we want to use.
    Add those here..
  */
  
#endif
  return RETOK;
}
示例#28
0
文件: checksum.c 项目: akwise/toolbox
ERRORCODE_T Checksum_Calculate(
    const char *pPathname,CHECKSUMTYPE_E Type,const char **ppChecksum)
{
    ERRORCODE_T ErrorCode;
    ERRORCODE_T TempErrorCode;
    unsigned int MHASHType;
    struct stat FileStats;
    MHASH HashData;
    FILE *pFile;
    unsigned int Count;
    unsigned int ReadSize;
    char pReadBuffer[CHECKSUM_READBUFFER_SIZE];
    unsigned char *pHash;


    DEBUGLOG_Printf4("Checksum_Calculate(%p(%s),%u,%p)",
                     pPathname,pPathname,Type,ppChecksum);
    DEBUGLOG_Login();

    /* Parameter checking. */
    if ( (pPathname==NULL) || (ppChecksum==NULL) )
        ErrorCode=ERRORCODE_NULLPARAMETER;
    else if (CHECKSUMTYPE_ISVALID(Type)==0)
        ErrorCode=ERRORCODE_INVALIDPARAMETER;
    else
    {
#if       !defined(USE_MHASH)
        ErrorCode=ERRORCODE_UNSUPPORTED;
#else     /* !defined(USE_MHASH) */
        /* Convert from CHECKSUM_ value to MHASH value. */
        ErrorCode=ERRORCODE_SUCCESS;
        switch(Type)
        {
        case CHECKSUMTYPE_CRC32:
            MHASHType=MHASH_CRC32;
            break;
        case CHECKSUMTYPE_MD5:
            MHASHType=MHASH_MD5;
            break;
        default:
            ErrorCode=ERRORCODE_INVALIDPARAMETER;
            break;
        }

        if (ErrorCode>0)
        {
            /* Get the file size. */
            if (stat(pPathname,&FileStats)==-1)
                ErrorCode=ERRORCODE_SYSTEMFAILURE;
            else
            {
                /* Initialize the hash. */
                HashData=mhash_init(MHASHType);
                if (HashData==MHASH_FAILED)
                    ErrorCode=ERRORCODE_LIBRARYFAILURE;
                else
                {
                    /* Open the file. */
                    pFile=fopen(pPathname,"rb");
                    if (pFile==NULL)
                        ErrorCode=ERRORCODE_SYSTEMFAILURE;
                    else
                    {
                        /* Read the file in chunks, computing the hash on each chunk. */
                        ErrorCode=ERRORCODE_SUCCESS;
                        Count=FileStats.st_size;
                        while( (feof(pFile)==0) && (ferror(pFile)==0) && (Count!=0) )
                        {
                            if (Count>=CHECKSUM_READBUFFER_SIZE)
                                ReadSize=CHECKSUM_READBUFFER_SIZE;
                            else
                                ReadSize=Count;
                            Count-=ReadSize;

                            if (fread(pReadBuffer,ReadSize,1,pFile)!=1)
                            {
                                ErrorCode=ERRORCODE_SYSTEMFAILURE;
                                break;
                            }

                            if (mhash(HashData,pReadBuffer,ReadSize)!=MUTILS_FALSE)
                            {
                                ErrorCode=ERRORCODE_LIBRARYFAILURE;
                                break;
                            }
                        }

                        TempErrorCode=ERRORCODE_SUCCESS;
                        if (fclose(pFile)!=0)
                            TempErrorCode=ERRORCODE_SYSTEMFAILURE;
                        if ( (TempErrorCode<0) && (ErrorCode>0) )
                            ErrorCode=TempErrorCode;
                    }

                    /* Get the hash value. */
                    pHash=mhash_end(HashData);
                    if ( (pHash==NULL) && (ErrorCode>0) )
                        ErrorCode=ERRORCODE_LIBRARYFAILURE;

                    if (ErrorCode>0)
                    {
                        /* Convert the hash value to a string to be returned. */
                        *ppChecksum=malloc(2*mhash_get_block_size(MHASHType)+1);
                        if (*ppChecksum==NULL)
                            ErrorCode=ERRORCODE_SYSTEMFAILURE;
                        else
                            for(Count=0; Count<mhash_get_block_size(MHASHType); Count++)
                                sprintf((char*)&((*ppChecksum)[2*Count]),"%.2x",pHash[Count]);
                    }
                }
            }
        }
#endif    /* !defined(USE_MHASH) */
    }

    DEBUGLOG_Logout();
    return(ErrorCode);
}
示例#29
0
char * map_calculate_hash(struct map * map)
{
  char * rv;

  rv = NULL;
  assert(map != NULL);

  unsigned char * hash;
  int             hash_size;

  hash      = NULL;
  hash_size = 0;
  
#if HAVE_LIBMHASH
  hash_size = mhash_get_block_size(MHASH_MD5);
  hash = malloc(hash_size);
  assert(hash != NULL);
  if(hash != NULL)
    {
      MHASH td;

      td = mhash_init(MHASH_MD5);
      if(td != MHASH_FAILED)
        { /* Hash together all the relevant data. */
          mhash(td, map->cave_name,        strlen(map->cave_name)     );
          mhash(td, &map->level,           sizeof map->level          );
          mhash(td, &map->is_intermission, sizeof map->is_intermission);
          mhash(td, &map->width,           sizeof map->width          );
          mhash(td, &map->height,          sizeof map->height         );
          mhash(td, &map->start_x,         sizeof map->start_x        );
          mhash(td, &map->start_y,         sizeof map->start_y        );
          mhash(td, &map->exit_x,          sizeof map->exit_x         );
          mhash(td, &map->exit_y,          sizeof map->exit_y         );
          mhash(td, &map->diamonds,        sizeof map->diamonds       );
          mhash(td, &map->diamonds_needed, sizeof map->diamonds_needed);
          mhash(td, &map->diamond_score,   sizeof map->diamond_score  );
          mhash(td, &map->time_score,      sizeof map->time_score     );
          mhash(td, map->data,             map->width * map->height   );
          mhash(td, &map->time,            sizeof map->time           );
          mhash(td, &map->ameba_time,      sizeof map->ameba_time     );
          mhash(td, &map->game_speed,      sizeof map->game_speed     );
          
          mhash_deinit(td, hash);
        }
      else
        {
          free(hash);
          hash = NULL;
        }
    }

#elif HAVE_LIBCRYPTO
  MD5_CTX context;

  hash_size = MD5_DIGEST_LENGTH;
  hash = malloc(hash_size);
  assert(hash != NULL);
  if(hash != NULL)
    {
      if(MD5_Init(&context))
        {
          int success;
          
          success             = MD5_Update(&context, map->cave_name,        strlen(map->cave_name)     );
          if(success) success = MD5_Update(&context, &map->level,           sizeof map->level          );
          if(success) success = MD5_Update(&context, &map->is_intermission, sizeof map->is_intermission);
          if(success) success = MD5_Update(&context, &map->width,           sizeof map->width          );
          if(success) success = MD5_Update(&context, &map->height,          sizeof map->height         );
          if(success) success = MD5_Update(&context, &map->start_x,         sizeof map->start_x        );
          if(success) success = MD5_Update(&context, &map->start_y,         sizeof map->start_y        );
          if(success) success = MD5_Update(&context, &map->exit_x,          sizeof map->exit_x         );
          if(success) success = MD5_Update(&context, &map->exit_y,          sizeof map->exit_y         );
          if(success) success = MD5_Update(&context, &map->diamonds,        sizeof map->diamonds       );
          if(success) success = MD5_Update(&context, &map->diamonds_needed, sizeof map->diamonds_needed);
          if(success) success = MD5_Update(&context, &map->diamond_score,   sizeof map->diamond_score  );
          if(success) success = MD5_Update(&context, &map->time_score,      sizeof map->time_score     );
          if(success) success = MD5_Update(&context, map->data,             map->width * map->height   );
          if(success) success = MD5_Update(&context, &map->time,            sizeof map->time           );
          if(success) success = MD5_Update(&context, &map->ameba_time,      sizeof map->ameba_time     );
          if(success) success = MD5_Update(&context, &map->game_speed,      sizeof map->game_speed     );
          
          if(success) success = MD5_Final(hash, &context);

          if(!success)
            {
              free(hash);
              hash = NULL;
            }
        }
      else
        {
          free(hash);
          hash = NULL;
        }
    }
#endif

  if(hash != NULL)
    {
      rv = malloc(hash_size * 2 + 1);
      assert(rv != NULL);
      if(rv != NULL)
        for(int i = 0; i < hash_size; i++)
          sprintf(rv + i * 2, "%.2x", hash[i]);
      free(hash);
    }
  
  return rv;
}
示例#30
0
int db_input_wrapper(char* buf, int max_size, int db)
{
  int retval=0;
  int c=0;
  int err=0;
  int* domd=NULL;
  url_t* db_url=NULL;
#ifdef WITH_MHASH
  char* tmp=NULL;
  MHASH* md=NULL;
  void* key=NULL;
  int keylen;
#endif
  FILE** db_filep=NULL;
#ifdef WITH_ZLIB
  gzFile* db_gzp=NULL;
#endif
  switch(db) {
  case DB_OLD: {
    db_url=conf->db_in_url;
    
    domd=&(conf->do_dboldmd);
#ifdef WITH_MHASH
    md=&(conf->dboldmd);
#endif
    
    db_filep=&(conf->db_in);
    
#ifdef WITH_ZLIB
    db_gzp=&(conf->db_gzin);
#endif
    break;
  }
  case DB_NEW: {
    db_url=conf->db_new_url;
    
    domd=&(conf->do_dbnewmd);
#ifdef WITH_MHASH
    md=&(conf->dbnewmd);
#endif
    
    db_filep=&(conf->db_new);
    
#ifdef WITH_ZLIB
    db_gzp=&(conf->db_gznew);
#endif
    break;
  }
  }

#ifdef WITH_CURL
  switch (db_url->type) {
  case url_http:
  case url_https:
  case url_ftp: {
    retval=url_fread(buf,1,max_size,(URL_FILE *)*db_filep);
    break;
  } 
  default:
#endif /* WITH CURL */


  /* Read a character at a time until we are doing md */
#ifdef WITH_ZLIB
  if((*db_gzp==NULL)&&(*domd)){
    retval=fread(buf,1,max_size,*db_filep);
  }
  if((*db_gzp!=NULL)&&(*domd)){
    if(gzeof(*db_gzp)){
      retval=0;
      buf[0]='\0';
    }else {
      if((retval=gzread(*db_gzp,buf,max_size))<0){
	error(0,_("gzread() failed: gzerr=%s!\n"),gzerror(*db_gzp,&err));
	retval=0;
	buf[0]='\0';
      } else {
	/* gzread returns 0 even if uncompressed bytes were read*/
	error(240,"nread=%d,strlen(buf)=%lu,errno=%s,gzerr=%s\n",
              retval,(unsigned long)strnlen((char*)buf, max_size),
              strerror(errno),gzerror(*db_gzp,&err));
	if(retval==0){
	  retval=strnlen((char*)buf, max_size);
	}
      }
    }
  }
  if((*db_gzp!=NULL)&&!(*domd)){
    c=gzgetc(*db_gzp);
    retval= (c==EOF) ? 0 : (buf[0] = c,1);
  }
  if((*db_gzp==NULL)&&!(*domd)){
    c=fgetc(*db_filep);
    if(c==(unsigned char)'\037'){
      c=fgetc(*db_filep);
      if(c==(unsigned char)'\213'){
	/* We got gzip header. */
	error(255,"Got Gzip header. Handling..\n");
	lseek(fileno(*db_filep),0L,SEEK_SET);
	*db_gzp=gzdopen(fileno(*db_filep),"rb");
	c=gzgetc(*db_gzp);
	error(255,"First character after gzip header is: %c(%#X)\n",c,c);
  if(c==-1) {
    int xx;
	  error(0,"Error reading gzipped file: %s\n",gzerror(*db_gzp,&xx));
    exit(EXIT_FAILURE);
  }
      }else {
	/* False alarm */
	ungetc(c,*db_filep);
      }
    }
    retval= (c==EOF) ? 0 : (buf[0] = c,1);
  }

#else /* WITH_ZLIB */
#ifdef WITH_MHASH
  if(*domd){
    retval=fread(buf,1,max_size,*db_filep);
  }else {
    c=fgetc(*db_filep);
    retval= (c==EOF) ? 0 : (buf[0] = c,1);
  }
#else /* WITH_MHASH */
  retval=fread(buf,1,max_size,*db_filep);
#endif /* WITH_MHASH */ 
#endif /* WITH_ZLIB */

#ifdef WITH_MHASH    
  if(*domd){
    if(!*md){
      if((key=get_db_key())!=NULL){
	keylen=get_db_key_len();
	
	if( (*md=
	     mhash_hmac_init(conf->dbhmactype,
			     key,
			     keylen,
			     mhash_get_hash_pblock(conf->dbhmactype)))==
	    MHASH_FAILED){
	  error(0, "mhash_hmac_init() failed for db check. Aborting\n");
	  exit(EXIT_FAILURE);
	}
      } else {
	*domd=0;
      }
    }
    /* FIXME This does not handle the case that @@end_config is on 
       buffer boundary. */
    if (*domd!=0) {
      if((tmp=strnstr(buf,"@@end_db",retval))!=NULL){
	/* We have end of db don't feed the last line to mhash */
	mhash(*md,(void*)buf,tmp-buf);
	/* We don't want to come here again after the *md has been deinited 
	   by db_readline_file() */
	*domd=0;
      } else {
	mhash(*md,(void*)buf,retval);
      }
    }
  }
#endif

#ifdef WITH_CURL
  }
#endif /* WITH CURL */
  return retval;
}