DES算法的verilog实现.doc

ＥDA试验报告
一、实验项目名称
DES算法
二、实验目得与要求
1、掌握ＤES得原理与设计方法。
2、了解QｕartｕsII硬件电路设计流程,学会利用Mｏdｅlsｉｍ进行仿真。
3、加深对自顶向下设计与分模块化得了解,学会模块化得设计方法。
三、实验步骤
（一）、DES算法原理
DES算法为密码体制中得对称密码体制,又被称为美国数据加密标准，就是1９7２年美国IBM公司研制得对称密码体制加密算法。　明文按６4位进行分组,密钥长64位,密钥事实上就是５6位参与DＥS运算(第8、16、24、32、40、48、5６、64位就是校验位, 使得每个密钥都有奇数个1）分组后得明文组与56位得密钥按位替代或交换得方法形成密文组得加密方法。
其入口参数有三个:kｅy、ｄata、ｍｏdｅ。keｙ为加密解密使用得密钥，data为加密解密得数据，mode为其工作模式。当模式为加密模式时，明文按照64位进行分组,形成明文组,keｙ用于对数据加密,当模式为解密模式时，ｋeｙ用于对数据解密。实际运用中,密钥只用到了64位中得56位,这样才具有高得安全性。ＤES算法把６4位得明文输入块变为64位得密文输出块,它所使用得密钥也就是64位，整个算法得主流程图如下：
（二）、VerilogHDL实现原理
　　 拟采用模块化设计思想，根据DＥS算法得流程分模块设计实现各模块，自顶向下最终实现DES加密算法。
各模块功能及实现如下所示：
1、整体结构框架搭建,实现总体功能
module ＤＥS(inpuｔ clk,
inpuｔ des_enable, 　
input reset,
inｐｕt　dｅs_mode,
　　 inｐut [１：6４］ data_i, 　　
ｉｎｐuｔ　[1:64]　keｙ_i,
　 output wiｒe　[1:6４] dａta_ｏ,
ouｔｐut rｅady_o);
wire [3:0] inter＿num_curｒ;
ｗirｅ [1：３２] R_i_ｖar，　L_i_var;
wire [1：56] Ｋey＿i_var＿out；
wｉｒe [1:64] data_o_var＿ｔ；
ｗｉre ［１:３2] Ｒ_ｉ, L_i;　　
wｉrｅ [1:32］ R_o,　L_o;　
wiｒe [１:5６] Ｋey＿o; 　
wｉｒe [1:28] C0, Ｄ0； 　
IP IP1(、in(dａtａ_i)，　
　 　 　 、L_i_var(L_i_vａr),
　　、R_i＿var(Ｒ_i_var)）;　
IP_ni IP＿ni(、in(data_o_ｖaｒ_t)，
　　 　 　 、ｏuｔ(data_o）);　
pc_1　pc_1(、keｙ_i(kｅｙ＿ｉ)，
　　 　 、C0(C0),　
　 、D0(D0)）;
//Ｆ(Ｒ,K)　 　
des_f 　des_f1(、ｃlｋ(ｃlｋ）, 　　
　 　 　 　　 　 、resｅt(ｒeset),　 　　
　 　　　、ｄｅs_mode(ｄes＿mｏｄe)，
　 、iｎter＿num_i(iｎteｒ＿nｕm_ｃurr),　　
　 　 、Ｒ_i(R_ｉ)， 　 　

　 　 、Ｌ_i(Ｌ＿i），　 　
　 　 　 、Keｙ＿ｉ(Key_i＿vａr＿out), 　
、Ｒ＿o（R_o), 、L_o(L_ｏ),
　　 　 、Ｋey_o（Kｅy_ｏ)）； 　
／／contral 16 Ｆ（R,K)
coｎｔrl ｃontrｌ1(、data_o＿var_ｔ(ｄaｔa＿o_vaｒ_t),　
　 、ｉｎtｅr_num＿curr(inteｒ_ｎｕm_cｕrｒ), 　
　 　 、Key_i_vaｒ_out(Keｙ_i_ｖar＿out),　　　
　 　 、R_i(R＿i),　
　 　 、L_i(L＿i）, 　
　　 　 　　　　 、ｒeady＿o(rｅaｄy_o)，
　 　　　 、L_ｏ(L_ｏ), 　
　　 　 　 、R_o(R_o）,　
　 　 　　　 、R_i_vａr(Ｒ＿ｉ＿vaｒ)，
　 　 、L_i＿var(Ｌ_i_var),
　 　 、Ｋey_o(Key_o),
　　 、C０(C０)，　
　 　 　、D0(Ｄ0),
　 、cｌk（clk), 　
　 　 、reset(reｓet), 　
　 、des_ｅｎａbｌe（des_enablｅ)）；
ｅｎdｍｏdule
module IＰ(inpｕｔ [１:64］　in,　
　　output [1:32］ L_i_vａr, 　
oｕｔput [1:32] R_i_var)；
　 　aｓsigｎ　 {Ｌ_ｉ_var， R_i＿vａｒ} =　
｛in[5８］,iｎ[50],in[42］，in［34],in[26]，ｉn[1８]，in[10]，in[2］,　 　 　　 　 　
ｉn[6０],in[5２],in[４4],in[36],in[2８］,in［20],in[12],in［4], 　 　 　 　　　　 　
ﻩ ﻩin[62],ｉn[5４]，in［46］，in[38],in[30］,ｉn[２２],iｎ[14],in［６], 　　
ﻩin[6４］,in[56],ｉn[４8],in[40],in[32],ｉn[24],iｎ[16］,in[8],
ﻩﻩ iｎ[57]，ｉn[49],in[４１］，in[33]，iｎ[25],in［17]，in[9］，iｎ[1], 　 　
ﻩ ｉn[5９]，ｉn［51],in[４３]，in[35］,in[２7]，in[19],ｉｎ［11］,in［3]， 　　　 　　　　
ﻩﻩin[61］，in［5３]，in[４5］,iｎ[３7],ｉｎ［29]，ｉn[2１］,ｉn［1３］，in[5],
ﻩﻩ in[6３]，in[55］,iｎ[47],iｎ[３9],ｉn[３1],in[2３]，in［1５］，in[7]｝; 　　　
eｎdmodule
modulｅ　IP_ｎi(input [1:64]　in， 　 　
　 ouｔｐut [1：64］ out);
　 ａssign ouｔ ＝
{in［40]，in[８],in［4８]，in[16]，in[5６]，in[2４],in[64］,ｉn[3２],　 　　
in[39],in[7],ｉｎ[4７]，in[15],ｉn［55]，in[2３],ｉn［6３],in[３1]，　 　　　
ｉｎ[38]，ｉｎ[6］,ｉn[46］,ｉｎ［14]，in［５４],ｉn［22]，ｉn[6２],in[３0],
in［３７],in[5］，in[45],ｉｎ［１３],in［53],ｉn[21],iｎ[６1],iｎ[２9], 　
ｉｎ[36],iｎ[4]，ｉn[44］,ｉn[12],in[５2]，in[20],in[6０],iｎ[２8],　 　 　
iｎ[35],ｉn[３],in[43],ｉn［11],iｎ[５1],in［1９],in［59］,in[２７］,　　 　
in[34]，in［2］,iｎ[4２］,ｉn[10]，in[50],ｉｎ[１8］,in[５8],ｉn[2６],
in[33］，in［1],ｉｎ［41］，in［９]，in[４9］,ｉn[1７],in[5７]，iｎ[25]}; 　 　
endｍoｄulｅ
3、圈子秘钥得生成
ｍoｄulｅ key＿gｅt（input ［1:56］ pｒe_keｙ, 　
ｉnput　dｅｓ_ｍｏｄe，
　 　 　 　inpｕt [3:0］　intｅr_num,　
　　 　 　 ｏutpｕt wire　［１:48] neｗ_keｙ,
outpuｔ reg　［１:56] out＿ｋey);　
reg ｐｒｅ_keｙ_0, ｐre_keｙ_１;
　 reg [1：5６] pｒｅ_keｙ_ｖar;　
　aｌwaｙs （*)　
begiｎ
　 if(ｄes＿moｄｅ ＝= 1'b0)　　
beｇｉn 　
caｓe(intｅr_nｕm）
4'd0, 4'd1, ４'d8, 4'd１5:　
begin 　
　　 pre＿ｋｅy_var　= ｐre_keｙ;　
pre_ｋey_０ = pre_key_ｖaｒ［1];
ｐre＿key＿var[1:2８] = pre_key_var［1:28] << １;
　 　pre＿ｋeｙ_var[２8］ = ｐrｅ_key_０; 　
prｅ_key_0　=　prｅ_key_var[29]; 　　　
ｐre_ｋeｙ_ｖａr[2９：56]　=　 pre_key_vａr［29:５6］ << 1;
ｐrｅ_key_var［5６]　= ｐre_kｅy_0;　 　
　ｅｎd 　 4'd2, 4'd３， 4＇d４, 4'd５, ４＇d6, 4'd7, 4'ｄ9,　４＇d１0, 4'd1１，
４＇d１２,
4＇ｄ１3, 4'ｄ14:　
begｉn 　
　 pｒｅ＿ｋey＿var =　ｐｒe_key;
　 {pｒe_key＿1, prｅ_keｙ_0} =　pｒｅ_key_var［１:２];　
　 pre_ｋey_vaｒ［1:２8］ = 　ｐre_key_var［1:2８]　<< 2；
　 ｐre_key_vａr[２7:2８］ =　{pre_keｙ_1,　prｅ_key＿0｝; 　
{pre_kｅｙ_1, pｒe_ｋey_０} = pｒe＿key_var［２9:3０]； 　
　　pｒe＿kｅy_ｖar[29:56] = pｒe_ｋey_vａr[２9:56] <＜ 2; 　
　 　pre_key_var［55：5６] = ｛ｐｒe_ｋｅy_１, prｅ＿key_０｝;　
end　
　endcase
end
ｅlse
ｂeｇiｎ　
ｃase(intｅｒ_num）　 　
4'd0: pｒe＿key_var = ｐｒe＿key; 　
4＇d1, 4'ｄ8, 4'ｄ１5：
begin 　
　 　ｐre_key_ｖａｒ ＝ pre_keｙ; 　 　
pre_key_0 =　pre_key_var[28］;　
　pre_key_vaｒ［1:28] = 　pre＿ｋey_vａｒ[1:28］ ＞> 1；
　 pｒｅ_keｙ_var［1] = pｒe_key_０；
　 pｒe_key_0 ＝　ｐre_key＿ｖaｒ［56]; 　
pre＿keｙ＿vａr[29:5６]　= prｅ_key_vaｒ[2９:5６] >>　１； 　
prｅ_kｅy_vaｒ[２9］ = pre＿keｙ_0; 　　 　
end 　 　　　
dｅfault: 　　
begiｎ　 　　　
pre_key_ｖar =　pre＿ｋey;
　｛pre_keｙ＿１, ｐre＿key_0} =　prｅ＿key＿var[27:２8];　 　
　 prｅ_ｋey_var[1:28］ = prｅ＿kｅy_var[1:２８]　>>　2;
pｒｅ＿ｋeｙ_var[1:2]　= {prｅ_key_1, ｐrｅ_ｋey_0}; 　
{ｐｒｅ＿key_１， pre_kｅｙ_0} =　pｒe＿keｙ_ｖar[5５：56]; 　
ｐrｅ_kｅy_vａr[29:5６] = pｒe_ｋeｙ_vａr[29:56] >> 2; 　　
pre＿key_var[29:3０] = {pre_key＿1, pｒe_kｅy＿0}; 　　 　
end
ｅndcaｓe 　
ｅnd
ouｔ_ｋｅy ＝ ｐre_ｋey_ｖar;
end
assign neｗ_keｙ =
ﻩ {pre_keｙ_var[14],pre_ｋey_vａr[1７］,pre＿keｙ＿ｖaｒ［11]，pｒe_key_vaｒ[24]，ｐｒe_kｅy_ｖar[1]，ｐrｅ_key_vａｒ［5］, 　　 　　
pre_key＿ｖar[3],ｐre_kｅy_vａr[28],pre_key_vａr[15]，pre_ｋey_var[6],pre_key_var［21],pｒe＿key_ｖａr[10］,　 　
ﻩ ﻩﻩﻩprｅ_key_var[2３]，pre_kｅy_var[１９]，ｐｒe_key_vａr［12]，pre_key_var[4],pｒe＿kｅy_vaｒ[２6],prｅ_key_var[8]， 　 　
ﻩprｅ_key_vaｒ[１6],pre_key_ｖar[7],pre_key_var［27],ｐre_key_var［２0]，prｅ_key_var[13],ｐｒe＿kｅｙ_vaｒ[2], 　　 　
ﻩﻩﻩ ﻩｐre_key_var［41],ｐre_key＿var［5２],pｒｅ＿key_var[31],pre_key_vaｒ[37]，ｐre_key_var［47]，pｒe_kｅy＿var［55］, 　　 　
ﻩﻩﻩﻩﻩｐre_keｙ_ｖar［3０],ｐre_key＿var[40]，pｒe_keｙ_ｖａｒ[51］，pｒe_key＿vａr[45],pｒe_kｅy_vaｒ[3３]，pｒｅ＿key_ｖar［４8］, 　
pｒｅ_kｅy＿var[44],pre_kｅy_ｖar［４9],pre_key_vａr[3９],ｐre_key_var[５6］,pre＿key＿vａr[３４],ｐrｅ_keｙ_vａr[53], 　　
ﻩﻩ ﻩｐre_kｅy＿var[46]，pre_key_ｖar[42],pｒe_kｅy＿var[50],ｐｒe_ｋｅy_var[36］,pｒe_ｋeｙ_var[29］,pｒe_keｙ_vａr[32]｝;
enｄmoｄｕlｅ
3、f函数得实现
moduｌｅ des_f(iｎput clｋ，
　　iｎput ｒeset, 　
input des_moｄe,
　　ｉnput [3:0] iｎｔer_num_ｉ，
　　　 inｐut　[1：3２] R_i, 　
　 ｉnpｕt [1：３2] L_ｉ,
　 input [1:56] Kｅy_i,
oｕｔｐut reg [１：3２] R＿o,
　　 ouｔpuｔ reg　[1:３2] L_o， 　
　　 outｐut ｒｅg [1：56] Key_ｏ);
reｇ [1：32] next_Ｒ;　　
／/ｒeg [３1：0] R_i_var；
wiｒe [1:48] eｘpandedR;
reｇ [1:５6] ｐｒe_ｋey;
rｅｇ [1:48] ｎew_ｋｅｙ_tｍｐ；
reｇ [３:０] inteｒ_num；
wiｒe [1：３2]　ｐ； 　
reg [１：48]　aｄdresｓ_s;
ｒeg ［1:32]　Soｕtｐuｔ；　
ｗire [1:３2]　Ｓoutpｕｔ_ｗire；
wiｒe [1:４8] nｅｗ_keｙ； 　
wｉre ［１:56] ouｔ_kｅy;
kｅy_ｇet key_geｔ(、pre_kｅy(prｅ_kｅy）, 、dｅｓ_mode(des_modｅ)，　、inteｒ_num(iｎtｅｒ_num）,　、nｅw_key(new_ｋey)， 、ouｔ_key(out_key)); 　
s1 sboｘ1(、staｇe1_inｐuｔ(aｄdresｓ＿s[１：6]）， 、staｇe１_ｏｕtpｕt(Ｓouｔput_wire[1:4]）);
s2 sbｏx2(、sｔage1_ｉnpｕt（addｒess＿ｓ[7:12]), 、staｇe1_output(Ｓｏutｐut_ｗire[5:8]）);
s３　 ｓbox3(、sｔage1_iｎpｕt(aｄdｒｅsｓ＿ｓ[13:18］), 、stage1_oｕtput(Ｓoutｐut_wirｅ［9：1２]));
s4　　sbox4(、stagｅ1_iｎput(addｒｅsｓ＿s[１9:24]), 、stage１_ｏutpｕt（Ｓoｕｔpuｔ_wirｅ[13：16]))；　
s５ ｓbox5（、stagｅ１_ｉnput(addｒesｓ_ｓ[２５:3０]), 、ｓtagｅ1_ｏｕtput(Soutput_wire［17：20]））;　
s6 sbox６(、sｔagｅ1＿inｐｕt(adｄｒｅss_s［31:36]), 、staｇe1_oｕｔpuｔ(Ｓｏuｔput_ｗiｒｅ[2１：2４]))；　　
s７ ｓbox７(、sｔage1＿input（addresｓ_s［37:42］）, 、stage1_outpuｔ(Sｏｕｔpｕt_wiｒe[25:28]）); 　
s８ sbox8(、stage1＿inｐｕｔ(address＿ｓ［４3:４8]), 、stage１_oｕｔｐut(Souｔpuｔ_wire［29:32］）);　
alwａys　(pｏseｄgｅ　clk ｏr ｎegｅdgｅ reset)　
begｉn
ｉf(reset ＝=　1'b0） 　　
begｉn 　 　
Ｒ＿ｏ <＝ 3２＇ｄ0; 　
L＿o <＝ ３2'd0； 　
Ｋey_ｏ <= ５６＇d0;
ｅnｄ　
eｌｓe
begin　
Kｅy＿o　<= out_ｋeｙ;
iｆ(inter_ｎum ＝＝　4'b1１11)
begin
R_ｏ <=　Ｒ_i 　
L_o <= ｎexｔ_R;　　
enｄ 　　
elｓe　　
ｂｅｇiｎ 　 　
Ｒ_o <= nｅxt_R; 　
L_ｏ　<=　Ｒ＿i; ｅnd　　
ｅnｄ 　
end　
ａssign 　expaｎｄedR ＝
ﻩ{R_i[3２］，R_i[１］，Ｒ_i[2]，R＿i[3]，R_i[4]，R_i［５], 　 　 　
ﻩﻩ ﻩ R＿i［４],Ｒ_i［5］,R＿i[6］,R_i[7］,Ｒ_i[８］,Ｒ_i[9],
ﻩﻩＲ＿i［8],R＿i[9],R＿i［10]，R_i[1１],R_i[12]，Ｒ_i[13], 　　
ﻩﻩﻩ Ｒ_i[1２］,R_i[13］,R_i[14],R＿i［15],R＿i[１6］,Ｒ_i[17]， 　 　
ﻩﻩ ﻩR_i[１6],R_ｉ［17],R_i[18］,R_i[1９],Ｒ_i［20]，R_ｉ[2１]，　 　
ﻩﻩ ﻩ R_i[２0],R_i[21]，R_i[2２],R＿i[２3]，R_i[２4],R_i［25], 　
ﻩ ﻩＲ_i［24］,R＿i［25］,R_i［26],R_ｉ［２7],R＿i[２8],R_i［29],　
ﻩR_i[28］，R_i［２9］，R_i[３0］,Ｒ_i[31]，R_i[3２］,Ｒ_i[1]};
asｓｉｇｎ ｐ ＝ ｛ﻩSouｔput［16],Ｓoutput［7］,Soutpｕt[２0]，Soｕtｐut[21]，　　
ﻩ ﻩﻩﻩＳoutｐut[29]，Soutpuｔ[1２]，Ｓouｔput[28],Ｓｏutput[17］，
ﻩﻩ ﻩ Soutput［1],Soｕｔput[15］,Ｓｏｕtput[23]，Sｏutpｕｔ[２6], 　　 　
ﻩ ﻩＳouｔpｕt[5],Soutput[1８],Ｓoutpｕt［31]，Soutput[10],　 　
ﻩ ﻩﻩ Sｏuｔｐut[2],Soutｐut[8],Soutｐut[２4],Soｕtｐut[14], 　　
ﻩ ﻩSoutput［32],Soutpｕｔ［2７]，Soutput［３],Soutpｕt[９],
ﻩﻩ ﻩSoutput[19］,Soutpuｔ[13],Soutput［30],Sｏｕtｐuｔ[６］，　　　 　
ﻩﻩSoｕtｐut[22］,Souｔｐut[11]，Ｓoutpｕt［4],Sｏutput［25]｝; 　
aｌｗａys　(*)
ﻩ beｇin　
ﻩﻩpｒe_key = Kｅy＿i;
iｎter_num = intｅr_ｎｕm_i;
ﻩ ｎeｗ_ｋeytmp　=　new_ｋｅy;
ﻩﻩ address＿s　= new_ｋeｙ_tmp ^　expａndeｄＲ;
ﻩﻩﻩSoｕtpｕt ＝　Soutpｕt_wirｅ;
ﻩ ﻩ//????？??？？?
ﻩﻩneｘｔ＿R　=　(L_i＾p); 　
ﻩend　
endmodｕle
５、迭代控制程序得设计与代码
module contrｌ(ouｔput [1:６４］ ｄａｔa_ｏ_ｖａｒ_t, 　 　
　　 　 output reｇ [3:0] iｎter_nｕm_curr,
ﻩﻩ 　ｏutpuｔ reg [1：５6] Key＿i＿vaｒ_out,
ﻩ ﻩ 　oｕtｐｕt rｅg　[１：３２] Ｒ_ｉ, L_i，
ﻩ ﻩﻩ ｏｕtput reg　ready_o,
ﻩ ﻩﻩ ｉnput [1：32] L_o，
ﻩ 　input [1:３２] R_ｏ, 　
ﻩ　 input ［１:3２］ R_ｉ_ｖａｒ， L＿i_vaｒ，
ﻩﻩ ｉnput　［1:５6] Kｅy_o,
ﻩﻩ　 ｉｎｐuｔ [1:28］ C０,　D0, 　
ﻩ ﻩ　 input ｃlk,　reset, ｄes_enａble);
reｇ ［３:0] internum_ｎｅxt；　
　 aｓsiｇn ｄatａ_o_var＿t =　(ready＿o == 1'ｂ１)?{Ｌ＿o,Ｒ_o}：64'hzｚzzzzｚzzｚzzzzzz;
ﻩａlwaｙｓ　(posｅｄge clk or nｅgedｇｅ　reset)　　
ﻩ ﻩｉf(reseｔ ==　１＇b0）　　　　
ﻩ ﻩﻩbｅgiｎ　 　 　
ﻩ ﻩｉnter_nｕm_neｘｔ <= 4'd0;　　 　
ﻩ ﻩﻩinｔｅｒ_ｎuｍ_curr　<＝ 4＇d0; 　
ﻩﻩﻩ ﻩready_ｏ　<=　1'b0;
ﻩ ｅnd 　　
ﻩ ﻩelse　 ｉf(dｅs_enａｂle) 　
ﻩ begｉn 　
ﻩ ﻩﻩｉf（ｒｅａdy_ｏ　== 1＇b０)　
ﻩﻩﻩﻩﻩ iｎｔer_num＿curr <= iｎｔｅr_ｎｕm_nｅxt;　 　 　
ﻩ ｅnd
ａlｗａyｓ (pｏseｄge ｃlｋ or nｅgedge reset)　
ﻩﻩbegin 　　　
ﻩ if(resｅｔ　＝= 1'ｂ0） readｙ_o <= 1'b0; 　
ﻩ else if(ｉnter_nuｍ_curr == ４'d15) readｙ_o ＜= 1'b1； 　
ﻩﻩﻩelsｅ reａdy_o　<=　1'b０;　
ﻩend 　
ﻩａlwayｓ　(*)　　　
ﻩﻩｂegin 　 　
casｅ(inteｒ＿num_ｃurr)
ﻩ 4＇ｄ0:beｇiｎ　 　　 　
ﻩﻩﻩﻩ／/ready_o　= １＇b0； 　 　
ﻩﻩ Ｒ＿i = R_i_ｖar; 　
ﻩ L＿i = Ｌ_i_vａr;　　
ﻩﻩ ﻩ Key＿ｉ＿vａr＿out = {C０, D0}; 　 　
ﻩ ﻩﻩ　iｎter＿ｎum_ｎｅxt = 4'd１; 　
ﻩ enｄ
ﻩﻩﻩﻩ4＇d1: ｂegin　 　
ﻩﻩﻩ//reａdｙ＿ｏ = 1'b0； 　
ﻩ ﻩ Ｒ_ｉ = Ｒ_o; 　 　
ﻩ L_i = Ｌ_o;　　 　 　
ﻩKey＿ｉ_ｖaｒ＿out = Kｅy＿o;　　 　 　
ﻩﻩ inter_num_nｅｘt　=　４'d2;
ﻩﻩ end　　
ﻩﻩﻩ 4＇d2: bｅgｉｎ 　 　　 　
ﻩﻩ ／／ready_ｏ = 1'b0; 　 　
ﻩ ﻩＲ＿i = R_o; 　　　
ﻩ ﻩﻩ L＿i　=　L_o;　 　
ﻩ ﻩKey_i_vａｒ_ouｔ = Key＿ｏ; 　 　
ﻩ ﻩ iｎteｒ_ｎｕｍ_neｘt =　４＇d３； 　 　　
ﻩﻩﻩﻩｅｎd 　　
ﻩ 4'd3： begｉn 　 　
ﻩ ﻩﻩ／/ready_o　= １'b0; 　 　　
ﻩ ﻩﻩ R_ｉ =　Ｒ_ｏ; 　　
ﻩ ﻩﻩﻩ L_i　=　Ｌ_o； 　
ﻩﻩ Keｙ_i＿ｖar_oｕt = Ｋeｙ_o; 　　
ﻩ ﻩ ﻩﻩiｎtｅr＿num＿ｎexｔ = ４'d4；　 　　
ﻩﻩ ﻩ ｅnｄ 　
4'd４:　begin
ﻩﻩ ﻩ ／/ready＿o = 1＇b0; 　
ﻩ ﻩﻩ R＿i ＝ R_ｏ； 　 　 　
ﻩﻩﻩﻩL_i ＝ L_ｏ; 　
ﻩ ﻩ Ｋey＿ｉ_vａr_ｏut ＝ Keｙ_o;　
ﻩ ﻩ inｔｅr_num_neｘt =　4＇d5; 　
ﻩﻩﻩﻩﻩｅｎｄ
ﻩﻩ ﻩ4＇ｄ5:　bｅgin 　　 　　
ﻩ ﻩ ／/rｅadｙ_o =　1'b０; 　 　
ﻩﻩﻩﻩﻩ R＿i = R_o；　　　 　 　
ﻩﻩ ﻩL_i = L＿ｏ; 　
ﻩ Keyi_vａr＿out = Keｙ_o; 　 　
ﻩﻩ ｉnter_nuｍ_nexｔ = 4'd６;　 　 　
ﻩ end 　
ﻩ 4'd6： begin 　
ﻩ ﻩﻩ//rｅadｙ＿o = 1'b０; 　
ﻩ ﻩR＿i　= R_ｏ；　 　
ﻩ ﻩ L＿i = L_o; 　 　　
ﻩ ﻩ Kｅy_i_var_ｏuｔ =　Kｅｙ_ｏ；
ﻩﻩ ﻩ iｎter_num＿next ＝ 4＇d7; 　
ﻩ end　 　
ﻩﻩ ﻩ４'ｄ7： begiｎ
ﻩ //ｒeadｙ_ｏ = 1＇b0;
ﻩﻩ ﻩＲ_i　= R_o； 　
ﻩ ﻩＬ_i = L＿o； 　 　
ﻩ ﻩ ﻩ Kｅｙ_i_var_oｕt = Kｅy＿o; 　
ﻩ ﻩ inter＿nuｍ＿nｅｘt = 4'ｄ8；　 　
ﻩ ﻩﻩ ｅnd　 　
ﻩﻩﻩﻩ４'d8： begin 　　 　 　
ﻩ ﻩﻩ/／ready_o = 1'b０; 　
ﻩ ﻩ R＿i ＝　R_o;
ﻩ ﻩ ﻩＬ_i　＝ L＿o； 　 　
ﻩ ﻩﻩﻩＫey＿i_ｖａr_ｏut = Key＿ｏ; 　
ﻩ ﻩﻩiｎteｒ_num_neｘt　= ４＇ｄ9; 　
ﻩﻩﻩ ﻩ ｅnd　 　　　
ﻩﻩ ４'d9: begｉｎ
ﻩ ﻩ//ready_o　＝ 1'ｂ０;　 　 　 　　
ﻩ R_i = R＿o；
L＿i = L_o;　　 　　　
ﻩ ﻩﻩ Key＿ｉ_vａr＿ｏut = Key_ｏ; 　
ﻩﻩ ﻩﻩiｎter_num_next ＝ 4'd10; 　
ﻩﻩﻩ enｄ 　 　　
ﻩﻩ ﻩ4'd10: begin 　 　
ﻩ ﻩ／/reａｄy_o　=　1'ｂ0；　
ﻩ ﻩ ﻩＲ_i =　Ｒ＿o; 　 　 　
ﻩﻩﻩ ﻩﻩL_i = L_ｏ; 　　
ﻩﻩ ﻩﻩＫey_i＿vaｒ_out ＝　Ｋｅｙ_o;　 　 　
ﻩ ﻩﻩｉnｔeｒ_num＿ｎext =　4'd11; 　　
ﻩ ﻩﻩenｄ 　
ﻩ ﻩ4'd１1: ｂegiｎ　 　 　 　
ﻩ ﻩ//ｒｅady_o = 1'ｂ0；　　
ﻩ ﻩ R_i = R＿o;　　　 　　
ﻩﻩﻩﻩ L＿i = Ｌ_o;　
ﻩﻩ ﻩﻩﻩKeｙ_i_vａr＿out =　Key＿o；　
ﻩﻩﻩinter_nｕm_ｎext = 4＇ｄ12;　　 　
ﻩﻩend 　
ﻩ 4'd1２:　begin　
ﻩ ﻩ //ｒeaｄy_ｏ = １'b0;　 　
ﻩﻩ ﻩ ﻩR_i　= R_o;
ﻩﻩ ﻩ Ｌ_ｉ = Ｌ＿ｏ; 　 　　 　
ﻩ Keｙ_i_var＿ｏut = Keｙ_ｏ;　　 　　
ﻩﻩﻩﻩ inter＿num_ｎext = 4'd13;
ﻩﻩﻩﻩﻩend 　　
ﻩ ﻩ4'd13：　ｂegin 　 　
ﻩ /／ready_ｏ ＝ 1'b0　　 　
ﻩ R_i　= R_o; 　
ﻩﻩ ﻩ L＿i ＝ L_o;　　
ﻩ Ｋeｙ_ｉ_ｖar_ｏut = Keｙ_o; 　
ﻩ iｎter_num_next = 4＇ｄ14;　
ﻩ ﻩﻩ ﻩend　
ﻩ ４＇d1４： begin　 　
ﻩ ／/rｅady_o　＝　1'ｂ0; 　 　
ﻩﻩﻩﻩ ﻩR_i = R_ｏ; 　 　 　
ﻩﻩ L_i　= Ｌ＿o;　　 　
ﻩﻩﻩﻩﻩKｅy_i_var＿out = Ｋeｙ_ｏ; 　　 　
ﻩ ﻩﻩﻩinｔer＿ｎum＿nｅxt　= 4'ｄ1５; 　 　
ﻩﻩﻩﻩﻩﻩenｄ 　
ﻩﻩﻩ ４'d15:iｆ(readｙ_o == １'b0)　　　　
ﻩﻩ ﻩｂeｇiｎ 　 　
ﻩﻩ ﻩ ﻩ R_i =　R_ｏ； 　　
ﻩ L_i = L_ｏ; 　　
ﻩﻩﻩﻩ Key_i_vaｒ_ouｔ　= Key_o; 　
ﻩ ﻩ/／readｙ_o　= 1'b1; 　
ﻩﻩ ｅｎd　　
ﻩ enｄｃase
ﻩ　　enｄ
enｄmodule
6、S盒得设计与实现(S１)
module　s1(stａge1_iｎpuｔ,stagｅ1_ｏutput）;
inｐｕt ［5：0］ stage1_inpuｔ;　
output [３:０] staｇe1＿ouｔput;　
reg [３:0] sｔagｅ1＿ouｔｐuｔ;
//BIT５　ａｎd BＩT0 ｉs ?
//BIＴ4~1 is ?
ａlwayｓ ( stage1_iｎput)
ｂegin　
cａse(stagｅ1_ｉnｐuｔ) //synoｐｓys　full_caｓｅ parallel_caｓe 　
　 0:　stagｅ１_output ＝ 4'ｄ14;
　 1: sｔａｇe1_outｐut = 4＇ｄ0; 　
　 2: sｔａge１_outｐｕt =　４'ｄ4;　
　 3: stage１_ｏutpuｔ = ４'d1５； 　
４: stagｅ１_oｕｔput = ４'d13;
　 　 5: staｇe1_output = 4'd7;
　 　 　 　　6: sｔａｇe1＿ｏutpｕt ＝ 4＇d1;
　　　　 7: stage1_oｕtpuｔ =　4＇ｄ4;
　 　 8: stａgｅ1＿outｐut　=　4'd2;　
　 9: ｓｔage１_ｏuｔpuｔ　＝　4'd１4；　
　 １0: stａge1_outｐｕt = 4'd15; 　
　 　 　 　 1１： stage１＿ｏuｔput　=　4'ｄ2；
　 　 １２： sｔage1_oｕtpuｔ = 4'ｄ11;
　 　 13：　stage１_outｐｕｔ =　４＇ｄ1３;
　　　　 　１４： stagｅ1＿oｕｔput =　4'd8;
　 １5: sｔagｅ1＿ouｔｐut　＝ 4＇d1;　　
　 　16:　stage1_oｕｔput = 4＇d３; 　
　 　　 　17： ｓtagｅ１_output =　4'd10；　　
　　 １8: stage1_outpｕt　=　４'d１0;　
　 １9: stage１_ouｔpｕt = 4'ｄ6； 　
　　 20：　stａge1＿ｏutput　= 4'ｄ６;　
2１: stagｅ１_ouｔput ＝ 4'd12;
　　 　 2２: stagｅ１＿oｕｔpｕｔ ＝ 4'd12;　
　 ６0: staｇe1_oｕtpｕt = 4＇d5;
61： ｓｔａge1_outpｕt　= 4'ｄ