//在main中测试argv[1]的三个hash值：
//./hash "arr/units.dat"
//./hash "unit/neutral/acritter.grp"
int main( int argc, char **argv )
{
unsigned long ulHashValue;
int i = 0;
if ( argc != 2 )
{
printf("please input two arguments/n");
return -1;
}
/*初始化数组：crytTable[0x500]*/
prepareCryptTable();
/*打印数组crytTable[0x500]里面的值*/
// for ( ; i < 0x500; i++ )
// {
// if ( i % 10 == 0 )
// {
// printf("/n");
// }
// printf("%-12X", cryptTable[i] );
// }
ulHashValue = HashString( argv[1], 0 );
printf("----%lu ----\n", ulHashValue );
ulHashValue = HashString( argv[1], 1 );
printf("----%lu ----\n", ulHashValue );
ulHashValue = HashString( argv[1], 2 );
printf("----%lu ----\n", ulHashValue );
ulHashValue = getHashIndex("haha", 100);
printf("----%lu ----\n", ulHashValue );
ulHashValue = getHashIndex("hehe", 100);
printf("----%lu ----\n", ulHashValue );
return 0;
}
///////////////////////////////////////////////////////////
//function:初始化hash表
//parameter:
//author: wuxiaoqi
//time: 2016-3-23
///////////////////////////////////////////////////////////
void Init_mghash(hashtable * HashMg)
{
long i;
prepareCryptTable();
* HashMg = (HASHMANGNODE*)malloc(sizeof(HASHMANGNODE) * DCHASH_SIZE);
if(* HashMg ==NULL)
return ;
for(i = 0; i<DCHASH_SIZE; i++)
{
((*HashMg)+i)->bExists = 0;
((*HashMg)+i)->nHashA = -1;
((*HashMg)+i)->nHashB = -1;
((*HashMg)+i)->pentityname = NULL;
((*HashMg)+i)->fqval = 0;
((*HashMg)+i)->score = 0.0001;
((*HashMg)+i)->pidcode = NULL;
}
}
int main()
{
int i, maxi, listenfd, connfd, sockfd,epfd;
int server_len,client_len;
ssize_t n;
char line[MAXLINE];
socklen_t clilen;
//声明epoll_event结构体的变量,ev用于注册事件,数组用于回传要处理的事件
struct epoll_event ev,events[EVTOTAL];
//生成用于处理accept的epoll专用的文件描述符
epfd=epoll_create(2048);
//启动在线用户数统计的线程
pthread_t dm;
pthread_attr_t attr={0};
pthread_attr_init (&attr);
pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
pthread_create(&dm,NULL,dmlog,NULL);
struct sockaddr_in clientaddr;
struct sockaddr_in serveraddr;
//定义每个EPOLL事件的收发消息
char RECV_MSG[100][30];
unsigned long HashTbInd;
//生成KEY值密码树1280[0x500]个
prepareCryptTable();
//ShowCryptTable();
ConnMemHashTable("/root/tt",0x07);
//printf("HEAD RECORD:%s\n",(RO_HPP+0x81E5E)->Raw_str);
listenfd = socket(AF_INET, SOCK_STREAM, 0);
//把socket设置为非阻塞方式
Setnonblocking(listenfd);
//设置与要处理的事件相关的文件描述符
ev.data.fd=listenfd;
//设置要处理的事件类型
ev.events=EPOLLIN|EPOLLET;
//注册epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);
//设置SOCKET SERVER基本参数
bzero(&serveraddr, sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
//char *local_addr="192.168.8.108";
//inet_aton(LOCAL_SVADDR,&(serveraddr.sin_addr));//htons(SERV_PORT);
serveraddr.sin_addr.s_addr = htons(INADDR_ANY);
serveraddr.sin_port=htons(SERV_PORT);
bind(listenfd,(struct sockaddr *)&serveraddr, sizeof(serveraddr));
listen(listenfd, LISTENQ);
maxi = 0;
for (;;) {
//等待epoll事件的发生
nfds=epoll_wait(epfd,events,EVTOTAL,-1);
//printf("online number:%d\n",nfds);
//处理所发生的所有事件
for(i=0;i<nfds;++i)
{
//printf("epollnum,epolldatafd,epolleventst,listenfd:%d,%d,%d,%d\n",i,events[i].data.fd,events[i].events,listenfd);
//如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，建立新的连接。
//在EPOLL EVENT中注册新连接
if(events[i].data.fd==listenfd)
{
client_len = sizeof(clientaddr);
connfd = accept(listenfd,(struct sockaddr *)&clientaddr, (socklen_t *)&client_len);
if(connfd<0){
perror("connfd<0");
exit(1);
}
Setnonblocking(connfd);
char *str = inet_ntoa(clientaddr.sin_addr);
//printf("sourd addr:%s;connfd=%d\n",str,connfd);
//设置用于读操作的文件描述符
ev.data.fd=connfd;
//设置用于注测的读操作事件
ev.events=EPOLLIN|EPOLLET;
//注册ev
epoll_ctl(epfd,EPOLL_CTL_ADD,connfd,&ev);
}
//如果是已经连接的用户，并且收到数据，那么进行读入。
//把新数据这件事儿在EPOLL EVENT 中注册新FD，如果没数据，则关闭EPOLL.EVENTS.DATA.FD
else if(events[i].events&EPOLLIN)
{
//printf(" IN:events&EPOLLIN&EPOLLOUT=%d,%d,%d\n",events[i].events,EPOLLIN,EPOLLOUT);
if ( (sockfd = events[i].data.fd) < 0) continue;
if ( (n = read(sockfd, RECV_MSG[i], MAXLINE)) < 0) {
if (errno == ECONNRESET) {
//usleep(1000);
close(sockfd);
events[i].data.fd = -1;
} else
printf("readline error\n");
} else if (n == 0) {
//usleep(1000);
//close(sockfd);
events[i].data.fd = -1;
}
//printf("%s",RECV_MSG[i]);
//设置用于写操作的文件描述符
ev.data.fd=sockfd;
//设置用于注册的写操作事件
ev.events=EPOLLOUT|EPOLLET;
//修改sockfd上要处理的事件为EPOLLOUT
epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
}
else if(events[i].events&EPOLLOUT)
{
//printf("OUT:events&EPOLLIN&EPOLLOUT=%d,%d,%d\n",events[i].events,EPOLLIN,EPOLLOUT);
sockfd = events[i].data.fd;
HashTbInd=(HashString(RECV_MSG[i],0)%HashTbSize);
//printf("%s:%X:%s ",RECV_MSG[i],HashTbInd,(RO_HPP)->Raw_str);
printf("%s:%X:%s \n",RECV_MSG[i],HashTbInd,(RO_HPP+HashTbInd)->Raw_str);
if ((*(RO_HPP+HashTbInd)).Hash1==HashString(RECV_MSG[i],1)&&((*(RO_HPP+HashTbInd)).bExist==0))
{
write(sockfd,(RO_HPP+HashTbInd)->Raw_str,strlen((RO_HPP+HashTbInd)->Raw_str));}
else
{write(events[i].data.fd,"NO RECORDS",9);}
//printf("RECV MSG=%s,SOCKFD=%d,nfds=%d,nfds_i=%d,RESPONSE OK\n",line,events[i].data.fd,nfds,i);
//close(sockfd);
//设置用于读操作的文件描述符
bzero(RECV_MSG[i],30);
ev.data.fd=sockfd;
//设置用于注测的读操作事件
ev.events=EPOLLIN|EPOLLET;
//close(sockfd);
//修改sockfd上要处理的事件为EPOLIN
epoll_ctl(epfd,EPOLL_CTL_MOD,sockfd,&ev);
}
}
}
}
static int signature_verify(const char *part_name)
{
unsigned int tmp_start;
unsigned int summary1, summary2;
unsigned int s_value[4], h_value[4];
unsigned char buffer[HASH_BUFFER_BYTES];
unsigned int read_bytes;
memset(buffer, 0, HASH_BUFFER_BYTES);
//计算hash值
prepareCryptTable(); //准备hash表
//获取签名
printf("ras init\n");
rsa_init();
printf("ras start\n");
if(!strcmp("boot", part_name))
{
tmp_start = sunxi_partition_get_offset_byname(part_name);
printf("find part %s\n", part_name);
read_bytes = sizeof(struct fastboot_boot_img_hdr);
if(!sunxi_flash_read(tmp_start, (read_bytes + 511)/512, buffer))
{
printf("signature0 read flash sig1 err\n");
return -1;
}
summary1 = HashString(buffer, 1, read_bytes); //1类hash
read_bytes = sizeof(struct image_header);
if(!sunxi_flash_read(tmp_start + CFG_FASTBOOT_MKBOOTIMAGE_PAGE_SIZE/512, (read_bytes + 511)/512, buffer))
{
printf("signature0 read flash sig2 err\n");
return -1;
}
summary1 = HashString(buffer, 1, read_bytes); //1类hash
//获取保存的签名
if(!sunxi_flash_read(tmp_start, 2, buffer))
{
printf("signature0 read flash sig3 err\n");
return -1;
}
s_value[0] = *(unsigned int *)(buffer + 608);
s_value[1] = *(unsigned int *)(buffer + 612);
s_value[2] = *(unsigned int *)(buffer + 616);
s_value[3] = *(unsigned int *)(buffer + 620);
rsa_decrypt( s_value, 4, h_value );
summary2 = (h_value[0]<<0) | (h_value[1]<<8) | (h_value[2]<<16) | (h_value[3]<<24);
#if 0
for(j=0;j<4;j++)
{
printf("s_value[%d] = %x\n", j, s_value[j]);
}
for(j=0;j<4;j++)
{
printf("h_value[%d] = %x\n", j, h_value[j]);
}
#endif
printf("summary by hash %x\n", summary1);
printf("summary by rsa %x\n", summary2);
if(summary1 != summary2)
{
printf("boot signature invalid\n");
return -1;
}
}
else if(!strcmp("system", part_name))
{
struct ext4_super_block *sblock;
tmp_start = sunxi_partition_get_offset_byname(part_name);
printf("find part %s\n", part_name);
printf("find system part\n");
HashString_init();
read_bytes = sizeof(struct ext4_super_block);
if(!sunxi_flash_read(tmp_start + CFG_SUPER_BLOCK_SECTOR, (read_bytes + 511)/512, buffer))
{
printf("signature1 read flash sig1 err\n");
return -1;
}
sblock = (struct ext4_super_block *)buffer;
#if 0
{
int k;
printf("s_inodes_count = %x\n", sblock->s_inodes_count);
printf("s_blocks_count_lo = %x\n", sblock->s_blocks_count_lo);
printf("s_r_blocks_count_lo = %x\n", sblock->s_r_blocks_count_lo);
printf("s_free_blocks_count_lo= %x\n", sblock->s_free_blocks_count_lo);
printf("s_free_inodes_count = %x\n", sblock->s_free_inodes_count);
printf("s_first_data_block = %x\n", sblock->s_first_data_block);
printf("s_log_block_size = %x\n", sblock->s_log_block_size);
printf("s_log_cluster_size = %x\n", sblock->s_log_cluster_size);
printf("s_blocks_per_group = %x\n", sblock->s_blocks_per_group);
printf("s_clusters_per_group = %x\n", sblock->s_clusters_per_group);
printf("s_inodes_per_group = %x\n", sblock->s_inodes_per_group);
printf("s_mtime = %x\n", sblock->s_mtime);
printf("s_wtime = %x\n", sblock->s_wtime);
printf("s_mnt_count = %x\n", sblock->s_mnt_count);
printf("s_max_mnt_count = %x\n", sblock->s_max_mnt_count);
printf("s_magic = %x\n", sblock->s_magic);
printf("s_state = %x\n", sblock->s_state);
printf("s_errors = %x\n", sblock->s_errors);
printf("s_minor_rev_level = %x\n", sblock->s_minor_rev_level);
printf("s_lastcheck = %x\n", sblock->s_lastcheck);
printf("s_checkinterval = %x\n", sblock->s_checkinterval);
printf("s_creator_os = %x\n", sblock->s_creator_os);
printf("s_rev_level = %x\n", sblock->s_rev_level);
printf("s_def_resuid = %x\n", sblock->s_def_resuid);
printf("s_def_resgid = %x\n", sblock->s_def_resgid);
printf("s_first_ino = %x\n", sblock->s_first_ino);
printf("s_inode_size = %x\n", sblock->s_inode_size);
printf("s_block_group_nr = %x\n", sblock->s_block_group_nr);
printf("s_feature_compat = %x\n", sblock->s_feature_compat);
printf("s_feature_incompat = %x\n", sblock->s_feature_incompat);
printf("s_feature_ro_compat = %x\n", sblock->s_feature_ro_compat);
for(k=0;k<16;k++)
{
printf("s_uuid[%d] = %x\n", k, sblock->s_uuid[k]);
}
for(k=0;k<16;k++)
{
printf("s_volume_name[%d] = %x\n", k, sblock->s_volume_name[k]);
}
for(k=0;k<64;k++)
{
printf("s_last_mounted[%d]= %x\n", k, sblock->s_last_mounted[k]);
}
printf("s_algorithm_usage_bitmap= %x\n", sblock->s_algorithm_usage_bitmap);
printf("s_prealloc_blocks = %x\n", sblock->s_prealloc_blocks);
printf("s_prealloc_dir_blocks = %x\n", sblock->s_prealloc_dir_blocks);
printf("s_reserved_gdt_blocks = %x\n", sblock->s_reserved_gdt_blocks);
for(k=0;k<16;k++)
{
printf("s_journal_uuid[%d]= %x\n", k, sblock->s_journal_uuid[k]);
}
printf("s_journal_inum = %x\n", sblock->s_journal_inum);
printf("s_journal_dev = %x\n", sblock->s_journal_dev);
printf("s_last_orphan = %x\n", sblock->s_last_orphan);
for(k=0;k<16;k++)
{
printf("s_hash_seed[%d] = %x\n", k, sblock->s_hash_seed[k]);
}
printf("s_def_hash_version = %x\n", sblock->s_def_hash_version);
printf("s_jnl_backup_type = %x\n", sblock->s_jnl_backup_type);
printf("s_desc_size = %x\n", sblock->s_desc_size);
printf("s_default_mount_opts = %x\n", sblock->s_default_mount_opts);
printf("s_first_meta_bg = %x\n", sblock->s_first_meta_bg);
printf("s_mkfs_time = %x\n", sblock->s_mkfs_time);
for(k=0;k<17;k++)
{
printf("s_jnl_blocks[%d] = %x\n", k, sblock->s_jnl_blocks[k]);
}
printf("s_blocks_count_hi = %x\n", sblock->s_blocks_count_hi);
printf("s_r_blocks_count_hi = %x\n", sblock->s_r_blocks_count_hi);
printf("s_free_blocks_count_hi= %x\n", sblock->s_free_blocks_count_hi);
printf("s_min_extra_isize = %x\n", sblock->s_min_extra_isize);
printf("s_want_extra_isize = %x\n", sblock->s_want_extra_isize);
printf("s_flags = %x\n", sblock->s_flags);
printf("s_raid_stride = %x\n", sblock->s_raid_stride);
printf("s_mmp_update_interval = %x\n", sblock->s_mmp_update_interval);
printf("s_mmp_block = %x\n", sblock->s_mmp_block);
printf("s_raid_stripe_width = %x\n", sblock->s_raid_stripe_width);
printf("s_log_groups_per_flex = %x\n", sblock->s_log_groups_per_flex);
printf("s_reserved_char_pad = %x\n", sblock->s_reserved_char_pad);
printf("s_reserved_pad = %x\n", sblock->s_reserved_pad);
printf("s_kbytes_written = %x\n", sblock->s_kbytes_written);
printf("s_snapshot_inum = %x\n", sblock->s_snapshot_inum);
printf("s_snapshot_id = %x\n", sblock->s_snapshot_id);
printf("s_snapshot_r_blocks_count= %x\n", sblock->s_snapshot_r_blocks_count);
printf("s_snapshot_list = %x\n", sblock->s_snapshot_list);
}
#endif
sblock->s_mtime = CFG_SUPER_BLOCK_STAMP_VALUE;
sblock->s_mnt_count = CFG_SUPER_BLOCK_STAMP_VALUE & 0xffff;
memset(sblock->s_last_mounted, 0, 64);
summary1 = HashString(buffer, 1, (unsigned int)&(((struct ext4_super_block *)0)->s_snapshot_list)); //1类hash
//获取保存的签名
if(!sunxi_flash_read(tmp_start, 2, buffer))
{
printf("signature1 read flash sig3 err\n");
return -1;
}
s_value[0] = *(unsigned int *)(buffer + 1000 - 10 * 4 + 0);
s_value[1] = *(unsigned int *)(buffer + 1000 - 10 * 4 + 4);
s_value[2] = *(unsigned int *)(buffer + 1000 - 10 * 4 + 8);
s_value[3] = *(unsigned int *)(buffer + 1000 - 10 * 4 + 12);
rsa_decrypt( s_value, 4, h_value );
summary2 = (h_value[0]<<0) | (h_value[1]<<8) | (h_value[2]<<16) | (h_value[3]<<24);
#if 0
for(j=0;j<4;j++)
{
printf("s_value[%d] = %x\n", j, s_value[j]);
}
for(j=0;j<4;j++)
{
printf("h_value[%d] = %x\n", j, h_value[j]);
}
#endif
printf("summary by hash %x\n", summary1);
printf("summary by rsa %x\n", summary2);
if(summary1 != summary2)
{
printf("system signature invalid\n");
return -1;
}
}
return 0;
}