此為轉貼資料 加密：DES演算法 最著名的保密密鑰或對稱密鑰加密演算法DES(Data Encryption Standard)是由IBM公司在70年代發展起來的，並經過政府的加密標準篩選後，於1976年11月被美國政府採用，DES隨後被美國國家標準局和美國國家標準協會(American National Standard Institute， ANSI) 承認。 DES使用56位密鑰對64位的資料塊進行加密，並對64位的資料塊進行16輪編碼。與每輪編碼時，一個48位元的“每輪”密鑰值由56位的完整密鑰得出來。DES用軟體進行解碼需要用很長時間，而用硬體解碼速度非常快，但幸運的是當時大多數黑客並沒有足夠的設備製造出這種硬體設備。在1977年，人們估計要耗資兩千萬美元才能建成一個專門電腦用於DES的解密，而且需要12個小時的破解才能得到結果。所以，當時DES被認?是一種十分強壯的加密方法。 但是，當今的電腦速度越來越快了，製造一台這樣特殊的機器的花費已經降到了十萬美元左右，所以用它來保護十億美元的銀行間線纜時，就會仔細考慮了。另一個方面，如果只用它來保護一台伺服器，那?DES確實是一種好的辦法，因?黑客絕不會僅僅?入侵一個伺服器而花那?多的錢破解DES密文。由於現在已經能用二十萬美圓製造一台破譯DES的特殊的電腦，所以現在再對要求“強壯”加密的場合已經不再適用了。 三重DES 因?確定一種新的加密法是否真的安全是極?困難的，而且DES的唯一密碼學缺點，就是密鑰長度相對比較短，所以人們並沒有放棄使用DES，而是想出了一個解決其長度問題的方法，即採用三重DES。這種方法用兩個密鑰對明文進行三次加密，假設兩個密鑰是K1和K2，其演算法的步驟如圖5.9所示： 1. 用密鑰K1進行DEA加密。 2. 用K2對步驟1的結果進行DES解密。 3. 用步驟2的結果使用密鑰K1進行DES加密。 這種方法的缺點，是要花費原來三倍時間，從另一方面來看，三重DES的112位密鑰長度是很“強壯”的加密方式了。 三重DES加密

------
**********************************************************
哈哈&兵燹
最會的2大絕招 這個不會與那個也不會 哈哈哈 粉好

Delphi K.Top的K.Top分兩個字解釋Top代表尖端的意思,希望本討論區能提供Delphi的尖端新知
K.表Knowlege 知識,就是本站的標語:Open our mind

DES算法 作者:fnlq http://www.encrypter.net/article_tw/encrypt0001.htm 【聲明】 一．本文實用於初學者，目的在於幫助大家熟悉一些系統底層的知識。 二．本文只是為了讓廣大網友共同提高一些基礎知識，本人決無賣弄之意，只供需要這方面知識的讀者閱讀，如果你是高手，或者不需要這方面知識，請跳過。 三．本文是一篇翻譯文章，如有雷同，敬請諒解。 四．本文歡迎傳抄轉載，但是不要用於任何商業用途。請尊重作者勞動，也歡迎來信交流 fnlq@263.net ======================================================================= 【正文】 DES算法理論 本世紀五十年代以來，密碼學研究領域出現了最具代表性的兩大成就。其中之一就是1971年美國學者塔奇曼 （Tuchman）和麥耶（Meyer）根據信息論創始人香農（Shannon）提出的「多重加密有效性理論」創立的，後於1977年由美國國家標準局頒布的數據加密標準。 DES密碼實際上是Lucifer密碼的進一步發展。它是一種採用傳統加密方法的區組密碼。 它的算法是對稱的，既可用於加密又可用於解密。 美國國家標準局1973年開始研究除國防部外的其它部門的計算機系統的數據加密標準，於1973年5月15日和1974年8月27日先後兩次向公眾發出了徵求加密算法的公告。 加密算法要達到的目的通常稱為DES密碼算法要求主要為以下四點： 提供高質量的數據保護，防止數據未經授權的洩露和未被察覺的修改；具有相當高的複雜性，使得破譯的開銷超過可能獲得的利益，同時又要便於理解和掌握 DES密碼體制的安全性應該不依賴於算法的保密，其安全性僅以加密密鑰的保密為基礎實現經濟，運行有效，並且適用於多種完全不同的應用。 1977年1月，美國政府頒布：採納IBM公司設計的方案作為非機密數據的正式數據加密標準（DES棗Data Encryption Standard）。 目前在這裡，隨著三金工程尤其是金卡工程的啟動，DES算法在POS、ATM、磁卡及智能卡（IC卡）、加油站、高速公路收費站等領域被廣泛應用，以此來實現關鍵數據的保密，如信用卡持卡人的PIN的加密傳輸，IC卡與POS間的雙向認證、金融交易數據包的MAC校驗等，均用到DES算法。 DES算法的入口參數有三個：Key、Data、Mode。其中Key為8個字節共64位，是DES算法的工作密鑰；Data也為8個字節64位，是要被加密或被解密的數據；Mode為DES的工作方式，有兩種：加密或解密。 DES算法是這樣工作的：如Mode為加密，則用Key 去把數據Data進行加密， 生成Data的密碼形式（64位）作為DES的輸出結果；如Mode為解密，則用Key去把密碼形式的數據Data解密，還原為Data的明碼形式（64位）作為DES的輸出結果。在通信網絡的兩端，雙方約定一致的Key，在通信的源點用Key對核心數據進行DES加密，然後以密碼形式在公共通信網（如電話網）中傳輸到通信網絡的終點，數據到達目的地後，用同樣的Key對密碼數據進行解密，便再現了明碼形式的核心數據。這樣，便保證了核心數據（如PIN、MAC等）在公共通信網中傳輸的安全性和可靠性。 通過定期在通信網絡的源端和目的端同時改用新的Key，便能更進一步提高數據的保密性，這正是現在金融交易網絡的流行做法。 DES算法詳述 DES算法把64位的明文輸入塊變為64位的密文輸出塊，它所使用的密鑰也是64位,其功能是把輸入的64位數據塊按位重新組合，並把輸出分為L0、R0兩部分，每部分各長32位，其置換規則見下表：

    58,50,12,34,26,18,10,2,60,52,44,36,28,20,12,4,
  62,54,46,38,30,22,14,6,64,56,48,40,32,24,16,8,
  57,49,41,33,25,17, 9,1,59,51,43,35,27,19,11,3,
  61,53,45,37,29,21,13,5,63,55,47,39,31,23,15,7,

即將輸入的第58位換到第一位，第50位換到第2位，...，依此類推，最後一位是原來的第7位。L0、R0則是換位輸出後的兩部分，L0是輸出的左32位，R0 是右32位，例：設置換前的輸入值為D1D2D3......D64，則經過初始置換後的結果為：L0=D58D50...D8；R0=D57D49...D7。 經過26次迭代運算後。得到L16、R16，將此作為輸入，進行逆置換，即得到密文輸出。逆置換正好是初始置的逆運算，例如，第1位經過初始置換後，處於第40位，而通過逆置換，又將第40位換回到第1位，其逆置換規則如下表所示：

  40,8,48,16,56,24,64,32,39,7,47,15,55,23,63,31,
  38,6,46,14,54,22,62,30,37,5,45,13,53,21,61,29,
  36,4,44,12,52,20,60,28,35,3,43,11,51,19,59,27,
  34,2,42,10,50,18,58 26,33,1,41, 9,49,17,57,25,

放大換位表

  32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, 8, 9, 10,11,
  12,13,12,13,14,15,16,17,16,17,18,19,20,21,20,21,
  22,23,24,25,24,25,26,27,28,29,28,29,30,31,32, 1,

單純換位表

  16,7,20,21,29,12,28,17, 1,15,23,26, 5,18,31,10,
  2,8,24,14,32,27, 3, 9,19,13,30, 6,22,11, 4,25,

在f(Ri,Ki)算法描述圖中，S1,S2...S8為選擇函數，其功能是把6bit數據變為4bit數據。下面給出選擇函數Si(i=1,2......8)的功能表： 選擇函數Si

    S1:
  14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,
  0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8,
  4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0,
  15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13,
S2:
  15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,
  3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5,
  0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15,
  13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9,
S3:
  10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,
  13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1,
  13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7,
  1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12,
S4:
  7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,
  13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9,
  10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4,
  3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14,
S5:
  2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,
  14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6,
  4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14,
  11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3,
S6:
  12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,
  10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8,
  9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6,
  4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13,
S7:
  4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1,
  13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6,
  1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2,
  6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12,
S8:
  13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,
  1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2,
  7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8,
  2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11,

在此以S1為例說明其功能，我們可以看到：在S1中，共有4行數據，命名為0，1、2、3行；每行有16列，命名為0、1、2、3，......，14、15列。

  現設輸入為： D＝D1D2D3D4D5D6
令：列＝D2D3D4D5
  行＝D1D6

然後在S1表中查得對應的數，以4位二進製表示，此即為選擇函數S1的輸出。下面給出子密鑰Ki(48bit)的生成算法 從子密鑰Ki的生成算法描述圖中我們可以看到：初始Key值為64位，但DES算法規定，其中第8、16、......64位是奇偶校驗位，不參與DES運算。故Key 實際可用位數便只有56位。即：經過縮小選擇換位表1的變換後，Key 的位數由64 位變成了56位，此56位分為C0、D0兩部分，各28位，然後分別進行第1次循環左移，得到C1、D1，將C1（28位）、D1（28位）合併得到56位，再經過縮小選擇換位2，從而便得到了密鑰K0（48位）。依此類推，便可得到K1、K2、......、K15，不過需要注意的是，16次循環左移對應的左移位數要依據下述規則進行： 循環左移位數 1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1 以上介紹了DES算法的加密過程。DES算法的解密過程是一樣的，區別僅僅在於第一次迭代時用子密鑰K15，第二次K14、......，最後一次用K0，算法本身並沒有任何變化。 DES算法具有極高安全性，到目前為止，除了用窮舉搜索法對DES算法進行攻擊外，還沒有發現更有效的辦法。而56位長的密鑰的窮舉空間為256，這意味著如果一台計算機的速度是每一秒種檢測一百萬個密鑰，則它搜索完全部密鑰就需要將近2285年的時間，可見，這是難以實現的，當然，隨著科學技術的發展，當出現超高速計算機後，我們可考慮把DES密鑰的長度再增長一些，以此來達到更高的保密程度。 由上述DES算法介紹我們可以看到：DES算法中只用到64位密鑰中的其中56位，而第8、16、24、......64位8個位並未參與DES運算，這一點，向我們提出了一個應用上的要求，即DES的安全性是基於除了8，16，24，......64位外的其餘56位的組合變化256才得以保證的。因此，在實際應用中，我們應避開使用第8，16，24，......64位作為有效數據位，而使用其它的56位作為有效數據位，才能保證DES算法安全可靠地發揮作用。如果不瞭解這一點，把密鑰Key的8，16，24，..... .64位作為有效數據使用，將不能保證DES加密數據的安全性，對運用DES來達到保密作用的系統產生數據被破譯的危險，這正是DES算法在應用上的誤區，是各級技術人員、各級領導在使用過程中應絕對避免的，而當今各金融部門及非金融部門，在運用DES工作，掌握DES工作密鑰Key的領導、主管們，極易忽略，給使用中貌似安全的系統，留下了被人攻擊、被人破譯的極大隱患。 DES算法應用誤區的驗證數據 筆者用Turbo C編寫了DES算法程序，並在PC機上對上述的DES 算法的應用誤區進行了騅，其驗證數據如下：

Key: 0x30 0x30 0x30 0x30......0x30（8個字節）
Data: 0x31 0x31 0x31 0x31......0x31（8個字節）
Mode: Encryption
結果：65 5e a6 28 cf 62 58 5f

如果把上述的Key換為8個字節的0x31，而Data和Mode均不變，則執行DES 後得到的密文完全一樣。類似地，用Key:8個0x32和用Key:8個0x33 去加密Data （8 個0x31），二者的圖文輸出也是相同的：5e c3 ac e9 53 71 3b ba 我們可以得到出結論： Key用0x30與用0x31是一樣的； Key用0x32與用0x33是一樣的，...... 當Key由8個0x32換成8個0x31後，貌似換成了新的Key，但由於0x30和0x31僅僅是在第8，16，24......64有變化，而DES算法並不使用Key的第8，16，......64位作為Key的有效數據位，故：加密出的結果是一樣的。 DES解密的驗證數據：

Key: 0x31 0x31......0x31（8個0x31）
Data: 65 5e a6 28 cf 62 58 5f
Mode: Decryption
結果：0x31 0x31......0x31（8個0x31）

由以上看出：DES算法加密與解密均工作正確。唯一需要避免的是：在應用中，避開使用Key的第8，16......64位作為有效數據位，從而便避開了DES 算法在應用中的誤區。 避開DES算法應用誤區的具體操作 在DES密鑰Key的使用、管理及密鑰更換的過程中，應絕對避開DES 算法的應用誤區，即：絕對不能把Key的第8，16，24......64位作為有效數據位，來對Key 進行管理。這一點，特別推薦給金融銀行界及非金融業界的領導及決策者們，尤其是負責管理密鑰的人，要對此點予以高度重視。有的銀行金融交易網絡，利用定期更換DES密鑰Key的辦法來進一步提高系統的安全性和可靠性，如果忽略了上述應用誤區，那麼，更換新密鑰將是徒勞的，對金融交易網絡的安全運行將是十分危險的，所以更換密鑰一定要保證新Key與舊Key真正的不同，即除了第8，16，24，...64位外其它位數據發生了變化，請務必對此保持高度重視！ 網路志工聯盟----Visita網站http://www.vista.org.tw ---[ 發問前請先找找舊文章 ]---

DES算法詳述          DES 算法網絡上很多，給你們一個    /* ================================================================ des() Description: DES algorithm,do encript or descript. ================================================================ */ int des(unsigned char *source,unsigned char * dest,unsigned char * inkey, int flg) { unsigned char bufout[64], kwork[56], worka[48], kn[48], buffer[64], key[64], nbrofshift, temp1, temp2; int valindex; register i, j, k, iter;    /* INITIALIZE THE TABLES */ /* Table - s1 */ static unsigned char s1[4][16] = { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7, 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8, 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0, 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 };    /* Table - s2 */ static unsigned char s2[4][16] = { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10, 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5, 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15, 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 };    /* Table - s3 */ static unsigned char s3[4][16] = { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8, 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1, 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7, 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 };    /* Table - s4 */ static unsigned char s4[4][16] = { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15, 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9, 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4, 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 };    /* Table - s5 */ static unsigned char s5[4][16] = { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9, 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6, 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14, 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 };    /* Table - s6 */ static unsigned char s6[4][16] = { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11, 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8, 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6, 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 };    /* Table - s7 */ static unsigned char s7[4][16] = { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1, 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6, 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2, 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 };    /* Table - s8 */ static unsigned char s8[4][16] = { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7, 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2, 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8, 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 };    /* Table - Shift */ static unsigned char shift[16] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };    /* Table - Binary */ static unsigned char binary[64] = { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1 };    /* MAIN PROCESS */ /* Convert from 64-bit key into 64-byte key */ for (i = 0; i < 8; i++) { key[8*i] = ((j = *(inkey + i)) / 128) % 2; key[8*i+1] = (j / 64) % 2; key[8*i+2] = (j / 32) % 2; key[8*i+3] = (j / 16) % 2; key[8*i+4] = (j / 8) % 2; key[8*i+5] = (j / 4) % 2; key[8*i+6] = (j / 2) % 2; key[8*i+7] = j % 2; }    /* Convert from 64-bit data into 64-byte data */ for (i = 0; i < 8; i++) { buffer[8*i] = ((j = *(source + i)) / 128) % 2; buffer[8*i+1] = (j / 64) % 2; buffer[8*i+2] = (j / 32) % 2; buffer[8*i+3] = (j / 16) % 2; buffer[8*i+4] = (j / 8) % 2; buffer[8*i+5] = (j / 4) % 2; buffer[8*i+6] = (j / 2) % 2; buffer[8*i+7] = j % 2; }    /* Initial Permutation of Data */ bufout[ 0] = buffer[57]; bufout[ 1] = buffer[49]; bufout[ 2] = buffer[41]; bufout[ 3] = buffer[33]; bufout[ 4] = buffer[25]; bufout[ 5] = buffer[17]; bufout[ 6] = buffer[ 9]; bufout[ 7] = buffer[ 1]; bufout[ 8] = buffer[59]; bufout[ 9] = buffer[51]; bufout[10] = buffer[43]; bufout[11] = buffer[35]; bufout[12] = buffer[27]; bufout[13] = buffer[19]; bufout[14] = buffer[11]; bufout[15] = buffer[ 3]; bufout[16] = buffer[61]; bufout[17] = buffer[53]; bufout[18] = buffer[45]; bufout[19] = buffer[37]; bufout[20] = buffer[29]; bufout[21] = buffer[21]; bufout[22] = buffer[13]; bufout[23] = buffer[ 5]; bufout[24] = buffer[63]; bufout[25] = buffer[55]; bufout[26] = buffer[47]; bufout[27] = buffer[39]; bufout[28] = buffer[31]; bufout[29] = buffer[23]; bufout[30] = buffer[15]; bufout[31] = buffer[ 7]; bufout[32] = buffer[56]; bufout[33] = buffer[48]; bufout[34] = buffer[40]; bufout[35] = buffer[32]; bufout[36] = buffer[24]; bufout[37] = buffer[16]; bufout[38] = buffer[ 8]; bufout[39] = buffer[ 0]; bufout[40] = buffer[58]; bufout[41] = buffer[50]; bufout[42] = buffer[42]; bufout[43] = buffer[34]; bufout[44] = buffer[26]; bufout[45] = buffer[18]; bufout[46] = buffer[10]; bufout[47] = buffer[ 2]; bufout[48] = buffer[60]; bufout[49] = buffer[52]; bufout[50] = buffer[44]; bufout[51] = buffer[36]; bufout[52] = buffer[28]; bufout[53] = buffer[20]; bufout[54] = buffer[12]; bufout[55] = buffer[ 4]; bufout[56] = buffer[62]; bufout[57] = buffer[54]; bufout[58] = buffer[46]; bufout[59] = buffer[38]; bufout[60] = buffer[30]; bufout[61] = buffer[22]; bufout[62] = buffer[14]; bufout[63] = buffer[ 6];    /* Initial Permutation of Key */ kwork[ 0] = key[56]; kwork[ 1] = key[48]; kwork[ 2] = key[40]; kwork[ 3] = key[32]; kwork[ 4] = key[24]; kwork[ 5] = key[16]; kwork[ 6] = key[ 8]; kwork[ 7] = key[ 0]; kwork[ 8] = key[57]; kwork[ 9] = key[49]; kwork[10] = key[41]; kwork[11] = key[33]; kwork[12] = key[25]; kwork[13] = key[17]; kwork[14] = key[ 9]; kwork[15] = key[ 1]; kwork[16] = key[58]; kwork[17] = key[50]; kwork[18] = key[42]; kwork[19] = key[34]; kwork[20] = key[26]; kwork[21] = key[18]; kwork[22] = key[10]; kwork[23] = key[ 2]; kwork[24] = key[59]; kwork[25] = key[51]; kwork[26] = key[43]; kwork[27] = key[35]; kwork[28] = key[62]; kwork[29] = key[54]; kwork[30] = key[46]; kwork[31] = key[38]; kwork[32] = key[30]; kwork[33] = key[22]; kwork[34] = key[14]; kwork[35] = key[ 6]; kwork[36] = key[61]; kwork[37] = key[53]; kwork[38] = key[45]; kwork[39] = key[37]; kwork[40] = key[29]; kwork[41] = key[21]; kwork[42] = key[13]; kwork[43] = key[ 5]; kwork[44] = key[60]; kwork[45] = key[52]; kwork[46] = key[44]; kwork[47] = key[36]; kwork[48] = key[28]; kwork[49] = key[20]; kwork[50] = key[12]; kwork[51] = key[ 4]; kwork[52] = key[27]; kwork[53] = key[19]; kwork[54] = key[11]; kwork[55] = key[ 3];    /* 16 Iterations */ for (iter = 1; iter < 17; iter++) { for (i = 0; i < 32; i++) buffer[i] = bufout[32+i];    /* Calculation of F(R, K) */ /* Permute - E */ worka[ 0] = buffer[31]; worka[ 1] = buffer[ 0]; worka[ 2] = buffer[ 1]; worka[ 3] = buffer[ 2]; worka[ 4] = buffer[ 3]; worka[ 5] = buffer[ 4]; worka[ 6] = buffer[ 3]; worka[ 7] = buffer[ 4]; worka[ 8] = buffer[ 5]; worka[ 9] = buffer[ 6]; worka[10] = buffer[ 7]; worka[11] = buffer[ 8]; worka[12] = buffer[ 7]; worka[13] = buffer[ 8]; worka[14] = buffer[ 9]; worka[15] = buffer[10]; worka[16] = buffer[11]; worka[17] = buffer[12]; worka[18] = buffer[11]; worka[19] = buffer[12]; worka[20] = buffer[13]; worka[21] = buffer[14]; worka[22] = buffer[15]; worka[23] = buffer[16]; worka[24] = buffer[15]; worka[25] = buffer[16]; worka[26] = buffer[17]; worka[27] = buffer[18]; worka[28] = buffer[19]; worka[29] = buffer[20]; worka[30] = buffer[19]; worka[31] = buffer[20]; worka[32] = buffer[21]; worka[33] = buffer[22]; worka[34] = buffer[23]; worka[35] = buffer[24]; worka[36] = buffer[23]; worka[37] = buffer[24]; worka[38] = buffer[25]; worka[39] = buffer[26]; worka[40] = buffer[27]; worka[41] = buffer[28]; worka[42] = buffer[27]; worka[43] = buffer[28]; worka[44] = buffer[29]; worka[45] = buffer[30]; worka[46] = buffer[31]; worka[47] = buffer[ 0];    /* KS Function Begin */ if (flg) { nbrofshift = shift[iter-1]; for (i = 0; i < (int) nbrofshift; i++) { temp1 = kwork[0]; temp2 = kwork[28]; for (j = 0; j < 27; j++) { kwork[j] = kwork[j+1]; kwork[j+28] = kwork[j+29]; } kwork[27] = temp1; kwork[55] = temp2; } } else if (iter > 1) { nbrofshift = shift[17-iter]; for (i = 0; i < (int) nbrofshift; i++) { temp1 = kwork[27]; temp2 = kwork[55]; for (j = 27; j > 0; j--) { kwork[j] = kwork[j-1]; kwork[j+28] = kwork[j+27]; } kwork[0] = temp1; kwork[28] = temp2; } }    /* Permute kwork - PC2 */ kn[ 0] = kwork[13]; kn[ 1] = kwork[16]; kn[ 2] = kwork[10]; kn[ 3] = kwork[23]; kn[ 4] = kwork[ 0]; kn[ 5] = kwork[ 4]; kn[ 6] = kwork[ 2]; kn[ 7] = kwork[27]; kn[ 8] = kwork[14]; kn[ 9] = kwork[ 5]; kn[10] = kwork[20]; kn[11] = kwork[ 9]; kn[12] = kwork[22]; kn[13] = kwork[18]; kn[14] = kwork[11]; kn[15] = kwork[ 3]; kn[16] = kwork[25]; kn[17] = kwork[ 7]; kn[18] = kwork[15]; kn[19] = kwork[ 6]; kn[20] = kwork[26]; kn[21] = kwork[19]; kn[22] = kwork[12]; kn[23] = kwork[ 1]; kn[24] = kwork[40]; kn[25] = kwork[51]; kn[26] = kwork[30]; kn[27] = kwork[36]; kn[28] = kwork[46]; kn[29] = kwork[54]; kn[30] = kwork[29]; kn[31] = kwork[39]; kn[32] = kwork[50]; kn[33] = kwork[44]; kn[34] = kwork[32]; kn[35] = kwork[47]; kn[36] = kwork[43]; kn[37] = kwork[48]; kn[38] = kwork[38]; kn[39] = kwork[55]; kn[40] = kwork[33]; kn[41] = kwork[52]; kn[42] = kwork[45]; kn[43] = kwork[41]; kn[44] = kwork[49]; kn[45] = kwork[35]; kn[46] = kwork[28]; kn[47] = kwork[31]; /* KS Function End */    /* worka XOR kn */ for (i = 0; i < 48; i++) worka[i] = worka[i] ^ kn[i];    /* 8 s-functions */ valindex = s1[2*worka[ 0]+worka[ 5]] [2*(2*(2*worka[ 1]+worka[ 2])+ worka[ 3])+worka[ 4]]; valindex = valindex * 4; kn[ 0] = binary[0+valindex]; kn[ 1] = binary[1+valindex]; kn[ 2] = binary[2+valindex]; kn[ 3] = binary[3+valindex]; valindex = s2[2*worka[ 6]+worka[11]] [2*(2*(2*worka[ 7]+worka[ 8])+ worka[ 9])+worka[10]]; valindex = valindex * 4; kn[ 4] = binary[0+valindex]; kn[ 5] = binary[1+valindex]; kn[ 6] = binary[2+valindex]; kn[ 7] = binary[3+valindex]; valindex = s3[2*worka[12]+worka[17]] [2*(2*(2*worka[13]+worka[14])+ worka[15])+worka[16]]; valindex = valindex * 4; kn[ 8] = binary[0+valindex]; kn[ 9] = binary[1+valindex]; kn[10] = binary[2+valindex]; kn[11] = binary[3+valindex]; valindex = s4[2*worka[18]+worka[23]] [2*(2*(2*worka[19]+worka[20])+ worka[21])+worka[22]]; valindex = valindex * 4; kn[12] = binary[0+valindex]; kn[13] = binary[1+valindex]; kn[14] = binary[2+valindex]; kn[15] = binary[3+valindex]; valindex = s5[2*worka[24]+worka[29]] [2*(2*(2*worka[25]+worka[26])+ worka[27])+worka[28]]; valindex = valindex * 4; kn[16] = binary[0+valindex]; kn[17] = binary[1+valindex]; kn[18] = binary[2+valindex]; kn[19] = binary[3+valindex]; valindex = s6[2*worka[30]+worka[35]] [2*(2*(2*worka[31]+worka[32])+ worka[33])+worka[34]]; valindex = valindex * 4; kn[20] = binary[0+valindex]; kn[21] = binary[1+valindex]; kn[22] = binary[2+valindex]; kn[23] = binary[3+valindex]; valindex = s7[2*worka[36]+worka[41]] [2*(2*(2*worka[37]+worka[38])+ worka[39])+worka[40]]; valindex = valindex * 4; kn[24] = binary[0+valindex]; kn[25] = binary[1+valindex]; kn[26] = binary[2+valindex]; kn[27] = binary[3+valindex]; valindex = s8[2*worka[42]+worka[47]] [2*(2*(2*worka[43]+worka[44])+ worka[45])+worka[46]]; valindex = valindex * 4; kn[28] = binary[0+valindex]; kn[29] = binary[1+valindex]; kn[30] = binary[2+valindex]; kn[31] = binary[3+valindex];    /* Permute - P */ worka[ 0] = kn[15]; worka[ 1] = kn[ 6]; worka[ 2] = kn[19]; worka[ 3] = kn[20]; worka[ 4] = kn[28]; worka[ 5] = kn[11]; worka[ 6] = kn[27]; worka[ 7] = kn[16]; worka[ 8] = kn[ 0]; worka[ 9] = kn[14]; worka[10] = kn[22]; worka[11] = kn[25]; worka[12] = kn[ 4]; worka[13] = kn[17]; worka[14] = kn[30]; worka[15] = kn[ 9]; worka[16] = kn[ 1]; worka[17] = kn[ 7]; worka[18] = kn[23]; worka[19] = kn[13]; worka[20] = kn[31]; worka[21] = kn[26]; worka[22] = kn[ 2]; worka[23] = kn[ 8]; worka[24] = kn[18]; worka[25] = kn[12]; worka[26] = kn[29]; worka[27] = kn[ 5]; worka[28] = kn[21]; worka[29] = kn[10]; worka[30] = kn[ 3]; worka[31] = kn[24];    /* bufout XOR worka */ for (i = 0; i < 32; i++) { bufout[i+32] = bufout[i] ^ worka[i]; bufout[i] = buffer[i]; } } /* End of Iter */    /* Prepare Output */ for (i = 0; i < 32; i++) { j = bufout[i]; bufout[i] = bufout[32+i]; bufout[32+i] = j; }    /* Inverse Initial Permutation */ buffer[ 0] = bufout[39]; buffer[ 1] = bufout[ 7]; buffer[ 2] = bufout[47]; buffer[ 3] = bufout[15]; buffer[ 4] = bufout[55]; buffer[ 5] = bufout[23]; buffer[ 6] = bufout[63]; buffer[ 7] = bufout[31]; buffer[ 8] = bufout[38]; buffer[ 9] = bufout[ 6]; buffer[10] = bufout[46]; buffer[11] = bufout[14]; buffer[12] = bufout[54]; buffer[13] = bufout[22]; buffer[14] = bufout[62]; buffer[15] = bufout[30]; buffer[16] = bufout[37]; buffer[17] = bufout[ 5]; buffer[18] = bufout[45]; buffer[19] = bufout[13]; buffer[20] = bufout[53]; buffer[21] = bufout[21]; buffer[22] = bufout[61]; buffer[23] = bufout[29]; buffer[24] = bufout[36]; buffer[25] = bufout[ 4]; buffer[26] = bufout[44]; buffer[27] = bufout[12]; buffer[28] = bufout[52]; buffer[29] = bufout[20]; buffer[30] = bufout[60]; buffer[31] = bufout[28]; buffer[32] = bufout[35]; buffer[33] = bufout[ 3]; buffer[34] = bufout[43]; buffer[35] = bufout[11]; buffer[36] = bufout[51]; buffer[37] = bufout[19]; buffer[38] = bufout[59]; buffer[39] = bufout[27]; buffer[40] = bufout[34]; buffer[41] = bufout[ 2]; buffer[42] = bufout[42]; buffer[43] = bufout[10]; buffer[44] = bufout[50]; buffer[45] = bufout[18]; buffer[46] = bufout[58]; buffer[47] = bufout[26]; buffer[48] = bufout[33]; buffer[49] = bufout[ 1]; buffer[50] = bufout[41]; buffer[51] = bufout[ 9]; buffer[52] = bufout[49]; buffer[53] = bufout[17]; buffer[54] = bufout[57]; buffer[55] = bufout[25]; buffer[56] = bufout[32]; buffer[57] = bufout[ 0]; buffer[58] = bufout[40]; buffer[59] = bufout[ 8]; buffer[60] = bufout[48]; buffer[61] = bufout[16]; buffer[62] = bufout[56]; buffer[63] = bufout[24];    j = 0; for (i = 0; i < 8; i++) { *(dest + i) = 0x00; for (k = 0; k < 7; k++) *(dest + i) = ((*(dest + i)) + buffer[j+k]) * 2; *(dest + i) = *(dest + i) + buffer[j+7]; j += 8; } }      網路志工聯盟----Visita網站http://www.vista.org.tw ---[ 發問前請先找找舊文章 ]---