哈尔滨工业大学(威海)__密码学应用与实践课程报告

1、Harbin Institute of Technology at Weihai密码学应用与实践课程报告专 业： 计算机科学与技术 班 级： 1004101 学 号： 100410129 姓 名： 刘杨 题目1.密码算法原理SHA-1是一种数据加密算法，该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。单向散列函数的安全性在于其产生散列值的操作过程具有较强的单向性。如果在输入序列中嵌入密码，那么任何人在不知道密码的情况下都

2、不能产生正确的散列值，从而保证了其安全性。SHA将输入流按照每块512位（64个字节）进行分块，并产生20个字节的被称为信息认证代码或信息摘要的输出。该算法输入报文的长度不限，产生的输出是一个160位的报文摘要。输入是按512 位的分组进行处理的。SHA-1是不可逆的、防冲突，并具有良好的雪崩效应。通过散列算法可实现数字签名实现，数字签名的原理是将要传送的明文通过一种函数运算（Hash）转换成报文摘要（不同的明文对应不同的报文摘要），报文摘要加密后与明文一起传送给接受方，接受方将接受的明文产生新的报文摘要与发送方的发来报文摘要解密比较，比较结果一致表示明文未被改动，如果不一致表示明文已被篡改。

3、MAC （信息认证代码）就是一个散列结果，其中部分输入信息是密码，只有知道这个密码的参与者才能再次计算和验证MAC码的合法性。SHA-1与MD5的比较因为二者均由MD4导出，SHA-1和MD5彼此很相似。相应的，他们的强度和其他特性也是相似，但还有以下几点不同：l 对强行攻击的安全性：最显著和最重要的区别是SHA-1摘要比MD5摘要长32 位。使用强行技术，产生任何一个报文使其摘要等于给定报摘要的难度对MD5是2128数量级的操作，而对SHA-1则是2160数量级的操作。这样，SHA-1对强行攻击有更大的强度。l 对密码分析的安全性：由于MD5的设计，易受密码分析的攻击，SHA-1显得不易受这

4、样的攻击。l 速度：在相同的硬件上，SHA-1的运行速度比MD5慢。原理参考：2.设计思想基本设计思想：分而治之所谓“分而治之”，即是把一个复杂的问题简单化为多个核心部件，首先加工各个独立部件，而后在统一合成，得到想要的结果。具体到本次设计而言，大致可把本次设计分为以下几个部分：输入处理：包括采用何种输入方式，是“运行后输入”，还是“运行前预先规定”；在这里，经过本人认真思考与仔细权衡，终于决定使用“运行前预先规定”，这是由于对于一个“加密算法验证程序”来说，最重要的不是“灵活界面输入性”，而是准确性，只要得到正确的结果，就是合格的验证程序，就是好的；而算错了结果，只追求“灵活的界面输入”，既

5、违背了加密程序的后台运行本质，有可能引发不必要的错误；因而必当选择“运行前预先规定”，同时，补充预先知道的正确结果进行对照，用以判断程序性能。数据处理过程：这是SHA-1加密算法的核心，它涉及了整个完整的SHA-1加密算法，是SHA-1加密算法的本质体现，也是所有不同SHA-1加密算法的交汇处。输出处理：这是人机交互的部分，设置一下问题：输出是否符合人类普遍的认知，如果不符合，这样的软件，将给其他人带来阅读以及理解上的不便；为此，输出逻辑则显得很重要，所以本人特别优化了输出的逻辑，多次调整输出行间距，最终找到合适输出方法。输出能否直接反映出加密算法的正确与否，所以本人特别输出了“预先已知的正确

6、结果”，方便校验与调试。输出反映了版权，如果不在输出方面强调版权，将容易被其他人盗版，为此，本人特别在输出结果的上下各加了“版权所有者信息”，用以确保版权安全。函数调用：（1）函数如何调用，影响这函数的执行效率 以及 执行的结果正确与否；为此关于调用顺序，本人修改多次。（2）函数的优化，优化可以减掉冗余函数，加快效率。5. 错误处理机制：主要使用以避免程序崩溃，并方便调试 以及 用户判断程序故障来用。流程图功能实现1. 跨文件调用技术：程序虽然不复杂，但由于需要多个文件相互支持，所以跨文件调用的功能就是最起码应当实现的功能2. 输出控制：将一连串难以比较的字符，分割成易于识别的字符组。3. 错

7、误校验：（1）输入不合要求以及违规，提示“无法应对，请检查输入是否有误”；（2）无法完成处理过程，提示“无法应对，处理发生异常”；（3）重置过程无法完成，提示“无法完成重置”。4. SHA-1加密算法的实现：（1）散列算法散列是信息的提炼，通常其长度要比信息小得多，且为一个固定长度。加密性强的散列一定是不可逆的，这就意味着通过散列结果，无法推出任何部分的原始信息。任何输入信息的变化，哪怕仅一位，都将导致散列结果的明显变化，这称之为雪崩效应。散列还应该是防冲突的，即找不出具有相同散列结果的两条信息。具有这些特性的散列结果就可以用于验证信息是否被修改。散列算法，是SHA-1的重要构成部分。（2）1

8、6进制转换的输出：SHA1始终把消息当成一个位（bit）字符串来处理。本文中，一个字（Word）是32位，而一个字节（Byte）是8位。也为的是输出字母组合，方便观测。版权限制:为了防止版权被盗用，将版权镶嵌在输出中。5.总结遇到的问题1：无法判断加密的正确性。解决方案1： 先加密得到正确的结果，不仅输出加密结果，还输出预先准备好的正确结果，比较即可。遇到的问题2：重置时出现终止框。解决方案2：增加错误处理机制，杜绝程序崩溃。遇到问题3：当测试 长用例（比方说“100000000个a”） 时，输入不便。解决方案3：增加重复次数数组，专门存储重复次数，即是说“100000000个a” = “a”

9、 * “次数100000000”，顺利解决。遇到的问题4：数据紧密输出，看不清，眼花。解决方案4：以2为单位，分割数据，做到两两输出。6.源代码Sha1.h*#ifndef _SHA1_H_#define _SHA1_H_#include TypeRedef.h#ifndef _SHA_enum_#define _SHA_enum_enum shaSuccess = 0, shaNull, /* 空指示参量 */ shaInputTooLong, /* 输入数据太长提示 */ shaStateError /* called Input after Result -以输入结果命名之 */;#en

10、dif#define SHA1HashSize 20/* * 以下这种结构将会控制上下文消息 for the SHA-1 * hashing operation */typedef struct SHA1Context uint32_t Intermediate_HashSHA1HashSize/4; /* Message Digest */ uint32_t Length_Low; /* Message length in bits */ uint32_t Length_High; /* Message length in bits */ /* Index into message bloc

11、k array */ int_least16_t Message_Block_Index; uint8_t Message_Block64; /* 512-bit message blocks */ int Computed; /* Is the digest computed? */ int Corrupted; /* Is the message digest corrupted? */ SHA1Context;/* * 函数原型 */int SHA1Reset( SHA1Context *);int SHA1Input( SHA1Context *, const uint8_t *, u

12、nsigned int);int SHA1Result( SHA1Context *, uint8_t Message_DigestSHA1HashSize);#endif /*_SHA1_H_*/Sha1.c*#include Sha1.h/* * 以下是为 SHA1 向左环形移位宏 之定义 */#define SHA1CircularShift(bits,word) (word) (32-(bits)/* 局部函数原型 */void SHA1PadMessage(SHA1Context *); /* 定义填充信息指针 */void SHA1ProcessMessageBlock(SHA1C

13、ontext *);/* * SHA1Reset * * 以下为数据初始化之操作 * Parameters:（参数设置） * context: in/out * The context to reset. * */int SHA1Reset(SHA1Context *context) if (!context) return shaNull; context-Length_Low = 0; context-Length_High = 0; context-Message_Block_Index = 0; context-Intermediate_Hash0 = 0 x67452301; con

14、text-Intermediate_Hash1 = 0 xEFCDAB89; context-Intermediate_Hash2 = 0 x98BADCFE; context-Intermediate_Hash3 = 0 x10325476; context-Intermediate_Hash4 = 0 xC3D2E1F0; context-Computed = 0; context-Corrupted = 0; return shaSuccess;/* * SHA1Result * * 以下为sha-1结果描述： *: * 该算法将会返回一个160比特的消息摘要队列 * * 或者输出计算错

15、误 * */int SHA1Result( SHA1Context *context, uint8_t Message_DigestSHA1HashSize) int i; if (!context | !Message_Digest) return shaNull; if (context-Corrupted) return context-Corrupted; if (!context-Computed) SHA1PadMessage(context); for(i=0; iMessage_Blocki = 0; context-Length_Low = 0; /* 长度清零 */ con

16、text-Length_High = 0; context-Computed = 1; for(i = 0; i Intermediate_Hashi2 8 * ( 3 - ( i & 0 x03 ) ); return shaSuccess;/* * 以下为sha-1输入描述： * * 接收单位长度为8字节倍数的消息 * */int SHA1Input( SHA1Context *context, const uint8_t *message_array, unsigned length) if (!length) return shaSuccess; if (!context | !mes

17、sage_array) return shaNull; if (context-Computed) context-Corrupted = shaStateError; return shaStateError; if (context-Corrupted) return context-Corrupted; while(length- & !context-Corrupted) context-Message_Blockcontext-Message_Block_Index+ = (*message_array & 0 xFF); context-Length_Low += 8; if (c

18、ontext-Length_Low = 0) context-Length_High+; if (context-Length_High = 0) /* Message is too long */ context-Corrupted = 1; if (context-Message_Block_Index = 64) SHA1ProcessMessageBlock(context); message_array+; return shaSuccess;/* * 以下为sha-1消息块描述： * * 消息块长度为固定之512比特 * */void SHA1ProcessMessageBlock

19、(SHA1Context *context) const uint32_t K = /* Constants defined in SHA-1 */ 0 x5A827999, 0 x6ED9EBA1, 0 x8F1BBCDC, 0 xCA62C1D6 ; int t; /* 循环计数 */ uint32_t temp; /* 临时缓存 */ uint32_t W80; /* 字顺序 */ uint32_t A, B, C, D, E; /* 设置系统磁盘缓存块 */ /* * 以下为初始化在W队列中的头16字数据 */ for(t = 0; t Message_Blockt * 4 Messa

20、ge_Blockt * 4 + 1 Message_Blockt * 4 + 2 Message_Blockt * 4 + 3; for(t = 16; t Intermediate_Hash0; B = context-Intermediate_Hash1; C = context-Intermediate_Hash2; D = context-Intermediate_Hash3; E = context-Intermediate_Hash4; /* * 以下为定义算法所用之数学函数及其迭代算法描述 */ for(t = 0; t 20; t+) temp = SHA1CircularSh

21、ift(5,A) + (B & C) | (B) & D) + E + Wt + K0; E = D; D = C; C = SHA1CircularShift(30,B); B = A; A = temp; for(t = 20; t 40; t+) temp = SHA1CircularShift(5,A) + (B C D) + E + Wt + K1; E = D; D = C; C = SHA1CircularShift(30,B); B = A; A = temp; for(t = 40; t 60; t+) temp = SHA1CircularShift(5,A) + (B &

22、 C) | (B & D) | (C & D) + E + Wt + K2; E = D; D = C; C = SHA1CircularShift(30,B); B = A; A = temp; for(t = 60; t Intermediate_Hash0 += A; context-Intermediate_Hash1 += B; context-Intermediate_Hash2 += C; context-Intermediate_Hash3 += D; context-Intermediate_Hash4 += E; context-Message_Block_Index =

23、0;/* * SHA1PadMessage * 数据填充模块 */void SHA1PadMessage(SHA1Context *context) if (context-Message_Block_Index 55) context-Message_Blockcontext-Message_Block_Index+ = 0 x80; while(context-Message_Block_Index Message_Blockcontext-Message_Block_Index+ = 0; SHA1ProcessMessageBlock(context); while(context-M

24、essage_Block_Index Message_Blockcontext-Message_Block_Index+ = 0; else context-Message_Blockcontext-Message_Block_Index+ = 0 x80; while(context-Message_Block_Index Message_Blockcontext-Message_Block_Index+ = 0; /* * 把最后64位保存为数据长度 */ context-Message_Block56 = context-Length_High 24; context-Message_B

25、lock57 = context-Length_High 16; context-Message_Block58 = context-Length_High 8; context-Message_Block59 = context-Length_High; context-Message_Block60 = context-Length_Low 24; context-Message_Block61 = context-Length_Low 16; context-Message_Block62 = context-Length_Low 8; context-Message_Block63 =

26、 context-Length_Low; SHA1ProcessMessageBlock(context);TypeRedef.h*#ifndef _STDINT_H #define _STDINT_H #define _need_wint_t #define _need_wchar_t #include /* 7.18.1.1 Exact-width integer types */ typedef signed char int8_t; typedef unsigned char uint8_t; typedef short int16_t; typedef unsigned short

27、uint16_t; typedef int int32_t; typedef unsigned uint32_t; typedef long int64_t; typedef unsigned long uint64_t; /* 7.18.1.2 Minimum-width integer types */ typedef signed char int_least8_t; typedef unsigned char uint_least8_t; typedef short int_least16_t; typedef unsigned short uint_least16_t; typede

28、f int int_least32_t; typedef unsigned uint_least32_t; typedef long int_least64_t; typedef unsigned long uint_least64_t; /* 7.18.1.3 Fastest minimum-width integer types * Not actually guaranteed to be fastest for all purposes * Here we use the exact-width types for 8 and 16-bit ints. */ typedef char

29、int_fast8_t; typedef unsigned char uint_fast8_t; typedef short int_fast16_t; typedef unsigned short uint_fast16_t; typedef int int_fast32_t; typedef unsigned int uint_fast32_t; typedef long int_fast64_t; typedef unsigned long uint_fast64_t; /* 7.18.1.4 Integer types capable of holding object pointer

30、s */ typedef int intptr_t; typedef unsigned uintptr_t; /* 7.18.1.5 Greatest-width integer types */ typedef long intmax_t; typedef unsigned long uintmax_t; /* 7.18.2 Limits of specified-width integer types */ #if !defined ( _cplusplus) | defined (_STDC_LIMIT_MACROS) /* 7.18.2.1 Limits of exact-width

31、integer types */ #define INT8_MIN (-128) #define INT16_MIN (-32768) #define INT32_MIN (-2147483647 - 1) #define INT64_MIN (-9223372036854775807LL - 1) #define INT8_MAX 127 #define INT16_MAX 32767 #define INT32_MAX 2147483647 #define INT64_MAX 9223372036854775807LL #define UINT8_MAX 0 xff /* 255U */

32、#define UINT16_MAX 0 xffff /* 65535U */ #define UINT32_MAX 0 xffffffff /* 4294967295U */ /* 7.18.2.2 Limits of minimum-width integer types */ #define INT_LEAST8_MIN INT8_MIN #define INT_LEAST16_MIN INT16_MIN #define INT_LEAST32_MIN INT32_MIN #define INT_LEAST64_MIN INT64_MIN #define INT_LEAST8_MAX I

33、NT8_MAX #define INT_LEAST16_MAX INT16_MAX #define INT_LEAST32_MAX INT32_MAX #define INT_LEAST64_MAX INT64_MAX #define UINT_LEAST8_MAX UINT8_MAX #define UINT_LEAST16_MAX UINT16_MAX #define UINT_LEAST32_MAX UINT32_MAX #define UINT_LEAST64_MAX UINT64_MAX /* 7.18.2.3 Limits of fastest minimum-width inte

34、ger types */ #define INT_FAST8_MIN INT8_MIN #define INT_FAST16_MIN INT16_MIN #define INT_FAST32_MIN INT32_MIN #define INT_FAST64_MIN INT64_MIN #define INT_FAST8_MAX INT8_MAX #define INT_FAST16_MAX INT16_MAX #define INT_FAST32_MAX INT32_MAX #define INT_FAST64_MAX INT64_MAX #define UINT_FAST8_MAX UINT

35、8_MAX #define UINT_FAST16_MAX UINT16_MAX #define UINT_FAST32_MAX UINT32_MAX #define UINT_FAST64_MAX UINT64_MAX /* 7.18.2.4 Limits of integer types capable of holding object pointers */ #define INTPTR_MIN INT32_MIN #define INTPTR_MAX INT32_MAX #define UINTPTR_MAX UINT32_MAX /* 7.18.2.5 Limits of grea

36、test-width integer types */ #define INTMAX_MIN INT64_MIN #define INTMAX_MAX INT64_MAX #define UINTMAX_MAX UINT64_MAX /* 7.18.3 Limits of other integer types */ #define PTRDIFF_MIN INT32_MIN #define PTRDIFF_MAX INT32_MAX #define SIG_ATOMIC_MIN INT32_MIN #define SIG_ATOMIC_MAX INT32_MAX #define SIZE_M

37、AX UINT32_MAX #ifndef WCHAR_MIN /* also in wchar.h */ #define WCHAR_MIN 0 #define WCHAR_MAX 0 xffff /* UINT16_MAX */ #endif /* * wint_t is unsigned short for compatibility with MS runtime */ #define WINT_MIN 0 #define WINT_MAX 0 xffff /* UINT16_MAX */ #endif /* !defined ( _cplusplus) | defined _STDC

38、_LIMIT_MACROS */ /* 7.18.4 Macros for integer constants */ #if !defined ( _cplusplus) | defined (_STDC_CONSTANT_MACROS) /* 7.18.4.1 Macros for minimum-width integer constants Accoding to Douglas Gwyn : This spec was changed in ISO/IEC 9899:1999 TC1; in ISO/IEC 9899:1999 as initially published, the e

39、xpansion was required to be an integer constant of precisely matching type, which is impossible to accomplish for the shorter types on most platforms, because C99 provides no standard way to designate an integer constant with width less than that of type int. TC1 changed this to require just an inte

40、ger constant *expression* with *promoted* type. */ #define INT8_C(val) (int8_t) + (val) #define UINT8_C(val) (uint8_t) + (val#U) #define INT16_C(val) (int16_t) + (val) #define UINT16_C(val) (uint16_t) + (val#U) #define INT32_C(val) val#L #define UINT32_C(val) val#UL #define INT64_C(val) val#LL #defi

41、ne UINT64_C(val) val#ULL /* 7.18.4.2 Macros for greatest-width integer constants */ #define INTMAX_C(val) INT64_C(val) #define UINTMAX_C(val) UINT64_C(val) #endif /* !defined ( _cplusplus) | defined _STDC_CONSTANT_MACROS */ #endif*#include #include #include TypeRedef.h#include Sha1.h/* * 定义测试模式 */#define TEST1 abc /* 只有一个分组-共有24位长度 * 需要填充一个1和423个0 * 最后两个字00000000 00000018表明原始消息长度是24位 */ #define TEST2a abcdbcdecdefdefgefghfghighijhi#define TEST2b jkijkljklmklmnlmnomnopnopq #define TEST2 TEST2a TEST2b /* 消息M是448位之ASCII码串 * 该消息被填充一个1，后跟511个0 * 并且以十六进制00000