OpenSSLOpenSSL之SHA
Posted 沧海一笑-dj
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了OpenSSLOpenSSL之SHA相关的知识，希望对你有一定的参考价值。
00. 目录
文章目录
01. SHA-1介绍
SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数。
SHA-1已经不再视为可抵御有充足资金、充足计算资源的攻击者。2005年，密码分析人员发现了对SHA-1的有效攻击方法，这表明该算法可能不够安全，不能继续使用，自2010年以来，许多组织建议用SHA-2或SHA-3来替换SHA-1。Microsoft、Google以及Mozilla都宣布，它们旗下的浏览器将在2017年前停止接受使用SHA-1算法签名的SSL证书。
2017年2月23日，CWI Amsterdam与Google宣布了一个成功的SHA-1碰撞攻击，发布了两份内容不同但SHA-1散列值相同的PDF文件作为概念证明。
02. SHA-0和SHA-1
最初载明的算法于1993年发布，称做安全散列标准（Secure Hash Standard），FIPSPUB 180。这个版本现在常被称为SHA-0。它在发布之后很快就被NSA撤回，并且由1995年发布的修订版本FIPS PUB 180-1（通常称为SHA-1）取代。SHA-1和SHA-0的算法只在压缩函数的消息转换部分差了一个比特的循环位移。根据NSA的说法，它修正了一个在原始算法中会降低散列安全性的弱点。然而NSA并没有提供任何进一步的解释或证明该弱点已被修正。而后SHA-0和SHA-1的弱点相继被攻破，SHA-1似乎是显得比SHA-0有抵抗性，这多少证实了NSA当初修正算法以增进安全性的声明。
SHA-0和SHA-1可将一个最大2比特的消息，转换成一串160位的消息摘要；其设计原理相似于MIT教授Ronald L. Rivest所设计的密码学散列算法MD4和MD5。
2.1 SHA-0的破解
在CRYPTO98上，两位法国研究者提出一种对SHA-0的攻击方式：在2的计算复杂度之内，就可以发现一次碰撞（即两个不同的消息对应到相同的消息摘要）；这个数字小于生日攻击法所需的2，也就是说，存在一种算法，使其安全性不到一个理想的散列函数抵抗攻击所应具备的计算复杂度。
2004年时，Biham和Chen也发现了SHA-0的近似碰撞，也就是两个消息可以散列出几乎相同的数值；其中162比特中有142比特相同。他们也发现了SHA-0的完整碰撞（相对于近似碰撞），将本来需要80次方的复杂度降低到62次方。
2004年8月12日，Joux, Carribault, Lemuet和Jalby宣布找到SHA-0算法的完整碰撞的方法，这是归纳Chabaud和Joux的攻击所完成的结果。发现一个完整碰撞只需要2的计算复杂度。他们使用的是一台有256颗Itanium2处理器的超级计算机，约耗80,000 CPU工时。
2004年8月17日，在CRYPTO2004的Rump会议上，王小云，冯登国（Feng）、来学嘉（Lai），和于红波（Yu）宣布了攻击MD5、SHA-0和其他散列函数的初步结果。他们攻击SHA-0的计算复杂度是2，这意味着他们的攻击成果比Joux还有其他人所做的更好。请参见MD5安全性。
2005年二月，王小云和殷益群、于红波再度发表了对SHA-0破密的算法，可在2的计算复杂度内就找到碰撞。
2.2 SHA-1的破解
鉴于SHA-0的破密成果，专家们建议那些计划利用SHA-1实现密码系统的人们也应重新考虑。在2004年CRYPTO会议结果公布之后，NIST即宣布他们将逐渐减少使用SHA-1，改以SHA-2取而代之。
2005年，Rijmen和Oswald发表了对SHA-1较弱版本（53次的加密循环而非80次）的攻击：在2的计算复杂度之内找到碰撞。
2005年二月，王小云、殷益群及于红波发表了对完整版SHA-1的攻击，只需少于2的计算复杂度，就能找到一组碰撞。（利用生日攻击法找到碰撞需要2的计算复杂度。）
这篇论文的作者们写道；“我们的破密分析是以对付SHA-0的差分攻击、近似碰撞、多区块碰撞技术、以及从MD5算法中查找碰撞的消息更改技术为基础。没有这些强力的分析工具，SHA-1就无法破解。”此外，作者还展示了一次对58次加密循环SHA-1的破密，在2个单位操作内就找到一组碰撞。完整攻击方法的论文发表在2005年八月的CRYPTO会议中。
殷益群在一次面谈中如此陈述：“大致上来说，我们找到了两个弱点：其一是前置处理不够复杂；其二是前20个循环中的某些数学运算会造成不可预期的安全性问题。”
2005年8月17日的CRYPTO会议尾声中王小云、姚期智、姚储枫再度发表更有效率的SHA-1攻击法，能在2个计算复杂度内找到碰撞。
2006年的CRYPTO会议上，Christian Rechberger和Christophe De Cannière宣布他们能在容许攻击者决定部分原消息的条件之下，找到SHA-1的一个碰撞。
在密码学的学术理论中，任何攻击方式，其计算复杂度若少于暴力搜索法所需要的计算复杂度，就能被视为针对该密码系统的一种破密法；但这并不表示该破密法已经可以进入实际应用的阶段。
就应用层面的考量而言，一种新的破密法出现，暗示着将来可能会出现更有效率、足以实用的改良版本。虽然这些实用的破密法版本根本还没诞生，但确有必要发展更强的散列算法来取代旧的算法。在“碰撞”攻击法之外，另有一种反译攻击法（Pre-image attack），就是由散列出的字符串反推原本的消息；反译攻击的严重性更在碰撞攻击之上，但也更困难。在许多会应用到密码散列的情境（如用户密码的存放、文件的数字签名等）中，碰撞攻击的影响并不是很大。举例来说，一个攻击者可能不会只想要伪造一份一模一样的文件，而会想改造原来的文件，再附上合法的签名，来愚弄持有公钥的验证者。另一方面，如果可以从密文中反推未加密前的用户密码，攻击者就能利用得到的密码登录其他用户的账户，而这种事在密码系统中是不能被允许的。但若存在反译攻击，只要能得到指定用户密码散列过后的字符串（通常存在影档中，而且可能不会透露原密码信息），就有可能得到该用户的密码。
2017年2月23日，Google公司公告宣称他们与CWI Amsterdam合作共同创建了两个有着相同的SHA-1值但内容不同的PDF文件，这代表SHA-1算法已被正式攻破。
03. OpenSSL中SHA
sha.h内容如下
/*
* Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the OpenSSL license (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
#ifndef HEADER_SHA_H
# define HEADER_SHA_H
# include <openssl/e_os2.h>
# include <stddef.h>
#ifdef __cplusplus
extern "C"
#endif
/*-
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
* ! SHA_LONG has to be at least 32 bits wide. !
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
*/
# define SHA_LONG unsigned int
# define SHA_LBLOCK 16
# define SHA_CBLOCK (SHA_LBLOCK*4)/* SHA treats input data as a
* contiguous array of 32 bit wide
* big-endian values. */
# define SHA_LAST_BLOCK (SHA_CBLOCK-8)
# define SHA_DIGEST_LENGTH 20
typedef struct SHAstate_st
SHA_LONG h0, h1, h2, h3, h4;
SHA_LONG Nl, Nh;
SHA_LONG data[SHA_LBLOCK];
unsigned int num;
SHA_CTX;
int SHA1_Init(SHA_CTX *c);
int SHA1_Update(SHA_CTX *c, const void *data, size_t len);
int SHA1_Final(unsigned char *md, SHA_CTX *c);
unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md);
void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
# define SHA256_CBLOCK (SHA_LBLOCK*4)/* SHA-256 treats input data as a
* contiguous array of 32 bit wide
* big-endian values. */
typedef struct SHA256state_st
SHA_LONG h[8];
SHA_LONG Nl, Nh;
SHA_LONG data[SHA_LBLOCK];
unsigned int num, md_len;
SHA256_CTX;
int SHA224_Init(SHA256_CTX *c);
int SHA224_Update(SHA256_CTX *c, const void *data, size_t len);
int SHA224_Final(unsigned char *md, SHA256_CTX *c);
unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md);
int SHA256_Init(SHA256_CTX *c);
int SHA256_Update(SHA256_CTX *c, const void *data, size_t len);
int SHA256_Final(unsigned char *md, SHA256_CTX *c);
unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
void SHA256_Transform(SHA256_CTX *c, const unsigned char *data);
# define SHA224_DIGEST_LENGTH 28
# define SHA256_DIGEST_LENGTH 32
# define SHA384_DIGEST_LENGTH 48
# define SHA512_DIGEST_LENGTH 64
/*
* Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64
* being exactly 64-bit wide. See Implementation Notes in sha512.c
* for further details.
*/
/*
* SHA-512 treats input data as a
* contiguous array of 64 bit
* wide big-endian values.
*/
# define SHA512_CBLOCK (SHA_LBLOCK*8)
# if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__)
# define SHA_LONG64 unsigned __int64
# define U64(C) C##UI64
# elif defined(__arch64__)
# define SHA_LONG64 unsigned long
# define U64(C) C##UL
# else
# define SHA_LONG64 unsigned long long
# define U64(C) C##ULL
# endif
typedef struct SHA512state_st
SHA_LONG64 h[8];
SHA_LONG64 Nl, Nh;
union
SHA_LONG64 d[SHA_LBLOCK];
unsigned char p[SHA512_CBLOCK];
u;
unsigned int num, md_len;
SHA512_CTX;
int SHA384_Init(SHA512_CTX *c);
int SHA384_Update(SHA512_CTX *c, const void *data, size_t len);
int SHA384_Final(unsigned char *md, SHA512_CTX *c);
unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md);
int SHA512_Init(SHA512_CTX *c);
int SHA512_Update(SHA512_CTX *c, const void *data, size_t len);
int SHA512_Final(unsigned char *md, SHA512_CTX *c);
unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md);
void SHA512_Transform(SHA512_CTX *c, const unsigned char *data);
#ifdef __cplusplus
#endif
#endif
函数说明
SHA1算法，是对MD5的升级，计算结果长度20个字节；推荐用户使用此算法， SHA256，SHA384，SHA512是对SHA1的升级；
函数的使用方法同SHA1相同。
int SHA_Init(SHA_CTX *c);
初始化SHA Context；
返回值： 1 成功，0 失败；
int SHA_Update(SHA_CTX *c, const void *data, size_t len);
用户循环调用此函数，可以将不同数据加在一起计算SHA1的值；
返回值： 1 成功，0失败；
int SHA_Final(unsigned char *md, SHA_CTX *c);
输出SHA1的数据；
返回值： 1 成功，0失败；
unsigned char *SHA(const unsigned char *d, size_t n, unsigned char *md);
SHA_Init,SHA_Update,SHA_Final 三个函数的组合；直接计算出SHA1数值；
返回值： 1 成功， 0失败；
void SHA_Transform(SHA_CTX *c, const unsigned char *data);
传递数据，内部函数，用户不需使用此函数；
04. SHA1测试
参考代码:
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <openssl/sha.h>
using namespace std;
//测试SHA
int main(void)
int ret = -1;
int i = 0;
SHA_CTX c;
const void *data = "让程序改变我们的生活";
unsigned char md[SHA_DIGEST_LENGTH];
unsigned char buf[SHA_DIGEST_LENGTH * 2 + 1];
//1. 初始化
ret = SHA1_Init(&c);
if (1 != ret)
cout << "SHA1_Init failed.." << endl;
return 1;
//2. 添加数据
ret = SHA1_Update(&c, data, strlen((char*)data));
if (1 != ret)
cout << "SHA1_Update failed.." << endl;
return 1;
//3. 计算结果
memset(md, 0, SHA_DIGEST_LENGTH);
ret = SHA1_Final(md, &c);
if (1 != ret)
cout << "SHA1_Final failed.." << endl;
return 1;
//4. 输出结果
memset(buf, 0, SHA_DIGEST_LENGTH * 2 + 1);
for (i = 0; i < SHA_DIGEST_LENGTH; i++)
sprintf((char*)&buf[i * 2], "%02X", md[i]);
cout << buf << endl;
cout << "===========================" << endl;
memset(md, 0, SHA_DIGEST_LENGTH);
SHA1((unsigned char *)data, strlen((char*)data), md);
memset(buf, 0, SHA_DIGEST_LENGTH * 2 + 1);
for (i = 0; i < SHA_DIGEST_LENGTH; i++)
//&buf[0] 0xEF --> "EF"
sprintf((char*)&buf[i * 2], "%02X", md[i]);
cout << buf << endl;
system("pause");
return 0;
测试结果：
05. 附录
5.1 百度百科: SHA-1
5.2 参考: https://ctf-wiki.github.io/ctf-wiki/crypto/hash/sha1/
5.3 官方网站：https://www.openssl.org/
以上是关于OpenSSLOpenSSL之SHA的主要内容，如果未能解决你的问题，请参考以下文章