SHA家族

時間 2020-05-12

標籤 sha 家族简体版

原文原文鏈接

安全散列算法（英語：Secure Hash Algorithm，縮寫爲SHA）是一個密碼散列函數家族，是FIPS所認證的安全散列算法。能計算出一個數字消息所對應到的，長度固定的字符串（又稱消息摘要）的算法。且若輸入的消息不一樣，它們對應到不一樣字符串的機率很高。java

家族成員

SHA家族的五個算法，分別是SHA-1、SHA-22四、SHA-25六、SHA-384，和SHA-512，由美國國家安全局（NSA）所設計，並由美國國家標準與技術研究院（NIST）發佈；是美國的政府標準。後四者有時並稱爲SHA-2。SHA-1在許多安全協定中廣爲使用，包括TLS和SSL、PGP、SSH、S/MIME和IPsec，曾被視爲是MD5（更早以前被廣爲使用的雜湊函數）的後繼者。但SHA-1的安全性現在被密碼學家嚴重質疑；雖然至今還沒有出現對SHA-2有效的攻擊，它的算法跟SHA-1基本上仍然類似；所以有些人開始發展其餘替代的雜湊算法。 [1]算法

SHA-0和1

最初載明的算法於1993年發佈，稱作安全雜湊標準（Secure Hash Standard），FIPS PUB 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的64次方位元的訊息，轉換成一串160位元的訊息摘要；其設計原理類似於MIT教授Ronald L. Rivest所設計的密碼學雜湊算法 MD4和 MD5。

SHA-0破解

在CRYPTO 98上，兩位法國研究者提出一種對SHA-0的攻擊方式：在261的計算複雜度以內，就能夠發現一次碰撞（即兩個不一樣的訊息對應到相同的訊息摘要）；這個數字小於生日攻擊法所需的2的80次方，也就是說，存在一種算法，使其安全性不到一個理想的雜湊函數抵抗攻擊所應具有的計算複雜度。

2004年時，Biham和 Chen也發現了SHA-0的近似碰撞，也就是兩個訊息能夠雜湊出幾乎相同的數值；其中162位元中有142位元相同。他們也發現了SHA-0的完整碰撞（相對於近似碰撞），將原本須要80次方的複雜度下降到62次方。

2004年8月12日，Joux, Carribault, Lemuet和Jalby宣佈找到SHA-0算法的完整碰撞的方法，這是概括Chabaud和Joux的攻擊所完成的結果。發現一個完整碰撞只須要251的計算複雜度。他們使用的是一臺有256顆Itanium2處理器的超級電腦，約耗80,000 CPU工時。

2004年8月17日，在 CRYPTO 2004的Rump會議上，王小云，馮登國、來學嘉，和於紅波宣佈了攻擊 MD5、SHA-0 和其餘雜湊函數的初步結果。他們攻擊SHA-0的計算複雜度是2的40次方，這意味着他們的攻擊成果比Joux還有其餘人所作的更好。請參見MD5 安全性。2005年二月，王小云和殷益羣、於紅波再度發表了對SHA-0破密的算法，可在2的39次方的計算複雜度內就找到碰撞。

SHA-1破解

鑑於SHA-0的破密成果，專家們建議那些計劃利用SHA-1實做密碼系統的人們也應從新考慮。在2004年 CRYPTO會議結果公佈以後，NIST即宣佈他們將逐漸減小使用SHA-1，改以SHA-2取而代之。

2005年，Rijmen和Oswald發表了對SHA-1較弱版本（53次的加密循環而非80次）的攻擊：在2的80次方的計算複雜度以內找到碰撞。

2005年二月，王小云、殷益羣及於紅波發表了對完整版SHA-1的攻擊，只需少於2的69次方的計算複雜度，就能找到一組碰撞。（利用生日攻擊法找到碰撞須要2的80次方的計算複雜度。）

這篇論文的做者們寫道；「咱們的破密分析是以對付SHA-0的差分攻擊、近似碰撞、多區塊碰撞技術、以及從MD5算法中尋找碰撞的訊息更改技術爲基礎。沒有這些強力的分析工具，SHA-1就沒法破解。」此外，做者還展現了一次對58次加密循環SHA-1的破密，在2的33次方個單位操做內就找到一組碰撞。完整攻擊方法的論文發表在2005年八月的CRYPTO會議中。

殷益羣在一次面談中如此陳述：「大體上來講，咱們找到了兩個弱點：其一是前置處理不夠複雜；其二是前20個循環中的某些數學運算會形成不可預期的安全性問題。」

2005年8月17日的CRYPTO會議尾聲中王小云、姚期智、姚儲楓再度發表更有效率的SHA-1攻擊法，能在2的63次方個計算複雜度內找到碰撞。

2006年的CRYPTO會議上，Christian Rechberger和Christophe De Cannière宣佈他們能在允許攻擊者決定部分原訊息的條件之下，找到SHA-1的一個碰撞。

在密碼學的學術理論中，任何攻擊方式，其計算複雜度若少於暴力搜尋法所須要的計算複雜度，就能被視爲針對該密碼系統的一種破密法；但這並不表示該破密法已經能夠進入實際應用的階段。

就應用層面的考量而言，一種新的破密法出現，暗示着未來可能會出現更有效率、足以實用的改良版本。雖然這些實用的破密法版本根本還沒誕生，但確有必要發展更強的雜湊算法來取代舊的算法。在「碰撞」攻擊法以外，另有一種反譯攻擊法（Pre-image attack），就是由雜湊出的字串反推本來的訊息；反譯攻擊的嚴重性更在碰撞攻擊之上，但也更困難。在許多會應用到密碼雜湊的情境（如用戶密碼的存放、文件的數位簽章等）中，碰撞攻擊的影響並非很大。舉例來講，一個攻擊者可能不會只想要僞造一份如出一轍的文件，而會想改造原來的文件，再附上合法的簽章，來愚弄持有私密金鑰的驗證者。另外一方面，若是能夠從密文中反推未加密前的使用者密碼，攻擊者就能利用獲得的密碼登入其餘使用者的賬戶，而這種事在密碼系統中是不能被容許的。但若存在反譯攻擊，只要能獲得指定使用者密碼雜湊事後的字串（一般存在影檔中，並且可能不會透露原密碼資訊），就有可能獲得該使用者的密碼。 [1]

SHA-1算法

如下是 SHA-1 算法的僞代碼：

Initialize variables:
h0 := 0x67452301
h1 := 0xEFCDAB89
h2 := 0x98BADCFE
h3 := 0x10325476
h4 := 0xC3D2E1F0
Pre-processing:
append the bit '1' to the message
append k bits '0', where k is the minimum number >= 0 such that the resulting message
length (in bits) is congruent to 448 (mod 512)
append length of message (before pre-processing), in bits, as 64-bit big-endian integer
Process the message in successive 512-bit chunks:
break message into 512-bit chunks
for each chunk
break chunk into sixteen 32-bit big-endian words w[i], 0 ≤ i ≤ 15
Extend the sixteen 32-bit words into eighty 32-bit words:
for i from 16 to 79
w[i] := (w[i-3] xor w[i-8] xor w[i-14] xor w[i-16]) leftrotate 1
Initialize hash value for this chunk:
a := h0
b := h1
c := h2
d := h3
e := h4
Main loop:
for i from 0 to 79
if 0 ≤ i ≤ 19 then
f := (b and c) or ((not b) and d)
k := 0x5A827999
else if 20 ≤ i ≤ 39
f := b xor c xor d
k := 0x6ED9EBA1
else if 40 ≤ i ≤ 59
f := (b and c) or (b and d) or (c and d)
k := 0x8F1BBCDC
else if 60 ≤ i ≤ 79
f := b xor c xor d
k := 0xCA62C1D6
temp := (a leftrotate 5) + f + e + k + w[i]
e := d
d := c
c := b leftrotate 30
b := a
a := temp
Add this chunk's hash to result so far:
h0 := h0 + a
h1 := h1 + b
h2 := h2 + c
h3 := h3 + d
h4 := h4 + e
Produce the final hash value (big-endian):
digest = hash = h0 append h1 append h2 append h3 append h4

SHA-2

NIST發佈了三個額外的SHA變體，這三個函數都將訊息對應到更長的訊息摘要。以它們的摘要長度（以位元計算）加在原名後面來命名：SHA-256，SHA-384和SHA-512。它們發佈於2001年的FIPS PUB 180-2草稿中，隨即經過審查和評論。包含SHA-1的FIPS PUB 180-2，於2002年以官方標準發佈。2004年2月，發佈了一次FIPS PUB 180-2的變動通知，加入了一個額外的變種SHA-224"，這是爲了符合雙金鑰3DES所需的金鑰長度而定義。

SHA-256和SHA-512是很新的雜湊函數，前者以定義一個word爲32位元，後者則定義一個word爲64位元。它們分別使用了不一樣的偏移量，或用不一樣的常數，然而，實際上兩者結構是相同的，只在循環執行的次數上有所差別。SHA-224以及SHA-384則是前述二種雜湊函數的截短版，利用不一樣的初始值作計算。

這些新的雜湊函數並無接受像SHA-1同樣的公衆密碼社羣作詳細的檢驗，因此它們的密碼安全性還不被你們普遍的信任。Gilbert和Handschuh在2003年曾對這些新變種做過一些研究，聲稱他們沒有找到弱點。 [2]

應用

SHA-1, SHA-224, SHA-256, SHA-384 和 SHA-512 都被須要安全雜湊算法的美國聯邦政府所應用，他們也使用其餘的密碼算法和協定來保護敏感的未保密資料。FIPS PUB 180-1也鼓勵私人或商業組織使用 SHA-1 加密。Fritz-chip 將極可能使用 SHA-1 雜湊函數來實現我的電腦上的數位版權管理。

首先推進安全雜湊算法出版的是已合併的數位簽章標準。

SHA 雜湊函數已被作爲 SHACAL 分組密碼算法的基礎。 [3]

哈希表介紹

散列表（Hash table，也叫哈希表），是根據關鍵碼值(Key value)而直接進行訪問的數據結構。也就是說，它經過把關鍵碼值映射到表中一個位置來訪問記錄，以加快查找的速度。這個映射函數叫作散列函數，存放記錄的數組叫作散列表。
15 111 % 15數據庫

問題

有一個公司,當有新的員工來報道時,要求將該員工的信息加入(id,性別,年齡,名字,住址..),當輸入該員工的id時,要求查找到該員工的全部信息.數組

要求:
不使用數據庫,,速度越快越好=>哈希表(散列)
添加時，保證按照id從低到高插入 [課後思考：若是id不是從低到高插入，但要求各條鏈表還是從低到高，怎麼解決?]
使用鏈表來實現哈希表, 該鏈表不帶表頭[即: 鏈表的第一個結點就存放僱員信息]
思路分析並畫出示意圖
代碼實現[增刪改查(顯示全部員工，按id查詢)]安全

代碼實現

1 package cn.smallmartial.hashTable;
  2 
  3 import java.util.HashMap;
  4 import java.util.Scanner;
  5 
  6 /**
  7  * @Author smallmartial
  8  * @Date 2019/6/13
  9  * @Email smallmarital@qq.com
 10  */
 11 public class HashTableDemo {
 12 
 13     public static void main(String[] args) {
 14         //建立hash表
 15         HashTab hashTab = new HashTab(7);
 16 
 17         //寫一個簡單的菜單
 18         String key = "";
 19         Scanner scanner = new Scanner(System.in);
 20         while(true) {
 21             System.out.println("add:  添加僱員");
 22             System.out.println("list: 顯示僱員");
 23             System.out.println("find: 查找僱員");
 24             System.out.println("exit: 退出系統");
 25 
 26             key = scanner.next();
 27             switch (key) {
 28                 case "add":
 29                     System.out.println("輸入id");
 30                     int id = scanner.nextInt();
 31                     System.out.println("輸入名字");
 32                     String name = scanner.next();
 33                     //建立 僱員
 34                     Emp emp = new Emp(id, name);
 35                     hashTab.add(emp);
 36                     break;
 37                 case "list":
 38                     hashTab.list();
 39                     break;
 40                 case "find":
 41                     System.out.println("請輸入要查找的id");
 42                     id = scanner.nextInt();
 43                     hashTab.findEmpById(id);
 44                     break;
 45                 case "exit":
 46                     scanner.close();
 47                     System.exit(0);
 48                 default:
 49                     break;
 50             }
 51         }
 52     }
 53 }
 54 //建立hashTab
 55 class HashTab{
 56     private  int size;
 57     private EmpLinkedList[] empLinkedListArray;
 58 
 59     public HashTab(int size) {
 60         this.size = size;
 61         empLinkedListArray = new EmpLinkedList[size];
 62 
 63         for (int i = 0; i < size; i++) {
 64              empLinkedListArray[i] = new EmpLinkedList();
 65         }
 66 
 67     }
 68 
 69     //添加僱員
 70     public void add(Emp emp){
 71         //根據員工ID 添加到哪條聯
 72         int hashFun = hashFun(emp.id);
 73         empLinkedListArray[hashFun].add(emp);
 74 
 75     }
 76     
 77     //遍歷鏈表
 78     public void list(){
 79         for (int i = 0; i < size; i++) {
 80             empLinkedListArray[i].list(i);
 81         }
 82     }
 83 
 84     //根據輸入的id,查找僱員
 85     public void findEmpById(int id) {
 86         //使用散列函數肯定到哪條鏈表查找
 87         int empLinkedListNO = hashFun(id);
 88         Emp emp = empLinkedListArray[empLinkedListNO].findEmpById(id);
 89         if(emp != null) {//找到
 90             System.out.printf("在第%d條鏈表中找到 僱員 id = %d\n", (empLinkedListNO + 1), id);
 91         }else{
 92             System.out.println("在哈希表中，沒有找到該僱員~");
 93         }
 94     }
 95     public int hashFun(int id){
 96         return id % size;
 97     }
 98 }
 99 //表示僱員
100 class Emp {
101     public int id;
102     public String name;
103     public Emp next;
104 
105     public Emp(int id, String name) {
106         this.id = id;
107         this.name = name;
108     }
109 }
110 //表示鏈表
111 class EmpLinkedList{
112     private Emp head;
113 
114     public void add(Emp emp){
115         if (head == null){
116             head = emp;
117             return;
118         }
119 
120         Emp curEmp = head;
121         while (true){
122             if (curEmp.next == null){
123                 break;
124             }
125             curEmp = curEmp.next;
126         }
127         curEmp.next = emp;
128     }
129 
130     //遍歷
131     public void list(int no){
132         if (head == null){
133             System.out.println("第"+no+"前鏈表爲空");
134             return;
135         }
136         System.out.print("第"+no+"鏈表信息爲：");
137         Emp curEmp = head;
138         while (true){
139             System.out.print(curEmp.id+"=>"+curEmp.name);
140             if (curEmp.next == null){
141                 break;
142             }
143             curEmp = curEmp.next;
144         }
145         System.out.println();
146     }
147 
148     //根據id查找僱員
149     //若是查找到，就返回Emp, 若是沒有找到，就返回null
150     public Emp findEmpById(int id) {
151         //判斷鏈表是否爲空
152         if(head == null) {
153             System.out.println("鏈表爲空");
154             return null;
155         }
156         //輔助指針
157         Emp curEmp = head;
158         while(true) {
159             if(curEmp.id == id) {//找到
160                 break;//這時curEmp就指向要查找的僱員
161             }
162             //退出
163             if(curEmp.next == null) {//說明遍歷當前鏈表沒有找到該僱員
164                 curEmp = null;
165                 break;
166             }
167             curEmp = curEmp.next;//之後
168         }
169 
170         return curEmp;
171     }
172 }

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。