asm.s43 15.4 KB
Newer Older
lwc-tester committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
/* Reference implementation of SPIX16(l_ad=0, l_m=16)
 Written by:
 Yunjie Yi <yunjie.yi@uwaterloo.ca>
 */

#include "msp430.h"                     ; #define controlled include file

        NAME    main                    ; module name

        PUBLIC  main                    ; make the main label vissible
                                        ; outside this module
        ORG     0FFFEh
        DC16    init                    ; set reset vector to 'init' label

        RSEG    CSTACK                  ; pre-declaration of segment
        RSEG    CODE                    ; place program in 'CODE' segment

init:   MOV     #SFE(CSTACK), SP        ; set up stack

main:   NOP                             ; main program
        MOV.W   #WDTPW+WDTHOLD,&WDTCTL  ; Stop watchdog timer


;;begin main func
        ;;CALL #bgbg     
        
        
;;Pre-save t and SC to the memory(flash)
        MOV.B #0x0F, &0xEE00
        MOV.B #0x47, &0xEE02
        MOV.B #0x04, &0xEE04
        MOV.B #0xB2, &0xEE06
        MOV.B #0x43, &0xEE08
        MOV.B #0xB5, &0xEE0A
        MOV.B #0xF1, &0xEE0C
        MOV.B #0x37, &0xEE0E
        MOV.B #0x44, &0xEE10
        MOV.B #0x96, &0xEE12
        MOV.B #0x73, &0xEE14
        MOV.B #0xEE, &0xEE16
        MOV.B #0xE5, &0xEE18
        MOV.B #0x4C, &0xEE1A
        MOV.B #0x0B, &0xEE1C
        MOV.B #0xF5, &0xEE1E
        
        MOV.B #0x47, &0xEE20
        MOV.B #0x07, &0xEE22
        MOV.B #0xB2, &0xEE24
        MOV.B #0x82, &0xEE26
        MOV.B #0xB5, &0xEE28
        MOV.B #0xA1, &0xEE2A
        MOV.B #0x37, &0xEE2C
        MOV.B #0x78, &0xEE2E
        MOV.B #0x96, &0xEE30
        MOV.B #0xA2, &0xEE32
        MOV.B #0xEE, &0xEE34
        MOV.B #0xB9, &0xEE36
        MOV.B #0x4C, &0xEE38
        MOV.B #0xF2, &0xEE3A
        MOV.B #0xF5, &0xEE3C
        MOV.B #0x85, &0xEE3E

        MOV.B #0x07, &0xEE40
        MOV.B #0x23, &0xEE42
        MOV.B #0x82, &0xEE44
        MOV.B #0xD9, &0xEE46
        ;;;

        MOV.B #0x08, &0xEF00
        MOV.B #0x64, &0xEF02
        MOV.B #0x86, &0xEF04
        MOV.B #0x6B, &0xEF06
        MOV.B #0xE2, &0xEF08
        MOV.B #0x6F, &0xEF0A
        MOV.B #0x89, &0xEF0C
        MOV.B #0x2C, &0xEF0E
        MOV.B #0xE6, &0xEF10
        MOV.B #0xDD, &0xEF12
        MOV.B #0xCA, &0xEF14
        MOV.B #0x99, &0xEF16
        MOV.B #0x17, &0xEF18
        MOV.B #0xEA, &0xEF1A
        MOV.B #0x8E, &0xEF1C
        MOV.B #0x0F, &0xEF1E

        MOV.B #0x64, &0xEF20
        MOV.B #0x04, &0xEF22
        MOV.B #0x6B, &0xEF24
        MOV.B #0x43, &0xEF26
        MOV.B #0x6F, &0xEF28
        MOV.B #0xF1, &0xEF2A
        MOV.B #0x2C, &0xEF2C
        MOV.B #0x44, &0xEF2E
        MOV.B #0xDD, &0xEF30
        MOV.B #0x73, &0xEF32
        MOV.B #0x99, &0xEF34
        MOV.B #0xE5, &0xEF36
        MOV.B #0xEA, &0xEF38
        MOV.B #0x0B, &0xEF3A
        MOV.B #0x0F, &0xEF3C
        MOV.B #0x47, &0xEF3E
        
        MOV.B #0x04, &0xEF40
        MOV.B #0xB2, &0xEF42
        MOV.B #0x43, &0xEF44
        MOV.B #0xB5, &0xEF46
        
;;finish pre-save
;;set vectors for the t's and SC's
;;load initial value to registerat locations from 0xfd00 to 0xfd40       


        MOV.W #0x0000, &0xED1E  ;;most left data in the fig.
        MOV.W #0x0000, &0xED1C
        MOV.W #0x0000, &0xED1A
        MOV.W #0x0000, &0xED18

        MOV.W #0x0000, &0xED16
        MOV.W #0x0000, &0xED14
        MOV.W #0x0000, &0xED12
        MOV.W #0x0000, &0xED10

        MOV.W #0x0000, &0xED0E
        MOV.W #0x0000, &0xED0C
        MOV.W #0x0000, &0xED0A
        MOV.W #0x0000, &0xED08

        MOV.W #0x0000, &0xED06
        MOV.W #0x0000, &0xED04
        MOV.W #0x0000, &0xED02
        MOV.W #0x0000, &0xED00  ;;most right data in the fig. When read from mem, it is from bottom to up



        
        CALL #FFUNAE

;;End main func
JMP $                           ; jump to current location '$'
                                        ; (endless loop)
                                        
;;this is the mode 
FFUNAE:
        CALL #FFUN3A    ;;1 initia
        CALL #FFUNLOAD
        CALL #FFUNKEY1         
        CALL #FFUNSAVE
        
        CALL #FFUN3A   ;2  initia
        CALL #FFUNLOAD
        CALL #FFUNKEY2
        CALL #FFUNSAVE
        
        CALL #FFUN3A

        MOV.W #0x0000, R15
WHIL8:  CMP.W #0x0010, R15
        JGE NEXT8

        CALL #FFUNLOAD
        CALL #FFUNM
        CALL #FFUNSAVE
        
        CALL #FFUN3B  ;RUN Enc 16 times

        INC R15
        JMP WHIL8
NEXT8:


        CALL #FFUNLOAD
        CALL #FFUNKEY1
        CALL #FFUNSAVE
        
        CALL #FFUN3A  ;9  Final
        CALL #FFUNLOAD
        CALL #FFUNKEY2
        CALL #FFUNSAVE

        CALL #FFUN3A ;10 Final
        
        
RET

;;load data
FFUNLOAD:
        MOV.B &0xED17, R12  ;;LOAD A[7] - A[4]
        MOV.B &0xED16, R11
        MOV.B &0xED15, R10
        MOV.B &0xED14, R9
        
        MOV.B &0xED07, R8 ;;LOAD C[7] - C[4]
        MOV.B &0xED06, R7
        MOV.B &0xED05, R6
        MOV.B &0xED04, R5
        
        MOV.B &0xED00, R4 ;LOAD E[0]
RET

;;this is the key absorption part in the mode
FFUNKEY1: ;;(R12 - R4)
        XOR #0x00, R12 ;;XOR with key
        XOR #0x00, R11
        XOR #0x00, R10
        XOR #0x00, R9
        
        XOR #0x00, R8
        XOR #0x00, R7
        XOR #0x00, R6
        XOR #0x00, R5
        XOR #0x0000, R4
RET

;;this is the key absorption part in the mode
FFUNKEY2: ;;(R12 - R4)
        XOR #0x00, R12 ;;XOR with key
        XOR #0x00, R11
        XOR #0x00, R10
        XOR #0x00, R9
        
        XOR #0x00, R8
        XOR #0x00, R7
        XOR #0x00, R6
        XOR #0x00, R5
        
        XOR #0x0000, R4
RET

;;this is the message absorption part in the mode  
FFUNM: ;;(R12 - R4)
        XOR #0x00, R12 ;;XOR with key
        XOR #0x00, R11
        XOR #0x00, R10
        XOR #0x00, R9
        
        XOR #0x00, R8
        XOR #0x00, R7
        XOR #0x00, R6
        XOR #0x00, R5
        
        XOR #0x0002, R4
RET

;;save data
FFUNSAVE:
        MOV.B R12, &0xED17   ;;save B[8] - B[1]
        MOV.B R11, &0xED16
        MOV.B R10, &0xED15
        MOV.B R9, &0xED14
        
        MOV.B R8, &0xED07   ;;save B[24] - B[25]
        MOV.B R7, &0xED06
        MOV.B R6, &0xED05
        MOV.B R5, &0xED04
        
        MOV.B R4, &0xED00 ;;save E[0]
RET

;;this is permutation box par 1
FFUN3A:   ;;LOOP the sliscp-light    ;;round 18
        PUSH R4
        PUSH R5
        PUSH R6
        PUSH R7
        PUSH R8
        PUSH R9
        PUSH R10
        PUSH R11
        PUSH R12
        PUSH R13
        PUSH R14
        PUSH R15

        MOV.W #0xEE00, &0xEC80
        MOV.W #0xEF00, &0xEC84
        MOV.W #0x0001, &0xEC88 ;Save the indicator of data location to the location 0xFC88, it is either 0 or 1



        MOV.W #0x0000, R14
WHIL3:  CMP.W #0x0012, R14
        JGE NEXTC
        CALL #FFUN2
        INC R14
        JMP WHIL3
NEXTC:  

        POP R15
        POP R14
        POP R13
        POP R12
        POP R11
        POP R10
        POP R9
        POP R8
        POP R7
        POP R6
        POP R5
        POP R4
RET


;;this is permutation box part 2
FFUN3B:   ;;LOOP the sliscp-light
        PUSH R4
        PUSH R5
        PUSH R6
        PUSH R7
        PUSH R8
        PUSH R9
        PUSH R10
        PUSH R11
        PUSH R12
        PUSH R13
        PUSH R14
        PUSH R15

        MOV.W #0xEE00, &0xEC80
        MOV.W #0xEF00, &0xEC84
        MOV.W #0x0001, &0xEC88 ;Save the indicator of data location to the location 0xFC88, it is either 0 or 1



        MOV.W #0x0000, R14
WHIL32:  CMP.W #0x0009, R14
        JGE NEXTC2
        CALL #FFUN2
        INC R14
        JMP WHIL32
NEXTC2:

        MOV.W &0xED80, &0xED00
        MOV.W &0xED82, &0xED02
        MOV.W &0xED84, &0xED04
        MOV.W &0xED86, &0xED06
        MOV.W &0xED88, &0xED08
        MOV.W &0xED8A, &0xED0A
        MOV.W &0xED8C, &0xED0C
        MOV.W &0xED8E, &0xED0E
        MOV.W &0xED90, &0xED10
        MOV.W &0xED92, &0xED12
        MOV.W &0xED94, &0xED14
        MOV.W &0xED96, &0xED16
        MOV.W &0xED98, &0xED18
        MOV.W &0xED9A, &0xED1A
        MOV.W &0xED9C, &0xED1C
        MOV.W &0xED9E, &0xED1E


        POP R15
        POP R14
        POP R13
        POP R12
        POP R11
        POP R10
        POP R9
        POP R8
        POP R7
        POP R6
        POP R5
        POP R4
RET


;;this is permutation round 
FFUN2:  ;; PASS data(&FD3C-&FD00), and R14(t)(&FB00-FB48) with Vector (&FC80), 
          ;;R15(sc)(&FC00-FC48) with Vector (&FC84), Indicator(&FC88)
            ;;...($FDBC-FD80) is used as temperaor ram data to save odd number operation data
        PUSH R14
        
        MOV.W &0xEC80, R12  ;;Get the current address of the t
        MOV.B @R12, R14  ;;save the t to r14
        MOV.W &0xEC84, R12  ;;Get the current address of the SC
        MOV.B @R12, R15       ;; sace the sc to r15
        
        MOV.W &0xEC88, R13
        CLRC
        RRA.W R13
        JNC SaveToMemR  ;;if R13=0, then jmp to SaveToMem1

SaveToMemL:
        MOV.W &0xED1E, R11  ;;most left data in the fig.
        MOV.W &0xED1C, R10
        MOV.W &0xED1A, R9
        MOV.W &0xED18, R8

        MOV.W &0xED16, R7
        MOV.W &0xED14, R6
        MOV.W &0xED12, R5
        MOV.W &0xED10, R4
        
        CALL #FFUN ;;finish the h on the left side
        
        XOR #0xFFFF, R11
        XOR #0xFFFF, R10
        XOR #0xFFFF, R9
        XOR #0xFF00, R8
        XOR R15, R8 
        
        XOR R7, R11
        XOR R6, R10
        XOR R5, R9
        XOR R4, R8
        
        MOV.W R11, &0xED86
        MOV.W R10, &0xED84
        MOV.W R9, &0xED82
        MOV.W R8, &0xED80
        MOV.W R7, &0xED9E
        MOV.W R6, &0xED9C
        MOV.W R5, &0xED9A
        MOV.W R4, &0xED98
        
        ADD.W #0x0002, &0xEC80
        ADD.W #0x0002, &0xEC84
        MOV.W &0xEC80, R12  ;;Get the current address of the t
        MOV.B @R12, R14  ;;save the t to r14
        MOV.W &0xEC84, R12  ;;Get the current address of the SC
        MOV.B @R12, R15       ;; sace the sc to r15


        MOV.W &0xED0E, R11
        MOV.W &0xED0C, R10
        MOV.W &0xED0A, R9
        MOV.W &0xED08, R8
        MOV.W &0xED06, R7
        MOV.W &0xED04, R6
        MOV.W &0xED02, R5
        MOV.W &0xED00, R4
        
        CALL #FFUN ;;finish the h on the left side
        
        XOR #0xFFFF, R11
        XOR #0xFFFF, R10
        XOR #0xFFFF, R9
        XOR #0xFF00, R8
        XOR R15, R8 
        
        XOR R7, R11
        XOR R6, R10
        XOR R5, R9
        XOR R4, R8
        
        MOV.W R11, &0xED96
        MOV.W R10, &0xED94
        MOV.W R9, &0xED92
        MOV.W R8, &0xED90
        MOV.W R7, &0xED8E
        MOV.W R6, &0xED8C
        MOV.W R5, &0xED8A
        MOV.W R4, &0xED88
        
        ADD.W #0x0002, &0xEC80
        ADD.W #0x0002, &0xEC84
        MOV.W #0x0000,&0xEC88
        JMP PermutFinished
        
SaveToMemR:
        MOV.W &0xED9E, R11  ;;most left data in the fig.
        MOV.W &0xED9C, R10
        MOV.W &0xED9A, R9
        MOV.W &0xED98, R8

        MOV.W &0xED96, R7
        MOV.W &0xED94, R6
        MOV.W &0xED92, R5
        MOV.W &0xED90, R4
        
        CALL #FFUN ;;finish the h on the left side
        
        XOR #0xFFFF, R11
        XOR #0xFFFF, R10
        XOR #0xFFFF, R9
        XOR #0xFF00, R8
        XOR R15, R8 
        
        XOR R7, R11
        XOR R6, R10
        XOR R5, R9
        XOR R4, R8
        
        MOV.W R11, &0xED06
        MOV.W R10, &0xED04
        MOV.W R9, &0xED02
        MOV.W R8, &0xED00
        MOV.W R7, &0xED1E
        MOV.W R6, &0xED1C
        MOV.W R5, &0xED1A
        MOV.W R4, &0xED18
        
        ADD.W #0x0002, &0xEC80
        ADD.W #0x0002, &0xEC84
        MOV.W &0xEC80, R12  ;;Get the current address of the t
        MOV.B @R12, R14  ;;save the t to r14
        MOV.W &0xEC84, R12  ;;Get the current address of the SC
        MOV.B @R12, R15       ;; sace the sc to r15


        MOV.W &0xED8E, R11
        MOV.W &0xED8C, R10
        MOV.W &0xED8A, R9
        MOV.W &0xED88, R8
        MOV.W &0xED86, R7
        MOV.W &0xED84, R6
        MOV.W &0xED82, R5
        MOV.W &0xED80, R4

        CALL #FFUN ;;finish the h on the left side

        XOR #0xFFFF, R11
        XOR #0xFFFF, R10
        XOR #0xFFFF, R9
        XOR #0xFF00, R8
        XOR R15, R8 
        
        XOR R7, R11
        XOR R6, R10
        XOR R5, R9
        XOR R4, R8
        
        MOV.W R11, &0xED16
        MOV.W R10, &0xED14
        MOV.W R9, &0xED12
        MOV.W R8, &0xED10
        MOV.W R7, &0xED0E
        MOV.W R6, &0xED0C
        MOV.W R5, &0xED0A
        MOV.W R4, &0xED08
        
        ADD.W #0x0002, &0xEC80
        ADD.W #0x0002, &0xEC84
        MOV.W #0x0001,&0xEC88
PermutFinished: 
        POP R14
RET

;;this is Simeck box
FFUN: ;(R7, R6, R5, R4, R14)
        PUSH R8
        PUSH R9
        PUSH R10
        PUSH R11
        
        MOV.W #0x0000, R12
WHIL2:  CMP.W #0x0008, R12 ; compare R15 and R14
        JGE NEXTB ; When R13>=8, then branch
        call #SimeckRF
        INC R12
        JMP WHIL2 ; Go back to beginning of WHILE loop
NEXTB:
        POP R11
        POP R10
        POP R9
        POP R8
RET


;; this is Simeck round
SimeckRF: ;(R7, R6, R5, R4, R14)
        PUSH R12
        
        MOV.W R7,R9  ; save the X0 data to R3, R2, R1, r0
        MOV.W R6,R8

        MOV.W #0x0005, R12 ;SET A
        CALL #LCircularShift ; pass r7, R6, R12 into the function.
                                                ; r30, r31 will be changed

        AND R9, R7 ;;first AND operation in the graph
        AND R8, R6

        MOV.W R7, R11 ;;move r7,r6 to save
        MOV.W R6, R10 

        MOV.W R9, R7 ;; retore R7 and R6 to original value
        MOV.W R8, R6



        MOV.W #0x0001, R12;SET c
        CALL #LCircularShift ; pass r19, r18, r17, r16, and r29 into the function.
                                                ; r30, r31 will be changed

        XOR R11, R7
        XOR R10, R6
        XOR R5, R7
        XOR R4, R6 ; then we need to xor rc with r7 and r6, then finish

        XOR #0xFFFF, R7
        MOV.W R14, R12
        BIS #0xFFFE, R12
        XOR R12, R6
        RRA.W R14
        
        MOV.W R9, R5
        MOV.W R8, R4

        POP R12
        
RET


;;this is circular shift
LCircularShift: ;(R7, R6, R12), where R15 is the number of shifts in bit
        PUSH R13

	MOV.W #0x0000,R13
        
WHIL:	CMP.W R12, R13 ; compare R12 and R14
        JGE NEXTA ; When R14>=R12, then branch
                      ;circular left shift begin for 2 Registers
        CLRC ; clear the carry
        RLA.W R7  ; shift R5 to the left by 1 bit
        JNC carry5 ; if carry is 0, then branch

        RLA.W R6
        BIS #0x0001, R6
        JNC carryFinish
        BIS #0x0001, R7
        JMP carryFinish
carry5:
        RLA.W R6 ; shift R
        JNC carryFinish ; if carry is 0, then branch
        BIS #0x0001, R7
carryFinish:
        
;finished the circular left shift for 4 reginsters R19:R18:R17:R16
        inc R13 ; n++
        JMP WHIL ; Go back to beginning of WHILE loop
NEXTA:
        POP R13
RET
        
;;End sub function        
        END