URL https://opencores.org/ocsvn/sha_core/sha_core/trunk

Subversion Repositories sha_core

[/] [sha_core/] [trunk/] [rtl/] [sha256.v] - Blame information for rev 4

Details | Compare with Previous | View Log


/////////////////////////////////////////////////////////////////////
////                                                             ////
////  SHA-256                                                    ////
////  Secure Hash Algorithm (SHA-256)                            ////
////                                                             ////
////  Author: marsgod                                            ////
////          marsgod@opencores.org                              ////
////                                                             ////
////                                                             ////
////  Downloaded from: http://www.opencores.org/cores/sha_core/  ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
////                                                             ////
//// Copyright (C) 2000-2002 marsgod                             ////
////                         marsgod@opencores.org               ////
////                                                             ////
////                                                             ////
//// This source file may be used and distributed without        ////
//// restriction provided that this copyright statement is not   ////
//// removed from the file and that any derivative work contains ////
//// the original copyright notice and the associated disclaimer.////
////                                                             ////
////     THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY     ////
//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   ////
//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS   ////
//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR      ////
//// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,         ////
//// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    ////
//// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE   ////
//// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR        ////
//// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF  ////
//// LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT  ////
//// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT  ////
//// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE         ////
//// POSSIBILITY OF SUCH DAMAGE.                                 ////
////                                                             ////
/////////////////////////////////////////////////////////////////////
 
`define SHA256_H0 32'h6a09e667
`define SHA256_H1 32'hbb67ae85
`define SHA256_H2 32'h3c6ef372
`define SHA256_H3 32'ha54ff53a
`define SHA256_H4 32'h510e527f
`define SHA256_H5 32'h9b05688c
`define SHA256_H6 32'h1f83d9ab
`define SHA256_H7 32'h5be0cd19
 
`define K00 32'h428a2f98
`define K01 32'h71374491
`define K02 32'hb5c0fbcf
`define K03 32'he9b5dba5
`define K04 32'h3956c25b
`define K05 32'h59f111f1
`define K06 32'h923f82a4
`define K07 32'hab1c5ed5
`define K08 32'hd807aa98
`define K09 32'h12835b01
`define K10 32'h243185be
`define K11 32'h550c7dc3
`define K12 32'h72be5d74
`define K13 32'h80deb1fe
`define K14 32'h9bdc06a7
`define K15 32'hc19bf174
`define K16 32'he49b69c1
`define K17 32'hefbe4786
`define K18 32'h0fc19dc6
`define K19 32'h240ca1cc
`define K20 32'h2de92c6f
`define K21 32'h4a7484aa
`define K22 32'h5cb0a9dc
`define K23 32'h76f988da
`define K24 32'h983e5152
`define K25 32'ha831c66d
`define K26 32'hb00327c8
`define K27 32'hbf597fc7
`define K28 32'hc6e00bf3
`define K29 32'hd5a79147
`define K30 32'h06ca6351
`define K31 32'h14292967
`define K32 32'h27b70a85
`define K33 32'h2e1b2138
`define K34 32'h4d2c6dfc
`define K35 32'h53380d13
`define K36 32'h650a7354
`define K37 32'h766a0abb
`define K38 32'h81c2c92e
`define K39 32'h92722c85
`define K40 32'ha2bfe8a1
`define K41 32'ha81a664b
`define K42 32'hc24b8b70
`define K43 32'hc76c51a3
`define K44 32'hd192e819
`define K45 32'hd6990624
`define K46 32'hf40e3585
`define K47 32'h106aa070
`define K48 32'h19a4c116
`define K49 32'h1e376c08
`define K50 32'h2748774c
`define K51 32'h34b0bcb5
`define K52 32'h391c0cb3
`define K53 32'h4ed8aa4a
`define K54 32'h5b9cca4f
`define K55 32'h682e6ff3
`define K56 32'h748f82ee
`define K57 32'h78a5636f
`define K58 32'h84c87814
`define K59 32'h8cc70208
`define K60 32'h90befffa
`define K61 32'ha4506ceb
`define K62 32'hbef9a3f7
`define K63 32'hc67178f2
 
module sha256 (clk_i, rst_i, text_i, text_o, cmd_i, cmd_w_i, cmd_o);
 
        input           clk_i;  // global clock input
        input           rst_i;  // global reset input , active high
 
        input   [31:0]  text_i; // text input 32bit
        output  [31:0]  text_o; // text output 32bit
 
        input   [2:0]   cmd_i;  // command input
        input           cmd_w_i;// command input write enable
        output  [3:0]   cmd_o;  // command output(status)
 
        /*
                cmd
                Busy Round W R
 
                bit3 bit2  bit1 bit0
                Busy Round W    R
 
                Busy:
 
                1       busy
 
                Round:
 
                1       internal round
 
                W:
 
                1       write data
 
                R:
 
                1       read data
 
        */
 
 
        reg     [3:0]   cmd;
        wire    [3:0]   cmd_o;
 
        reg     [31:0]  text_o;
 
        reg     [6:0]   round;
        wire    [6:0]   round_plus_1;
 
        reg     [2:0]   read_counter;
 
        reg     [31:0]  H0,H1,H2,H3,H4,H5,H6,H7;
        reg     [31:0]  W0,W1,W2,W3,W4,W5,W6,W7,W8,W9,W10,W11,W12,W13,W14;
        reg     [31:0]  Wt,Kt;
        reg     [31:0]  A,B,C,D,E,F,G,H;
 
        reg             busy;
 
        assign cmd_o = cmd;
        always @ (posedge clk_i)
        begin
                if (rst_i)
                        cmd <= 'b0;
                else
                if (cmd_w_i)
                        cmd[2:0] <= cmd_i[2:0];         // busy bit can't write
                else
                begin
                        cmd[3] <= busy;                 // update busy bit
                        if (~busy)
                                cmd[1:0] <= 2'b00;      // hardware auto clean R/W bits
                end
        end
 
        wire [31:0] f1_EFG_32,f2_ABC_32,f3_A_32,f4_E_32,f5_W1_32,f6_W14_32,T1_32,T2_32;
        wire [31:0] next_Wt,next_E,next_A;
        wire [255:0] SHA256_result;
 
        assign f1_EFG_32 = (E & F) ^ (~E & G);
 
        assign f2_ABC_32 = (A & B) ^ (B & C) ^ (A & C);
 
        assign f3_A_32 = {A[1:0],A[31:2]} ^ {A[12:0],A[31:13]} ^ {A[21:0],A[31:22]};
 
        assign f4_E_32 = {E[5:0],E[31:6]} ^ {E[10:0],E[31:11]} ^ {E[24:0],E[31:25]};
 
        assign f5_W1_32 = {W1[6:0],W1[31:7]} ^ {W1[17:0],W1[31:18]} ^ {3'b000,W1[31:3]};
 
        assign f6_W14_32 = {W14[16:0],W14[31:17]} ^ {W14[18:0],W14[31:19]} ^ {10'b00_0000_0000,W14[31:10]};
 
 
        assign T1_32 = H[31:0] + f4_E_32 + f1_EFG_32 + Kt + Wt;
 
        assign T2_32 = f3_A_32 + f2_ABC_32;
 
        assign next_Wt = f6_W14_32 + W9[31:0] + f5_W1_32 + W0[31:0];
        assign next_E = D[31:0] + T1_32;
        assign next_A = T1_32 + T2_32;
 
 
        assign SHA256_result = {A,B,C,D,E,F,G,H};
 
        assign round_plus_1 = round + 1;
 
        //------------------------------------------------------------------    
        // SHA round
        //------------------------------------------------------------------
        always @(posedge clk_i)
        begin
                if (rst_i)
                begin
                        round <= 'd0;
                        busy <= 'b0;
 
                        W0  <= 'b0;
                        W1  <= 'b0;
                        W2  <= 'b0;
                        W3  <= 'b0;
                        W4  <= 'b0;
                        W5  <= 'b0;
                        W6  <= 'b0;
                        W7  <= 'b0;
                        W8  <= 'b0;
                        W9  <= 'b0;
                        W10 <= 'b0;
                        W11 <= 'b0;
                        W12 <= 'b0;
                        W13 <= 'b0;
                        W14 <= 'b0;
                        Wt  <= 'b0;
 
                        A <= 'b0;
                        B <= 'b0;
                        C <= 'b0;
                        D <= 'b0;
                        E <= 'b0;
                        F <= 'b0;
                        G <= 'b0;
                        H <= 'b0;
 
                        H0 <= 'b0;
                        H1 <= 'b0;
                        H2 <= 'b0;
                        H3 <= 'b0;
                        H4 <= 'b0;
                        H5 <= 'b0;
                        H6 <= 'b0;
                        H7 <= 'b0;
                end
                else
                begin
                        case (round)
 
                        'd0:
                                begin
                                        if (cmd[1])
                                        begin
                                                W0 <= text_i;
                                                Wt <= text_i;
                                                busy <= 'b1;
                                                round <= round_plus_1;
 
                                                case (cmd[2])
                                                        1'b0:   // sha-256 first message
                                                                begin
                                                                        A <= `SHA256_H0;
                                                                        B <= `SHA256_H1;
                                                                        C <= `SHA256_H2;
                                                                        D <= `SHA256_H3;
                                                                        E <= `SHA256_H4;
                                                                        F <= `SHA256_H5;
                                                                        G <= `SHA256_H6;
                                                                        H <= `SHA256_H7;
 
                                                                        H0 <= `SHA256_H0;
                                                                        H1 <= `SHA256_H1;
                                                                        H2 <= `SHA256_H2;
                                                                        H3 <= `SHA256_H3;
                                                                        H4 <= `SHA256_H4;
                                                                        H5 <= `SHA256_H5;
                                                                        H6 <= `SHA256_H6;
                                                                        H7 <= `SHA256_H7;
                                                                end
                                                        1'b1:   // sha-256 internal message
                                                                begin
                                                                        H0 <= A;
                                                                        H1 <= B;
                                                                        H2 <= C;
                                                                        H3 <= D;
                                                                        H4 <= E;
                                                                        H5 <= F;
                                                                        H6 <= G;
                                                                        H7 <= H;
                                                                end
                                                endcase
                                        end
                                        else
                                        begin   // IDLE
                                                round <= 'd0;
                                        end
                                end
                        'd1:
                                begin
                                        W1 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd2:
                                begin
                                        W2 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd3:
                                begin
                                        W3 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd4:
                                begin
                                        W4 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd5:
                                begin
                                        W5 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd6:
                                begin
                                        W6 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd7:
                                begin
                                        W7 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd8:
                                begin
                                        W8 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd9:
                                begin
                                        W9 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd10:
                                begin
                                        W10 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd11:
                                begin
                                        W11 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd12:
                                begin
                                        W12 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd13:
                                begin
                                        W13 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd14:
                                begin
                                        W14 <= text_i;
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd15:
                                begin
                                        Wt <= text_i;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd16,
                        'd17,
                        'd18,
                        'd19,
                        'd20,
                        'd21,
                        'd22,
                        'd23,
                        'd24,
                        'd25,
                        'd26,
                        'd27,
                        'd28,
                        'd29,
                        'd30,
                        'd31,
                        'd32,
                        'd33,
                        'd34,
                        'd35,
                        'd36,
                        'd37,
                        'd38,
                        'd39,
                        'd40,
                        'd41,
                        'd42,
                        'd43,
                        'd44,
                        'd45,
                        'd46,
                        'd47,
                        'd48,
                        'd49,
                        'd50,
                        'd51,
                        'd52,
                        'd53,
                        'd54,
                        'd55,
                        'd56,
                        'd57,
                        'd58,
                        'd59,
                        'd60,
                        'd61,
                        'd62,
                        'd63:
                                begin
                                        W0  <= W1;
                                        W1  <= W2;
                                        W2  <= W3;
                                        W3  <= W4;
                                        W4  <= W5;
                                        W5  <= W6;
                                        W6  <= W7;
                                        W7  <= W8;
                                        W8  <= W9;
                                        W9  <= W10;
                                        W10 <= W11;
                                        W11 <= W12;
                                        W12 <= W13;
                                        W13 <= W14;
                                        W14 <= Wt;
                                        Wt  <= next_Wt;
 
                                        H <= G;
                                        G <= F;
                                        F <= E;
                                        E <= next_E;
                                        D <= C;
                                        C <= B;
                                        B <= A;
                                        A <= next_A;
 
                                        round <= round_plus_1;
                                end
                        'd64:
                                begin
                                        A <= next_A + H0;
                                        B <= A + H1;
                                        C <= B + H2;
                                        D <= C + H3;
                                        E <= next_E + H4;
                                        F <= E + H5;
                                        G <= F + H6;
                                        H <= G + H7;
                                        round <= 'd0;
                                        busy <= 'b0;
                                end
                        default:
                                begin
                                        round <= 'd0;
                                        busy <= 'b0;
                                end
                        endcase
                end
        end
 
 
        //------------------------------------------------------------------    
        // Kt generator
        //------------------------------------------------------------------    
        always @ (posedge clk_i)
        begin
                if (rst_i)
                begin
                        Kt <= 'b0;
                end
                else
                begin
                        case (round)
                                'd00:   Kt <= `K00;
                                'd01:   Kt <= `K01;
                                'd02:   Kt <= `K02;
                                'd03:   Kt <= `K03;
                                'd04:   Kt <= `K04;
                                'd05:   Kt <= `K05;
                                'd06:   Kt <= `K06;
                                'd07:   Kt <= `K07;
                                'd08:   Kt <= `K08;
                                'd09:   Kt <= `K09;
                                'd10:   Kt <= `K10;
                                'd11:   Kt <= `K11;
                                'd12:   Kt <= `K12;
                                'd13:   Kt <= `K13;
                                'd14:   Kt <= `K14;
                                'd15:   Kt <= `K15;
                                'd16:   Kt <= `K16;
                                'd17:   Kt <= `K17;
                                'd18:   Kt <= `K18;
                                'd19:   Kt <= `K19;
                                'd20:   Kt <= `K20;
                                'd21:   Kt <= `K21;
                                'd22:   Kt <= `K22;
                                'd23:   Kt <= `K23;
                                'd24:   Kt <= `K24;
                                'd25:   Kt <= `K25;
                                'd26:   Kt <= `K26;
                                'd27:   Kt <= `K27;
                                'd28:   Kt <= `K28;
                                'd29:   Kt <= `K29;
                                'd30:   Kt <= `K30;
                                'd31:   Kt <= `K31;
                                'd32:   Kt <= `K32;
                                'd33:   Kt <= `K33;
                                'd34:   Kt <= `K34;
                                'd35:   Kt <= `K35;
                                'd36:   Kt <= `K36;
                                'd37:   Kt <= `K37;
                                'd38:   Kt <= `K38;
                                'd39:   Kt <= `K39;
                                'd40:   Kt <= `K40;
                                'd41:   Kt <= `K41;
                                'd42:   Kt <= `K42;
                                'd43:   Kt <= `K43;
                                'd44:   Kt <= `K44;
                                'd45:   Kt <= `K45;
                                'd46:   Kt <= `K46;
                                'd47:   Kt <= `K47;
                                'd48:   Kt <= `K48;
                                'd49:   Kt <= `K49;
                                'd50:   Kt <= `K50;
                                'd51:   Kt <= `K51;
                                'd52:   Kt <= `K52;
                                'd53:   Kt <= `K53;
                                'd54:   Kt <= `K54;
                                'd55:   Kt <= `K55;
                                'd56:   Kt <= `K56;
                                'd57:   Kt <= `K57;
                                'd58:   Kt <= `K58;
                                'd59:   Kt <= `K59;
                                'd60:   Kt <= `K60;
                                'd61:   Kt <= `K61;
                                'd62:   Kt <= `K62;
                                'd63:   Kt <= `K63;
                                default:Kt <= 'd0;
                        endcase
                end
        end
 
        //------------------------------------------------------------------    
        // read result 
        //------------------------------------------------------------------    
        always @ (posedge clk_i)
        begin
                if (rst_i)
                begin
                        text_o <= 'b0;
                        read_counter <= 'b0;
                end
                else
                begin
                        if (cmd[0])
                        begin
                                read_counter <= 'd7;    // sha-256      256/32=8
                        end
                        else
                        begin
                        if (~busy)
                        begin
                                case (read_counter)
                                        'd7:    text_o <= SHA256_result[8*32-1:7*32];
                                        'd6:    text_o <= SHA256_result[7*32-1:6*32];
                                        'd5:    text_o <= SHA256_result[6*32-1:5*32];
                                        'd4:    text_o <= SHA256_result[5*32-1:4*32];
                                        'd3:    text_o <= SHA256_result[4*32-1:3*32];
                                        'd2:    text_o <= SHA256_result[3*32-1:2*32];
                                        'd1:    text_o <= SHA256_result[2*32-1:1*32];
                                        'd0:    text_o <= SHA256_result[1*32-1:0*32];
                                        default:text_o <= 'b0;
                                endcase
                                if (|read_counter)
                                        read_counter <= read_counter - 'd1;
                        end
                        else
                        begin
                                text_o <= 'b0;
                        end
                        end
                end
        end
 
endmodule
 

Browse

Tools

Subversion Repositories sha_core

[/] [sha_core/] [trunk/] [rtl/] [sha256.v] - Blame information for rev 4

Line No.	Rev	Author	Line
1	2	marsgod	`/////////////////////////////////////////////////////////////////////`
2			`//// ////`
3			`//// SHA-256 ////`
4			`//// Secure Hash Algorithm (SHA-256) ////`
5			`//// ////`
6			`//// Author: marsgod ////`
7			`//// marsgod@opencores.org ////`
8			`//// ////`
9			`//// ////`
10			`//// Downloaded from: http://www.opencores.org/cores/sha_core/ ////`
11			`//// ////`
12			`/////////////////////////////////////////////////////////////////////`
13			`//// ////`
14			`//// Copyright (C) 2000-2002 marsgod ////`
15			`//// marsgod@opencores.org ////`
16			`//// ////`
17			`//// ////`
18			`//// This source file may be used and distributed without ////`
19			`//// restriction provided that this copyright statement is not ////`
20			`//// removed from the file and that any derivative work contains ////`
21			`//// the original copyright notice and the associated disclaimer.////`
22			`//// ////`
23			//// THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY ////
24			`//// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED ////`
25			`//// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ////`
26			`//// FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR ////`
27			`//// OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ////`
28			`//// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ////`
29			`//// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE ////`
30			`//// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR ////`
31			`//// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF ////`
32			`//// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ////`
33			`//// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT ////`
34			`//// OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ////`
35			`//// POSSIBILITY OF SUCH DAMAGE. ////`
36			`//// ////`
37			`/////////////////////////////////////////////////////////////////////`
38
39			`define SHA256_H0 32'h6a09e667
40			`define SHA256_H1 32'hbb67ae85
41			`define SHA256_H2 32'h3c6ef372
42			`define SHA256_H3 32'ha54ff53a
43			`define SHA256_H4 32'h510e527f
44			`define SHA256_H5 32'h9b05688c
45			`define SHA256_H6 32'h1f83d9ab
46			`define SHA256_H7 32'h5be0cd19
47
48			`define K00 32'h428a2f98
49			`define K01 32'h71374491
50			`define K02 32'hb5c0fbcf
51			`define K03 32'he9b5dba5
52			`define K04 32'h3956c25b
53			`define K05 32'h59f111f1
54			`define K06 32'h923f82a4
55			`define K07 32'hab1c5ed5
56			`define K08 32'hd807aa98
57			`define K09 32'h12835b01
58			`define K10 32'h243185be
59			`define K11 32'h550c7dc3
60			`define K12 32'h72be5d74
61			`define K13 32'h80deb1fe
62			`define K14 32'h9bdc06a7
63			`define K15 32'hc19bf174
64			`define K16 32'he49b69c1
65			`define K17 32'hefbe4786
66			`define K18 32'h0fc19dc6
67			`define K19 32'h240ca1cc
68			`define K20 32'h2de92c6f
69			`define K21 32'h4a7484aa
70			`define K22 32'h5cb0a9dc
71			`define K23 32'h76f988da
72			`define K24 32'h983e5152
73			`define K25 32'ha831c66d
74			`define K26 32'hb00327c8
75			`define K27 32'hbf597fc7
76			`define K28 32'hc6e00bf3
77			`define K29 32'hd5a79147
78			`define K30 32'h06ca6351
79			`define K31 32'h14292967
80			`define K32 32'h27b70a85
81			`define K33 32'h2e1b2138
82			`define K34 32'h4d2c6dfc
83			`define K35 32'h53380d13
84			`define K36 32'h650a7354
85			`define K37 32'h766a0abb
86			`define K38 32'h81c2c92e
87			`define K39 32'h92722c85
88			`define K40 32'ha2bfe8a1
89			`define K41 32'ha81a664b
90			`define K42 32'hc24b8b70
91			`define K43 32'hc76c51a3
92			`define K44 32'hd192e819
93			`define K45 32'hd6990624
94			`define K46 32'hf40e3585
95			`define K47 32'h106aa070
96			`define K48 32'h19a4c116
97			`define K49 32'h1e376c08
98			`define K50 32'h2748774c
99			`define K51 32'h34b0bcb5
100			`define K52 32'h391c0cb3
101			`define K53 32'h4ed8aa4a
102			`define K54 32'h5b9cca4f
103			`define K55 32'h682e6ff3
104			`define K56 32'h748f82ee
105			`define K57 32'h78a5636f
106			`define K58 32'h84c87814
107			`define K59 32'h8cc70208
108			`define K60 32'h90befffa
109			`define K61 32'ha4506ceb
110			`define K62 32'hbef9a3f7
111			`define K63 32'hc67178f2
112
113			`module sha256 (clk_i, rst_i, text_i, text_o, cmd_i, cmd_w_i, cmd_o);`
114
115			`input clk_i; // global clock input`
116			`input rst_i; // global reset input , active high`
117
118			`input [31:0] text_i; // text input 32bit`
119			`output [31:0] text_o; // text output 32bit`
120
121			`input [2:0] cmd_i; // command input`
122			`input cmd_w_i;// command input write enable`
123			`output [3:0] cmd_o; // command output(status)`
124
125			`/*`
126			`cmd`
127			`Busy Round W R`
128
129			`bit3 bit2 bit1 bit0`
130			`Busy Round W R`
131
132			`Busy:`
133
134			`1 busy`
135
136			`Round:`
137
138			`1 internal round`
139
140			`W:`
141
142			`1 write data`
143
144			`R:`
145
146			`1 read data`
147
148			`*/`
149
150
151			`reg [3:0] cmd;`
152			`wire [3:0] cmd_o;`
153
154			`reg [31:0] text_o;`
155
156			`reg [6:0] round;`
157			`wire [6:0] round_plus_1;`
158
159			`reg [2:0] read_counter;`
160
161			`reg [31:0] H0,H1,H2,H3,H4,H5,H6,H7;`
162			`reg [31:0] W0,W1,W2,W3,W4,W5,W6,W7,W8,W9,W10,W11,W12,W13,W14;`
163			`reg [31:0] Wt,Kt;`
164			`reg [31:0] A,B,C,D,E,F,G,H;`
165
166			`reg busy;`
167
168			`assign cmd_o = cmd;`
169			`always @ (posedge clk_i)`
170			`begin`
171			`if (rst_i)`
172			`cmd <= 'b0;`
173			`else`
174			`if (cmd_w_i)`
175			`cmd[2:0] <= cmd_i[2:0]; // busy bit can't write`
176			`else`
177			`begin`
178			`cmd[3] <= busy; // update busy bit`
179			`if (~busy)`
180			`cmd[1:0] <= 2'b00; // hardware auto clean R/W bits`
181			`end`
182			`end`
183
184			`wire [31:0] f1_EFG_32,f2_ABC_32,f3_A_32,f4_E_32,f5_W1_32,f6_W14_32,T1_32,T2_32;`
185			`wire [31:0] next_Wt,next_E,next_A;`
186			`wire [255:0] SHA256_result;`
187
188			`assign f1_EFG_32 = (E & F) ^ (~E & G);`
189
190			`assign f2_ABC_32 = (A & B) ^ (B & C) ^ (A & C);`
191
192			`assign f3_A_32 = {A[1:0],A[31:2]} ^ {A[12:0],A[31:13]} ^ {A[21:0],A[31:22]};`
193
194			`assign f4_E_32 = {E[5:0],E[31:6]} ^ {E[10:0],E[31:11]} ^ {E[24:0],E[31:25]};`
195
196			`assign f5_W1_32 = {W1[6:0],W1[31:7]} ^ {W1[17:0],W1[31:18]} ^ {3'b000,W1[31:3]};`
197
198			`assign f6_W14_32 = {W14[16:0],W14[31:17]} ^ {W14[18:0],W14[31:19]} ^ {10'b00_0000_0000,W14[31:10]};`
199
200
201			`assign T1_32 = H[31:0] + f4_E_32 + f1_EFG_32 + Kt + Wt;`
202
203			`assign T2_32 = f3_A_32 + f2_ABC_32;`
204
205			`assign next_Wt = f6_W14_32 + W9[31:0] + f5_W1_32 + W0[31:0];`
206			`assign next_E = D[31:0] + T1_32;`
207			`assign next_A = T1_32 + T2_32;`
208
209
210			`assign SHA256_result = {A,B,C,D,E,F,G,H};`
211
212			`assign round_plus_1 = round + 1;`
213
214			`//------------------------------------------------------------------`
215			`// SHA round`
216			`//------------------------------------------------------------------`
217			`always @(posedge clk_i)`
218			`begin`
219			`if (rst_i)`
220			`begin`
221			`round <= 'd0;`
222			`busy <= 'b0;`
223
224			`W0 <= 'b0;`
225			`W1 <= 'b0;`
226			`W2 <= 'b0;`
227			`W3 <= 'b0;`
228			`W4 <= 'b0;`
229			`W5 <= 'b0;`
230			`W6 <= 'b0;`
231			`W7 <= 'b0;`
232			`W8 <= 'b0;`
233			`W9 <= 'b0;`
234			`W10 <= 'b0;`
235			`W11 <= 'b0;`
236			`W12 <= 'b0;`
237			`W13 <= 'b0;`
238			`W14 <= 'b0;`
239			`Wt <= 'b0;`
240
241			`A <= 'b0;`
242			`B <= 'b0;`
243			`C <= 'b0;`
244			`D <= 'b0;`
245			`E <= 'b0;`
246			`F <= 'b0;`
247			`G <= 'b0;`
248			`H <= 'b0;`
249
250			`H0 <= 'b0;`
251			`H1 <= 'b0;`
252			`H2 <= 'b0;`
253			`H3 <= 'b0;`
254			`H4 <= 'b0;`
255			`H5 <= 'b0;`
256			`H6 <= 'b0;`
257			`H7 <= 'b0;`
258			`end`
259			`else`
260			`begin`
261			`case (round)`
262
263			`'d0:`
264			`begin`
265			`if (cmd[1])`
266			`begin`
267			`W0 <= text_i;`
268			`Wt <= text_i;`
269			`busy <= 'b1;`
270			`round <= round_plus_1;`
271
272			`case (cmd[2])`
273			`1'b0: // sha-256 first message`
274			`begin`
275			A <= `SHA256_H0;
276			B <= `SHA256_H1;
277			C <= `SHA256_H2;
278			D <= `SHA256_H3;
279			E <= `SHA256_H4;
280			F <= `SHA256_H5;
281			G <= `SHA256_H6;
282			H <= `SHA256_H7;
283
284			H0 <= `SHA256_H0;
285			H1 <= `SHA256_H1;
286			H2 <= `SHA256_H2;
287			H3 <= `SHA256_H3;
288			H4 <= `SHA256_H4;
289			H5 <= `SHA256_H5;
290			H6 <= `SHA256_H6;
291			H7 <= `SHA256_H7;
292			`end`
293			`1'b1: // sha-256 internal message`
294			`begin`
295			`H0 <= A;`
296			`H1 <= B;`
297			`H2 <= C;`
298			`H3 <= D;`
299			`H4 <= E;`
300			`H5 <= F;`
301			`H6 <= G;`
302			`H7 <= H;`
303			`end`
304			`endcase`
305			`end`
306			`else`
307			`begin // IDLE`
308			`round <= 'd0;`
309			`end`
310			`end`
311			`'d1:`
312			`begin`
313			`W1 <= text_i;`
314			`Wt <= text_i;`
315
316			`H <= G;`
317			`G <= F;`
318			`F <= E;`
319			`E <= next_E;`
320			`D <= C;`
321			`C <= B;`
322			`B <= A;`
323			`A <= next_A;`
324
325			`round <= round_plus_1;`
326			`end`
327			`'d2:`
328			`begin`
329			`W2 <= text_i;`
330			`Wt <= text_i;`
331
332			`H <= G;`
333			`G <= F;`
334			`F <= E;`
335			`E <= next_E;`
336			`D <= C;`
337			`C <= B;`
338			`B <= A;`
339			`A <= next_A;`
340
341			`round <= round_plus_1;`
342			`end`
343			`'d3:`
344			`begin`
345			`W3 <= text_i;`
346			`Wt <= text_i;`
347
348			`H <= G;`
349			`G <= F;`
350			`F <= E;`
351			`E <= next_E;`
352			`D <= C;`
353			`C <= B;`
354			`B <= A;`
355			`A <= next_A;`
356
357			`round <= round_plus_1;`
358			`end`
359			`'d4:`
360			`begin`
361			`W4 <= text_i;`
362			`Wt <= text_i;`
363
364			`H <= G;`
365			`G <= F;`
366			`F <= E;`
367			`E <= next_E;`
368			`D <= C;`
369			`C <= B;`
370			`B <= A;`
371			`A <= next_A;`
372
373			`round <= round_plus_1;`
374			`end`
375			`'d5:`
376			`begin`
377			`W5 <= text_i;`
378			`Wt <= text_i;`
379
380			`H <= G;`
381			`G <= F;`
382			`F <= E;`
383			`E <= next_E;`
384			`D <= C;`
385			`C <= B;`
386			`B <= A;`
387			`A <= next_A;`
388
389			`round <= round_plus_1;`
390			`end`
391			`'d6:`
392			`begin`
393			`W6 <= text_i;`
394			`Wt <= text_i;`
395
396			`H <= G;`
397			`G <= F;`
398			`F <= E;`
399			`E <= next_E;`
400			`D <= C;`
401			`C <= B;`
402			`B <= A;`
403			`A <= next_A;`
404
405			`round <= round_plus_1;`
406			`end`
407			`'d7:`
408			`begin`
409			`W7 <= text_i;`
410			`Wt <= text_i;`
411
412			`H <= G;`
413			`G <= F;`
414			`F <= E;`
415			`E <= next_E;`
416			`D <= C;`
417			`C <= B;`
418			`B <= A;`
419			`A <= next_A;`
420
421			`round <= round_plus_1;`
422			`end`
423			`'d8:`
424			`begin`
425			`W8 <= text_i;`
426			`Wt <= text_i;`
427
428			`H <= G;`
429			`G <= F;`
430			`F <= E;`
431			`E <= next_E;`
432			`D <= C;`
433			`C <= B;`
434			`B <= A;`
435			`A <= next_A;`
436
437			`round <= round_plus_1;`
438			`end`
439			`'d9:`
440			`begin`
441			`W9 <= text_i;`
442			`Wt <= text_i;`
443
444			`H <= G;`
445			`G <= F;`
446			`F <= E;`
447			`E <= next_E;`
448			`D <= C;`
449			`C <= B;`
450			`B <= A;`
451			`A <= next_A;`
452
453			`round <= round_plus_1;`
454			`end`
455			`'d10:`
456			`begin`
457			`W10 <= text_i;`
458			`Wt <= text_i;`
459
460			`H <= G;`
461			`G <= F;`
462			`F <= E;`
463			`E <= next_E;`
464			`D <= C;`
465			`C <= B;`
466			`B <= A;`
467			`A <= next_A;`
468
469			`round <= round_plus_1;`
470			`end`
471			`'d11:`
472			`begin`
473			`W11 <= text_i;`
474			`Wt <= text_i;`
475
476			`H <= G;`
477			`G <= F;`
478			`F <= E;`
479			`E <= next_E;`
480			`D <= C;`
481			`C <= B;`
482			`B <= A;`
483			`A <= next_A;`
484
485			`round <= round_plus_1;`
486			`end`
487			`'d12:`
488			`begin`
489			`W12 <= text_i;`
490			`Wt <= text_i;`
491
492			`H <= G;`
493			`G <= F;`
494			`F <= E;`
495			`E <= next_E;`
496			`D <= C;`
497			`C <= B;`
498			`B <= A;`
499			`A <= next_A;`
500
501			`round <= round_plus_1;`
502			`end`
503			`'d13:`
504			`begin`
505			`W13 <= text_i;`
506			`Wt <= text_i;`
507
508			`H <= G;`
509			`G <= F;`
510			`F <= E;`
511			`E <= next_E;`
512			`D <= C;`
513			`C <= B;`
514			`B <= A;`
515			`A <= next_A;`
516
517			`round <= round_plus_1;`
518			`end`
519			`'d14:`
520			`begin`
521			`W14 <= text_i;`
522			`Wt <= text_i;`
523
524			`H <= G;`
525			`G <= F;`
526			`F <= E;`
527			`E <= next_E;`
528			`D <= C;`
529			`C <= B;`
530			`B <= A;`
531			`A <= next_A;`
532
533			`round <= round_plus_1;`
534			`end`
535			`'d15:`
536			`begin`
537			`Wt <= text_i;`
538
539			`H <= G;`
540			`G <= F;`
541			`F <= E;`
542			`E <= next_E;`
543			`D <= C;`
544			`C <= B;`
545			`B <= A;`
546			`A <= next_A;`
547
548			`round <= round_plus_1;`
549			`end`
550			`'d16,`
551			`'d17,`
552			`'d18,`
553			`'d19,`
554			`'d20,`
555			`'d21,`
556			`'d22,`
557			`'d23,`
558			`'d24,`
559			`'d25,`
560			`'d26,`
561			`'d27,`
562			`'d28,`
563			`'d29,`
564			`'d30,`
565			`'d31,`
566			`'d32,`
567			`'d33,`
568			`'d34,`
569			`'d35,`
570			`'d36,`
571			`'d37,`
572			`'d38,`
573			`'d39,`
574			`'d40,`
575			`'d41,`
576			`'d42,`
577			`'d43,`
578			`'d44,`
579			`'d45,`
580			`'d46,`
581			`'d47,`
582			`'d48,`
583			`'d49,`
584			`'d50,`
585			`'d51,`
586			`'d52,`
587			`'d53,`
588			`'d54,`
589			`'d55,`
590			`'d56,`
591			`'d57,`
592			`'d58,`
593			`'d59,`
594			`'d60,`
595			`'d61,`
596			`'d62,`
597			`'d63:`
598			`begin`
599			`W0 <= W1;`
600			`W1 <= W2;`
601			`W2 <= W3;`
602			`W3 <= W4;`
603			`W4 <= W5;`
604			`W5 <= W6;`
605			`W6 <= W7;`
606			`W7 <= W8;`
607			`W8 <= W9;`
608			`W9 <= W10;`
609			`W10 <= W11;`
610			`W11 <= W12;`
611			`W12 <= W13;`
612			`W13 <= W14;`
613			`W14 <= Wt;`
614			`Wt <= next_Wt;`
615
616			`H <= G;`
617			`G <= F;`
618			`F <= E;`
619			`E <= next_E;`
620			`D <= C;`
621			`C <= B;`
622			`B <= A;`
623			`A <= next_A;`
624
625			`round <= round_plus_1;`
626			`end`
627			`'d64:`
628			`begin`
629			`A <= next_A + H0;`
630			`B <= A + H1;`
631			`C <= B + H2;`
632			`D <= C + H3;`
633			`E <= next_E + H4;`
634			`F <= E + H5;`
635			`G <= F + H6;`
636			`H <= G + H7;`
637			`round <= 'd0;`
638			`busy <= 'b0;`
639			`end`
640			`default:`
641			`begin`
642			`round <= 'd0;`
643			`busy <= 'b0;`
644			`end`
645			`endcase`
646			`end`
647			`end`
648
649
650			`//------------------------------------------------------------------`
651			`// Kt generator`
652			`//------------------------------------------------------------------`
653			`always @ (posedge clk_i)`
654			`begin`
655			`if (rst_i)`
656			`begin`
657			`Kt <= 'b0;`
658			`end`
659			`else`
660			`begin`
661			`case (round)`
662			'd00: Kt <= `K00;
663			'd01: Kt <= `K01;
664			'd02: Kt <= `K02;
665			'd03: Kt <= `K03;
666			'd04: Kt <= `K04;
667			'd05: Kt <= `K05;
668			'd06: Kt <= `K06;
669			'd07: Kt <= `K07;
670			'd08: Kt <= `K08;
671			'd09: Kt <= `K09;
672			'd10: Kt <= `K10;
673			'd11: Kt <= `K11;
674			'd12: Kt <= `K12;
675			'd13: Kt <= `K13;
676			'd14: Kt <= `K14;
677			'd15: Kt <= `K15;
678			'd16: Kt <= `K16;
679			'd17: Kt <= `K17;
680			'd18: Kt <= `K18;
681			'd19: Kt <= `K19;
682			'd20: Kt <= `K20;
683			'd21: Kt <= `K21;
684			'd22: Kt <= `K22;
685			'd23: Kt <= `K23;
686			'd24: Kt <= `K24;
687			'd25: Kt <= `K25;
688			'd26: Kt <= `K26;
689			'd27: Kt <= `K27;
690			'd28: Kt <= `K28;
691			'd29: Kt <= `K29;
692			'd30: Kt <= `K30;
693			'd31: Kt <= `K31;
694			'd32: Kt <= `K32;
695			'd33: Kt <= `K33;
696			'd34: Kt <= `K34;
697			'd35: Kt <= `K35;
698			'd36: Kt <= `K36;
699			'd37: Kt <= `K37;
700			'd38: Kt <= `K38;
701			'd39: Kt <= `K39;
702			'd40: Kt <= `K40;
703			'd41: Kt <= `K41;
704			'd42: Kt <= `K42;
705			'd43: Kt <= `K43;
706			'd44: Kt <= `K44;
707			'd45: Kt <= `K45;
708			'd46: Kt <= `K46;
709			'd47: Kt <= `K47;
710			'd48: Kt <= `K48;
711			'd49: Kt <= `K49;
712			'd50: Kt <= `K50;
713			'd51: Kt <= `K51;
714			'd52: Kt <= `K52;
715			'd53: Kt <= `K53;
716			'd54: Kt <= `K54;
717			'd55: Kt <= `K55;
718			'd56: Kt <= `K56;
719			'd57: Kt <= `K57;
720			'd58: Kt <= `K58;
721			'd59: Kt <= `K59;
722			'd60: Kt <= `K60;
723			'd61: Kt <= `K61;
724			'd62: Kt <= `K62;
725			'd63: Kt <= `K63;
726			`default:Kt <= 'd0;`
727			`endcase`
728			`end`
729			`end`
730
731			`//------------------------------------------------------------------`
732			`// read result`
733			`//------------------------------------------------------------------`
734			`always @ (posedge clk_i)`
735			`begin`
736			`if (rst_i)`
737			`begin`
738			`text_o <= 'b0;`
739			`read_counter <= 'b0;`
740			`end`
741			`else`
742			`begin`
743			`if (cmd[0])`
744			`begin`
745			`read_counter <= 'd7; // sha-256 256/32=8`
746			`end`
747			`else`
748			`begin`
749			`if (~busy)`
750			`begin`
751			`case (read_counter)`
752			`'d7: text_o <= SHA256_result[832-1:732];`
753			`'d6: text_o <= SHA256_result[732-1:632];`
754			`'d5: text_o <= SHA256_result[632-1:532];`
755			`'d4: text_o <= SHA256_result[532-1:432];`
756			`'d3: text_o <= SHA256_result[432-1:332];`
757			`'d2: text_o <= SHA256_result[332-1:232];`
758			`'d1: text_o <= SHA256_result[232-1:132];`
759			`'d0: text_o <= SHA256_result[132-1:032];`
760			`default:text_o <= 'b0;`
761			`endcase`
762			`if (\|read_counter)`
763			`read_counter <= read_counter - 'd1;`
764			`end`
765			`else`
766			`begin`
767			`text_o <= 'b0;`
768			`end`
769			`end`
770			`end`
771			`end`
772
773			`endmodule`
774