散列算法代码
❶ sha256算法填充电路部分代码
包括了：SHA-224、SHA-256、SHA-384、SHA-512、SHA-512/224、SHA-512/256。
这些变体除了生成摘要的长度、循环运行的次数等一些微小差异外，算法的基本结构是一致的。
回到SHA256上，说白了，它就是一个哈希函数。
哈希函数，又称散列算法，是一种从任何一种数据中创建小的数字“指纹”的方法。
散列函数把消息或数据压缩成摘要，使得数据量变小，将数据的格式固定下来。
该函数将数据打乱混合，重新创建一个叫做散列值（或哈希值）的指纹。散列值通常用一个短的随机字母和数字组成的字符串来代表。
❷ 一个安全的散列算法需要具备哪些属性
一个安全的散列算法需要具备的属性：
1、能对抗野蛮的攻击，能够抵御穷举法的攻势。
2、具有无限定义域，如任意长度的字节字符串和有限的值域或者固定长度的比特串。
3、具备应用的多样性，对于给定的散列值，没有实用的方法可以计算出一个原始输入，也就是说很难伪造。
4、能够因为环境因素的变化，如机器配置或者IP地址的改变而有变动。以保证源文件的安全性。
5、方便错误监测和修复函数。当散列函数被用于校验和的时候可以用相对较短的散列值来验证任意长度的数据是否被更改过。
6、安全散列算法接受的输入文档小于2的64次方 位，产生160位的报文摘要。该算法实际的目标使得找出一个能够匹配给定的散列值的文本是不可能的计算。
❸ 常用的散列函数有哪些
常用的哈希函数
通用的哈希函数库有下面这些混合了加法和一位操作的字符串哈希算法。下面的这些算法在用法和功能方面各有不同，但是都可以作为学习哈希算法的实现的例子。(其他版本代码实现见下载）
1.RS
从RobertSedgwicks的Algorithms in C一书中得到了。我(原文作者)已经添加了一些简单的优化的算法，以加快其散列过程。
[java]view plainprint?
publiclongRSHash(Stringstr)
{
intb=378551;
inta=63689;
longhash=0;
for(inti=0;i<str.length();i++)
{
hash=hash*a+str.charAt(i);
a=a*b;
}
returnhash;
}
publiclongJSHash(Stringstr)
{
longhash=1315423911;
for(inti=0;i<str.length();i++)
{
hash^=((hash<<5)+str.charAt(i)+(hash>>2));
}
returnhash;
}
publiclongPJWHash(Stringstr)
{
longBitsInUnsignedInt=(long)(4*8);
longThreeQuarters=(long)((BitsInUnsignedInt*3)/4);
longOneEighth=(long)(BitsInUnsignedInt/8);
longHighBits=(long)(0xFFFFFFFF)<<(BitsInUnsignedInt-OneEighth);
longhash=0;
longtest=0;
for(inti=0;i<str.length();i++)
{
hash=(hash<<OneEighth)+str.charAt(i);
if((test=hash&HighBits)!=
2.JS
Justin Sobel写的一个位操作的哈希函数。
[c-sharp]view plainprint?
3.PJW
该散列算法是基于贝尔实验室的彼得J温伯格的的研究。在Compilers一书中（原则，技术和工具），建议采用这个算法的散列函数的哈希方法。
[java]view plainprint?
❹ C语言中的hash函数
Hash，一般翻译做"散列"，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
HASH主要用于信息安全领域中加密算法，它把一些不同长度的信息转化成杂乱的128位的编码里，叫做HASH值. 也可以说，hash就是找到一种数据内容和数据存放地址之间的映射关系。Hash算法在信息安全方面的应用主要体现在以下的3个方面：文件校验、数字签名、鉴权协议
程程序实现
// 说明：Hash函数（即散列函数）在程序设计中的应用目标 ------ 把一个对象通过某种转换机制对应到一个
//size_t类型（即unsigned long）的整型值。
// 而应用Hash函数的领域主要是 hash表（应用非常广）、密码等领域。
// 实现说明：
// ⑴、这里使用了函数对象以及泛型技术，使得对所有类型的对象（关键字）都适用。
// ⑵、常用类型有对应的偏特化，比如string、char*、各种整形等。
// ⑶、版本可扩展，如果你对某种类型有特殊的需要，可以在后面实现专门化。
// ⑷、以下实现一般放在头文件中，任何包含它的都可使用hash函数对象。
//------------------------------------实现------------------------------------------------
#include <string>
using std::string;
inlinesize_thash_str(const char* s)
{
unsigned long res = 0;
for (; *s; ++s)
res = 5 * res + *s;
returnsize_t(res);
}
template <class Key>
struct hash
{
size_toperator () (const Key& k) const;
};
// 一般的对象，比如：vector< queue<string> >；的对象，需要强制转化
template < class Key >
size_thash<Key>::operator () (const Key& k) const
{
size_tres = 0;
size_tlen = sizeof(Key);
const char* p = reinterpret_cast<const char*>(&k);
while (len--)
{
res = (res<<1）^*p++;
}
return res;
}
// 偏特化
template<>
size_thash< string >::operator () (const string& str) const
{
return hash_str(str.c_str());
}
typedef char* PChar;
template<>
size_thash<PChar>::operator () (const PChar& s) const
{
return hash_str(s);
}
typedef const char* PCChar;
template<>
size_thash<PCChar>::operator () (const PCChar& s) const
{
return hash_str(s);
}
template<> size_t hash<char>::operator () (const char& x) const { return x; }
template<> size_t hash<unsigned char>::operator () (const unsigned char& x) const { return x; }
template<> size_t hash<signed char>::operator () (const signed char& x) const { return x; }
template<> size_t hash<short>::operator () (const short& x) const { return x; }
template<> size_t hash<unsigned short>::operator () (const unsigned short& x) const { return x; }
template<> size_t hash<int>::operator () (const int& x) const { return x; }
template<> size_t hash<unsigned int>::operator () (const unsigned int& x) const { return x; }
template<> size_t hash<long>::operator () (const long& x) const { return x; }
template<> size_t hash<unsigned long>::operator () (const unsigned long& x) const { return x; }
// 使用说明：
//
// ⑴、使用时首先由于是泛型，所以要加上关键字类型。
//
// ⑵、其次要有一个函数对象，可以临时、局部、全局的，只要在作用域就可以。
//
// ⑶、应用函数对象作用于对应类型的对象。
//----------------------- hash函数使用举例 -------------------------
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main()
{
vector<string> vstr⑵；
vstr[0] = "sjw";
vstr[1] = "suninf";
hash<string> strhash; // 局部函数对象
cout << " Hash value: " << strhash(vstr[0]) << endl;
cout << " Hash value: " << strhash(vstr[1]) << endl;
cout << " Hash value: " << hash< vector<string> >() (vstr) << endl;
cout << " Hash value: " << hash<int>() （100） << endl; // hash<int>() 临时函数对象
return 0;
}
❺ 什么是单向散列算法
散列函数
又称hash函数，Hash函数(也称杂凑函数或杂凑算法)就是把任意长的输入消息串变化成固定长的输出串的一种函数。这个输出串称为该消息的杂凑值。一般用于产生消息摘要，密钥加密等.
一个安全的杂凑函数应该至少满足以下几个条件:
①输入长度是任意的;
②输出长度是固定的,根据目前的计算技术应至少取128bits长,以便抵抗生日攻击;
③对每一个给定的输入,计算输出即杂凑值是很容易的
④给定杂凑函数的描述,找到两个不同的输入消息杂凑到同一个值是计算上不可行的,或给定杂凑函数的描述和一个随机选择的消息,找到另一个与该消息不同的消息使得它们杂凑到同一个值是计算上不可行的。
Hash函数主要用于完整性校验和提高数字签名的有效性,目前已有很多方案。这些算法都是伪随机函数,任何杂凑值都是等可能的。输出并不以可辨别的方式依赖于输入;在任何输入串中单个比特的变化,将会导致输出比特串中大约一半的比特发生变化。
常见散列函数(Hash函数)
·MD5（Message Digest Algorithm 5）：是RSA数据安全公司开发的一种单向散列算法，MD5被广泛使用，可以用来把不同长度的数据块进行暗码运算成一个128位的数值；
·SHA（Secure Hash Algorithm）这是一种较新的散列算法，可以对任意长度的数据运算生成一个160位的数值；
·MAC（Message Authentication Code）：消息认证代码，是一种使用密钥的单向函数，可以用它们在系统上或用户之间认证文件或消息。HMAC（用于消息认证的密钥散列法）就是这种函数的一个例子。
·CRC（Cyclic Rendancy Check）：循环冗余校验码，CRC校验由于实现简单，检错能力强，被广泛使用在各种数据校验应用中。占用系统资源少，用软硬件均能实现，是进行数据传输差错检测地一种很好的手段（CRC 并不是严格意义上的散列算法，但它的作用与散列算法大致相同，所以归于此类）。
❻ 有没有基于哈希算法实现的英汉词典代码（c/c++实现）
如果你用的是C++11或者以上，unordered_map是最好的选择，
因为这个容器本身就是哈希实现的。
#include<unordered_map>
#include<string>
#include<iostream>
usingnamespacestd;
intmain()
{
unordered_map<string,string>Dict;
Dict["Hello"]="你好";
Dict["You"]="你";
Dict["Good"]="Good";
cout<<Dict["Hello"]<<endl;
return0;
}
如果你用的是老的c++，只有map可用的话，可以自己写个hash函数，
我采用了ELFHash，针对字符串的：
#include<map>
#include<string>
#include<iostream>
usingnamespacestd;
unsignedELFHash(string&s)
{
constchar*str=s.c_str();
unsignedhash=0;
unsignedx=0;
while(*str)
{
hash=(hash<<4)+(*str++);
if((x=hash&0xF0000000L)!=0)
{
hash^=(x>>24);
hash&=~x;
}
}
return(hash&0x7FFFFFFF);
}
map<unsigned,string>Dict;
boolAddWord(stringen,stringzh)
{
unsignedhash=ELFHash(en);
if(Dict.find(hash)==Dict.end())
{
Dict[hash]=zh;
returntrue;
}
else
returnfalse;
}
string&GetWord(stringen)
{
unsignedhash=ELFHash(en);
if(Dict.find(hash)!=Dict.end())
returnDict[hash];
returnstring();
}
intmain()
{
AddWord("Hello","你好");
AddWord("You","你");
AddWord("Good","好");
cout<<GetWord("Hello")<<endl;
return0;
}
❼ 设计一个散列函数，用它存储二维点的坐标。这是我们的C语言编程作业，我写了如下代码，但是有BUG：
这个已经帮你改了，你可以运行一下
# include <stdio.h>
# include <malloc.h>
# include <string.h>
#define NHASH 31
typedef struct zuobiao
{
int x;
int y;
struct zuobiao * next; //chain
}Nameval;
//函数声明
Nameval * create();
Nameval *srt(Nameval *head,Nameval *t);
void main(void)
{
Nameval * sym,*head;
head=create();
//print(head);
sym=(struct zuobiao*)malloc(sizeof(struct zuobiao));
printf("请输入要查找的坐标值：\nx = ");
scanf("%d", &sym->x);
printf("y = "); scanf("%d", &sym->y);
srt(head,sym);
}
///////////////////////////////////////////////////////////////
Nameval * create()
{
Nameval *head,*tail,*p;int x;
head= tail=NULL;
printf("请输入坐标点的个数：");
scanf("%d",&x);
while(x>0)
{
p=(struct zuobiao*)malloc(sizeof(struct zuobiao));
printf("请输入坐标的值：\nx = ");
scanf("%d", &p->x);
printf("y = "); scanf("%d", &p->y);
//p->age=x;
p->next=NULL;
if(head==NULL)
{
head=tail=p;
}
else
{
tail->next=p;
tail=p;
}
x--;
}
return(head);
}
//////////////////////////////////////////////////////////////////
Nameval *srt(Nameval *head,Nameval *t)
{
Nameval *p,*q;
p=(Nameval *)malloc(sizeof(Nameval));
p=head;
if(p==NULL) return NULL;
while(((p->x!=t->x)||(p->y!=t->y))&&(p->next!=NULL))
{
q=p;
p=p->next;
}
if((p->x==t->x)&&(p->y==t->y))
{
printf("已经有了这个坐标\n");
}
else if((p->next==NULL)&&(p->x!=t->x))
{
p->next=t;
t->next=NULL;
printf("新坐标已经插入\n");
}
//free(p);
return head;
}
可以推荐你加QQ群218691837
❽ 散列算法的概念
在信息安全技术中，经常需要验证消息的完整性，散列（Hash）函数提供了这一服务，它对不同长度的输入消息，产生固定长度的输出。这个固定长度的输出称为原输入消息的“散列”或“消息摘要”（Message digest）。一个安全的哈希函数H必须具有以下属性：
l）H能够应用到大小不一的数据上。
2）H能够生成大小固定的输出。
3）对于任意给定的x，H（x）的计算相对简单。
4）对于任意给定的代码h，要发现满足H（x）=h的x在计算上是不可行的。
5) 对于任意给定的块x，要发现满足H（y）=H（x）而y=x在计算上是不可行的。
6）要发现满足H（X）=H（y）的（X，y）对在计算上是不可行的
❾ 非高手勿扰!请教高手:哈希值是怎样计算的原理是什么
1 基本原理
我们使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数， 也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素"分类"，然后将这个元素存储在相应"类"所对应的地方。
但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了"冲突"，换句话说，就是把不同的元素分在了相同的"类"之中。后面我们将看到一种解决"冲突"的简便做法。
总的来说，"直接寻址"与"解决冲突"是哈希表的两大特点。
2 函数构造
构造函数的常用方法（下面为了叙述简洁，设 h(k) 表示关键字为 k 的元素所对应的函数值）：
a) 除余法：
选择一个适当的正整数 p ，令 h(k ) = k mod p
这里， p 如果选取的是比较大的素数，效果比较好。而且此法非常容易实现，因此是最常用的方法。
b) 数字选择法：
如果关键字的位数比较多，超过长整型范围而无法直接运算，可以选择其中数字分布比较均匀的若干位，所组成的新的值作为关键字或者直接作为函数值。
3 冲突处理
线性重新散列技术易于实现且可以较好的达到目的。令数组元素个数为 S ，则当 h(k) 已经存储了元素的时候，依次探查 (h(k)+i) mod S , i=1,2,3…… ，直到找到空的存储单元为止（或者从头到尾扫描一圈仍未发现空单元，这就是哈希表已经满了，发生了错误。当然这是可以通过扩大数组范围避免的）。
4 支持运算
哈希表支持的运算主要有：初始化(makenull)、哈希函数值的运算(h(x))、插入元素(insert)、查找元素(member)。
设插入的元素的关键字为 x ，A 为存储的数组。
初始化比较容易，例如
const empty=maxlongint; // 用非常大的整数代表这个位置没有存储元素
p=9997; // 表的大小
procere makenull;
var i:integer;
begin
for i:=0 to p-1 do
A[i]:=empty;
End;
哈希函数值的运算根据函数的不同而变化，例如除余法的一个例子：
function h(x:longint):Integer;
begin
h:= x mod p;
end;
我们注意到，插入和查找首先都需要对这个元素定位，即如果这个元素若存在，它应该存储在什么位置，因此加入一个定位的函数 locate
function locate(x:longint):integer;
var orig,i:integer;
begin
orig:=h(x);
i:=0;
while (i<S)and(A[(orig+i)mod S]<>x)and(A[(orig+i)mod S]<>empty) do
inc(i);
//当这个循环停下来时，要么找到一个空的存储单元，要么找到这个元
//素存储的单元，要么表已经满了
locate:=(orig+i) mod S;
end;
插入元素
procere insert(x:longint);
var posi:integer;
begin
posi:=locate(x); //定位函数的返回值
if A[posi]=empty then A[posi]:=x
else error; //error 即为发生了错误，当然这是可以避免的
end;
查找元素是否已经在表中
procere member(x:longint):boolean;
var posi:integer;
❿ lanman散列算法对用户口令信息进行处理时，密钥长度为多少字符
1、 Windows系统本地帐号信息存储
Windows NT/2000/2003/XP等系统使用sam文件作为本地用户账户数据库，所有本地帐号的登录名和口令等相关信息都保存在这个文件中。系统对保存在sam中的口令信息进行了加密处理，以保护口令信息的机密性。此外，在系统运行期间，sam文件被system账号锁定，即使是administrator账号也无法对其进行删除或拷贝等操作。 为了保证Windows操作系统的向后兼容性，Windows NT/2000/2003/XP系统采用了两种不同的机制对帐号的口令信息进行加密，所以在sam文件中每个用户口令对应着两个口令字，一个是LanMan版本的LM散列值，另一个是NT版本的NTLM散列值。
LanMan散列算法
LanMan散列算法对用户口令信息的处理过程：
第一，将所有英文字母均转换为大写字母形式；
第二，检查密钥长度是否是14个字符，如果密钥长度不足14个字符则用0补足；（注：Windows NT和Windows 2000系统密钥最长为14个字符，而Windows 2003和xp无此限制，如果密钥超过14个字符，则不会生成LM散列值，而是只生成NTLM散列值）
第三，将密钥平均分成两份，每份含7个字符，再分别对每份密钥进行加密处理；
第四，最后将加密处理后的密码组合起来。得到最终的LM散列值。
LM Hash示例：假设明文口令是"Welcome"
首先全部转换成大写，再变换成机器存储模式数据，在变换过程中如果明文口令不足14字节，则在后面添加0x00补足14字节。
"WELCOME" -> 57454C434F4D4500000000000000
(注：可以将明文口令复制到UltraEdit编辑器中使用十六进制方式查看即可获取明文口令的十六进制串）
然后将上述代码分割成两组7字节的数据，分别经str_to_key()函数处理得到两组8字节数据
57454C434F4D45 -str_to_key()-> 56A25288347A348A
00000000000000 -str_to_key()-> 0000000000000000
这两组8字节数据将采用DESKEY算法对魔术字符串"KGS!@#$%"进行标准DES加密，"KGS!@#$%"对应的机器代码为：4B47532140232425
56A25288347A348A -对4B47532140232425进行标准DES加密-> C23413A8A1E7665F
0000000000000000 -对4B47532140232425进行标准DES加密-> AAD3B435B51404EE
最后将加密后的这两组数据简单拼接，就得到了最后的LM Hash
LM Hash: