Theta() C 的 SHA-3 索引說明x,zX,和x,z

SHA-3： http ://csrc.nist.gov/publications/drafts/fips-202/fips_202_draft.pdf

我正在研究 SHA-3(256) 的 Python 實現，並使用在http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/SHA3-256_Msg30.pdf中找到的中間雜湊值例如 30 位散列消息。我在索引狀態數組時遇到問題。

在 30 位 SHA-3(256) 範例消息中，請參閱第 0 輪的 Theta() 之前的“異或狀態（作為整數通道）”。

[0, 0] = 00000001997b5853
[1, 0] = 0000000000000000
[2, 0] = 0000000000000000
[3, 0] = 0000000000000000
[4, 0] = 0000000000000000
[0, 1] = 0000000000000000
[1, 1] = 0000000000000000
[2, 1] = 0000000000000000
[3, 1] = 0000000000000000
[4, 1] = 0000000000000000
[0, 2] = 0000000000000000
[1, 2] = 0000000000000000
[2, 2] = 0000000000000000
[3, 2] = 0000000000000000
[4, 2] = 0000000000000000
[0, 3] = 0000000000000000
[1, 3] = 8000000000000000
[2, 3] = 0000000000000000
[3, 3] = 0000000000000000
[4, 3] = 0000000000000000
[0, 4] = 0000000000000000
[1, 4] = 0000000000000000
[2, 4] = 0000000000000000
[3, 4] = 0000000000000000
[4, 4] = 0000000000000000

我假設車道被標記

$$ x,y $$, 並且是關於 SHA-3 中的約定大綱, 3.1.4 其中$$ 0,0 $$=00000001997b5853 表示狀態數組的中間通道。 我可以製作那些 25 個 64 位通道。我的理解是，如果您將這些通道從上到下連接起來，也就是說按照它們在範例文件中出現的順序，您將生成表示狀態數組的總位字元串，然後將其傳遞到 Theta()？string_representing_state_array='

現在從 3.1.2 開始，A

$$ x,y,z $$=S$$ w(5y+x)+z $$ w 是常數 64。

C[x,z]=S[w(5(0)+x)+z] ? S[w(5(1)+x)+z] ? S[w(5(2)+x)+z] ? S[w(5(3)+x)+z] ? S[w(5(4)+x)+z].

函式異或：

def xo(bit_string_1,bit_string_2):
   xor_list=[]
   for i in range(len(bit_string_1)):
       if bit_string_1[i]=='0' and bit_string_2[i]=='0':
           xor_list.append('0')
       if bit_string_1[i]=='1' and bit_string_2[i]=='1':
           xor_list.append('0')
       if bit_string_1[i]=='0' and bit_string_2[i]=='1':
           xor_list.append('1')
       if bit_string_1[i]=='1' and bit_string_2[i]=='0':
           xor_list.append('1')
   return(l_s(xor_list))

def L_P(SET,n):
   #A function to break SET into n length chunks
   to_return=[]
   j=0
   k=n
   while k<len(SET)+1:
       to_return.append(SET[j:k])
       j=k
       k+=n 
   return(to_return)

def beta_theta(s):
   c_xz=[]
   for x in range(5):
       for z in range(64):
           c_xz.append(xo(xo(xo(xo(s[(64*((5*4)+x))+z],s[(64*((5*3)+x))+z]),s[(64*((5*2)+x))+z]),s[(64*((5*1)+x))+z]),s[(64*((5*0)+x))+z]))
   c_xz=L_P(c_xz,64)
   return(c_xz)

其中 s=string_representing_state_array。

我現在的問題是，如果函式 beta_theta(s) 返回 c_xz，並且在 theta() 中的第 2 步具有正確的索引？我正在使用 320 位 c_xz 並將其拆分為 5 個 64 位塊，但我認為這不會返回正確的索引來生成 d_xz。

PS。SHA-3 <<<<<<< 奧卡姆剃刀。

我花了很多時間閱讀您的程式碼，我確實認為這個問題最終在這裡有點離題。所以請按照我的所有評論和程式碼審查（即使我不應該……）

首先，即使您實現它的方式非正常，您的索引等也沒有錯……對於 $ \theta $ 操作（它變得更棘手 $ \pi $ 和 $ \rho $ ).

這 $ \theta $ 步驟需要使用兩個輔助數組：一個用於奇偶校驗（您的c_xz），一個用於計算theta 效應。請務必這樣做，以免您讀取修改後的值！.

概述 $ \theta $ 是以下（現在你是對的）：

這是我對您的程式碼的評論和一些改進建議，繼續…

首先你寫這個：

def xo(bit_string_1,bit_string_2):
   xor_list=[]
   for i in range(len(bit_string_1)):
       if bit_string_1[i]=='0' and bit_string_2[i]=='0':
           xor_list.append('0')
       if bit_string_1[i]=='1' and bit_string_2[i]=='1':
           xor_list.append('0')
       if bit_string_1[i]=='0' and bit_string_2[i]=='1':
           xor_list.append('1')
       if bit_string_1[i]=='1' and bit_string_2[i]=='0':
           xor_list.append('1')
   return xor_list

很難理解你在做什麼，你應該嘗試分成多個子功能。見下圖：

# implementation of the xor between two chars (easier to read and uses the XOR operator)
def xor_string(a,b):
   return '1' if ((a == '1') ^ (b == '1')) else '0';

# the same function as yours but a bit more readable
def xor_list_string(a,b):
   xor_list = []
   for i in range(len(a)):
       xor_list.append(xor_string(a[i],b[i]))
   return xor_list

# test : should result in ['0','1','1','0']
lst1 = ['0','0','1','1']
lst2 = ['0','1','0','1']

print xo(lst1,lst2)
print xor_list_string(lst1,lst2)

在您定義的下一個函式中：

def L_P(SET,n):
   #A function to break SET into n length chunks
   to_return=[]
   j=0
   k=n
   while k<len(SET)+1:
       to_return.append(SET[j:k])
       j=k
       k+=n
   return(to_return)

k 的使用是多餘的，見下圖：

def L_P2(SET,n):
   to_return = [] ; j = 0
   while j + n <= len(SET):
       to_return.append(SET[j:j+n])
       j += n
   return to_return

然後你的定義beta_theta相當模糊（在那個鏈中發生了什麼xo。你不需要內聯表達式。另外因為你正在訪問位，我建議你定義一個訪問函式：

def pos(x,y,z,w):
   return (w*((5*y)+x))+z

因此您可以計算奇偶校驗平面或c_xz：

# get the parity plane
def theta_plane(s,w):
   c_xz = []  #this will be the parity plane
   for x in range(5):
       for z in range(w):
           aux1 = xor_string(s[pos(x,0,z,w)],s[pos(x,1,z,w)])
           aux2 = xor_string(s[pos(x,2,z,w)],s[pos(x,3,z,w)])
           aux1 = xor_string(s[pos(x,4,z,w)],aux1)
           aux1 = xor_string(aux1,aux2)
           c_xz.append(aux1)
   c_xz = L_P(c_xz,w)
   return(c_xz)

# or even better:
def theta_plane_b(s,w):
   c_xz = []  #this will be the parity plane
   for x in range(5):
       for z in range(w):
           aux = '0'
           for y in range(5): #this shows clearly that you are xoring over y.
               aux = xor_string(aux,b(s,x,y,z,w))

           c_xz.append(aux)

   c_xz = L_P(c_xz,w)
   return(c_xz)

之後，您可以計算您的 theta 效應：

def theta_effect(c_xz,w):
   d_xz = []
   for x in range(5):
       aux = []
       for z in range(w):
           aux.append(xor_string(c_xz[(x-1)%5][z],c_xz[(x+1)%5][(z-1)%w]))
           #This needed a mod 5
       d_xz.append(aux)
   return d_xz

然後，您可以將 theta 效果返回到狀態：

def xor_back_to_state(s,d_xz,w):
   for x in range(5):
       for z in range(w):
           for y in xrange(5):
               s[pos(x,y,z,w)] = xor_string(s[pos(x,y,z,w)],d_xz[x][z])

   return s

def theta(state,w):
   c_xz = []
   d_xz = []
   s_xyz = []
   c_xz = beta_theta(state,w)
   d_xz = theta_effect(c_xz,w)
   s_xyz = xor_back_to_state(d_xz,w)
   return s_xyz

我希望這個答案對您的編碼實踐和對 Keccak 的看法有所幫助。

引用自：https://crypto.stackexchange.com/questions/42450