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行業創新基地、四川移動應用協同創新中心、廣元院士（專家）工作站、廣元雲計算大數據工程研發中心。