The document describes the implementation of an encryption algorithm in VHDL. It includes the design of an ALU, program counter that can jump, and expanded memory. The ALU was changed to support hierarchical operation codes and branch logic. The program counter can now jump via a 7-bit MUX. Memory was also expanded. Simulation results verified the correctness of encryption for each character and generation of an authentication tag.

1. 3211 Project
Design: Jiang Yucheng
Implementation: Zheng Bohan
Result: Zheng Wenguang

2. High Level C Programming
Encryption
int key=[0x12,0x34,0x56,0x78,0x9A,0xBC,0xDE,0xF0];
int text=[0x43,0x6F,0x6D,0x70,0x41,0x72,0x63,0x68]; //plain text of "CompArch"
int RN=[0x11,0x90,0x52,0xC8,0xB7,0xCE,0xD4,0x31,
0xD3,0xCB,0xF1,0xB5,0x73,0xAB,0xBF,0x62];
int i,j,k;
Int mask = 0xF0;
for (i=0 ; i<length(text) ; i++){
for (j=0 ; j <length(key) ; j++){
text[i] = bitxor( text[i] , key[j] );
k = bitand(text[i],mask);
text[i]=RN[k];
}
}

3. High Level C Programming
Tag
int key=[0x12,0x34,0x56,0x78,0x9A,0xBC,0xDE,0xF0];
int text=[0x43,0x6F,0x6D,0x70,0x41,0x72,0x63,0x68]; //plain text of "CompArch"
int mask=0x80;
int tag = 0x00;
int text_temp , j=0;
Int N = length(text)/8 , R = length (text) % 8 ;
for(i=0 ; i<N ; i++){
for(cnt=0 ; cnt<8 ; cnt++) {
if (bitand(key[j],mask) == 0x80)
text_temp = bit_shift_left( text[i] , 1 );
else
text_temp = text[i];
tag = bitxor(text_temp,tag);
bit_shift_left(key[j] , 1); }
if(j==7){
j = 0; }
else{
j++;}
}
for(i=0 ; i<R ; i++){
if (bitand(key[j],mask) == 0x80)
text_temp = bit_shift_left( text[i] , 1 );
else
text_temp = text[i];
tag = bitxor(text_temp,tag);
bit_shift_left(key[j] , 1);
}

4. ISA
Op - Code rs rt rd
Op – Code rs rt offset
Op - Code rs rt instance
Op - Code rt/rd
Add
Sub
Xor
And
Beq
Bne
Load
Store
Addi
shift

5. Assembly Language
Encryption
(0) addi $s1 , $s0 , F # $s1 = 15
(1) addi $s1 , $s1 , 9 # $s1 the pointer of the plaintext (the head of the stack is 24)
(2) load $s2 , $s1 , 0 # $s2 the current char pointer
(3) load $s15 , $s2 , 0 # $s15 current char
(4) add $s3 , $s15 ,$s0 # $s3 working char which will be overwriten during encryption
loop
(5) addi $s4 , $s0 , 15 # $s4 key pointer (one element before because of the loop
starts with an increment)
(6) load $s6 , $s1 , 2 # $s6 = 15 the mask to get the index of RN table stored in
data_memory(26)
(7) load $s7 , $s1 , 3 # $s7 = F0 last key value need to be used in bne instruction
(8) load $s8 , $s1 , 4 # $s8 = 10 which stores the "encryption" tag address for
loop
(9) load $14, $1 , 1 # $s14 stores the pointer of cipher text
--data preparation

6. Assembly Language
Encryption
(10) addi $s4 , $s4 , 1 # increase the key pointer jump addr
(11) load $s5 , $s4 , 0 # $5 get the 16bit key value from the data memo
(12) xor $s9 , $s3 , $s5 # $s9 <= $s3 xor $s5
(13) and $s10, $s9 , $s6 # mask and get the rn table index
(14) load $s11, $s10, $s0 # $11 one loop result
(15) add $s3 , $s11, $s0 # overwrite the working char for next loop
(16) add $s12, $s5 , $s0 # tmp reg $s12 stores the current key for bne judgement
(17) bne $s12, $s7 , $s8 # if it is NOT the last key ,continue loop
(18) no op
(20) addi $2 , $2 , 1 # plaintext pointer move ahead
(21) load $15 , $2 , 0 # $15 current char
(22) add $3 , $15 ,$0 # $3 working char which will be overwriten during encryption loop
(23) addi $14 ,$14 , 1
(24) addi $4 , $0 , 15 # let the key pointer point to the head of the key again
(25) bne $15 , $0 , $8 # make a definate not equal to jump--Process 0 24 Char
pointer
Working
char
Key
pointer
Current
key value
0x000F
(mask)
Last key
Value
Jump addr Xor
result
RN
index
One loop
result
Current
key
Cipher
pointer
Current
char

7. Assembly Language
Tag
(29) load $s2, $s1, 1 # $s2 loads mem(25)
(30) load $s11, $s1, 5 # $s11 loads mem(29) ~1$B
(31) load $s12, $s1, 6 # $s12 loads mem(30) ~2$C
(32) load $s5, $s1, 7 # $s5 loads mem(31) mask
(33) addi $s7, $s1, 8 # $s7=32
(34) load $s7, $s7, 0 # $s7 loads mem(32)
(35) addi $s14, $s1, 9 # $s14=33
(36) load $s14, $s14, 0 # $s14 loads mem(33)
(37) add $s8, $s0, $s0 #$s8=0
(38) add $s10, $s0, $s0 #$s10=0
(39) add $s13, $s0, $s0 #$S13=0
(40) add $s9, $s0, $s0 #$s9=0
(41) addi $s9, $s0, 8 #$s9=8
(42) add $s1, $s0, $s0 #$s1=0
(43) addi $s1, $s0, 15 #$s1=15
(44) addi $s1, $s1, 1 #$s1=16
--data preparation

8. Assembly Language
(45) load $s3, $s1, 0 #$S3 loads mem(16) key $S3 jump addr(2) load next key
(46) load $s4, $s2, 0 #$s4 loads mem(134) text $s4 jump addr(1) load next cipher
(47) beq $s0, $s4, $s13 #beq text to null
(48) no op
(49) add $s6, $s3, $s5 #$s6 result of mask of key
(50) bne $s6, $s5, $s7 #bne result of AND to mask
(51) no op
(52) shift $s7, $s7, 1 #$s4 shift left
(53) xor $s8, $s4, $s8 #$s4 xor $s8 => $s8 jump addr(3)
(54) shift $s3, $s3, 1 #$s3 key shift left
(55) addi $s2, $s2, 1 #move text pointer
(56) addi $s10, $s10, 1 #cnt for text +1
(57) bne $s10, $s9, $s11
(58) no op
0 Key
Cipher
pointer
pointer
(59) add $s10, $s0, $s0 #reset cnt for text
(60) addi $s1, $s1, 1 #move key pointer
(61) addi $s13, $s13, 1 #cnt for key +1
(62) bne $s13, $s9, $s12 #bne cot for key to 8
(63) no op
(64) sub $s1, $s9, $s1 #key pointer points to 16
(65) add $s13, $s0, $s0 #reset cnt for key
(66) bne $s13, $s9, $s12 #bne cnt for key to 8
(67) no op
Current
key
Current
cipher text
0x80
(mask)
Mask
result
Addr 3
Xor
result
8 Text
count
Addr 1
Addr 2 Key count Addr of
stop

9. Instruction Count
Encryption: 10 + 9Nx8 + 7N
Tag: 16+ 13N + 6 (N/8)+ 4(N/64) (n/8 & n/64
round up)
Total : 26+93N
(if input is 100 plain text) 9326 instructions

10. The Original Design
:-/
1. ALU is just an adder
2. The pc can only run sequentially
3. Every memory is not big enough

11. The Overall Design
1. Change the adder to ALU
2. Program Counter can jump
3. Expand the memory

12. Special Feature 1 : ALU
1. New Input for hierarchical operation code
2. New out put for branch logical

13. Special Feature 2 : Branch
1. New input and output in Reg File for branch addressing
2. Branch logical in the top level between component ALU&PC
3. 7bit MUX to decide sequentially running or jump

14. Clock Design
1. Brach operation or memory load? Definitely LOAD!
2. Cycle Time = 1.5 + 0.5 + 1.5 + 1.5 + 2 + 3 + 1.5 + 0.5*(7+4+16)
= 25ns

15. High Level Instruction Exec

16. Questions ! Fire Away !

17. Results
• VHDL model

18. Results
• VHDL model
plain text are stored from memory(34)

19. Results
• Explanation of simulation
Encryption
key points
1.How to achieve the
loop for encryption of
one char.
2.How to jump to the
next char.
3.how to jump to tag

20. Results
• Explanation of simulation
Tag
key points
1. How to determine "shift" or "no-shift"
2. How to use the second 8-bit key
3. How to reuse the key

21. Results
• Verification of the correctness of results
Encryption
1.initialization
2.Encryption loop for one char
3.Encryption loop for next char
4.jump to tag

22. Results
initialization

23. Results
• Verification of the correctness of results
Encryption loop for one char.

24. Results
• Verification of the correctness of results
Encryption for the next char

25. Results
• Verification of the correctness of results
jump to tag

26. Results
• Verification of the correctness of results
Tag
1.No shift part
2.Shift part
3.The next 8-bit key
4.Count for 8-bit key

27. Results
• Verification of the correctness of results
no-shift part

28. Results
• Verification of the correctness of results
shift part

29. Results
• Verification of the correctness of results
The next 8-bit key

30. Results
• Verification of the correctness of results
Count for 8-bit key

31. THANK YOU