信息安全工程实践

《信息安全工程实践二》

实践报告

东北大学软件学院

一、程序实践概述

1、题目名称：Linux操作系统及其相关命令，Linux编程基础

Linux程序设计基础

2、时间进度：

12学时

3、开发环境：

Ubantu

二、问题分析

1、功能说明：

熟练掌握如下Linux命令。

①系统信息命令:who,w,du,du,df等

②文件操作命令:touch,cp,mv,rm,find,grep,cat,more,sort等

③目录操作命令:ls,dir,mkdir,rmdir,cd

④进程操作命令:ps,top,cal,last,whereis,date

⑤网络操作命令:ping,write,telnet,ftp,talk

⑥ vi命令

①编程实现快速排序算法；

②实现文本文件拷贝函数copy(f_source, f_target)；即实现如下功能：

$ ./copy f1 f2

以上程序执行后当前目录会形成一个新的文件f2，且其内容与f1完全一致。

③编写一个程序，要求：输入N个学生的学号和成绩，并保存在stu.txt文本文件中，对学生成绩进行排序并把排序后的结果输出到score.txt文件中,同时在屏幕上输出高于平均成绩的学生的学号和成绩。

④编写一个程序找出串str1和串str2的所有最长公共子串。

⑤从文件file.in中读出整数，将其中不同整数及其出现次数，按整数由大到小的顺序输出到文件t.out中。要求：采用2叉有序树做为存储结构。（选作）

2、解决方案：

利用PPT中所提供的相关函数使用解决问题

三、方案设计

1、模块结构：

模块功能图和模块描述

①根据用户输入数组进行快速排序，然后输出排序后的数组

②用户创建f1，然后运行函数生成f2

③根据用户输入学生的数据，生成原数据stu文本以及根据成绩进行排序并把排序后的结果输出到score文本中，在屏幕上输出高于平均成绩的学生的学号和成绩

④根据用户输入的两个字符串，找出最长公共子串

⑤读出文件中的整数，将其中不同整数及其出现次数，按整数由大到小的顺序输出到文件t.out中

2、数据结构：

①int a[10]

②FILE *fp1,*fp2

③struct student{

int number;

int score;

}student[10]

④char a[10],b[10]

⑤文本f1

3、总体流程：

给出流程图

②

③

④

⑤

4、关键算法：

给出关键算法描述

①if (num>1) {//重复的判断条件，如果长度小于2，则不需排序 while (i != j) {

for (j=num-1; i

m++;

if (a[j]

a[i] = a[j];

n++;

break;

}

}

for (i=0; i

m++;

if (a[i]>k) {

a[j] = a[i];

n++;

break;

}

}

a[i] = k;

}

sort(a, i);

sort(a+i+1, num-i-1);

}

②while((c=fgetc(fp1))!=EOF){//将f1拷贝到f2中

fputc(c,fp2);

putchar(c);

}

③for(i=0;i

a[i]=student[i].score;

}

sort(a,m);

for(i=0;i

for(j=0;j

if(a[i]==student[j].score){

strcpy(student1[i].num,student[j].num);

student1[i].score=student[j].score;

}

}

}

fp=fopen("score.txt","w+");

fwrite(&student1,sizeof(student1),1,fp);

fclose(fp);

④for(i=0;i

for(j=0;j

strcpy(a, "0");

p=i;

q=j;

while(s1[p]==s2[q]&&s2[p]!=0){

a[m]=s2[q];

p++;

q++;

m++;

}

if(strlen(a)>strlen(b))

{

strcpy(b,a);

}

m=0;

}

}

⑤

四、调试记录

给出测试用例

五、创新说明

①用户可以自行定义数据，根据用户输入的数组进行排序

②将f1的内容同时在屏幕上输出，用户可以直接查看文件内容

③用户可以自行定义学生个数以及在屏幕上输入学生数据，并且将成绩单独放到另一数组排序后根据序号对结构体排序

④用户可以输入任一字符串进行对比

⑤

一、程序实践概述

1、题目名称：

Socket编程基础

（1）时间服务器

（2）远程文件备份服务器

2、时间进度：

8学时

3、开发环境：

Ubantu

二、问题分析

1、功能说明：

①编程实现时间服务器

编写一个网络时间服务器timeserver，该服务器能应具有如下功能：

●够为网络上的用户提供时间服务，即为网络用户返回服务器的当前时间；

●记录发出请求的网络用户的IP地址（保存到文件中），格式如下：

IP地址请求时间

编写时间服务客户端timeclient，该客户端能够向服务器发送时间服务请求，并把获得的时间返回给用户。

②编程实现远程文件备份服务器

分别采用TCP或UDP协议编写一个远程数据备份服务器，运行客户端将本地文件备份到远程的服务器中。

服务器的功能：接受客户端请求，把客户端的文件进行备份（可以备份到指定的文件夹）。

客户端的功能：与远程服务器进行连接，在连接后把本地的文件发送给远程备份服务器。

③设计并实现带身份认证的远程数据备份服务器（选作）

在实验②的基础上增加身份管理和认证功能：

2、解决方案：

服务器端过程就是socket->bind->listen->accept->Read,write

对于客户端则是socket->connect->read,write

三、方案设计

1、模块结构：

2、数据结构：

①文件操作，time_t t，socket

②文件操作，socket

3、总体流程：

4、关键算法：

①time_t t;

if(argc!=2) //获得ip地址

{

printf("usage %s\n",argv[0]);

return 0;

}

if((he = gethostbyname(argv[1])) == NULL)

{

printf("gethostbyname error\n");

return 0;

}

if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)

{

printf("socket() error \n");

return 0;

}

bzero(&server, sizeof(server));

server.sin_family = AF_INET;

server.sin_port = htons(PORT);

server.sin_addr = *((struct in_addr *)he->h_addr);

if(connect(sockfd, (struct sockaddr *)&server, sizeof(server)) == -1) {

printf("connetc() error\n");

return 0;

}

recv(sockfd,(void *)&t,sizeof(time_t),0);

printf("Time is %s\n",ctime(&t));

②

5、界面设计：

直接使用终端界面进行

四、调试记录

给出测试用例

五、创新说明

①拥有错误提示，即用户可以知道是哪个模块出错，方便进行检查

②拥有用户认证功能，即登录时需要特定的用户名跟密码，客户端在屏幕上输入文件路径上载，服务端再输入存贮的文件路径。

一、程序实践概述

1、题目名称：

Libpcap开发包使用

2、时间进度：

16学时

3、开发环境：

Ubantu

二、问题分析

1、功能说明：

（1）获取网络接口名字和掩码等信息

（2）捕获数据包（单个数据包和多个数据包两种情况）

（3）以太网数据报捕获

（4）ARP数据包捕获

2、解决方案：

使用QT图形化编程，将4个功能分别对应4个按钮点击事件，并把抓包结果输出在文本框中

三、方案设计

1、模块结构：

2、数据结构：

Libpcap

3、总体流程：

4、关键算法：

给出关键算法描述

void getip(){

char error_content[PCAP_ERRBUF_SIZE];

struct in_addr net_ip_address; //网络地址

struct in_addr net_mask_address;//掩码地址

char *net_interface; //接口名字

char *net_ip_string; //网络地址字符串形式

char *net_mask_string; //掩码地址字符串形式

u_int32_t net_ip; //网络地址

u_int32_t net_mask; //掩码地址

net_interface=pcap_lookupdev(error_content); //获取网络接口

pcap_lookupnet( //获取网络和掩码地址

net_interface,

&net_ip,

&net_mask,

error_content

) ;

printf("接口名字为：%s\n",net_interface);

net_ip_address.s_addr=net_ip;

net_ip_string=inet_ntoa(net_ip_address); //网络地址转为字符串形式

printf("网络地址为：%s\n",net_ip_string);

net_mask_address.s_addr=net_mask;

net_mask_string=inet_ntoa(net_mask_address);//掩码地址转为字符串形式printf("掩码地址为：%s\n",net_mask_string);

}

void getpacket(){

char error_content[PCAP_ERRBUF_SIZE];

struct pcap_pkthdr protocol_header; //数据包头

pcap_t *pcap_handle; //libpcap句柄

struct bpf_program bpf_filter; //BPF过滤规则

char bpf_filter_string[]="ip"; //过滤规则

const u_char *packet_content; //数据包内容

bpf_u_int32 net_mask; //掩码地址

bpf_u_int32 net_ip; //网络地址

char *net_interface; //网络接口

net_interface=pcap_lookupdev(error_content); //获取网络接口

pcap_lookupnet( //获取网络和掩码地址

net_interface,

&net_ip,

&net_mask,

error_content

) ;

pcap_handle=pcap_open_live(net_interface,BUFSIZ,1,0,error_content);

//网络接口，数据包大小，混杂模式，等待时间，错误信息pcap_compile(pcap_handle,&bpf_filter,bpf_filter_string,0,net_ip);

//编译过滤原则

pcap_setfilter(pcap_handle,&bpf_filter); //设置过滤原则

packet_content=pcap_next(pcap_handle,&protocol_header);//捕获一个数据包

printf("从%s 捕获了一个数据包\n",net_interface);

printf("数据包长度为：%d\n",protocol_header.len);

pcap_close(pcap_handle);

}

void getpackets(){

void packet_callback(u_char *argument,const struct pcap_pkthdr* packet_header,const u_char* packet_content){

static int packet_number=1;

printf("捕获数据包的个数为：%d\n",packet_number);

packet_number++;

}

char error_content[PCAP_ERRBUF_SIZE];

struct pcap_pkthdr protocol_header; //数据包头

pcap_t *pcap_handle; //libpcap句柄

struct bpf_program bpf_filter; //BPF过滤规则

char bpf_filter_string[]="ip"; //过滤规则

const u_char *packet_content; //数据包内容

bpf_u_int32 net_mask; //掩码地址

bpf_u_int32 net_ip; //网络地址

char *net_interface; //网络接口

net_interface=pcap_lookupdev(error_content); //获取网络接口

pcap_lookupnet( //获取网络和掩码地址

net_interface,

&net_ip,

&net_mask,

error_content

) ;

pcap_handle=pcap_open_live(net_interface,BUFSIZ,1,0,error_content);

//网络接口，数据包大小，混杂模式，等待时间，错误信息pcap_compile(pcap_handle,&bpf_filter,bpf_filter_string,0,net_ip);

//编译过滤原则

pcap_setfilter(pcap_handle,&bpf_filter); //设置过滤原则

pcap_loop(pcap_handle,10,packet_callback,NULL);

pcap_close(pcap_handle);

}

void getethernet(){

struct ether_header{

u_int8_t ether_dhost[8]; //目的以太网地址

u_int8_t ether_shost[8];//源以太网地址

u_int16_t ether_type; //以太网类型

};

char error_content[PCAP_ERRBUF_SIZE];

struct pcap_pkthdr protocol_header; //数据包头

pcap_t *pcap_handle; //libpcap句柄

struct bpf_program bpf_filter; //BPF过滤规则

char bpf_filter_string[]="ip"; //过滤规则

bpf_u_int32 net_mask; //掩码地址

bpf_u_int32 net_ip; //网络地址

char *net_interface; //网络接口

const u_char *packet_content; //数据包缓存

u_char *mac_string; //以太网地址

u_short ethernet_type; //以太网类型

struct ether_header *ethernet_protocol;//以太网协议变量

net_interface=pcap_lookupdev(error_content); //获取网络接口

pcap_lookupnet( //获取网络和掩码地址

net_interface,

&net_ip,

&net_mask,

error_content

) ;

pcap_handle=pcap_open_live(net_interface,BUFSIZ,1,0,error_content);

//网络接口，数据包大小，混杂模式，等待时间，错误信息pcap_compile(pcap_handle,&bpf_filter,bpf_filter_string,0,net_ip);

//编译过滤原则

pcap_setfilter(pcap_handle,&bpf_filter); //设置过滤原则

if(pcap_datalink(pcap_handle)!=DLT_EN10MB)

return;

packet_content=pcap_next(pcap_handle,&protocol_header);//捕获一个网络数据包

printf("从%s 捕获了一个数据包\n",net_interface);

printf("该数据包时间信息为：%s\n",ctime((const time_t*)&protocol_https://www.360docs.net/doc/c513461726.html,_sec));

printf("数据包长度为：%d\n",protocol_header.len);

ethernet_protocol=(struct ether_header*)packet_content;

ethernet_type=ntohs(ethernet_protocol->ether_type);//获得以太网类型

printf("以太网类型为：%04x\n",ethernet_type);

switch(ethernet_type){

case 0x0800: printf("协议类型为IP协议\n");break;

case 0x0806: printf("协议类型为ARP协议\n");break;

case 0x8035: printf("协议类型为RARP协议\n");break;

default: break;

}

mac_string=ethernet_protocol->ether_shost;//获得源以太网地址

printf("源以太网地址为：%02x:%02x:%02x:%02x:%02x:%02x",*mac_string,*(mac_string+1),*(mac_string+2),*(m ac_string+3),*(mac_string+4),*(mac_string+5));

mac_string=ethernet_protocol->ether_dhost;//获得目的以太网地址

printf("目的以太网地址为：%02x:%02x:%02x:%02x:%02x:%02x",*mac_string,*(mac_string+1),*(mac_string+2),*(m ac_string+3),*(mac_string+4),*(mac_string+5));

pcap_close(pcap_handle);

}

void getarp(){

pcap_t* pcap_handle;

char error_content[PCAP_ERRBUF_SIZE];

char *net_interface;

struct bpf_program bpf_filter;

char bpf_filter_string[]="arp";

bpf_u_int32 net_mask; //掩码地址

bpf_u_int32 net_ip; //网络地址

pcap_lookupnet( //获取网络和掩码地址

net_interface,

&net_ip,

&net_mask,

error_content

) ;

struct ether_header{

u_int8_t ether_dhost[8]; //目的以太网地址

u_int8_t ether_shost[8];//源以太网地址

u_int16_t ether_type; //以太网类型

};

typedef u_int32_t in_addr_t;

struct arp_header{ //arp协议格式

u_int16_t arp_hardware_type;//硬件地址类型

u_int16_t arp_protocol_type;//协议地址类型

u_int8_t arp_hardware_length;//硬件地址长度

u_int8_t arp_protocol_length;//协议地址长度

u_int16_t arp_operation_code;//操作类型

u_int8_t arp_source_ethernet_address[6];//源以太网地址

u_int8_t arp_source_ip_address[4];//源IP地址

u_int8_t arp_destination_ethernet_address[6];//目的以太网地址

u_int8_t arp_destination_ip_address[4];//目的IP地址

};

void arp_protocol_packet_callback(u_char *argument,const struct pcap_pkthdr* packet_header,const u_char* packet_content){

struct arp_header *arp_protocol; //arp协议变量

u_short protocol_type;//协议类型

u_short hardware_type;//硬件类型

u_short operation_code;//操作类型

u_char *mac_string;//以太网地址

struct in_addr source_ip_address;//源IP地址

struct in_addr destination_ip_address;//目的IP地址

u_char hardware_length;//硬件长度

u_char protocol_length;//协议长度

arp_protocol=(struct arp_header*)(packet_content+14);

hardware_type=ntohs(arp_protocol->arp_hardware_type);

protocol_type=ntohs(arp_protocol->arp_protocol_type);

operation_code=ntohs(arp_protocol->arp_operation_code);

protocol_length=arp_protocol->arp_protocol_length;

hardware_length=arp_protocol->arp_hardware_length;

printf("ARP硬件类型为：%d\n",hardware_type);

printf("ARP协议类型为：%d\n",protocol_type);

printf("ARP硬件长度为：%d\n",protocol_length);

printf("ARP协议长度为：%d\n",protocol_length);

printf("ARP操作类型为：%d\n",operation_code);

switch(operation_code){

case 1:printf("ARP查询协议\n");break;

case 2:printf("ARP应答协议\n");break;

case 3:printf("RARP查询协议\n");break;

case 4:printf("RARP应答协议\n");break;

default: break;

}

mac_string=arp_protocol->arp_source_ethernet_address;

printf("源以太网地址为：%02x:%02x:%02x:%02x:%02x:%02x",*mac_string,*(mac_string+1),*(mac_string+2),*(m ac_string+3),*(mac_string+4),*(mac_string+5));

memcpy((void *)&source_ip_address,(void *)&arp_protocol->arp_source_ip_address,sizeof(struct in_addr));

printf("源IP网地址为：%s\n",inet_ntoa(source_ip_address));

mac_string=arp_protocol->arp_destination_ethernet_address;

printf("目的以太网地址为：%02x:%02x:%02x:%02x:%02x:%02x",*mac_string,*(mac_string+1),*(mac_string+2),*(m ac_string+3),*(mac_string+4),*(mac_string+5));

memcpy((void *)&destination_ip_address,(void *)&arp_protocol->arp_destination_ip_address,sizeof(struct in_addr));

printf("目的IP网地址为：%s\n",inet_ntoa(destination_ip_address));

}

void ethernet_protocol_packet_callback(u_char *argument,const struct pcap_pkthdr* packet_header,const u_char* packet_content){

u_short ethernet_type;

struct ether_header *ethernet_protocol;

u_char *mac_string;

static int packet_number=1;

printf("捕获了%d个ARP数据包\n",packet_number);

ethernet_protocol=(struct ether_header*)packet_content;

ethernet_type=ntohs(ethernet_protocol->ether_type);

printf("以太网类型为：%04x\n",ethernet_type);

switch(ethernet_type){

case 0x0800: printf("协议类型为IP协议\n");break;

case 0x0806: printf("协议类型为ARP协议\n");break;

case 0x8035: printf("协议类型为RARP协议\n");break;

default: break;

}

mac_string=ethernet_protocol->ether_shost;//获得源以太网地址

printf("源以太网地址为：%02x:%02x:%02x:%02x:%02x:%02x",*mac_string,*(mac_string+1),*(mac_string+2),*(m ac_string+3),*(mac_string+4),*(mac_string+5));

mac_string=ethernet_protocol->ether_dhost;//获得目的以太网地址

printf("目的以太网地址为：%02x:%02x:%02x:%02x:%02x:%02x",*mac_string,*(mac_string+1),*(mac_string+2),*(m ac_string+3),*(mac_string+4),*(mac_string+5));

switch(ethernet_type){

case 0x0806: arp_protocol_packet_callback(argument,packet_header,packet_content);break;

default: break;

}

packet_number++;

pcap_handle=pcap_open_live(net_interface,BUFSIZ,1,0,error_content);

//网络接口，数据包大小，混杂模式，等待时间，错误信息pcap_compile(pcap_handle,&bpf_filter,bpf_filter_string,0,net_ip);

//编译过滤原则

pcap_setfilter(pcap_handle,&bpf_filter); //设置过滤原则

if(pcap_datalink(pcap_handle)!=DLT_EN10MB)

return;

pcap_loop(pcap_handle,-1,ethernet_protocol_packet_callback,NULL);//捕获一个网络数据包

pcap_close(pcap_handle);

}

5、界面设计：

直接使用终端界面

四、调试记录

给出测试用例

五、创新说明

使用QT图形化界面，拥有更好的用户交互功能，并且将每次数据存贮在一个全局变量中再输出。