信息安全基础实习报告Word文件下载.docx
《信息安全基础实习报告Word文件下载.docx》由会员分享，可在线阅读，更多相关《信息安全基础实习报告Word文件下载.docx（24页珍藏版）》请在冰豆网上搜索。
k个检验元，组成长为n的序列：
，称这个序列为码字。
在二进制情况下，信息组总共有k2个
，因此通过编码器后，相应的码字也有k2个，称这k2个码字集合为（
k）
分组码。
n长序列的可能排列总共有n2种。
称被选取的k2个
n重为许用码组，其余kn22个为禁用码组，称R
k
/
n为码率。
那么对于（7，3）码即为用7位长的序列表示3位信息码，7位长序列的可能排列总共有128个。
许用码组有8个，其余128-8=120个禁用码组，码率为R=3/7=42.86%。
对于长度为n的二进制分组码，可以表示成（n，k），通常用于前向纠错。
在分组码中，监督位加到信息位之后，形成新码，在编码中，k个信息位，被编为n位长度，（n-k）个监督码的作用是实现检错和纠错。
⏹编码原理
（1）根据给定的生成矩阵G，求得监督码与信息码之间呈线性关系即编码方程。
（2）输入信息码，代入上述编码方程中，得到各监督码。
（3）监督码附带在信息码之后，一起输出，即得到编码结果。
已知线性分组码的生成矩阵
1001110
G=0100111
0011101
因为
[C6C5C4]G=[C6C5C4C3C2C1C0]即
1001110
[C6C5C4]0100111=[C6C5C4C3C2C1C0]
所以由上式可以得到编码方程组
C6=C6
C5=C5
C4=C4
=
+
表1信息码、监督码、许用码对照表
信息组
监督码
码字
000
0000
0000000
001
1101
0011101
010
0111
0100111
011
1010
0111010
100
1110
1001110
101
0011
1010011
110
1001
1101001
111
0100
1110100
⏹译码原理
（1）根据生成矩阵计算出监督矩阵H，由H计算出伴随式S。
（2）如果S=[0,0,0,0]，R1无错。
（3）如果S与H的转置矩阵的某一行相等，则有一个错误，找到相应的错误图样E，则正确的接收到的码字R2=R1+E（二进制异或）。
（4）译出的码为R2的前3位。
（5）如果S不等于H转置的任意一行，则有两个或多个错误，不能得到正确的译码结果。
G=[IkP]（3）
其中Ik是k阶单位矩阵，这里k=3
1110
G=0111（4）
1101
监督矩阵H=[QIr]（5）
1000
0100
Ir=0010（6）
0001
P=QT（7）
所以由（4）得
101
111
Q=110（8）
011
因此由（5）（6）（8）得监督矩阵
1011000
1110100
Q=1100010（9）
0110001
4.算法实现
4.1图片处理
⏹定义结构体
//位图文件头定义;
//其中不包含文件类型信息（由于结构体的内存结构决定，
//要是加了的话将不能正确读取文件信息）
typedefstructtagBITMAPFILEHEADER
{
//WORDbfType;
//文件类型，必须是0x424D，即字符“BM”
DWORDbfSize;
//文件大小
WORDbfReserved1;
//保留字
WORDbfReserved2;
DWORDbfOffBits;
//从文件头到实际位图数据的偏移字节数
}BITMAPFILEHEADER;
typedefstructtagBITMAPINFOHEADER
DWORDbiSize;
//信息头大小
LONGbiWidth;
//图像宽度
LONGbiHeight;
//图像高度
WORDbiPlanes;
//位平面数，必须为1
WORDbiBitCount;
//每像素位数
DWORDbiCompression;
//压缩类型
DWORDbiSizeImage;
//压缩图像大小字节数
LONGbiXPelsPerMeter;
//水平分辨率
LONGbiYPelsPerMeter;
//垂直分辨率
DWORDbiClrUsed;
//位图实际用到的色彩数
DWORDbiClrImportant;
//本位图中重要的色彩数
}BITMAPINFOHEADER;
//位图信息头定义
typedefstructtagRGBQUAD
BYTErgbBlue;
//该颜色的蓝色分量
BYTErgbGreen;
//该颜色的绿色分量
BYTErgbRed;
//该颜色的红色分量
BYTErgbReserved;
//保留值
}RGBQUAD;
//调色板定义
typedefstructtagIMAGEDATA//像素信息
BYTEblue;
//BYTEgreen;
//BYTEred;
}IMAGEDATA;
⏹像素保存
boolBMP:
:
readOfBMP（）
cout<
<
"
\t正在读取原文件信息,请稍后...\n"
<
endl;
FILE*fpi;
fpi=fopen（"
G:
\\学习资料\\信息安全基础实习\\ConsoleApplication1\\ConsoleApplication1\\test1.BMP"
"
rb"
）;
if（fpi==NULL）
{
cout<
\t无法打开文件1!
\n"
returnfalse;
}
//判断是否是bmp格式文件
WORDbfType;
fread（&
bfType,1,sizeof（WORD）,fpi）;
if（bfType!
=0x4d42）
\t不是bmp格式的图片!
//读取bmp文件的文件头和信息头
strHead,1,sizeof（tagBITMAPFILEHEADER）,fpi）;
strInfo,1,sizeof（tagBITMAPINFOHEADER）,fpi）;
//读取调色板
for（unsignedintnCounti=0;
nCounti<
strInfo.biClrUsed;
nCounti++）
fread（（char*）&
（strPla[nCounti].rgbBlue）,1,sizeof（BYTE）,fpi）;
（strPla[nCounti].rgbGreen）,1,sizeof（BYTE）,fpi）;
（strPla[nCounti].rgbRed）,1,sizeof（BYTE）,fpi）;
（strPla[nCounti].rgbReserved）,1,sizeof（BYTE）,fpi）;
strInfo.biWidth=（strInfo.biWidth*sizeof（IMAGEDATA）+3）/4*4;
longwidth=strInfo.biWidth;
longheight=strInfo.biHeight;
//width=（width*sizeof（IMAGEDATA）+3）/4*4;
//申请并初始化存储像素
imageDataPtr=newIMAGEDATA[width*height];
for（inti=0;
i<
height;
++i）
for（intj=0;
j<
width;
++j）
{
（*（imageDataPtr+i*width+j））.blue=0;
//（*（imageDataPtr+i*width+j））.green=0;
//（*（imageDataPtr+i*width+j））.red=0;
}
fread（imageDataPtr,sizeof（structtagIMAGEDATA）*width,height,fpi）;
fclose（fpi）;
\t原文件读取完毕!
returntrue;
}
4.2Huffman解压缩
⏹Huffman树构造
构造哈夫曼树非常简单，将所有的节点放到一个队列中，用一个节点替换两个频率最低的节点，新节点的频率就是这两个节点的频率之和。
这样，新节点就是两个被替换节点的父节点了。
如此循环，直到队列中只剩一个节点（树根）。
voidHaffman（intweight[],HaffNodehaffTree[]）
inti,j,m1,m2,x1,x2;
for（i=0;
i<
2*MaxN-1;
i++）
if（i<
MaxN）
haffTree[i].letter=（char）i;
haffTree[i].weight=weight[i];
haffTree[i].flag=0;
haffTree[i].parent=-1;
haffTree[i].leftChild=-1;
haffTree[i].rightChild=-1;
MaxN-1;
m1=m2=MaxValue;
x1=x2=0;
for（j=0;
j<
MaxN+i;
j++）
if（haffTree[j].weight<
m1&
&
haffTree[j].flag==0）
{
m2=m1;
x2=x1;
m1=haffTree[j].weight;
x1=j;
}
elseif（haffTree[j].weight<
m2&
m2=haffTree[j].weight;
x2=j;
haffTree[x1].parent=MaxN+i;
haffTree[x2].parent=MaxN+i;
haffTree[x1].flag=1;
haffTree[x2].flag=1;
haffTree[MaxN+i].weight=haffTree[x1].weight+haffTree[x2].weight;
haffTree[MaxN+i].leftChild=x1;
haffTree[MaxN+i].rightChild=x2;
⏹Huffman编码
解压缩比构造哈夫曼树要简单的多，将输入缓冲区中的每个编码用对应的ASCII码逐个替换就可以了。
只要记住，这里的输入缓冲区是一个包含每个ASCII值的编码的位流。
因此，为了用ASCII值替换编码，我们必须用位流搜索哈夫曼树，直到发现一个叶节点，然后将它的ASCII值添加到输出缓冲区中：
voidHaffmanEncode（HaffNodehaffTree[],charcode[MaxN][MaxN]）//编码结果保存在2.txt文档中
charhcode[MaxN];
intstart,i,child,parent;
MaxN;
start=MaxN-1;
hcode[--start]='
\0'
;
child=i;
parent=haffTree[child].parent;
while（parent!
=-1）
if（haffTree[parent].leftChild==child）
hcode[--start]='
0'
elsehcode[--start]='
1'
child=parent;
parent=haffTree[child].parent;
strcpy（code[i],&
hcode[start]）;
⏹Huffman译码
voidHaffmanDecode（HaffNodehaffTree[]）//译码结果保存在5.txt文档中
FILE*fp1,*fp2;
inti=2*MaxN-2;
charc;
if（（fp1=fopen（"
\\学习资料\\信息安全基础实习\\ConsoleApplication1\\ConsoleApplication1\\2.txt"
））==NULL）
printf（"
CannotOpenTheFile!
exit
（1）;
if（（fp2=fopen（"
\\学习资料\\信息安全基础实习\\ConsoleApplication1\\ConsoleApplication1\\4.txt"
wb"
fscanf（fp1,"
%c"
&
c）;
do
if（c=='
）i=haffTree[i].leftChild;
elsei=haffTree[i].rightChild;
if（haffTree[i].leftChild==-1）
fputc（haffTree[i].letter,fp2）;
i=2*MaxN-2;
fscanf（fp1,"
}while（c!
='
@'
fclose（fp1）;
fclose（fp2）;
4.3线性分组码
⏹线性分组码编码
voidEncode（）
intc1[3],c2[7];
stringstr,b1;
inti=0;
FILE*fp2,*fp3;
r"
无法打开文件！
"
if（（fp3=fopen（"
3.txt"
w"
while（!
feof（fp2））
fscanf（fp2,"
str）;
//将2.txt中二进制流写入str中
str[i]='
intnum=i;
num--;
num;
b1[i]=str[i];
if（i%3==0）
c1[0]=str[i]-'
elseif（i%3==1）
c1[1]=str[i]-'
elseif（i%3==2）
c1[2]=str[i]-'
if（（i+1）%3==0）
c2[0]=c1[0];
c2[1]=c1[1];
c2[2]=c1[2];
c2[3]=c1[0]+c1[2];
c2[4]=c1[0]+c1[1]+c1[2];
c2[5]=c1[0]+c1[1];
c2[6]=c1[1]+c1[2];
for（intj=0;
7;
if（c2[j]==2）
c2[j]=0;
elseif（c2[j]==3）
c2[j]=1;
fprintf（fp3,"
%d"
c2[j]）;
//将线性分组码编码结果放在3.txt中
fclose（fp3）;
⏹线性分组码译码
voidDecoding（）
{
intG[3][7]={{1,0,0,1,1,1,0},{0,1,0,0,1,1,1},{0,0,1,1,1,0,1}};
intP[3][4],Q[4][3],HT[7][3],R2[7],C[3];
intR1[7];
intH[4][7]={0},S[4]={0},E[7]={0};
inti,j,n,k,t=0,w;
FILE*fp1,*fp2;
stringstr;
intnum;
i=0;
if（（fp1=fopen（"
6.txt"
"
））==NULL）
{
printf（"
exit
（1）;
}
if（（fp2=fopen（"
））==NULL）//将线性分组码的译码结果存入4.txt中
while（!
feof（fp1））
fscanf（fp1,"
&
str[i++]）;
num=i;
//printf（"
num=%d"
num）;
for（i=0;
i<
3;
i++）
for（j=3;
j<
7;
j++）
P[i][j-3]=G[i][j];
for（j=0;
4;
Q[j][i]=P[i][j];
H[i][j]=Q[i][j];
j=3;
H[i][i+j]=1;
HT[j][i]=H[i][j];
for（w=0;
w<
num;
w++）
if（w%7==0）
R1[0]=str[w]-'
elseif（w%7==1）
R1[1]=str[w]-'
elseif（w%7==2）
R1[2]=str[w]-'
elseif（w%7==3）
R1[3]=str[w]-'
elseif（w%7==4）
R1[4]=str[w]-'
elseif（w%7==5）
R1[5]=str[w]-'
elseif（w%7==6）
R1[6]=str[w]-'
intS[4]={0};
intE[7]={0};
t=0;
if（（w+1）%7==0）
{
for（i=0;
for（j=0;
S[i]=S[i]+R
升级会员 