散列演算法代碼
❶ 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: