Hash散列算法详细解析（三）

最新推荐文章于 2024-03-10 17:37:24 发布
最新推荐文章于 2024-03-10 17:37:24 发布
阅读量3.2k 收藏 5
点赞数
分类专栏： Algorithm 文章标签： 算法 buffer c ui class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/relianceslee/article/details/723755
版权

4 ripemd算法

        顾名思义ripemd就是成熟md算法，是Hans Dobbertin等3人在md4,md5的基础上，于1996年提出来的。算法共有4个标准128、160、256和320，其对应输出长度分别为16字节、20字节、32字节和40字节。不过，让人难以致信的是ripemd的设计者们根本就没有真正设计256和320位这2种标准，他们只是在128位和160位的基础上，修改了初始参数和s-box来达到输出为256和320位的目的。所以，256位的强度和128相当，而320位的强度和160位相当。

       ripemd建立在md的基础之上，所以，其添加数据的方式和md5完全一样。

其参考代码如下：
define.h在md5算法里面有说明。

ripemd.h文件：

#ifndef Goodzzp_RipeMd_05_10_20_12
#define Goodzzp_RipeMd_05_10_20_12

//ripemd128,160,256,320
//program be Goodzzp
//05,10,20
//128 and 160 are referred:
//http://homes.esat.md_kuleuven.be/~bosselae/ripemd160.html
//256 and 320 are not guarranteed to be safe than 128 or 160
//referred: Crypto++5.21

#include "define.h"

//128-320需要的5论变换
#define md_F(x, y, z)    (x ^ y ^ z)
#define md_G(x, y, z)    (z ^ (x & (y^z)))
#define md_H(x, y, z)    (z ^ (x | ~y))
#define md_I(x, y, z)    (y ^ (z & (x^y)))
#define md_J(x, y, z)    (x ^ (y | ~z))
//常量
#define md_k0 0
#define md_k1 0x5a827999UL
#define md_k2 0x6ed9eba1UL
#define md_k3 0x8f1bbcdcUL
#define md_k4 0xa953fd4eUL
#define md_k5 0x50a28be6UL
#define md_k6 0x5c4dd124UL
#define md_k7 0x6d703ef3UL
#define md_k8 0x7a6d76e9UL
#define md_k9 0 
// for 160 and 320
#define md_Subround(f, a, b, c, d, e, x, s, md_k)        /
 a += f(b, c, d) + x + md_k;/
 a = rotlFixed((UI32)a, s) + e;/
 c = rotlFixed((UI32)c, 10U)
// for 128 and 256
#define md1_Subround(f, a, b, c, d, x, s, md_k)        /
 a += f(b, c, d) + x + md_k;/
 a = rotlFixed((UI32)a, s);

//...begin ripemd128

//RipeMd128散列类
class RipeMD128
{
public:
 //输出结果的长度（字节）
 static UI32 OutDataLength()
 {
  return 128/8;
 }
 //RipeMD128变换函数
 //out:输出，长度为16，要求事先已经分配了内存
 //in:输入
 //length:输入值的长度
 void Hash(UI8 *out,const UI8 *in,UI32 length)
 {
  UI32 i = length>>6,j=(length&0x3f),md_k;
  //对数据64 64个字节的计算
  for(md_k=0;md_k  {
   StepTransform((UI8 *)(in + md_k * 64),64,length);
  }
  //最后计算尾数
  StepTransform((UI8 *)(in + 64 * i),j,length);
  //拷贝输出
  memcpy(out,MDbuf,16);
  //恢复m_state值
  RipeMD128();
 }
 //初始化
 //这里就是4个刚开始的值
 RipeMD128()
 {
  MDbuf[0] = 0x67452301UL;
  MDbuf[1] = 0xefcdab89UL;
  MDbuf[2] = 0x98badcfeUL;
  MDbuf[3] = 0x10325476UL;
 }
private:
 //每步的变换函数
 //输入:
 //  data:   要处理的数据块（不大于64字节）
 //  dataBlockLen: 数据块的长度
 //  dataTotalLen: 要处理的所有数据块的总长度
 //输出结果保存在m_state里面
 void StepTransform(UI8 *data,UI32 dataBlockLen, UI32 dataTotalLen)
 {
  UI8 buffer[64];
  UI32 len=dataTotalLen*8;

  memset(buffer,0,64);//清空数据为0
  memcpy(buffer,data,dataBlockLen);//拷贝数据到缓冲

  if(dataBlockLen <64) //需要增加数据
  {
   if(dataBlockLen<56)//当前数据是最后若干个，而且不需要增加一次变换
   {
    //添加1和0
    buffer[dataBlockLen]=0x80;
    //添加长度
    buffer[56]=(UI8)(len&0xff);
    len>>=8;
    buffer[57]=(UI8)(len&0xff);
    len>>=8;
    buffer[58]=(UI8)(len&0xff);
    len>>=8;
    buffer[59]=(UI8)(len&0xff);
    //变换
    FirstTransform((UI32*)buffer);
    CoreTransform();
   }
   else if(dataBlockLen>=56)
   {
    //添加1和0
    buffer[dataBlockLen]=0x80;
    //变换
    FirstTransform((UI32*)buffer);
    CoreTransform();
    //添加长度
    memset(buffer,0,64);
    buffer[56]=(UI8)(len&0xff);
    len>>=8;
    buffer[57]=(UI8)(len&0xff);
    len>>=8;
    buffer[58]=(UI8)(len&0xff);
    len>>=8;
    buffer[59]=(UI8)(len&0xff);
    //变换
    FirstTransform((UI32*)buffer);
    CoreTransform();
   }
  }
  else if(dataBlockLen == 64)
  {
   //变换
   FirstTransform((UI32*)buffer);
   CoreTransform();
  }
 }

 //把64字节的原始数据data进行初步转化到m_data中去
 void FirstTransform(UI32 *data)
 {
  memcpy(X,data,64);
 }
 
 //核心变换
 void CoreTransform()
 {
  UI32 a1, b1, c1, d1, a2, b2, c2, d2;
  a1 = a2 = MDbuf[0];
  b1 = b2 = MDbuf[1];
  c1 = c2 = MDbuf[2];
  d1 = d2 = MDbuf[3];

  md1_Subround(md_F, a1, b1, c1, d1, X[ 0], 11, md_k0);
  md1_Subround(md_F, d1, a1, b1, c1, X[ 1], 14, md_k0);
  md1_Subround(md_F, c1, d1, a1, b1, X[ 2], 15, md_k0);
  md1_Subround(md_F, b1, c1, d1, a1, X[ 3], 12, md_k0);
  md1_Subround(md_F, a1, b1, c1, d1, X[ 4],  5, md_k0);
  md1_Subround(md_F, d1, a1, b1, c1, X[ 5],  8, md_k0);
  md1_Subround(md_F, c1, d1, a1, b1, X[ 6],  7, md_k0);
  md1_Subround(md_F, b1, c1, d1, a1, X[ 7],  9, md_k0);
  md1_Subround(md_F, a1, b1, c1, d1, X[ 8], 11, md_k0);
  md1_Subround(md_F, d1, a1, b1, c1, X[ 9], 13, md_k0);
  md1_Subround(md_F, c1, d1, a1, b1, X[10], 14, md_k0);
  md1_Subround(md_F, b1, c1, d1, a1, X[11], 15, md_k0);
  md1_Subround(md_F, a1, b1, c1, d1, X[12],  6, md_k0);
  md1_Subround(md_F, d1, a1, b1, c1, X[13],  7, md_k0);
  md1_Subround(md_F, c1, d1, a1, b1, X[14],  9, md_k0);
  md1_Subround(md_F, b1, c1, d1, a1, X[15],  8, md_k0);

  md1_Subround(md_G, a1, b1, c1, d1, X[ 7],  7, md_k1);
  md1_Subround(md_G, d1, a1, b1, c1, X[ 4],  6, md_k1);
  md1_Subround(md_G, c1, d1, a1, b1, X[13],  8, md_k1);
  md1_Subround(md_G, b1, c1, d1, a1, X[ 1], 13, md_k1);
  md1_Subround(md_G, a1, b1, c1, d1, X[10], 11, md_k1);
  md1_Subround(md_G, d1, a1, b1, c1, X[ 6],  9, md_k1);
  md1_Subround(md_G, c1, d1, a1, b1, X[15],  7, md_k1);
  md1_Subround(md_G, b1, c1, d1, a1, X[ 3], 15, md_k1);
  md1_Subround(md_G, a1, b1, c1, d1, X[12],  7, md_k1);
  md1_Subround(md_G, d1, a1, b1, c1, X[ 0], 12, md_k1);
  md1_Subround(md_G, c1, d1, a1, b1, X[ 9], 15, md_k1);
  md1_Subround(md_G, b1, c1, d1, a1, X[ 5],  9, md_k1);
  md1_Subround(md_G, a1, b1, c1, d1, X[ 2], 11, md_k1);
  md1_Subround(md_G, d1, a1, b1, c1, X[14],  7, md_k1);
  md1_Subround(md_G, c1, d1, a1, b1, X[11], 13, md_k1);
  md1_Subround(md_G, b1, c1, d1, a1, X[ 8], 12, md_k1);

  md1_Subround(md_H, a1, b1, c1, d1, X[ 3], 11, md_k2);
  md1_Subround(md_H, d1, a1, b1, c1, X[10], 13, md_k2);
  md1_Subround(md_H, c1, d1, a1, b1, X[14],  6, md_k2);
  md1_Subround(md_H, b1, c1, d1, a1, X[ 4],  7, md_k2);
  md1_Subround(md_H, a1, b1, c1, d1, X[ 9], 14, md_k2);
  md1_Subround(md_H, d1, a1, b1, c1, X[15],  9, md_k2);
  md1_Subround(md_H, c1, d1, a1, b1, X[ 8], 13, md_k2);
  md1_Subround(md_H, b1, c1, d1, a1, X[ 1], 15, md_k2);
  md1_Subround(md_H, a1, b1, c1, d1, X[ 2], 14, md_k2);
  md1_Subround(md_H, d1, a1, b1, c1, X[ 7],  8, md_k2);
  md1_Subround(md_H, c1, d1, a1, b1, X[ 0], 13, md_k2);
  md1_Subround(md_H, b1, c1, d1, a1, X[ 6],  6, md_k2);
  md1_Subround(md_H, a1, b1, c1, d1, X[13],  5, md_k2);
  md1_Subround(md_H, d1, a1, b1, c1, X[11], 12, md_k2);
  md1_Subround(md_H, c1, d1, a1, b1, X[ 5],  7, md_k2);
  md1_Subround(md_H, b1, c1, d1, a1, X[12],  5, md_k2);

  md1_Subround(md_I, a1, b1, c1, d1, X[ 1], 11, md_k3);
  md1_Subround(md_I, d1, a1, b1, c1, X[ 9], 12, md_k3);
  md1_Subround(md_I, c1, d1, a1, b1, X[11], 14, md_k3);
  md1_Subround(md_I, b1, c1, d1, a1, X[10], 15, md_k3);
  md1_Subround(md_I, a1, b1, c1, d1, X[ 0], 14, md_k3);
  md1_Subround(md_I, d1, a1, b1, c1, X[ 8], 15, md_k3);
  md1_Subround(md_I, c1, d1, a1, b1, X[12],  9, md_k3);
  md1_Subround(md_I, b1, c1, d1, a1, X[ 4],  8, md_k3);
  md1_Subround(md_I, a1, b1, c1, d1, X[13],  9, md_k3);
  md1_Subround(md_I, d1, a1, b1, c1, X[ 3], 14, md_k3);
  md1_Subround(md_I, c1, d1, a1, b1, X[ 7],  5, md_k3);
  md1_Subround(md_I, b1, c1, d1, a1, X[15],  6, md_k3);
  md1_Subround(md_I, a1, b1, c1, d1, X[14],  8, md_k3);
  md1_Subround(md_I, d1, a1, b1, c1, X[ 5],  6, md_k3);
  md1_Subround(md_I, c1, d1, a1, b1, X[ 6],  5, md_k3);
  md1_Subround(md_I, b1, c1, d1, a1, X[ 2], 12, md_k3);

  md1_Subround(md_I, a2, b2, c2, d2, X[ 5],  8, md_k5);
  md1_Subround(md_I, d2, a2, b2, c2, X[14],  9, md_k5);
  md1_Subround(md_I, c2, d2, a2, b2, X[ 7],  9, md_k5);
  md1_Subround(md_I, b2, c2, d2, a2, X[ 0], 11, md_k5);
  md1_Subround(md_I, a2, b2, c2, d2, X[ 9], 13, md_k5);
  md1_Subround(md_I, d2, a2, b2, c2, X[ 2], 15, md_k5);
  md1_Subround(md_I, c2, d2, a2, b2, X[11], 15, md_k5);
  md1_Subround(md_I, b2, c2, d2, a2, X[ 4],  5, md_k5);
  md1_Subround(md_I, a2, b2, c2, d2, X[13],  7, md_k5);
  md1_Subround(md_I, d2, a2, b2, c2, X[ 6],  7, md_k5);
  md1_Subround(md_I, c2, d2, a2, b2, X[15],  8, md_k5);
  md1_Subround(md_I, b2, c2, d2, a2, X[ 8], 11, md_k5);
  md1_Subround(md_I, a2, b2, c2, d2, X[ 1], 14, md_k5);
  md1_Subround(md_I, d2, a2, b2, c2, X[10], 14, md_k5);
  md1_Subround(md_I, c2, d2, a2, b2, X[ 3], 12, md_k5);
  md1_Subround(md_I, b2, c2, d2, a2, X[12],  6, md_k5);

  md1_Subround(md_H, a2, b2, c2, d2, X[ 6],  9, md_k6);
  md1_Subround(md_H, d2, a2, b2, c2, X[11], 13, md_k6);
  md1_Subround(md_H, c2, d2, a2, b2, X[ 3], 15, md_k6);
  md1_Subround(md_H, b2, c2, d2, a2, X[ 7],  7, md_k6);
  md1_Subround(md_H, a2, b2, c2, d2, X[ 0], 12, md_k6);
  md1_Subround(md_H, d2, a2, b2, c2, X[13],  8, md_k6);
  md1_Subround(md_H, c2, d2, a2, b2, X[ 5],  9, md_k6);
  md1_Subround(md_H, b2, c2, d2, a2, X[10], 11, md_k6);
  md1_Subround(md_H, a2, b2, c2, d2, X[14],  7, md_k6);
  md1_Subround(md_H, d2, a2, b2, c2, X[15],  7, md_k6);
  md1_Subround(md_H, c2, d2, a2, b2, X[ 8], 1

最低0.47元/天 解锁文章
Hash散列算法详细解析（五）
木头人专栏
09-22 5881
 关键词： tiger    fastest    hash                                                 可能大家很少听说过Tiger算法。Tiger由Ross在1995年提出。Tiger号称是最快的Hash算法，专门为64位机器做了优化。Tiger和md5的添加数据的方式不同，它不是加上1个1及若干个0，而是增加一个0x01和若干个
RIPEMD-160哈希算法实现示例
QQ604666459的博客
09-05 2839
RIPEMD-160哈希算法实现示例 参考： https://en.bitcoin.it/wiki/RIPEMD-160 Bitcoin (0.16.0)实现源码: // Internal implementation code. namespace { /// Internal RIPEMD-160 implementation. namespace ripemd...
信息摘要算法-RipeMD以及HmacRipeMD算法
weixin_33693070的博客
04-01 272
为什么80%的码农都做不了架构师？>>> ...
RIPEMD算法：多功能哈希算法的瑰宝
最新发布
03-10 855
RIPEMD算法作为一种哈希算法，通过生成数据的哈希值来验证数据的完整性和真实性，在数据传输和存储过程中具有重要作用。RIPEMD算法具有快速计算、不同输出长度和较高的安全性等优点，但也存在碰撞攻击和算法演进等缺点。与其他算法相比，RIPEMD算法在一定情况下具有独特优势。通过Python示例，我们可以了解RIPEMD算法的实际应用和工作原理。综上所述，RIPEMD算法是数据完整性验证的重要工具，为数据安全保护提供了可靠的支持。
【Java小工匠聊密码学】--消息摘要--RIPEMD算法
weixin_33751566的博客
06-29 292
1、什么是RIPEMD RIPEMD（RACE Integrity Primitives Evaluation Message Digest，RACE原始完整性校验消息摘要，是Hans Dobbertin等3人在md4,md5的基础上，于1996年提出来的。算法共有4个标准128、160、256和320，其对...
C语言ripemd160算法,RIPEMD加密，RIPEMD消息摘要算法：RIPEMD-128、RIPEMD-160、RIPEMD-256、RIPEMD-320...
weixin_35600835的博客
05-24 1294
RIPEMD加密，对输入字符实现RIPEMD家族四种消息摘要算法。RIPEMD(RACE Integrity Primitives Evaluation Message Digest)，中文译为“RACE原始完整性校验消息摘要”，是比利时鲁汶大学COSIC研究小组开发的散列函数算法。RIPEMD使用MD4的设计原理，并针对MD4的算法缺陷进行改进，1996年首次发布RIPEMD-128版本，在性能...
散列算法（C++）
11-01
根据给定的信息，我们可以分析出该段代码是关于散列算法的一个实现案例，主要通过C++语言编写（尽管代码实际采用的是C语言风格），用于构建一个基于散列表的马尔可夫链文本生成器。下面我们将详细解析这段代码中的...
java的散列算法
05-13
本文将深入探讨Java中的一种常见散列算法——SHA-1（Secure Hash Algorithm 1），并通过一个具体的Java类`SHA1`来展示其实现细节。 #### SHA-1简介 SHA-1是美国国家安全局（NSA）设计的一种安全散列算法，被广泛...
FNN-Hash：神经网络实现的字符串散列算法研究
资源摘要信息:"FNN-Hash:一种灵活的实验性散列算法，该算法使用神经网络体系结构来计算给定字符串的散列" FNN-Hash是一种创新的散列算法，它采用神经网络的结构来计算特定字符串的哈希值。该算法的灵活性在于其能够...
哈希函数RIPEMD-160的规格与计算过程
Chahot的博客
03-17 3326
RIPEMD160是96年制作的，基于MD4。所有的MD哈希运算法则本质上都是一样的，那就是通过多轮次的循环进入不同的压缩函数后，再与一些既定的XOR常数项进行运算即可。 RIPEMD处理的函数块大小是512bit，因此可以作为输入的消息应该是512的倍数，如果信息不是512bit的整数倍，则追加padding补齐相对的位数。Padding有不同的追加方式，最基本的是全
ripemd160实现源码
07-07
hash算法ripemd160，c语言编写
ripemd160 加密算法
象牙塔下的渣渣
06-02 8826
哈希值的输出值一般是16进制的字符串。而16进制字符串，每两个字符占一个字节。我们知道，一个字节=8bit. 以sha256为例： - 256bit-&gt;64位16进制字符。 package main import ( "fmt" "crypto/sha256" ) func main() { hasher := sha256.New() has...
SHA256与ripemd160两种算法应用
The_Reader的博客
10-08 2460
  package main import ( "crypto/sha256" "fmt" "encoding/hex" "golang.org/x/crypto/ripemd160" ) func main() { hashed := sha256.New() hashed.Write([]byte("i am wek")) hash := hashed.Sum(nil)...
算法收集 - Hash解析 -03- ripemd算法说明
BugMsg的专栏
04-17 928
ripemd算法        顾名思义ripemd就是成熟md算法，是Hans Dobbertin等3人在md4,md5的基础上，于1996年提出来的。算法共有4个标准128、160、256和320，其对应输出长度分别为16字节、20字节、32字节和40字节。不过，让人难以致信的是ripemd的设计者们根本就没有真正设计256和320位这2种标准，他们只是在128位和160位的基础上，修改了
单向散列 —— 简介、SHA256加密算法、RIPEMD160加密算法
The_Reader的博客
11-12 7905
单向散列 单向散列算法，又称hash函数（杂凑函数，或者杂凑算法），就是把任意输入消息字符串变成固定长的输出串的一种函数，这个输出串称为该消息的杂凑值，一般使用产生消息摘要，密钥加密等。具体指的是根据输入消息计算后，输出固定长度数值的算法，输出数值也成为“散列值”或消息摘要，其长度通常在128~256位之间。 输入的长度可以是任意的 输出长度是固定的，根据目前的计算技术应至少取128bit长...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值