密码学课程设计信安101.docx
《密码学课程设计信安101.docx》由会员分享，可在线阅读，更多相关《密码学课程设计信安101.docx（24页珍藏版）》请在冰豆网上搜索。
密码学课程设计信安101
密
码
学
课
程
设
计
指导老师:
谢林
班级:
信息安全10-1
目录
实验一MD5散列函数的实现…………………………………………3
1.1算法概述……………………………………………………………6
1.2算法设计思路………………………………………………………6
1.3实现算法分析………………………………………………………6
1.4运行结果……………………………………………………………11
1.5密码安全性分析……………………………………………………11
实验二分组密码AES加密解密………………………………………11
2.1算法概述……………………………………………………………11
2.2算法设计思路………………………………………………………12
2.3实现算法分析……………………………………………………13
2.4运行结果……………………………………………………………14
2.5密码安全性分析…………………………………………………15
实验三RSA加密算法的实现…………………………………………15
3.1算法概述……………………………………………………………15
3.2算法设计思路………………………………………………………15
3.3实现算法析………………………………………………………16
3.4运行结果……………………………………………………………19
3.5密码安全性分析………………………………………………19
实验体会及收获……………………………………………………….19
实验一MD5散列函数的实现
1.1算法概述
MD表示消息摘要，对输入的任意长度消息，算法产生128位的散列值（或消息摘要）。
MD5为计算机领域广泛使用的一种散列函数，用以提供消息的完整性保护。
1.2算法设计思路
MD5散列函数的处理过程分为如下几步：
（1）消息填充：
对原始消息填充，使得其比特长在模512下余448，即填充后消息的长度为512的某一倍数减64.这一步是必需的，即使原始消息的长度已经满足要求，仍需要填充。
例如：
消息的长度正好为448bit，则需要填充512bit，使其长度为960bit，因此填充的比特数在1到512之间。
填充方式是固定的：
第一位为1，其他位为0，例如需要填充100bit，则填充一个1和后面附上99个0。
（2）添加消息长度：
在第一步填充后，留有64个bit位，这64bit用来填充消息被填充前的长度。
如果消息长度大于264，则以264取模。
前两步完成以后，消息的长度为512的倍数（设倍数为L）。
可将消息表示成分组长为512的一系列分组Y0，Y1，…Yl-1。
每一个512bit分组是16个（32bit）字，因此消息中的总字数为N=16L。
（3）初始化MD缓冲区：
MD5算法使用128bit长的缓冲区以存储中间结果和最终Hash值。
缓冲区可表示为4个32位长的寄存器（A，B，C，D），将存储器初始化为以下的32位整数：
A=67452301、B=EFCDAB、C=98BADCFE、D=10325476.每个寄存器都以little-endian方式存储数据，也就是最低有效字节存储在低位地址字节位置，4个寄存器按如下存储：
A=01234567，B=89ABCDEF，C=FEDCBA98,D=7654321
（4）以分组为单位进行消息处理：
每个分组Ya都经过一个压缩函数HMD5处理，包括4轮处理过程，MD5算法是一种迭代型Hash函数，压缩函数HMD5是算法的核心。
压缩函数按如下方式工作：
a.四个轮运算的结构相同，但各轮使用不同的基本逻辑函数，我们分别称之为F、G、H和I；
b.每轮的输入时当前要处理的512位的分组Yq和128位缓冲区的当前值A、B、C、D的内容，输出仍然放在缓冲区中产生新的A、B、C、D；
c.每轮的处理过程还需要使用常数表T中元素的1/4.第4轮的输出再与第1轮的输入CVq相加，相加时将CVq看作4个32bit的字，每个字与第4轮输出的对应的字按模232相加，相加的结果就是本轮压缩函数的输出。
Hmd5压缩函数要用到常数表T，该表有64个元素。
该表通过正弦函数构建的，这个表提供了一个随机化的32bit模式集，它将消除输入数据的任何规律性。
（5）输出：
消息的所有L个分组被处理完以后，最后一个HMD5的输出即为产生的消息摘要（Hash值）。
下面我们具体描述一下MD5的压缩函数：
压缩函数中有四轮处理过程，每轮对缓冲区A,B,C,D进行16步迭代运算，单步操作如图所示：
MD5压缩函数要经过四轮处理，每轮又包括16步，且每轮以不同次序使用16个字。
其中第一轮以字的初始次序使用，第二轮到第四轮分别对字的次序i做置换后得到一个新次序，然后以新次序使用16个字。
三个置换分别为;
四轮处理过程中分别使用基本的逻辑函数,F,G,H,I.每个逻辑函数的输入为3个32bit的字，输出是一个32bit的字，其中的运算为逐比特的逻辑运算。
四轮处理过程中，每一轮的16步都是一个循环左移，移动的位数用S表示。
1.3算法分析
MD5加密算法java实现（PS:
因为最近刚接触学习JAVA所以第一个加密是由java语言实现的）
public class MD5 {
/* 下面这些S11-S44实际上是一个4*4的矩阵，在原始的C实现中是用#define 实现的，
这里把它们实现成为static final是表示了只读，切能在同一个进程空间内的多个
Instance间共享,简言之其实就是上述的位移表*/
static final int S11 = 7;
static final int S12 = 12;
static final int S13 = 17;
static final int S14 = 22;
static final int S21 = 5;
static final int S22 = 9;
static final int S23 = 14;
static final int S24 = 20;
static final int S31 = 4;
static final int S32 = 11;
static final int S33 = 16;
static final int S34 = 23;
static final int S41 = 6;
static final int S42 = 10;
static final int S43 = 15;
static final int S44 = 21;
/* 下面的三个成员是MD5计算过程中用到的3个核心数据，在原始的C实现中
被定义到MD5_CTX结构中
*/
private long[] state = new long[4]; // state （ABCD）
private long[] count = new long[2]; // number of bits, modulo 2^64 （lsb first）
private byte[] buffer = new byte[64]; // input buffer
/* digestHexStr是MD5的唯一一个公共成员，是最新一次计算结果的
16进制ASCII表示.
public String digestHexStr;
/* digest,是最新一次计算结果的2进制内部表示，表示128bit的MD5值.
private byte[] digest = new byte[16];
getMD5ofStr是类MD5最主要的公共方法，入口参数是你想要进行MD5变换的字符串
返回的是变换完的结果，这个结果是从公共成员digestHexStr取得的,每轮要经过16步．
*/
public String getMD5ofStr（String inbuf） {
md5Init（）;
md5Update（inbuf.getBytes（）, inbuf.length（））;
md5Final（）;
digestHexStr = "";
for （int i = 0; i < 16; i++） {
digestHexStr += byteHEX（digest[i]）;
}
return digestHexStr;
}
// 这是MD5这个类的标准构造函数，JavaBean要求有一个public的并且没有参数的构造函数
public MD5（） {
md5Init（）;
return;
}
/* md5Init是一个初始化函数，初始化核心变量，装入标准的幻数 */
private void md5Init（） {
count[0] = 0L;
count[1] = 0L;
///* Load magic initialization constants.
state[0] = 0x67452301L;
state[1] = 0xefcdab89L;
state[2] = 0x98badcfeL;
state[3] = 0x10325476L;
return;
}
/* F, G, H ,I 是4个基本的MD5函数，在原始的MD5的C实现中，由于它们是
简单的位运算，可能出于效率的考虑把它们实现成了宏，在java中，我们把它们
实现成了private方法，名字保持了原来C中的。
*/
private long F（long x, long y, long z） {
return （x & y） | （（~x） & z）;
}
private long G（long x, long y, long z） {
return （x & z） | （y & （~z））;
}
private long H（long x, long y, long z） {
return x ^ y ^ z;
}
private long I（long x, long y, long z） {
return y ^ （x | （~z））;
}
/*
FF,GG,HH和II将调用F,G,H,I进行近一步变换
FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
Rotation is separate from addition to prevent recomputation.
*/
private long FF（long a, long b, long c, long d, long x, long s,
long ac） {
a += F （b, c, d） + x + ac;
a = （（int） a << s） | （（int） a >>> （32 - s））;
a += b;
return a;
}
private long GG（long a, long b, long c, long d, long x, long s,
long ac） {
a += G （b, c, d） + x + ac;
a = （（int） a << s） | （（int） a >>> （32 - s））;
a += b;
return a;
}
private long HH（long a, long b, long c, long d, long x, long s,
long ac） {
a += H （b, c, d） + x + ac;
a = （（int） a << s） | （（int） a >>> （32 - s））;
a += b;
return a;
}
private long II（long a, long b, long c, long d, long x, long s,
long ac） {
a += I （b, c, d） + x + ac;
a = （（int） a << s） | （（int） a >>> （32 - s））;
a += b;
return a;
}
/* md5Transform是MD5核心变换程序，这是MAD5压缩函数要经过的四轮处理，每一轮又包含了16步迭代。
*/
private void md5Transform （byte block[]） {
long a = state[0], b = state[1], c = state[2], d = state[3];
long[] x = new long[16];
Decode （x, block, 64）;
/* Round 1 */
a = FF （a, b, c, d, x[0], S11, 0xd76aa478L）; /* 1 */
d = FF （d, a, b, c, x[1], S12, 0xe8c7b756L）; /* 2 */
c = FF （c, d, a, b, x[2], S13, 0x242070dbL）; /* 3 */
b = FF （b, c, d, a, x[3], S14, 0xc1bdceeeL）; /* 4 */
a = FF （a, b, c, d, x[4], S11, 0xf57c0fafL）; /* 5 */
d = FF （d, a, b, c, x[5], S12, 0x4787c62aL）; /* 6 */
c = FF （c, d, a, b, x[6], S13, 0xa8304613L）; /* 7 */
b = FF （b, c, d, a, x[7], S14, 0xfd469501L）; /* 8 */
a = FF （a, b, c, d, x[8], S11, 0x698098d8L）; /* 9 */
d = FF （d, a, b, c, x[9], S12, 0x8b44f7afL）; /* 10 */
c = FF （c, d, a, b, x[10], S13, 0xffff5bb1L）; /* 11 */
b = FF （b, c, d, a, x[11], S14, 0x895cd7beL）; /* 12 */
a = FF （a, b, c, d, x[12], S11, 0x6b901122L）; /* 13 */
d = FF （d, a, b, c, x[13], S12, 0xfd987193L）; /* 14 */
c = FF （c, d, a, b, x[14], S13, 0xa679438eL）; /* 15 */
b = FF （b, c, d, a, x[15], S14, 0x49b40821L）; /* 16 */
/* Round 2 */
a = GG （a, b, c, d, x[1], S21, 0xf61e2562L）; /* 17 */
d = GG （d, a, b, c, x[6], S22, 0xc040b340L）; /* 18 */
c = GG （c, d, a, b, x[11], S23, 0x265e5a51L）; /* 19 */
b = GG （b, c, d, a, x[0], S24, 0xe9b6c7aaL）; /* 20 */
a = GG （a, b, c, d, x[5], S21, 0xd62f105dL）; /* 21 */
d = GG （d, a, b, c, x[10], S22, 0x2441453L）; /* 22 */
c = GG （c, d, a, b, x[15], S23, 0xd8a1e681L）; /* 23 */
b = GG （b, c, d, a, x[4], S24, 0xe7d3fbc8L）; /* 24 */
a = GG （a, b, c, d, x[9], S21, 0x21e1cde6L）; /* 25 */
d = GG （d, a, b, c, x[14], S22, 0xc33707d6L）; /* 26 */
c = GG （c, d, a, b, x[3], S23, 0xf4d50d87L）; /* 27 */
b = GG （b, c, d, a, x[8], S24, 0x455a14edL）; /* 28 */
a = GG （a, b, c, d, x[13], S21, 0xa9e3e905L）; /* 29 */
d = GG （d, a, b, c, x[2], S22, 0xfcefa3f8L）; /* 30 */
c = GG （c, d, a, b, x[7], S23, 0x676f02d9L）; /* 31 */
b = GG （b, c, d, a, x[12], S24, 0x8d2a4c8aL）; /* 32 */
/* Round 3 */
a = HH （a, b, c, d, x[5], S31, 0xfffa3942L）; /* 33 */
d = HH （d, a, b, c, x[8], S32, 0x8771f681L）; /* 34 */
c = HH （c, d, a, b, x[11], S33, 0x6d9d6122L）; /* 35 */
b = HH （b, c, d, a, x[14], S34, 0xfde5380cL）; /* 36 */
a = HH （a, b, c, d, x[1], S31, 0xa4beea44L）; /* 37 */
d = HH （d, a, b, c, x[4], S32, 0x4bdecfa9L）; /* 38 */
c = HH （c, d, a, b, x[7], S33, 0xf6bb4b60L）; /* 39 */
b = HH （b, c, d, a, x[10], S34, 0xbebfbc70L）; /* 40 */
a = HH （a, b, c, d, x[13], S31, 0x289b7ec6L）; /* 41 */
d = HH （d, a, b, c, x[0], S32, 0xeaa127faL）; /* 42 */
c = HH （c, d, a, b, x[3], S33, 0xd4ef3085L）; /* 43 */
b = HH （b, c, d, a, x[6], S34, 0x4881d
升级会员 