1. 网络信息安全实验
C语言编写的一个DES加密源程序如下，不解释，自己慢慢看：
C语言编写的一个DES加密源程序如下，不解释，自己慢慢看：
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <memory.h>
#define PLAIN_FILE_OPEN_ERROR -1
#define KEY_FILE_OPEN_ERROR -2
#define CIPHER_FILE_OPEN_ERROR -3
#define OK 1;
typedef char ElemType;
int IP_Table[64] = { 57,49,41,33,25,17,9,1,
59,51,43,35,27,19,11,3,
61,53,45,37,29,21,13,5,
63,55,47,39,31,23,15,7,
56,48,40,32,24,16,8,0,
58,50,42,34,26,18,10,2,
60,52,44,36,28,20,12,4,
62,54,46,38,30,22,14,6};
int IP_1_Table[64] = {39,7,47,15,55,23,63,31,
38,6,46,14,54,22,62,30,
37,5,45,13,53,21,61,29,
36,4,44,12,52,20,60,28,
35,3,43,11,51,19,59,27,
34,2,42,10,50,18,58,26,
33,1,41,9,49,17,57,25,
32,0,40,8,48,16,56,24};
int E_Table[48] = {31, 0, 1, 2, 3, 4,
3, 4, 5, 6, 7, 8,
7, 8,9,10,11,12,
11,12,13,14,15,16,
15,16,17,18,19,20,
19,20,21,22,23,24,
23,24,25,26,27,28,
27,28,29,30,31, 0};
int P_Table[32] = {15,6,19,20,28,11,27,16,
0,14,22,25,4,17,30,9,
1,7,23,13,31,26,2,8,
18,12,29,5,21,10,3,24};
int S[8][4][16] =/* S1 */
{{{14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7},
{0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8},
{4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0},
{15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13}},
/* S2 */
{{15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10},
{3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5},
{0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15},
{13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9}},
/* S3 */
{{10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8},
{13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1},
{13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7},
{1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12}},
/* S4 */
{{7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15},
{13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9},
{10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4},
{3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14}},
/* S5 */
{{2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9},
{14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6},
{4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14},
{11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3}},
/* S6 */
{{12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11},
{10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8},
{9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6},
{4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13}},
/* S7 */
{{4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1},
{13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6},
{1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2},
{6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12}},
/* S8 */
{{13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7},
{1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2},
{7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8},
{2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11}}};
int PC_1[56] = {56,48,40,32,24,16,8,
0,57,49,41,33,25,17,
9,1,58,50,42,34,26,
18,10,2,59,51,43,35,
62,54,46,38,30,22,14,
6,61,53,45,37,29,21,
13,5,60,52,44,36,28,
20,12,4,27,19,11,3};
int PC_2[48] = {13,16,10,23,0,4,2,27,
14,5,20,9,22,18,11,3,
25,7,15,6,26,19,12,1,
40,51,30,36,46,54,29,39,
50,44,32,46,43,48,38,55,
33,52,45,41,49,35,28,31};
int MOVE_TIMES[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};
int ByteToBit(ElemType ch,ElemType bit[8]);
int BitToByte(ElemType bit[8],ElemType *ch);
int Char8ToBit64(ElemType ch[8],ElemType bit[64]);
int Bit64ToChar8(ElemType bit[64],ElemType ch[8]);
int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]);
int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]);
int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]);
int DES_ROL(ElemType data[56], int time);
int DES_IP_Transform(ElemType data[64]);
int DES_IP_1_Transform(ElemType data[64]);
int DES_E_Transform(ElemType data[48]);
int DES_P_Transform(ElemType data[32]);
int DES_SBOX(ElemType data[48]);
int DES_XOR(ElemType R[48], ElemType L[48],int count);
int DES_Swap(ElemType left[32],ElemType right[32]);
int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]);
int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48], ElemType plainBlock[8]);
int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile);
int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile);
int ByteToBit(ElemType ch, ElemType bit[8]){
int cnt;
for(cnt = 0;cnt < 8; cnt++){
*(bit+cnt) = (ch>>cnt)&1;
}
return 0;
}
/* 娴滃矁绻橀崚𨱍版祮阉广垺鍨氱€涙 濡?*/
int BitToByte(ElemType bit[8],ElemType *ch){
int cnt;
for(cnt = 0;cnt < 8; cnt++){
*ch |= *(bit + cnt)<<cnt;
}
return 0;
}
int Char8ToBit64(ElemType ch[8],ElemType bit[64]){
int cnt;
for(cnt = 0; cnt < 8; cnt++){
ByteToBit(*(ch+cnt),bit+(cnt<<3));
}
return 0;
}
int Bit64ToChar8(ElemType bit[64],ElemType ch[8]){
int cnt;
memset(ch,0,8);
for(cnt = 0; cnt < 8; cnt++){
BitToByte(bit+(cnt<<3),ch+cnt);
}
return 0;
}
int DES_MakeSubKeys(ElemType key[64],ElemType subKeys[16][48]){
ElemType temp[56];
int cnt;
DES_PC1_Transform(key,temp);
for(cnt = 0; cnt < 16; cnt++){
DES_ROL(temp,MOVE_TIMES[cnt]);
DES_PC2_Transform(temp,subKeys[cnt]);
}
return 0;
}
int DES_PC1_Transform(ElemType key[64], ElemType tempbts[56]){
int cnt;
for(cnt = 0; cnt < 56; cnt++){
tempbts[cnt] = key[PC_1[cnt]];
}
return 0;
}
int DES_PC2_Transform(ElemType key[56], ElemType tempbts[48]){
int cnt;
for(cnt = 0; cnt < 48; cnt++){
tempbts[cnt] = key[PC_2[cnt]];
}
return 0;
}
int DES_ROL(ElemType data[56], int time){
ElemType temp[56];
memcpy(temp,data,time);
memcpy(temp+time,data+28,time);
memcpy(data,data+time,28-time);
memcpy(data+28-time,temp,time);
memcpy(data+28,data+28+time,28-time);
memcpy(data+56-time,temp+time,time);
return 0;
}
int DES_IP_Transform(ElemType data[64]){
int cnt;
ElemType temp[64];
for(cnt = 0; cnt < 64; cnt++){
temp[cnt] = data[IP_Table[cnt]];
}
memcpy(data,temp,64);
return 0;
}
int DES_IP_1_Transform(ElemType data[64]){
int cnt;
ElemType temp[64];
for(cnt = 0; cnt < 64; cnt++){
temp[cnt] = data[IP_1_Table[cnt]];
}
memcpy(data,temp,64);
return 0;
}
int DES_E_Transform(ElemType data[48]){
int cnt;
ElemType temp[48];
for(cnt = 0; cnt < 48; cnt++){
temp[cnt] = data[E_Table[cnt]];
}
memcpy(data,temp,48);
return 0;
}
int DES_P_Transform(ElemType data[32]){
int cnt;
ElemType temp[32];
for(cnt = 0; cnt < 32; cnt++){
temp[cnt] = data[P_Table[cnt]];
}
memcpy(data,temp,32);
return 0;
}
int DES_XOR(ElemType R[48], ElemType L[48] ,int count){
int cnt;
for(cnt = 0; cnt < count; cnt++){
R[cnt] ^= L[cnt];
}
return 0;
}
int DES_SBOX(ElemType data[48]){
int cnt;
int line,row,output;
int cur1,cur2;
for(cnt = 0; cnt < 8; cnt++){
cur1 = cnt*6;
cur2 = cnt<<2;
line = (data[cur1]<<1) + data[cur1+5];
row = (data[cur1+1]<<3) + (data[cur1+2]<<2)
+ (data[cur1+3]<<1) + data[cur1+4];
output = S[cnt][line][row];
data[cur2] = (output&0X08)>>3;
data[cur2+1] = (output&0X04)>>2;
data[cur2+2] = (output&0X02)>>1;
data[cur2+3] = output&0x01;
}
return 0;
}
int DES_Swap(ElemType left[32], ElemType right[32]){
ElemType temp[32];
memcpy(temp,left,32);
memcpy(left,right,32);
memcpy(right,temp,32);
return 0;
}
int DES_EncryptBlock(ElemType plainBlock[8], ElemType subKeys[16][48], ElemType cipherBlock[8]){
ElemType plainBits[64];
ElemType Right[48];
int cnt;
Char8ToBit64(plainBlock,plainBits);
DES_IP_Transform(plainBits);
for(cnt = 0; cnt < 16; cnt++){
memcpy(Right,plainBits+32,32);
DES_E_Transform(Right);
DES_XOR(Right,subKeys[cnt],48);
DES_SBOX(Right);
DES_P_Transform(Right);
DES_XOR(plainBits,Right,32);
if(cnt != 15){
DES_Swap(plainBits,plainBits+32);
}
}
DES_IP_1_Transform(plainBits);
Bit64ToChar8(plainBits,cipherBlock);
return 0;
}
int DES_DecryptBlock(ElemType cipherBlock[8], ElemType subKeys[16][48],ElemType plainBlock[8]){
ElemType cipherBits[64];
ElemType Right[48];
int cnt;
Char8ToBit64(cipherBlock,cipherBits);
DES_IP_Transform(cipherBits);
for(cnt = 15; cnt >= 0; cnt--){
memcpy(Right,cipherBits+32,32);
DES_E_Transform(Right);
DES_XOR(Right,subKeys[cnt],48);
DES_SBOX(Right);
DES_P_Transform(Right);
DES_XOR(cipherBits,Right,32);
if(cnt != 0){
DES_Swap(cipherBits,cipherBits+32);
}
}
DES_IP_1_Transform(cipherBits);
Bit64ToChar8(cipherBits,plainBlock);
return 0;
}
int DES_Encrypt(char *plainFile, char *keyStr,char *cipherFile){
FILE *plain,*cipher;
int count;
ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
ElemType bKey[64];
ElemType subKeys[16][48];
if((plain = fopen(plainFile,"rb")) == NULL){
return PLAIN_FILE_OPEN_ERROR;
}
if((cipher = fopen(cipherFile,"wb")) == NULL){
return CIPHER_FILE_OPEN_ERROR;
}
memcpy(keyBlock,keyStr,8);
Char8ToBit64(keyBlock,bKey);
DES_MakeSubKeys(bKey,subKeys);
while(!feof(plain)){
if((count = fread(plainBlock,sizeof(char),8,plain)) == 8){
DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
fwrite(cipherBlock,sizeof(char),8,cipher);
}
}
if(count){
memset(plainBlock + count,'\0',7 - count);
plainBlock[7] = 8 - count;
DES_EncryptBlock(plainBlock,subKeys,cipherBlock);
fwrite(cipherBlock,sizeof(char),8,cipher);
}
fclose(plain);
fclose(cipher);
return OK;
}
int DES_Decrypt(char *cipherFile, char *keyStr,char *plainFile){
FILE *plain, *cipher;
int count,times = 0;
long fileLen;
ElemType plainBlock[8],cipherBlock[8],keyBlock[8];
ElemType bKey[64];
ElemType subKeys[16][48];
if((cipher = fopen(cipherFile,"rb")) == NULL){
return CIPHER_FILE_OPEN_ERROR;
}
if((plain = fopen(plainFile,"wb")) == NULL){
return PLAIN_FILE_OPEN_ERROR;
}
memcpy(keyBlock,keyStr,8);
Char8ToBit64(keyBlock,bKey);
DES_MakeSubKeys(bKey,subKeys);
fseek(cipher,0,SEEK_END);
fileLen = ftell(cipher);
rewind(cipher);
while(1){
fread(cipherBlock,sizeof(char),8,cipher);
DES_DecryptBlock(cipherBlock,subKeys,plainBlock);
times += 8;
if(times < fileLen){
fwrite(plainBlock,sizeof(char),8,plain);
}
else{
break;
}
}
if(plainBlock[7] < 8){
for(count = 8 - plainBlock[7]; count < 7; count++){
if(plainBlock[count] != '\0'){
break;
}
}
}
if(count == 7){
fwrite(plainBlock,sizeof(char),8 - plainBlock[7],plain);
}
else{
fwrite(plainBlock,sizeof(char),8,plain);
}
fclose(plain);
fclose(cipher);
return OK;
}
int main()
{
DES_Encrypt("out.xml","key.txt","out.des");
DES_Decrypt("out.des","key.txt","out.des.xml");
return 0;
}
2. 跪求操作系统之文件系统实验源代码
首先研究 Linux 源代码树的顶层目录，它通常（但不总是）位于 /usr/src/linux-。我们不会研究得过于详细，因为 Linux 源代码经常会发生变化，但是，我们将尝试让给出的信息足以找出特定驱动程序或函数的位置。
Makefile：这个文件是整个源代码树的顶层 makefile。它定义了很多实用的变量和规则，比如默认的 gcc 编译标记。
Documentation/：这个目录中包含很多关于配置内核、运行 ramdisk 等任务的实用信息（但通常是过时的）。不过，与不同配置选项相应的帮助条目并不在这里 —— 它们在每个源代码目录的 Kconfig 文件中。
arch/：所有与体系结构相关的代码都在这个目录以及 include/asm- 目录中。在此目录中，每种体系结构都有自己的目录。例如，用于基于 PowerPC 的计算机的代码位于 arch/ppc 目录中。在这些目录里，可以找到底层内存管理、中断处理、早期初始化、汇编例程，等等。
crypto/：这是内核本身所用的加密 API。
drivers/：按照惯例，在此目录的子目录中可以找到运行外围设备的代码。包括视频驱动程序、网卡驱动程序、底层 SCSI 驱动程序，以及其他类似的驱动程序。例如，在 drivers/net 中可以找到大部分网卡驱动程序。将一类驱动程序组合在一起的某些更高层代码，可能会（也可能不会）像底层驱动程序本身那些包含在同一目录中。
fs/：通用文件系统的代码（称做 VFS，即 Virtual File System）和各个不同文件系统的代码都可以在这个目录中找到。ext2 文件系统是在 Linux 中最常广泛使用的文件系统之一；在 fs/ext2 中可以找到读取 ext2 格式的代码。并不是所有文件系统都会编译或运行；对某些寻找内核项目的人而言，更生僻的文件系统永远都是理想的候选者。
include/：在 .c 文件的开头所包含的大部分头文件都可以在这个目录中找到。 asm- 目录下是与体系结构相关的包含（include ）文件。部分内核构建过程创建从 asm 指定 asm- 的符号链接。这样，无需将其固定编码到 .c 文件 #include 就可以获得用于那个体系结构的正确文件。其他目录中包含的是 非-体系结构-相关 的头文件。如果在不只一个 .c 文件中使用了某个结构体、常量或者变量，那么它可能应该放入其中一个头文件中。
init/：这个目录中的文件包括 main.c、创建 早期用户空间（early userspace） 的代码，以及其他初始化代码。可以认为 main.c 是内核“粘合剂（glue）”。在下一部分将深入讨论 main.c。早期用户空间提供了 Linux 内核引导起来时所需要的功能，而这些功能并不需要在内核本身运行。
ipc/：IPC 的意思是 进程间通信（interprocess communication）。它包含了共享内存、信号量以及其他形式 IPC 的代码。
kernel/：不适合放在任何其他位置的通用内核级代码位于此处。这里有高层系统调用代码，以及 printk() 代码、调度程序、信号处理代码，等等。文件名包含很多信息，所以可以使用 ls kernel/，并非能常准确地猜到每个文件的功能。
lib/：这里是对所有内核代码都通用的实用例程。常见的字符串操作、调试例程，以及命令行解析代码都位于此处。
mm/：这个目录中是高层次内核管理代码。联合使用这些例程以及底层的与体系结构相关的例程（通常位于 arch//mm/ 目录中）来实现虚拟内存（Virtual memory，VM）。在这里会完成早期内存管理（在内存子系统完全建立起来之前需要它），以及文件的内存映射、页高速缓存管理、内存分配、RAM 中页的清除（还有很多其他事情）。
net/：这里是高层网络代码。底层网络驱动程序与此层次代码交换数据包，这个层次的代码可以根据数据包将数据传递给用户层应用程序，或者丢弃数据，或者在内核中使用它。net/core 包含大部分不同的网络协议都可以使用的代码，和某些位于 net/ 目录本身中的文件一样。特定的网络协议在 net/ 的子目录下实现。例如，在 net/ipv4 目录中可以找到 IP（版本 4）代码。
scripts/：这个目录中包含的脚本可用于内核的构建，但并不将任何代码加入到内核本身之中。例如，各种配置工具可以将它们的文件放在这里。
security/：在这里可以找到不同 Linux 安全模型的代码，比如 NSA Security-Enhanced Linux 以及套接字和网络安全钩子函数（hooks），以及其他安全选项。
sound/：这里放置的是声卡驱动程序和其他与声音相关的代码。
usr/：此目录中的代码用于构建包含 root 文件系统映像的 cpio-格式 的归档文件，用于早期用户空间。
3. 网络安全-TCP-IP攻击
概述
1. SYN-Flooding攻击效果,受害者系统卡死.
2. TCP-RST攻击实现已经建立的TCP连接断开.
3. TCP会话劫持,劫持TCP会话,并实现反向Shell.
实验环境
1. 三台Linux系统主机,一台作为攻击者,一台作为受害者,一台作为观察者.
2. 为了简化TCP序列号和源端口号的“猜测”,实验处于同一局域网内,你可以使用嗅探器来获取受害者信息.
SYN-Flooding攻击
1. SYN-Flooding攻击原理
SYN-Flooding是DoS攻击的一种，攻击者向受害者的TCP端口发送很多SYN请求，但攻击者无意完成三次握手过程.
攻击者要么使用欺骗性的假的IP地址，要么不要继续完成整个三次握手过程.
通过这种攻击，攻击者可以淹没用于半连接的受害者队列，即已完成SYN，SYN-ACK但尚未得到最终ACK的连接.
当这个队列已满时，受害者不能再进行任何连接.
正常三次握手过程:
在Linux中，我们可以使用以下命令检查
我们可以使用命令“netstat -na”来检查队列的使用情况，即与监听端口相关联的半连接的数量.
这种半连接的状态是SYN-RECV。如果三次握手完成，则连接的状态将为ESTABLISHED.
在这个任务中，你需要演示SYN-Flooding攻击:
您可以使用Netwox来执行攻击，然后使用嗅探器捕获攻击性数据包.
在攻击发生时，在受害机器上运行“netstat -na”命令，并将结果与攻击前的结果进行比较.
2. Netwox 76简介
3. SYN Cookie防御机制
如果你的攻击看起来不成功，你可以检查是否启用了SYN cookie机制.
SYN cookie是抵抗SYN-Flooding的防御机制.
防御原理简介:
在TCP服务器收到TCP SYN包并返回TCP SYN+ACK包时，不分配一个专门的数据区，
而是根据这个SYN包计算出一个cookie值.
在收到TCP ACK包时，TCP服务器在根据那个cookie值检查这个TCP ACK包的合法性.
如果合法，再分配专门的数据区进行处理未来的TCP连接.
你可以使用sysctl命令打开/关闭SYN cookie机制：
4. 实验结果分析
比较 netstat -na 前后状态如下:
产生大量的TCP半连接,阻塞了队列,导致后续正常TCP连接无法建立!!
TCP-RST攻击
1. FTP协议
2. TELNET协议
3. SSH协议
4. Newox 78简介
5. 实验结果分析
-** FTP**
FTP服务器地址: 192.168.59.146/24
FTP客户端地址: 192.168.59.144/24
攻击者地址: 192.168.59.1/24
攻击者终端对受害者进行TCP-RST打击:
结果显示:已经建立的TCP连接断开.
Telnet服务器地址: 192.168.59.146/24
Telnet客户端地址: 192.168.59.144/24
攻击者地址: 192.168.59.1/24
攻击者终端对受害者进行TCP-RST打击:
结果显示:已经建立的TCP连接断开.
SSH服务器地址: 192.168.59.146/24
SSH客户端地址: 192.168.59.144/24
攻击者地址: 192.168.59.1/24
攻击者终端对受害者进行TCP-RST打击:
结果显示:已经建立的TCP连接断开.
TCP会话劫持
1. 会话劫持简介
TCP会话劫持攻击的目标是通过向该会话中注入恶意内容来劫持两名受害者之间的现有TCP连接（会话）.
如果这个连接是一个telnet会话,攻击者可以在这个会话中注入恶意命令(例如删除重要文件),导致受害者执行恶意命令.
2. Wireshark简介
如果您使用Wireshark观察网络流量,当Wireshark显示TCP序列号时,
默认情况下会显示相对序列号,它等于实际序列号减去初始序列号.
如果想查看包中的实际序列号,则需要右键单击Wireshark输出的TCP部分,
然后选择"Protocol Preference". 在弹出窗口中，取消选"Relative Sequence Number"选项.
3. Netwox 40简介
4. 实验结果分析
Telnet服务器地址: 192.168.59.148/24
Telnet客户端地址: 192.168.59.146/24
攻击者地址: 192.168.59.1/24
攻击者终端对受害者进行TCP会话劫持:
我们要伪造发下一个包:
所以直接采用nextseq作为下一个包的ack,采用ack作为下一个包的seq.
最后一个Telnet数据包内容如下:
我们伪造向服务器 192.168.59.148 发送 ls 命令,
通过netwox构造我们的攻击指令如下:
在wireshark上显示抓包数据如下:
来创建我们的肉鸡~
现在我们来通过NC反弹一个Shell,来控制我们受害者:
首先是构造NC命令:
实验结果如图:
首先看结果:我们成功拿到了服务器上的用户gu的所有权限!
咱们再来看看抓包数据,通过抓包数据,你可以看到最后一条Telnet的TCP数据,通过这些数据,就可以很方便通过Netwox构造攻击语句了!!
4. 单片机大一19个实验代码
实验一
实验（一）:本程序的功能是点亮一个发光二极管
#include<reg51.h>
sbit led=P1^0;
void main()
{
led=0;
while(1);
}
实验（二）:本程序的功能是点亮一个发光二极管
#include<reg51.h>
Void main()
{
P1=0xfe;
While(1)
;
}
实验（三）:本程序的功能是点亮三个发光二极管
#include <reg51.h>
Sbit LED0=P1^0;
Sbit LED1=P1^1;
Sbit LED2=P1^2;
Void main()
{
LED0=0;
LED1=0;
LED2=0;
While(1);
}
实验（四）:本程序的功能是点亮三个发光二极管
#include <reg51.h>
Void main()
{
P1=0xf8;
While(1)
;
}
实验二
实验（一）:本程序的功能是使D0交替闪烁，频率始终一致
#include<reg51.h>
sbit LED0=P1^0;
void Delay(unsigned int t);
void main()
{
while(1)
{
LED0=0;
Delay(10000);
LED0=1;
Delay(10000);
}
}
void Delay(unsigned int t)
{
while(--t);
}
实验（二）:本程序的功能是使D0交替闪烁，前10次的闪烁频率与后10次不同
#include<reg51.h>
sbit LED0=P1^0;
void Delay(unsigned int t);
void main()
{
Unsigned char i;
while(1)
{
For(i=0;i<10;i++)
{
LED0=0;
Delay(10);
LED0=1;
Delay=(10);
}
For(i=0;i<10;i++)
{
LED0=0;
Delay(6000);
LED0=1;
Delay(6000);
}
}
}
Void Delay(unsigned int t)
{
Unsigned i,j;
For(i=0;i<t;i++)
For(j=0;j<1000;j++)
;
}
实验（三）:本程序的功能是使D0、D2、D4交替闪烁，前10次的闪烁频率与后10次不同
#include<reg51.h>
sbit LED0=P1^0;
sbit LED2=P1^2;
sbit LED4=P1^4;
void Delay(unsigned int t);
void main()
{
Unsigned char i;
while(1)
{
For(i=0;i<10;i++)
{
LED0=0;
LED2=0;
LED4=0;
Delay(100);
LED0=1;
LED2=1;
LED4=1;
Delay=(100);
}
For(i=0;i<10;i++)
{
LED0=0;
LED2=0;
LED4=0;
Delay(1000);
LED0=1;
LED2=1;
LED4=1;
Delay(1000);
}
}
}
Void Delay(unsigned int t)
{
Unsigned i,j;
For(i=0;i<t;i++)
For(j=0;j<1000;j++)
;
}
实验（四）:本程序的功能是使D0、D2、D4交替闪烁，前10次的闪烁频率与后10次不同
#include<reg51.h>
void Delay(unsigned int t);
void main()
{
Unsigned char i;
while(1)
{
For(i=0;i<10;i++)
{
P1=0xff;
Delay(100);
P1=0xea;
Delay=(100);
}
For(i=0;i<10;i++)
{
P1=0xff;
Delay(1000);
P1=0xea;
Delay(1000);
}
}
}
Void Delay(unsigned int t)
{
Unsigned i,j;
For(i=0;i<t;i++)
For(j=0;j<1000;j++)
;
}
实验三
实验（一）:Proteus本程序的功能是使D0-D7从右至左依次被点亮
#include<reg51.h>
void Delay(unsigned int t);
void main()
{
unsigned char i;
Delay(50000);
P1=0xff;
for(i=0;i<8;i++)
{
Delay(50000);
P1<<=1;
}
while(1)
;
}
void Delay(unsigned int t)
{
while(--t);
}
实验（二）:本程序的功能是使D0-D7从左至右依次被点亮
#include<reg51.h>
void Delay(unsigned int t);
void main()
{
unsigned char i;
Delay(50000);
P1=0xff;
for(i=0;i<8;i++)
{
Delay(50000);
P1>>=1;
}
while(1)
;
}
void Delay(unsigned int t)
{
while(--t);
}
实验四
实验（一）:本程序的功能是使D0-D7从有至左被点亮，某时刻只有一个灯亮，最终D7在亮
#include<reg51.h>
#include<intrins.h>
void delay(unsigned int t);
void main()
{
unsigned char i;
P1=0xfe;
delay(50000);
for(i=0;i<7;i++)
{
P1=crol_(P1,1);
delay(50000);
}
while(1)
;
}
void delay(unsigned int t)
{
while(--t);
}
实验（二）:本程序的功能是使D0-D7从有至左被点亮，某时刻只有一个灯亮，最终D0在亮
#include<reg51.h>
#include<intrins.h>
void delay(unsigned int t);
void main()
{
unsigned char i;
P1=0x7f;
delay(50000);
for(i=0;i<7;i++)
{
P1=_crol_(P1,1);
delay(50000);
}
while(1);
}
void delay(unsigned int t)
{
while(--t);
}
实验五
#include<reg51.h>
sbit K0=P1^0;
sbit K1=P1^1;
sbit LED0=P1^2;
sbit LED1=P1^3;
void main()
{
while(1)
{
if(K0==1)
LED0=1;
else
LED0=0;
if(K1==1)
LED1=1;
else
LED1=0;
}
}
实验六
(1)实验箱程序清单
#include<reg51.h>
sbit K0=P0^0;
sbit lemp=P1^0;
void main()
{
while(1)
{
if(K0==0)
lemp=0;
else
lemp=1;
}
}
2.Proteus 仿真程序清党
#include<reg51.h>
sbit K0=P0^0;
sbit lamp=P3^0;
void main()
{
While(1)
{
if(K0==0)
lamp=0;
else
lamp=1;
}
}
实验七
#include<reg51.h>
#define uint unsigned int
#define uchar unsigned char
sbit K0=P1^0;
void delay(uint x)
{
uint i,j;
for(i=0;i<x;i++)
for(j=0;j<1000;j++)
;
}
void main()
{
while(1)
{
K0=1;
delay(50);
K0=0;
delay(50);
}
}
实验十
（1）仿真一程序清单
#include<reg51.h>
sbit sdata=P1^0;
sbit clk=P1^1;
void delay(unsigned int x)
{
unsigned int I,j;
for(i=0;i<x;i++)
for(j=0;i<60000;i++)
;
}
void write_74ls164(unsigned char dat)
{
unsigned char i;
for(i=0;i<8;i++)
{
Clk=0;
sdata=dat&0x01;
clk=1;
delay(50000);
dat=dat>>1;
}
}
void main()
{
write_74ls164(0x01);
while(1);
}
（2）仿真二程序清单
#include <reg51.h>
#define uchar unsigned char
#define uint unsigned int
sbit sda=P1^0;
sbit clk=P1^1;
void write_741s164(uchar dat)
{
uchar i;
for(i=0;i<8;i++)
{
clk=0;
sda=dat&0x01;
clk=1;
dat=dat>>1;
}
}
void delay(uint x)
{
uchar y;
for(;x>0;x--)
for(y=1000;y>0;y--);
}
void main()
{
while(1)
{
write_741s164(0xff);
delay(1000);
}
}
（3）仿真三程序清单
#include <reg51.h>
#define uchar unsigned char
#define uint unsigned int
sbit sda=P1^0;
sbit clk=P1^1;
uchar a[2]={0xff,0xf6};
void write_741s164(uchar dat)
{
uchar i;
for(i=0;i<8;i++)
{
clk=0;
sda=dat&0x01;
clk=1;
dat=dat>>1;
}
}
void delay(uint x)
{
uchar y;
for(;x>0;x--)
for(y=1000;y>0;y--);
}
void main()
{
while(1)
{
write_741s164(a[0]);
write_741s164(a[1]);
delay(1000);
}
}
（4）实验箱程序清单
#include<reg51.h》
#define uchar unsigned char
#define uint unsigned int
sbit sda=P1^0;
sbit clk=P1^1;
uchar a[5]={0xfe,0xfc,0x9c,0xb6,0x60};
void write_74ls164(uchar dat)
{
uchar I;
for(i=0;i<8;i++)
{
clk=0;
sda=dat&0x01;
clk=1;
dat=dat>>1;
}
}
void delayls(uint x)
{
uchar y;
for(;x>0;x--)
for(y=1000;y>0;y--)
;
}
void main()
{
while(1)
{
write_74ls164(a[0]);
write_74ls164(a[1]);
write_74ls164(a[2]);
write_74ls164(a[3]);
write_74ls164(a[4]);
delayls(3000);
}
}
实验十一
#include <reg51.h>
#define uchar unsigned char
#define uint unsigned int
uchar anma[6]={0x06,0x7d,0x7f,0x06,0x7d,0x7f};
uchar weima[6]={0x20,0x10,0x08,0x04,0x02,0x01};
void dealy(uint x)
{
uint i,j;
for(i=0;i<x;i++)
for(j=0;j<1000;j++);
}
void main()
{
uchar i;
while (1)
{
for(i=0;i<6;i++)
{
P0=anma[i];
P1=weima[i];
dealy(80);
}
}
}
实验十二
#include<reg51.h>
void main(){
unsigned char x;
while(1)
{
x=P1;
switch(x)
{
case 0xfe:P2=0x3f;break;
case 0xfd:P2=0x06;break;//84218421
case 0xfb:P2=0x5b;break;//2 01011011
case 0xf7:P2=0x4f;break;//3 01001111
case 0xef:P2=0x66;break;//4 01100110
case 0xdf:P2=0x6b;break;//5 01101101
case 0xbf:P2=0x7d;break;//6 01111101
case 0x7f:P2=0x07;break;
}
}
}
实验十三
#include<reg51.h>
#define GPIO_KEY P1
unsigned char m[16]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
unsigned char KeyValue;
void ys(unsigned int c);
void KeyDown();
void main()
{
while(1)
{
KeyDown();
P2=m[KeyValue];
ys(25);
}
}
void KeyDown()
{
char a=0;
GPIO_KEY=0x0f;
if(GPIO_KEY!=0x0f)
{
ys(1);
if(GPIO_KEY!=0x0f)
{
GPIO_KEY=0xf0;
switch(GPIO_KEY)
{
case(0xe0): KeyValue=0;break;
case(0xd0): KeyValue=1;break;
case(0xb0): KeyValue=2;break;
case(0x70): KeyValue=3;break;
}
GPIO_KEY=0x0f;
switch(GPIO_KEY)
{
case(0x0e): KeyValue=KeyValue;break;
case(0x0d): KeyValue=KeyValue+4;break;
case(0x0b): KeyValue=KeyValue+8;break;
case(0x07): KeyValue=KeyValue+12;break;
}
while((a<50)&&(GPIO_KEY!=0x0f))
{
ys(1);
a++;
}
}
}
}
void ys(unsigned int c)
{
unsigned char a,b;
for(;c>0;c--)
{
for(b=38;b>0;b--)
{
for(a=130;a>0;a--)
;
}
}
}
实验十四
#include<reg51.h>
sbit sz=P3^4;
void delay(unsigned int x)
{
unsigned int i,j;
for(i=0;i<x;i++)
for(j=0;j<1000;j++);
}
void main()
{
TMOD=0X05;
TH0=0;
TL0=0;
TR0=1;
while(1)
{
P1=TL0;
delay(0);
}
}
实验十五
（1）中断方式
#include<reg51.h>
sbit led=P1^0;
unsigned int counter;
void timer0_inter()interrupt 1
{
counter++;
}
void main()
{
led=1;
TH0=0x9c;
TL0=0x9c;
TMOD=0X02;
ET0=1;
EA=1;
TR0=1;
while(1)
{
if(counter==10000)
{
counter=0;
led=~led;
}
}
}
（2）非中断方式：
#include<reg51.h>
sbit led=P1^0;
void timer0(unsigned int x)
{
unsigned int i=0;
TH0=0x9c;
TL0=0x9c;
TR0=1;
while(i<x)
{
while(TF0==0)
;
i++;
TF0=0;
}
}
void main()
{
Led=1;
TMOD=0x02;
while(1)
{
led=0;
timer0(10000);
led=1;
timer0(10000);
}
}
实验十六
#include<reg51.h>
sbit P1_0=P1^0;
sbit P1_1=P1^1;
void delay();
void main()
{
P1_0=0;
P1_1=0;
EA=1;
IT0=1;
EX0=1;
while(1)
{
P1_1=0;
delay();
P1_1=1;
delay();
}
}
void int0() interrupt 0
{
bit saveled;
EA=0;
saveled=P1_1;
P1_0=!P1_0;
delay();
delay();
delay();
P1_1=saveled;
EA=1;
}
void delay()
{
unsigned int m,n;
for(m=0;m<250;m++)
for(n=0;n<255;n++)
;
}
实验十七
#include<reg51.h>
void delay();
void right();
void main()
{
P1=0xff;
EA=1;
IT0=1;
EX0=1;
while(1)
{
right();
}
}
void int0() interrupt 0
{
unsigned char saveled,i;
EA=0;
saveled=P1;
P1=0xff;
for(i=0;i<10;i++)
{
P1=~P1;
delay();
}
P1=saveled;
EA=1;
}
void right()
{
unsigned char i,k;
k=0x80;
for(i=0;i<8;i++)
{
P1=~k;
delay();
k>>=1;
}
}
void delay()
{
unsigned int m,n;
for(m=0;m<250;m++)
for(n+0;n<255;n++)
;
}
实验十八
#include<reg51.h>
sbit led1=P1^0;
sbit led2=P1^1;
void delayls();
void main()
{
EA=1;
IT0=1;
EX0=1;
TMOD=0x01;
TH0=0x3c;
TL0=0xb0;
TR0=1;
while(1)
{
led1=0;
delayls();
led1=1;
led2=0;
delayls();
led2=1;
}
}
void int0() interrupt 0
{
unsigned char saveled;
EA=0;
saveled=P1;
led1=1;
led2=0;
delayls();
delayls();
delayls();
delayls();
led2=1;
P1=saveled;
EA=1;
}
void delayls()
{
unsigned char i=0;
while(i!=20)
{
if(TF0==1)
{
i++;
TH0=0x3c;
TL0=0xb0;
TF0=0;
}
}
}
实验十八
#include<reg51.h>
sbit led1=P1^0;
sbit led2=P1^1;
void delayls();
void main()
{
EA=1;
IT0=1;
EX0=1;
TMOD=0x01;
TH0=0x3c;
TL0=0xb0;
TR0=1;
while(1)
{
P1_0=0;
delayls();
P1_0=1;
P1_1=0;
delayls();
P1_1=1;
}
}
void int0() interrupt 0
{
unsigned char saveled;
EA=0;
saveled=P1;
P1_0=1;
P1_1=0;
delayls();
delayls();
delayls();
delayls();
P1_1=1;
P1=saveled;
EA=1;
}
void delayls()
{
unsigned char i=0;
while(i!=20)
{
if(TF0==1)
{
i++;
TH0=0x3c;
TL0=0xb0;
TF0=0;
}
}
}
实验二十
(1)串口以工作方式1实现数据收发
#include <reg51.h>
#define uint unsigned int
#define uchar unsigned char
void delay(uint x)
{
uint y,z;
for(y=x;y>0;y--)
for(z=250;z>0;z--)
;
}
void timer1_int()
{
TMOD=0x20;
TL1=0xfd;
TH1=0xfd;
TR1=1;
}
void serial_int()
{
PCON=0;
SCON=0x40;
}
void main()
{
uchar send_data=0;
uchar i=0;
timer1_int();
serial_int();
IE=0x00;
while(1)
{
send_data='A';
for(i=0;i<26;i++)
{
SBUF=send_data;
while(TI==0)
;
TI=0;
send_data++;
delay(1000);
}
delay(6000);
}
}
（2）89c51点对点通讯
#include<reg51.h>
#define uint unsigned int
#define uchar unsigned char
sbit P2_0=P2^0;
sbit P2_1=P2^1;
uchar led[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
uchar num;
void delay(uchar x)
{
uchar y,z;
for(y=x;y>0;y--)
for(z=250;z>0;z++)
;
}
void display(uchar num)
{
P2_0=0;
P0=~led[num/10];
delay(5);
P2_0=1;
P2_1=0;
P0=~led[num%10];
delay(5);
P2_1=1;
}
void TAKE_SBUF(uchar dat)
{
ES=0;
SUBF=dat;
while(~TI)
;
TI=0;
ES=1;
}
void main()
{
SCON=0x90;
EA=1;
ES=1;
P2=0xff;
num=0;
TAKE_SUBF(num+1);
while(1)
;
}
void intorupt()interrupt 4
{
uchar num;
Uchar i;
RI=0;
num=SUBF;
if(num>99)
Num=0;
for(i=100;i>0;i--)
display(num);
TAKE_SBUF(num+1);
}
实验二十三
#include<reg51.h>
#define ZHK P0
#define ZLK P1
#define uchar unsigned char
#define uint unsigned int
uchar h1[]={0xf7,0xef};
uchar l1[]={0x18,0x18};
uchar h2[]={0xfb,0xf7,0xef,0xdf};
uchar l2[]={0x3c,0x24,0x24,0x3c};
uchar h3[]={0xfd,0xfb,0xf7,0xef,0xdf,0xbf};
uchar l3[]={0x7e,0x42,0x42,0x42,0x42,0x7e};
uchar h4[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
uchar l4[]={0xff,0x81,0x81,0x81,0x81,0x81,0x81,0xff};
void delay(uchar x)
{
uchar y,z;
for(y=x;y>0;y--)
for(z=250;z>0;z--)
;
}
void main()
{
uchar i;
while(1)
{
for(i=0;i<2;i++)
{
ZHK=h1[i];
ZLK=l1[i];
delay(5);
}
delay(100);
for(i=0;i<4;i++)
{
ZHK=h2[i];
ZLK=l2[i];
delay(5);
}
delay(100);
for(i=0;i<6;i++)
{
ZHK=h3[i];
ZLK=l3[i];
delay(5);
}
delay(100);
for(i=0;i<8;i++)
{
ZHK=h4[i];
ZLK=l4[i];
delay(5);
}
delay(100);
}
}
实验二十四
#include<reg51.h>
#define uint unsigned int
#define uchar unsigned char
sbit lcde=P1^0;
sbit lcdrs=P1^1;
uchar i;
uchar a1[]="Welcome to ";
uchar a2[]="an yuan";
void chushihua();
void write_c(uchar c);
void write_d(uchar d);
void delay(uint x);
void main()
{
chushihua();
write_c(0x80+0x00);
for(i=0;i<11;i++)
{
write_d(a1[i]);
delay(10);
}
write_c(0x80+0x41);
for(i=0;i<11;i++)
{
write_d(a2[i]);
delay(10);
}
for(i=0;i<3;i++)
{
write_c(0x18);
delay(10);
}
while(1)
;
}
void chushihua()
{
lcde=0;
write_c(0x38);
write_c(0x0f);
write_c(0x01);
write_c(0x06);
}
void write_c(uchar c)
{
lcdrs=0;
P2=c;
delay(2);
lcde=1;
delay(5);
lcde=0;
delay(2);
}
void write_d(uchar d)
{
lcdrs=1;
P2=d;
delay(2);
lcde=1;
delay(5);
lcde=0;
delay(2);
}
void delay(uint x)
{
uint i,j;
for(i=x;i>0;i--)
for(j=120;j>0;j--)
;
}
5. 网络安全学什么编程语言
网络安全学会学习C和C++、Python，编程语言。
1、C和C++
作为一种高级编程语言，Python越来越受到网络专家的欢迎。它之所以吸引人，主要是因为它代码的可读性、语法清晰和简单，以及大量库的可用性。因此，无论你想做什么任务，你都可以使用Python轻松完成任务。
例如，你可以使用该语言将TCP数据包发送到计算机，执行恶意软件分析，并创建入侵检测系统，而对第三方工具的依赖性最小。然而，与C/C++不同，Python并不是底层的；因此，它可能无法为提供足够硬件资源可见性。
6. 信息安全实验四图像信息隐藏c++代码
#include#include#includetypedef struct list{ struct list *next;int num; //学号 char name[30];//姓名int age; //年龄char sex; //性别 char addr[50];//地址 char mobile[11];//号码 int department; //寝室号}user; void insert(user *h);void edit(user *h);void del(user *h);void S_byName(user *h);void S_byNum(user *h);void display(user *h); int main(){ int flag; user *head=(user *)malloc(sizeof(user)); head->next=NULL; while(1) { printf(" 1、添加新用户信息\n"); printf(" 2、修改用户信息\n"); printf(" 3、删除已有用户信息\n"); printf(" 4、根据用户名查询信息\n"); printf(" 5、根据学号查询信息\n"); printf(" 6、显示全部用户信息\n");printf(" 7、清屏\n"); printf(" 8、退出\n"); printf("请选择："); scanf("%d",&flag); if(flag==1) insert(head); else if(flag==2) edit(head); else if(flag==3) del(head); else if(flag==4) S_byName(head); else if(flag==5) S_byNum(head); else if(flag==6) display(head);else if(flag==7)system("clear"); else if(flag==8) return 0; else printf("输入有误，请重新选择！\n"); }}void insert(user *h){ user *p=(user *)malloc(sizeof(user)); p->next=h->next; h->next=p;printf("请输入新增用户学号：");scanf("%d",&p->num); printf("请输入新增用户名称（最多30个字）："); scanf("%s",p->name);printf("请输入新增用户年龄：");scanf("%d",&p->age);printf("请输入新增用户性别：");scanf("%c",&p->sex); printf("请输入新增用户的家庭住址(最多50字)："); scanf("%s",p->addr); printf("请输入新增用户的电话号码（11位数）："); scanf("%s",p->mobile);printf("请输入新增用户寝室号：");scanf("%d",&p->department); printf("新用户记录成功添加：%d %s %d %c %s %s %d\n",p->num,p->name,p->age,p->sex, p->addr,p->mobile, p->department);}void edit(user *h){ int num; int flag=0; user *lh=h->next; printf("输入要修改用户的学号："); scanf("%d",&num); while(lh) { if(num == lh->num) { flag=1;printf("请输入新增用户学号：");scanf("%d",&lh->num);printf("请输入新增用户名称（最多30个字）：");scanf("%s",lh->name);printf("请输入新增用户年龄：");scanf("%d",&lh->age);printf("请输入新增用户性别：");scanf("%c",&lh->sex);printf("请输入新增用户的家庭住址(最多50字)：");scanf("%s",lh->addr);printf("请输入新增用户的电话号码（11位数）：");scanf("%s",lh->mobile);printf("请输入新增用户寝室号：");scanf("%d",&lh->department);printf("新用户记录成功添加：%d %s %d %c %s %s %d\n",lh->num,lh->name,lh->age,lh->sex, lh->addr,lh->mobile, lh->department); break; } lh=lh->next; } if(!flag) printf("不存在这样的用户\n\n");}void S_byName(user *h){ char name[30]; int flag=0; user *lh=h->next; printf("输入要查找的用户名称："); scanf("%s",name); while(lh) { if(strcmp(name,lh->name)==0) { flag=1; printf("用户信息为：%d %s %d %c %s %s %d\n",lh->num,lh->name,lh->age,lh->sex, lh->addr,lh->mobile, lh->department); break; } lh=lh->next; } if(!flag) printf("用户名不存在\n\n");}void S_byNum(user *h){ int num; int flag=0; user *lh=h->next; printf("输入要查找的学号："); scanf("%d",&num); while(lh) { if(num == lh->num) { flag=1; printf("用户信息:%d %s %d %c %s %s %d\n",lh->num,lh->name,lh->age,lh->sex, lh->addr,lh->mobile, lh->department); break; } lh=lh->next; } if(!flag) printf("找不到匹配的号码\n\n");}void display(user *h){ user *lh=h->next; int i=1; while(lh) { printf("第%d条用户信息:%d %s %d %c %s %s %d\n",i,lh->num,lh->name,lh->age,lh->sex, lh->addr,lh->mobile, lh->department); lh=lh->next; i++; } printf("\n");}void del(user *h){ int num; int flag=0; user *lh=h; printf("输入要删除的用户学号："); scanf("%d",&num); while(lh->next) { if(num == lh->next->num) { flag=1; printf("删除用户成功：%d %s %d %c %s %s %d\n",lh->num,lh->name,lh->age,lh->sex, lh->addr,lh->mobile, lh->department); lh->next=lh->next->next; break; } lh=lh->next; } if(!flag) printf("用户名不存在\n\n");}
7. 请问无线传感网络中，网络编码的仿真怎样用matlab实现求代码，最好是有详细说明的
pi*f*t)
所以，程序可以这样写：
f=1;
A=1;
t=0:0.1:10;
m=A*cos(2*pi*f*t)
说点题外话：
最近有会员在知道投诉吧里投诉我，说我没有给大家提供完整程序，不配做Matlab专家。
不知道大家是怎么看待的，我认为我告诉你使用哪一个函数，然后你去Matlab里进行尝试，通过自己的努力，解决问题。
这样你不就是可以学到很多知识么？
这是一个学习进步的过程，作为Matlab专家，我本人不会给大家提供完整的程序。
而且由于专家条例，我也不可以把程序的链接放在这里。
你在使用过程中，遇到问题，欢迎你把错误信息贴出来，我会尽量告诉你怎么修改。
8. 如何实现网络安全
如何实现网络安全
如何实现网络安全，现在是一个网络技术高度发展的时代，生活中越来越多人喜欢在网络上冲浪，以至于现在有很多网络诈骗，所网络的安全问题是需要人们去注意的，那么，人在网络如何实现网络安全，下面我整理了相关内容。
如何实现网络安全1
从世界来说，网络的根服务器掌握在美国，日本等少数几个国家之中，打利比亚的时候，美国就断了利比亚的根域名，利比亚有一段时间根本上不了国际 网。说到更近一点，美国的几大公司在抢购北电的6000多专利，其中有无线网络等和网络以及电脑有关的大量的专利。所以说，网络的很多游戏规则都在别人手 里。
从国家来说，网络安全分为三块。1、网络以及电脑的规则掌握（软硬件上），2、国家级的硬件系统，包括基础网络，各种防火墙和止血点，各种防御和 攻击设备。3、国家级的计算机人才系统，包括国家级的军队系统和藏兵于民的人才民兵系统，是的，网络如果有危险，在除去规则以外的斗争，最可怕的不仅仅是 国家级军队，而是这个国家的整体国民计算机技术的基础。虽然，2000年左右的中美黑客大战过去了很多年了，当是，面对无穷的人海和无孔不入的各种个性的 入侵方式，国家级的军队是远远不够的，计算机科学有些也是适合的是偏执者适合的是可能是英国最近抓的19岁天才少年和拒群病患者，这种人的实力在网络上可 能是一个正规网络部队也比不上的。
其实网络安全和计算机的基础安全是紧密联系，包括计算机的系统，手机系统，计算机的生产，硬盘等硬件的制造，这里面太多要注意了。网络安全是一个数学，电子科学，社会工程学，哲学，心理学，太空学等一系列的东西。
说以说要实现网络安全，要从小抓起，要从基础做起，要从对于网络安全的民间人才的有度的放松，做到内宽外紧，登高望远。
如何实现网络安全2
（一）、磁盘阵列（RAID）
目前服务器有硬RAID跟软RAID，硬R只有在硬件支持的情况下，均会设置到位，可以根据顾客需求对RAID类型进行设置（R1或者R5），从而到达加速读取与数据冗余，而软R是在硬件不支持的情况下出现，软R相对硬R性能方面会低一些，这里介绍下软R的原理，以RAID1为例（两块硬盘）：
RAID 1它的宗旨是最大限度的保证用户数据的可用性和可修复性。 RAID 1的操作方式是把用户写入硬盘的数据百分之百地自动复制到另外一个硬盘上。由于对存储的数据进行百分之百的.备份，在所有RAID级别中，RAID 1提供最高的数据安全保障。同样，由于数据的百分之百备份，备份数据占了总存储空间的一半
RAID1虽不能提高存储性能，但由于其具有的高数据安全性，使其尤其适用于存放重要数据，如服务器和数据库存储等领域。 如果即对大量数据需要存取，同时又对数据安全性要求严格那就需要应用到RAID 10或者RAID5，（需要3快以上硬盘。）
RAID 10是建立在RAID 0和RAID 1基础上，RAID 1在这里就是一个冗余的备份阵列，而RAID 0则负责数据的读写阵列。其实，图1只是一种RAID 10方式，更多的情况是从主通路分出两路（以4个硬盘时为例），做Striping操作，即把数据分割，而这分出来的每一路则再分两路，做Mirroring操作，即互做镜像。这就是RAID 10名字的来历（也因此被很多人称为RAID 0+1），而不是像RAID 5、3那样的全新等级
（二）、数据备份（增值服务）
1、手动备份
2、自动备份（代码编写一段自动计划， 在国内或者国外购买一个无限空间，每周增量备份一次。）
（三）、灾难恢复（硬盘损坏）
大家都知道，服务器许要长期长时间不间断的工作，硬盘是保存数据的部件，硬盘故障或者损坏会导致服务器无法运行，甚至数据无法恢复，对个人乃至企业带来无法估量的后果，如何恢复数据。
数据灾难恢复工具对损坏硬盘的修复，将数据深入将90%以上的数据提取出来。 同时还可对以被格式化的数据，甚至在格式化之后又重新写入的磁盘，均可恢复源数据。
如何实现网络安全3
随着信息技术的发展，数据的价值变得越来越高，网络安全的重要性也不断得到提升。
对于很多企业来说，成立专业的系统或者网络安全部门变得越来越必要。
要做好安全管理，最重要的一个原则就是权限最小化原则，不论对于网络还是系统。
从网络接入的角度考虑，默认应该是全部拒绝访问，根据白名单需求开通。
而且开通应该尽量遵循允许最少的源地址访问，开通最少的可访问端口。
从系统的角度来说，不同的人员，不同的需求，应该申请使用不同的账号，做好隔离。
每个账号的权限，应该遵循最小化的原则，不是必须要使用的，不应该开放。
要意识到，安全与方便之间，通常存在冲突，而且可能消耗更多的成本或资源。
9. 巢湖学院代码是多少
代码是10380。巢湖学院（Chaohu University），位于安徽省合肥市，是一所安徽省属全日制普通本科院校、地方性应用型本科院校。
学院介绍
巢湖学院前身是1977年秋创建的安徽师范大学巢湖专科班；1983年2月经国务院批准，正式设立巢湖师范专科学校；2002年4月经教育部批准，升格为本科院校，并更名巢湖学院。2019年，学校正式成为安徽省省级硕士立项建设单位。
截至2021年6月，学校占地面积1324.5亩，总建筑面积39.5万平方米，图书文献资源总量359.79万册，其中纸质文献116.52万余册；设有13个二级学院，58个本科专业；有教职工952人，全日制在校生17019人。
合作交流
截至2018年9月，学校以安徽省应用型本科高校“行知联盟”为依托，进行校际合作，实现学分互认和资源共享；在国际交流合作方面，与韩国、美国、爱尔兰等国家及台湾地区15个院校建立合作关系，与韩国韩瑞大学开展视觉传达设计本科教育“2+2”合作项目，与爱尔兰阿斯隆理工学院开展酒店管理本科教育“3+1”合作项目。学校与科大讯飞、惠而浦（中国）、安徽富煌、皖维集团、安徽华星化工、巢湖市人民法院等100多家企事业单位保持合作关系。
文化传统
校名标识为赵朴初书体“巢湖学院”。
校徽为同心双环内嵌中英文校名、建校时间以及由英文字母C与H构成的扬帆船只图案的圆形徽标。
10. 四川信息职业技术学院代码是多少
四川信息职业技术学院代码是13815。学院始建于1976年，时称广元无线电技工学校，1994年成立四川省电子工业学校，2004年成立四川信息职业技术学院，2009年11月通过人才培养工作评估。
科研机构
根据2020年2月学校官网显示，学院牵头成立了四川电子信息行业职教联盟、广元职业教育集团、广元市职业教育研究中心；建成了教育部-中兴通讯ICT行业创新基地、四川移动应用协同创新中心、广元院士（专家）工作站、广元云计算大数据工程研发中心。
科研成果
根据2020年2月学校官网显示，学院取得应用科研项目100余项，市级科研项目150项，国家授权专利296项。公开发表论文2193篇，其中核心期刊586篇。
馆藏资源
截至2018年12月，学院图书馆馆舍面积1.47万平方米，馆藏纸质图书62.3万册，电子图书14.1万册，折合7168GB。2019学年新增2.2万册，中文纸质专业期刊771种。
对外交流
根据2020年2月学校官网显示，学院构建以“工学结合、校企合作”为基础的人才培养模式，先后与联想、华为、中兴、惠普、谷歌、西门子等企业开展校企合作，建成联想、中兴等企业学院，组建了数十个定向培养班。
科研机构
根据2020年2月学校官网显示，学院牵头成立了四川电子信息行业职教联盟、广元职业教育集团、广元市职业教育研究中心；建成了教育部-中兴通讯ICT行业创新基地、四川移动应用协同创新中心、广元院士（专家）工作站、广元云计算大数据工程研发中心。