Assembly Language Programming

November 6, 2013

FASM – 6502 Assembly Language Simulator – Part 1

Filed under: Assembly Language, Compilers, Cryptography, Encryption — Tags: , , , , , , , , , — programmer209 @ 4:10 pm

This post describes a simulator for the 6502 assembly language that I have written in the x86 assembly language using the Flat Assembler (FASM).

x86 Code

The actual x86 code for the simulator is given in Part 2.

References

This simulator is based partly on the LISA assembler for the Apple II computer as described in the book:

Using 6502 Assembly Language – Randy Hyde

A manual for the LISA assembler can be found here:

LISA Assembler Version 2.5 Manual Online

A detailed reference for the 6502 instruction set can be found here:

homepage.ntlworld.com/cyborgsystems/CS_Main/6502/6502.htm

My simulator in no way supports every feature of the LISA assembler as described in the above sources. The sections below describe what elements of the 6502 assembly language are supported by my simulator.

Memory

Total memory available is 65536 bytes, with absolute memory addresses being 16 bits in length. The memory is organised into 256 pages of 256 bytes each.

Registers

Accumulator An 8-bit register. Most operations are carried out through the accumulator.
Index Register X An 8-bit register. Used for counters and offsets.
Index Register Y An 8-bit register. Used for counters and offsets.
Stack Pointer An 8-bit register pointing to the stack. Incremented when a byte is pulled. Decremented when a byte is pushed.
Program Counter A 16-bit register pointing to the next instruction to be executed.
Processor Status An 8-bit register holding the processor status word (PSW).

Status Flags

Includes the carry flag (C), the zero flag (Z), the overflow flag (V) and the negative flag (N). These are bits within the PSW (processor status word).

Operand Expressions

An operand expression can contain one or two arguments. If there are two arguments they must be separated by a plus or minus sign. An argument can be a number, symbol or char constant as described in the table:

Hex Number If a dollar sign $ is detected, the number following it will be read as a hex number.
Decimal Number If an exclamation ! is detected, the number following it will be read as a decimal number. A decimal number does not need to be preceded by an exclamation. If a number is detected (without a $, % or !) the compiler will try to read it as a decimal number.
Binary Number If a percent sign % is detected, the number following it will be read as a binary number.
Symbol If a symbol is detected, the compiler will look it up in the symbol table to get it’s value.
* If an asterix is detected, the compiler will substitute the current value of the location counter.
Character Constant If a single character enclosed in quotes is detected, the compiler will substitute it’s ASCII value. 
Some examples:

  lda $1A2B
  adc $F6
  adc %10110110
  adc !56
  adc 56
  lda SUM
  cmp "A"
  lda $C5+%1101
  sbc 123+$EE
  and A-B
  ora $12+XYZ
  lda #A+B
  lda #$FD+ASDF
  lda /SUM+%11010011
  bne *+10
  lda #"T"+"5"
  eor $123+99,x
  lda (%1101-$AC,x)
  sta (1234+ZXC),y

Symbols

A symbol can contain up to 14 characters, and is terminated by a white space character or CRLF. Symbols can contain letters, numbers or an underscore. The compiler stores any symbols it finds in the symbol table which starts at page 252 in memory. 16 bytes are allocated for each symbol in this table. The first 14 bytes are for the symbol, while the last 2 bytes are for the 16 bit value (address) of the symbol. Symbols are case insensitive (all lower case chars are converted to upper case by the compiler).

A symbol must always begin with a letter. The compiler detects a symbol by looking in the first column of a line for this first letter. If a line does not contain a symbol then the first column must be left blank.

Pseudo-Ops

EQU Label EQU operand Assign a 2 byte value to a symbol. The operand can only contain a decimal, binary or hex number.
EPZ Label EPZ operand Assign a 1 byte value to a symbol. The operand can only contain a decimal, binary or hex number.
DFS Label DFS expression Define storage. The expression gives the number of bytes to reserve in memory.
ORG Label ORG expression Set the value of the location counter, as given by the expression. The label is optional.
HEX Label HEX operand Place up to 4 bytes into memory, starting from the current position as given by the location counter. The operand can only contain hex digits (up to 8). No $ is required. The label is optional.
ADR Label ADR expression Place the 2 bytes as given by the expression into memory, first the low byte and then the high byte. The label is optional.
BYT Label BYT expression Place the low byte as given by the expression into memory. The label is optional.
HBY Label HBY expression Place the high byte as given by the expression into memory. The label is optional.
DBY Label DBY expression Place the 2 bytes as given by the expression into memory, first the high byte and then the low byte. The label is optional. 
Some examples:

A equ $1234
B equ !68
C equ 70
D equ %11001101

XYZ epz $A5
ASDF epz 10
ZXC epz %1011

ARR dfs 100
KEY dfs 32,0
 
  org $800
  org 2000
  org %1111

  hex 1A2B3C4D
  hex ABCDEF
  hex 48

  adr ARR+7
  adr $3456

  byt $12
  byt A

  hby 4567
  hby %1110001110011

  dby 64532
  dby $9876
  dby D+100

Addressing Modes

Accumulator No operand is required. The instruction acts upon the accumulator.
Implied No operand is required. The register acted upon is implied by the instruction.
Relative Used only by the branch instructions. The operand is an address that must be within -128 to +127 bytes of the address of the instruction that follows the branch instruction.
Immediate The operand is an immediate value, preceded by a # or /. If # the lower byte of the operand is used. If / the upper byte of the operand is used.
Zero Page The operand is a 1 byte address value that points only to a zero page location.
Absolute The operand is a 2 byte address value that can point to any location in memory.
zp,x Zero page indexed with x: zp is a zero page base address. The target address is obtained by adding the contents of the x index register. If Base + Index is greater than $FF, wrapping occurs.
zp,y Zero page indexed with y: zp is a zero page base address. The target address is obtained by adding the contents of the y index register. If Base + Index is greater than $FF, wrapping occurs.
a,x Absolute address indexed with x: a is an absolute base address. The target address is obtained by adding the contents of the x index register. If Base + Index is greater than $FFFF, wrapping occurs.
a,y Absolute address indexed with y: a is an absolute base address. The target address is obtained by adding the contents of the y index register. If Base + Index is greater than $FFFF, wrapping occurs.
(zp,x) Indexed indirect addressing: a zero page address is calculated by adding the contents of the x index register to zp. If the result is greater than $FF, wrapping occurs. Then an absolute 2 byte target address is read from the location given by the zero page address.
(zp),y Indirect indexed addressing: a base address is read from the zero page location given by zp. Then the contents of the index register y is added to the base to give the final target address. If Base + Index is greater than $FFFF, wrapping occurs.
(a) Indirect addressing: the target address is read from the absolute memory location a. Used only by the JMP instruction.

Addressing Mode Examples

Accumulator:

  asl
  ror
  lsr
  ror

Implied:

  nop
  clc
  inx
  pha
  tax
  tsx
  plp

Relative:

  bne *+40
  beq EQ

Immediate:

  lda #12
  lda /$4567
  adc #$FE

Zero Page:

  sta 10
  sbc 40
  lsr 77
  eor A

Absolute:

  lda $3456
  ora $7890
  jmp $5678
  jsr CALC

Indirect:

  jmp ($3456)
  jmp (P_ADD)

Demonstration of the zp,x mode, showing how zp+x wraps back around when it becomes greater than $FF. 

; ================================================

  ldx #0

LOOP

  txa
  sta $80,x
  inx
  cpx #0
  bne LOOP

; ================================================

Demonstration of the a,y mode: write the value of y to the absolute base address of $300 offset by y. 

; ================================================

  ldy #0

LOOP

  tya
  sta $300,y
  iny
  cpy #0
  bne LOOP

; ================================================

Demonstration of the (zp,x) mode. First a table of 2 byte absolute addresses is created on the zero page (LOOP_1). Loop two then uses the sta instruction in the (zp,x) mode to write a table of values to the target addresses. 

; ================================================

  ldx #0

LOOP_1

  ; create a table of 2 byte target addresses 
  ; (= $300 + x) on the zero page

  ; the first byte of each address is x
  ; the second byte is 3

  txa
  lsr
  sta 0,x
  inx
  lda #3
  sta 0,x
  inx
  cpx #0
  bne LOOP_1

LOOP_2

  ; 0+x is the zero page address that stores
  ; the 2 byte target address

  txa
  sta (0,x)
  inx
  inx
  cpx #0
  bne LOOP_2  
  
; ================================================

Demonstration of the (zp),y mode. This code creates exactly the same table of data at absolute address $300. The difference is that only one address needs to be stored on the zero page. The statement sta (0),y reads this address from location 0 and then adds y to it to get the target address. 

; ================================================

  ; store the address $300 at zero page location 0

  lda #0
  sta 0
  lda #3
  sta 1

  ldy #0

LOOP

  ; store the value 2*y at $300+y

  tya
  asl
  sta (0),y
  iny
  cpy #$80
  bne LOOP  

; ================================================

Add & Subtract

ADC is add with carry, so before using ADC the carry bit should be cleared (CLC).

Before using the SBC instruction the carry bit should be set using the SEC instruction. Setting the carry to 1 is the same as setting the borrow bit to 0, and vice versa. If after the execution of a SBC instruction the carry is 0 (borrow = 1), it means that a bit needed to be borrowed to successfully complete the subtraction. If no borrow was required then the carry bit will be 1.

See the Big Number Subtraction example program below.

  ADC SBC
Immediate 69 E9
Zero Page 65 E5
Absolute 6D ED
zp,x 75 F5
a,x 7D FD
a,y 79 F9
(zp,x) 61 E1
(zp),y 71 F1
Flags CVZN CVZN

Logical

  AND ORA EOR BIT
Immediate 29 09 49 –
Zero Page 25 05 45 24
Absolute 2D 0D 4D 2C
zp,x 35 15 55 –
a,x 3D 1D 5D –
a,y 39 19 59 –
(zp,x) 21 01 41 –
(zp),y 31 11 51 –
Flags ZN ZN ZN VZN

Note that XOR can be used in place of EOR.

Shift & Rotate

These are the only type of instructions that use the Accumulator mode.

  ASL LSR ROL ROR
Accumulator 0A 4A 2A 6A
Zero Page 06 46 26 66
Absolute 0E 4E 2E 6E
zp,x 16 56 36 76
a,x 1E 5E 3E 7E
Flags CZN CZN CZN CZN

Load & Store

  LDA STA LDX STX LDY STY
Immediate A9 – A2 – A0 –
Zero Page A5 85 A6 86 A4 84
Absolute AD 8D AE 8E AC 8C
zp,x B5 95 – – B4 94
zp,y – – B6 96 – –
a,x BD 9D – – BC –
a,y B9 99 BE – – –
(zp,x) A1 81 – – – –
(zp),y B1 91 – – – –
Flags ZN – ZN – ZN –

Increment & Decrement

  INC DEC
Zero Page E6 C6
Absolute EE CE
zp,x F6 D6
a,x FE DE
Flags ZN ZN

Compare

The CMP instruction compares a byte in memory M with the accumulator ACC.

– If ACC – M >= 0 the C flag is set.

– If ACC – M = 0 the Z flag is set.

– If ACC – M < 0 the N flag is set.

The CPX and CPY instructions work in the same way, but for the X and Y registers.

  CMP CPX CPY
Immediate C9 E0 C0
Zero Page C5 E4 C4
Absolute CD EC CC
zp,x D5 – –
a,x DD – –
a,y D9 – –
(zp,x) C1 – –
(zp),y D1 – –
Flags CZN CZN CZN

Branch

The branches are the only type of instruction to use relative mode. The operand is an address in memory, which is used to calculate a single byte offset that is relative to the address of the instruction after the branch instruction. The branch instructions all assemble to 2 bytes – the opcode byte plus the offset byte. Therefore the branch destination must be within -126 to +129 bytes of the address of the branch instruction.

  Opcode Description
BPL 10 Branch if N = 0
BMI 30 Branch if N = 1
BVC 50 Branch if V = 0
BVS 70 Branch if V = 1
BCC 90 Branch if C = 0
BCS B0 Branch if C = 1
BNE D0 Branch if Z = 0
BEQ F0 Branch if Z = 1

Note that BGE can be used in place of BCS, BLT in place of BCC, BTR in place of BEQ, and BFL in place of BNE.

Implied Mode Instructions

  Opcode Flags Description
NOP EA – No operation
SEC 38 C Set C
CLC 18 C Clear C
CLV B8 V Clear V
INX E8 ZN Increment X
DEX CA ZN Decrement X
INY C8 ZN Increment Y
DEY 88 ZN Decrement Y
PHA 48 – Push ACC to the stack
PLA 68 ZN Pull ACC from the stack
TAX AA ZN Copy ACC to X
TXA 8A ZN Copy X to ACC
TAY A8 ZN Copy ACC to Y
TYA 98 ZN Copy Y to ACC
TSX BA ZN Copy SP to X
TXS 9A – Copy X to SP
PHP 08 – Push PSW to the stack
PLP 28 CZVN Pull PSW from the stack

Jump Instructions

  JMP JSR RTS
Absolute 4C 20 –
Indirect 6C – –
Implied – – 60

BRK

The BRK instruction is assembled as a single zero byte. When the simulator encounters a zero byte, the program counter is advanced by one and then execution stops. Thus the brk instruction can be used to stop a program altogether, or as a breakpoint where execution of a program can be resumed by pressing the [Run Code] or [Step] buttons again.

The Simulator

The simulator has two main dialogs, the Edit dialog and the Run dialog.

The Edit Dialog

6502-Edit-Dialog

The 6502 code is typed into the text input area on the left. Press the [Compile Assembly] button to assemble the code. The output will then be displayed in the output text area on the right. The code is compiled in 2 passes. On the first pass all of the symbols are resolved and added to the symbol table. On the second pass the instructions are assembled. Apart from character constants everything is case insensitive. The compiler simply converts lower case to upper case.

The code is assembled starting from location $200 in the main memory of the 6502. By default execution starts from this address.

To view the symbol table press the [View Symbols] button. To return to the listing of the assembled code press [View Output].

Press the [Clear Assembly] button to clear both text areas.

To run and debug the code press the [Execute Code] button. This will open up the Run dialog.

The Run Dialog

6502-Run-Dialog

A listing of the assembled code is displayed on the top left. The last instruction executed is shown on the middle left. The state of the registers is shown on the bottom left. The top right displays the bytes in memory two pages at a time, and also displays the watch. The bottom right is the ASCII string input area.

To run the code, press the [Run Code] button.

To execute the code one instruction at a time, press the [Step] button.

To reset the program counter to it’s default value of $200, press the [Reset PC] button.

To reset the 6502 machine and clear the entire memory contents, press the [Reset Machine] button.

To view the watch, press the [View Watch] button. To stop viewing the watch and display the pages in memory, just select a page from the combo box.

To return to the Edit dialog, press [Edit Code].

The ASCII Input Area

A text string can be entered directly into memory via the ASCII input area on the bottom right of the Run dialog. Simply enter some text and press the [Load ASCII] button. Note that CRLFs will be filtered out.

Four pages in memory are set aside for this purpose (pages 248-251) starting from memory location $F800. After the [Load ASCII] button has been pressed, any ascii data stored within these 4 pages of memory will be displayed in the ASCII input area.

ASCII data can also be entered into the area of memory starting at $F800 via a program, where it will be displayed once the [Run Code] button has been pressed. The code here prints a Hello World message. 

; ================================================

 ldy #0

LOOP

 lda MESSAGE,y
 cmp #0
 beq DONE
 sta $f800,y
 iny
 jmp LOOP

DONE

 jmp STOP

MESSAGE 

 byt 'H','E','L','L','O',' '
 byt 'W','O','R','L','D'

STOP
 
 brk

; ================================================

A string containing a hex number can be entered into memory via the ASCII input area and then converted to a numerical value stored elsewhere by using a program such as this one. Simply enter a hex number and press [Load ASCII]. Then press [Run Code] to run the program. The ascii characters stored at $F800 are converted to a number and stored at location $300.

; ================================================

  ; convert the string of ASCII hex digits at ASC
  ; to a hexadecimal value at HXD

  ; HXD = big endian byte order

; ================================================

Y_SRC epz 0
Y_DEST epz 1

ASC epz 2
HXD epz 4

; ================================================

  lda #0
  sta Y_SRC
  sta Y_DEST

  sta ASC
  sta HXD

  lda #$F8
  sta ASC+1

  lda #$03
  sta HXD+1

; ================================================

D1

  ; digit 1

  ldy Y_SRC
  lda (ASC),y
  cmp #0
  beq DONE
  jsr CHAR_TO_HEX
  cmp #$FF
  beq NEXT

  asl
  asl
  asl
  asl

  ldy Y_DEST
  sta (HXD),y

D2

  ; digit 2

  inc Y_SRC
  ldy Y_SRC
  cpy #0
  beq DONE
  lda (ASC),y
  cmp #0
  beq DONE
  jsr CHAR_TO_HEX
  cmp #$FF
  beq D2
  ldy Y_DEST
  ora (HXD),y
  sta (HXD),y
  inc Y_DEST

NEXT

  inc Y_SRC
  ldy Y_SRC
  cpy #0
  beq DONE
  jmp D1 

DONE

  jmp THE_END

; ================================================

CHAR_TO_HEX

  ; convert an ASCII char to a hex value

  ; 0-9 and A-F

  cmp #'0'
  bmi NOT_HEX
  cmp #'9'
  bmi ADD_09
  beq ADD_09
  cmp #'A'
  bmi NOT_HEX
  cmp #'F'
  bmi ADD_AF
  beq ADD_AF
  jmp NOT_HEX

ADD_09

  sec
  sbc #'0'
  jmp RET

ADD_AF

  sec
  sbc #'A'
  clc
  adc #10		
  jmp RET  

NOT_HEX

 lda #$FF

RET

  rts 

; ================================================

THE_END

; ================================================

The Watch

Add an item to the watch by pressing the [Add To Watch] button. A dialog box appears into which is entered either a symbol or hexadecimal address (prefixed by a $) and the number of bytes (up to 256) to include in the watch. So to watch how execution of a program affects the 100 bytes starting from location $600, just enter $600 as the address to watch and 100 as the number of bytes to include in the watch. Press the [View Watch] button to display the addresses currently being watched. Up to 12 addresses can be watched at any one time.

Memory Map

The memory map for the simulator. The memory is organised into 256 pages of 256 bytes each, giving a total of 65536 bytes,

Page 0 $00 – $FF: zero page memory.
Page 1 $100 – $1FF: the stack.
Page 2 Pages 2-247 contain assembled code and data. By default code is assembled and executed starting from the address $200.
Page 248 Pages 248-251 can be used to directly load ASCII strings.
Page 252 Pages 252-255 are used by the symbol table.

Example Programs

Below are some programs I have written and tested for the simulator.

Big Number Bitwise Rotation

Rotate left by one bit. Keep on pressing the [Run Code] button to repeat. The brk instruction here acts as a breakpoint. 

; ================================================

  ldy #0
  lda #1

FILL

  ; fill the zero page with data
 
  sta 0,y
  iny
  cpy #0
  bne FILL

REPEAT

  ldx #$FF
  clc
  php

ROTL

  ; rotate the zero page bytes left by 1 bit

  ; the bytes are in big endian byte order

  plp
  rol 0,x
  php 
  dex
  cpx #$ff
  bne ROTL

  ; or the carry bit from byte $0 back into byte $FF

  lda #0
  plp
  adc #0
  ora $FF
  sta $FF

  brk

  jmp REPEAT

; ================================================

Rotate right by one bit. Keep on pressing the [Run Code] button to repeat. The brk instruction here acts as a breakpoint. 

; ================================================

  ldy #0
  lda #1

FILL

  ; fill the zero page with data
 
  sta 0,y
  iny
  cpy #0
  bne FILL

REPEAT

  ldx #0
  clc
  php

ROTR

  ; rotate the zero page bytes right by 1 bit

  ; the bytes are in big endian byte order

  plp
  ror 0,x
  php 
  inx
  cpx #0
  bne ROTR

  ; or the carry bit from byte $FF back into byte $0

  lda #0
  plp
  ror
  ora 0
  sta 0

  brk

  jmp REPEAT

; ================================================

CRC-16

CRC-16 long division method. The first 2 bytes of MSG become the CRC. 

; ================================================

  ; CRC-16

; ================================================

  org 0

  ; Polynomial = 80 05

P0 byt $80
P1 byt $05

  ; the initial xor

INIT byt $ff,$ff

  ; the final xor

FINAL byt 0,0

; ================================================

  org $200

  ; xor INIT into the first 2 bytes of MSG

  lda MSG
  eor INIT
  sta MSG
  lda MSG+1
  eor INIT+1
  sta MSG+1

CRC

  ; CRC-16 - long division method

  ; get the next bit from MSG

  jsr SHL

  ; if the bit is zero - do nothing

  bcc NEXT

  ; xor the polynomial into the first 2 bytes of MSG

  lda MSG
  eor P0
  sta MSG
  lda MSG+1
  eor P1
  sta MSG+1

NEXT

  ; decrement the bit and byte counters

  dec X8
  lda X8
  cmp #0
  bne CRC
  lda #8
  sta X8
  dec LEN
  lda LEN
  cmp #0
  bne CRC

  ; xor FINAL into the first 2 bytes of MSG

  lda MSG
  eor FINAL
  sta MSG
  lda MSG+1
  eor FINAL+1
  sta MSG+1

  ; the first 2 bytes of MSG now contain the CRC

  jmp STOP

; ================================================

SHL

  ; shift left the message bytes by 1 bit

  ; shl all 256 bytes starting from MSG

  ; MSG is in big endian byte order

  ; so start from the byte at MSG + $FF

  ldx #$ff
  clc
  php

ROT

  plp
  rol MSG,x
  php 
  dex
  cpx #$ff
  bne ROT

  ; need the carry bit - so pull PSW from the stack

  plp

  rts

; ================================================

  ; count the number of bits in each byte

X8 byt 8

  ; the length of the input message (max = 256 bytes)

LEN byt 16

; ================================================

STOP

  brk

; ================================================

  org $300

  ; the input message - can be up to 256 bytes

MSG 

  byt $1,$2,$3,$4,$5,$6,$7,$8
  byt $9,$0,$A,$B,$C,$D,$E,$F

; ================================================

CRC-16 table method. The 2 byte result is stored at zero page location 0. 

; ================================================

  ; CRC-16 - Table Method

; ================================================

CRC epz 0
INIT epz 16
FINAL epz 32
BIT epz 48
BYTES epz 49
T_ENTRY epz 52

; ================================================

  ; for Y = $0 to Y = $FF

  ldy #0

FILL_TABLE

  ; generate a 256 element table

  ; the low byte for each entry is stored from $600-$6FF
  ; the high byte for each entry is stored from $700-$7FF

  ; load the value of Y into the lower byte

  sty BYTES

  ; load zero into the higher byte

  lda #0
  sta BYTES+1

  ; count the bits

  lda #8
  sta BIT

XOR_P

  ; get the next bit

  asl BYTES+1
  rol BYTES
  bcc NEXT

  ; xor the polynomial into BYTES, if the bit is set

  lda #$80
  eor BYTES
  sta BYTES
  lda #$05
  eor BYTES+1
  sta BYTES+1

NEXT

  ; for each bit in BYTES

  dec BIT
  lda BIT
  cmp #0
  bne XOR_P  

  ; store the lower byte at $600 + Y

  lda BYTES
  sta $600,y

  ; store the higher byte at $700 + Y

  lda BYTES+1
  sta $700,y

  ; get the next Y

  iny
  cpy #0
  bne FILL_TABLE

; ================================================

  ; set the value of the initial xor ($FFFF)

  lda #$ff
  sta INIT
  sta INIT+1

  ; set the value of the final xor ($0000)

  lda #0
  sta FINAL
  sta FINAL+1

; ================================================

  ; load the first 2 bytes of MSG into CRC

  lda MSG
  sta CRC
  lda MSG+1
  sta CRC+1

  ; xor INIT into the 2 bytes of CRC

  lda INIT
  eor CRC
  sta CRC
  lda INIT+1
  eor CRC+1
  sta CRC+1

  ldy #2

CALC_CRC

  ; the first byte of CRC is the index to the table

  ldx CRC

  ; get the table entry

  lda $600,x
  sta T_ENTRY
  lda $700,x
  sta T_ENTRY+1

  ; shift out the first CRC byte
  ; copy up the next CRC byte
  ; shift in the next MSG byte

  lda CRC+1
  sta CRC
  lda MSG,y
  sta CRC+1

  ; xor in the table entry

  lda CRC
  eor T_ENTRY
  sta CRC
  lda CRC+1
  eor T_ENTRY+1
  sta CRC+1

  iny
  cpy LEN
  bne CALC_CRC

PAD_1

  ; the first padding (zero) byte

  ldx CRC

  lda $600,x
  sta T_ENTRY
  lda $700,x
  sta T_ENTRY+1

  lda CRC+1
  sta CRC
  lda #0
  sta CRC+1
 
  lda CRC
  eor T_ENTRY
  sta CRC
  lda CRC+1
  eor T_ENTRY+1
  sta CRC+1

PAD_2

  ; the second padding (zero) byte

  ldx CRC

  lda $600,x
  sta T_ENTRY
  lda $700,x
  sta T_ENTRY+1

  lda CRC+1
  sta CRC
  lda #0
  sta CRC+1
 
  lda CRC
  eor T_ENTRY
  sta CRC
  lda CRC+1
  eor T_ENTRY+1
  sta CRC+1

  ; xor FINAL into the 2 bytes of CRC

  lda FINAL
  eor CRC
  sta CRC
  lda FINAL+1
  eor CRC+1
  sta CRC+1

  jmp STOP

; ================================================

  ; the length of the input message (bytes)

LEN byt 16

  org $300

  ; the input message - can be up to 256 bytes

MSG 

  byt $1,$2,$3,$4,$5,$6,$7,$8
  byt $9,$0,$A,$B,$C,$D,$E,$F

; ================================================

STOP

  brk

; ================================================

CRC-32

CRC-32 long division method. The first 4 bytes of MSG become the CRC. 

; ================================================

  ; CRC-32

; ================================================

  org 0

 ; Polynomial = 04 C1 1D B7

P0 byt $04
P1 byt $C1
P2 byt $1D
P3 byt $B7

  ; the initial xor

INIT byt $ff,$ff,$ff,$ff

  ; the final xor

FINAL byt $ff,$ff,$ff,$ff

; ================================================

  org $200

  ; xor INIT into the first 4 bytes of MSG

  lda MSG
  eor INIT
  sta MSG
  lda MSG+1
  eor INIT+1
  sta MSG+1
  lda MSG+2
  eor INIT+2
  sta MSG+2
  lda MSG+3
  eor INIT+3
  sta MSG+3

CRC

  ; CRC-32 - long division method

  ; get the next bit from MSG

  jsr SHL

  ; if the bit is zero - do nothing

  bcc NEXT

  ; xor the polynomial into the first 4 bytes of MSG

  lda MSG
  eor P0
  sta MSG
  lda MSG+1
  eor P1
  sta MSG+1
  lda MSG+2
  eor P2
  sta MSG+2
  lda MSG+3
  eor P3
  sta MSG+3

NEXT

  ; decrement the bit and byte counters

  dec X8
  lda X8
  cmp #0
  bne CRC
  lda #8
  sta X8
  dec LEN
  lda LEN
  cmp #0
  bne CRC

  ; xor FINAL into the first 4 bytes of MSG

  lda MSG
  eor FINAL
  sta MSG
  lda MSG+1
  eor FINAL+1
  sta MSG+1
  lda MSG+2
  eor FINAL+2
  sta MSG+2
  lda MSG+3
  eor FINAL+3
  sta MSG+3

  ; the first 4 bytes of MSG now contain the CRC

  jmp STOP

; ================================================

SHL

  ; shift left the message bytes by 1 bit

  ; shl all 256 bytes starting from MSG

  ; MSG is in big endian byte order

  ; so start from the byte at MSG + $FF

  ldx #$ff
  clc
  php

ROT

  plp
  rol MSG,x
  php 
  dex
  cpx #$ff
  bne ROT

  ; need the carry bit - so pull PSW from the stack

  plp

  rts

; ================================================

  ; count the number of bits in each byte

X8 byt 8

  ; the length of the input message (max = 256 bytes)

LEN byt 4

; ================================================

STOP

  brk

; ================================================

  org $300

  ; the input message - can be up to 256 bytes

MSG 

  byt $31,$32,$33,$34

; ================================================

Random Numbers

Use the LCG to generate a 256 byte random number. 

; ================================================

  ; Linear Congruential Generator

  ; X(n+1) = (aX(n) + c) mod m

  ; m = 1 00 00 00 00

  ; a = 00 03 43 FD

  ; c = 00 26 9E C3

  ; X(0) = 12 34 56 78

; ================================================

  ; use the LCG to randomly fill the 
  ; 256 bytes starting at $300

; ================================================

DWORD_1 epz 0
DWORD_2 epz 4
RESULT epz 8

RND equ $300

; ================================================

  ; set DWORD_1 equal to a = 00 03 43 FD

  lda #$FD
  sta DWORD_1
  lda #$43
  sta DWORD_1+1
  lda #$03
  sta DWORD_1+2
  lda #$00
  sta DWORD_1+3

  ; set DWORD_2 equal to X(0) = 12 34 56 78

  lda #$78
  sta DWORD_2
  lda #$56
  sta DWORD_2+1
  lda #$34
  sta DWORD_2+2
  lda #$12
  sta DWORD_2+3

  ; Y is the offset from RND = $300

  ldy #0

REPEAT

  ; calculate: aX(n)

  jsr MULT

  ; add c = 00 26 9E C3

  lda RESULT
  clc
  adc #$C3
  sta DWORD_2
  lda RESULT+1
  adc #$9E
  sta DWORD_2+1
  lda RESULT+2
  adc #$26
  sta DWORD_2+2
  lda RESULT+3
  adc #0
  sta DWORD_2+3

  ; store the result at RND + Y

  lda RESULT
  sta RND,y
  iny
  lda RESULT+1
  sta RND,y
  iny
  lda RESULT+2
  sta RND,y
  iny
  lda RESULT+3
  sta RND,y
  iny

  cpy #0
  bne REPEAT

  brk

; ================================================

MULT

  ; multiply two 4 byte values mod m = 1 00 00 00 00

  ; X counts the bits

  ldx #0

  ; initialise RESULT = 0

  lda #0
  sta RESULT
  sta RESULT+1
  sta RESULT+2
  sta RESULT+3

LOOP

  ; left shift RESULT

  asl RESULT
  rol RESULT+1
  rol RESULT+2
  rol RESULT+3

  ; left shift DWORD_2 to set the carry bit

  asl DWORD_2
  rol DWORD_2+1
  rol DWORD_2+2
  rol DWORD_2+3

  bcc NEXT

  ; if the carry bit is set, add DWORD_1 to RESULT

  lda DWORD_1
  clc
  adc RESULT
  sta RESULT
  lda DWORD_1+1
  adc RESULT+1
  sta RESULT+1
  lda DWORD_1+2
  adc RESULT+2
  sta RESULT+2
  lda DWORD_1+3
  adc RESULT+3
  sta RESULT+3

NEXT

  ; for each of the 32 bits in DWORD_2

  inx
  cpx #32
  bne LOOP

  rts

; ================================================

Big Number Subtraction

Two 256 byte random numbers are generated: RND_1 and RND_2. Then RND_1 is subtracted from RND_2. The subtraction is done in two different ways:

(1) SUBTRACT uses SBC to compute RND_2,x – RND_1,x for each of the 256 bytes.

(2) ADD_NOT uses ADC to compute RND_2,x + NOT(RND_1),x for each of the 256 bytes.

Note that for 6502 subtraction the carry bit must be initially set (SEC). 

; ================================================

  ; use the linear congruential generator to 
  ; create two 256 byte random numbers, and 
  ; then subtract one from the other

; ================================================

DWORD_1 epz 0
DWORD_2 epz 4
RESULT epz 8
TEMP epz 12
COUNT epz 14

RND_1 equ $400
RND_2 equ $500
DIFF equ $600
INV_SUM equ $700

; ================================================

  ; use the LCG to randomly fill the 
  ; 256 bytes starting at $400

; ================================================

  ; set DWORD_1 equal to a = 00 03 43 FD

  lda #$FD
  sta DWORD_1
  lda #$43
  sta DWORD_1+1
  lda #$03
  sta DWORD_1+2
  lda #$00
  sta DWORD_1+3

  ; set DWORD_2 equal to X(0) = 12 34 56 78

  lda #$78
  sta DWORD_2
  lda #$56
  sta DWORD_2+1
  lda #$34
  sta DWORD_2+2
  lda #$12
  sta DWORD_2+3

  ldy #0

LOOP_1

  ; calculate: aX(n)

  jsr MULT

  ; add c = 00 26 9E C3

  lda RESULT
  clc
  adc #$C3
  sta DWORD_2
  lda RESULT+1
  adc #$9E
  sta DWORD_2+1
  lda RESULT+2
  adc #$26
  sta DWORD_2+2
  lda RESULT+3
  adc #0
  sta DWORD_2+3

  ; store the result at RND_1 + Y

  lda RESULT
  sta RND_1,y
  iny
  lda RESULT+1
  sta RND_1,y
  iny
  lda RESULT+2
  sta RND_1,y
  iny
  lda RESULT+3
  sta RND_1,y
  iny

  cpy #0
  bne LOOP_1

; ================================================

  ; use the LCG to randomly fill the 
  ; 256 bytes starting at $500

; ================================================

  ldy #0

LOOP_2

  ; calculate: aX(n)

  jsr MULT

  ; add c = 00 26 9E C3

  lda RESULT
  clc
  adc #$C3
  sta DWORD_2
  lda RESULT+1
  adc #$9E
  sta DWORD_2+1
  lda RESULT+2
  adc #$26
  sta DWORD_2+2
  lda RESULT+3
  adc #0
  sta DWORD_2+3

  ; store the result at RND_2 + Y

  lda RESULT
  sta RND_2,y
  iny
  lda RESULT+1
  sta RND_2,y
  iny
  lda RESULT+2
  sta RND_2,y
  iny
  lda RESULT+3
  sta RND_2,y
  iny

  cpy #0
  bne LOOP_2

; ================================================

  ; subtract RND_1 from RND_2

  jsr SUBTRACT

; ================================================

  ; add NOT(RND_1) to RND_2

  jsr ADD_NOT

; ================================================

STOP

  brk

; ================================================

MULT

  ; multiply two 4 byte values mod m = 1 00 00 00 00

  ldx #0

  ; initialise RESULT = 0

  lda #0
  sta RESULT
  sta RESULT+1
  sta RESULT+2
  sta RESULT+3

LOOP

  ; left shift RESULT

  asl RESULT
  rol RESULT+1
  rol RESULT+2
  rol RESULT+3

  ; left shift DWORD_2 to set the carry bit

  asl DWORD_2
  rol DWORD_2+1
  rol DWORD_2+2
  rol DWORD_2+3

  bcc NEXT

  ; if the carry bit is set, add DWORD_1 to RESULT

  lda DWORD_1
  clc
  adc RESULT
  sta RESULT
  lda DWORD_1+1
  adc RESULT+1
  sta RESULT+1
  lda DWORD_1+2
  adc RESULT+2
  sta RESULT+2
  lda DWORD_1+3
  adc RESULT+3
  sta RESULT+3

NEXT

  ; for each of the 32 bits in DWORD_2

  inx
  cpx #32
  bne LOOP

  rts

; ================================================

SUBTRACT

  ; DIFF = RND_2 - RND_1

  ; big endian byte order

  ldx #$FF

  sec
  php

S_LOOP

  lda RND_2,x
  plp
  sbc RND_1,x
  php
  sta DIFF,x

  dex
  cpx #$FF
  bne S_LOOP

  plp

  rts

; ================================================

ADD_NOT

  ; INV_SUM = RND_2 + NOT(RND_1)

  ; big endian byte order

  ldx #$FF

  sec
  php

I_LOOP

  lda RND_1,x
  eor #$FF
  plp
  adc RND_2,x
  php
  sta INV_SUM,x

  dex
  cpx #$FF
  bne I_LOOP

  plp

  rts

; ================================================

Big Number Multiply

Two 256 byte random numbers are generated: RND_1 and RND_2. They are then multiplied together and the 512 byte result stored at OUTPUT_1 and OUTPUT_2. 

; ================================================

  ; use the linear congruential generator to 
  ; create two 256 byte random numbers, and 
  ; then multiply them together

; ================================================

DWORD_1 epz 0
DWORD_2 epz 4
RESULT epz 8
TEMP epz 12
COUNT epz 14

RND_1 equ $400
RND_2 equ $500

OUTPUT_1 equ $600
OUTPUT_2 equ $700

; ================================================

  ; use the LCG to randomly fill the 
  ; 256 bytes starting at $400

; ================================================

  ; set DWORD_1 equal to a = 00 03 43 FD

  lda #$FD
  sta DWORD_1
  lda #$43
  sta DWORD_1+1
  lda #$03
  sta DWORD_1+2
  lda #$00
  sta DWORD_1+3

  ; set DWORD_2 equal to X(0) = 12 34 56 78

  lda #$78
  sta DWORD_2
  lda #$56
  sta DWORD_2+1
  lda #$34
  sta DWORD_2+2
  lda #$12
  sta DWORD_2+3

  ldy #0

LOOP_1

  ; calculate: aX(n)

  jsr MULT

  ; add c = 00 26 9E C3

  lda RESULT
  clc
  adc #$C3
  sta DWORD_2
  lda RESULT+1
  adc #$9E
  sta DWORD_2+1
  lda RESULT+2
  adc #$26
  sta DWORD_2+2
  lda RESULT+3
  adc #0
  sta DWORD_2+3

  ; store the result at RND_1 + Y

  lda RESULT
  sta RND_1,y
  iny
  lda RESULT+1
  sta RND_1,y
  iny
  lda RESULT+2
  sta RND_1,y
  iny
  lda RESULT+3
  sta RND_1,y
  iny

  cpy #0
  bne LOOP_1

; ================================================

  ; use the LCG to randomly fill the 
  ; 256 bytes starting at $500

; ================================================

  ldy #0

LOOP_2

  ; calculate: aX(n)

  jsr MULT

  ; add c = 00 26 9E C3

  lda RESULT
  clc
  adc #$C3
  sta DWORD_2
  lda RESULT+1
  adc #$9E
  sta DWORD_2+1
  lda RESULT+2
  adc #$26
  sta DWORD_2+2
  lda RESULT+3
  adc #0
  sta DWORD_2+3

  ; store the result at RND_2 + Y

  lda RESULT
  sta RND_2,y
  iny
  lda RESULT+1
  sta RND_2,y
  iny
  lda RESULT+2
  sta RND_2,y
  iny
  lda RESULT+3
  sta RND_2,y
  iny

  cpy #0
  bne LOOP_2

; ================================================

  ; now multiply RND_1 by RND_2

  jsr BIG_MULT

; ================================================

STOP

  brk

; ================================================

MULT

  ; multiply two 4 byte values mod m = 1 00 00 00 00

  ldx #0

  ; initialise RESULT = 0

  lda #0
  sta RESULT
  sta RESULT+1
  sta RESULT+2
  sta RESULT+3

LOOP

  ; left shift RESULT

  asl RESULT
  rol RESULT+1
  rol RESULT+2
  rol RESULT+3

  ; left shift DWORD_2 to set the carry bit

  asl DWORD_2
  rol DWORD_2+1
  rol DWORD_2+2
  rol DWORD_2+3

  bcc NEXT

  ; if the carry bit is set, add DWORD_1 to RESULT

  lda DWORD_1
  clc
  adc RESULT
  sta RESULT
  lda DWORD_1+1
  adc RESULT+1
  sta RESULT+1
  lda DWORD_1+2
  adc RESULT+2
  sta RESULT+2
  lda DWORD_1+3
  adc RESULT+3
  sta RESULT+3

NEXT

  ; for each of the 32 bits in DWORD_2

  inx
  cpx #32
  bne LOOP

  rts

; ================================================

BIG_MULT

  ; multiply RND_1 by RND_2

  ; store the result in |OUTPUT_1|OUTPUT_2|
  
  ldx #0
  stx COUNT

LP_1

  ldy #0

  lda RND_2,x
  sta TEMP

LP_2

  jsr SHL

  asl TEMP
  bcc NEXT_BIT

  jsr ADD

NEXT_BIT

  iny
  cpy #8
  bne LP_2

  inc COUNT
  ldx COUNT
  cpx #0
  bne LP_1

  rts

; ================================================

ADD

  ; add |RND_1| to |OUTPUT_1|OUTPUT_2|

  ; big endian byte order

  ldx #$FF

  clc
  php

L1

  ; add RND_1 to OUTPUT_2

  lda RND_1,x
  plp
  adc OUTPUT_2,x
  php
  sta OUTPUT_2,x
  
  dex
  cpx #$FF
  bne L1

L2

  ; add the carry bit to OUTPUT_1

  plp
  bcc DONE
  lda #0
  adc OUTPUT_1,x
  php
  sta OUTPUT_1,x

  dex
  cpx #$FF
  bne L2

DONE

  rts

; ================================================

SHL

  ; rotate the bytes left by 1 bit

  ; the bytes are in big endian byte order

  ldx #$FF
  clc
  php

ROTL_2

  ; the 256 bytes starting at OUTPUT_2

  plp
  rol OUTPUT_2,x
  php 
  dex
  cpx #$FF
  bne ROTL_2

ROTL_1

  ; the 256 bytes starting at OUTPUT_1

  plp
  rol OUTPUT_1,x
  php 
  dex
  cpx #$FF
  bne ROTL_1

  ; get the carry bit from (OUTPUT_1 + 0)

  lda #0
  plp
  adc #0

  ; or the carry bit into (OUTPUT_2 + FF)

  ora OUTPUT_2+$FF
  sta OUTPUT_2+$FF

  rts

; ================================================

Serpent-1 Encryption

A 32 byte key is used to generate a 560 byte key schedule. Pointers are used to access the key schedule because it is bigger than 256 bytes. The 16 byte input plain text is stored at zero page location 32. The 32 byte key is stored at zero page location 80. The 16 byte output cipher text is written to zero page location 48 once the program has finished execution. 

; ================================================

  ; Serpent-1 Encryption

; ================================================

  ; pointers to the sub-key array

PTR_KS_0 epz 0
PTR_KS_1 epz 2
PTR_KS_2 epz 4
PTR_KS_3 epz 6
PTR_KS_4 epz 8

INDEX epz 10
TEMP_W epz 12
ROUND epz 16

  ; the plain text (16 bytes)

P_TEXT epz 32

  ; the cipher text (16 bytes)

C_TEXT epz 48

  ; the key (32 bytes)

THE_KEY epz 80

; ================================================

  ; initialise the plain text

  org P_TEXT

  byt $00,$11,$22,$33
  byt $44,$55,$66,$77
  byt $88,$99,$AA,$BB
  byt $CC,$DD,$EE,$FF

; ================================================

  ; initialise the key

  org THE_KEY

  byt $12,$34,$56,$78
  byt $90,$AB,$CD,$EF
  byt $12,$34,$56,$78
  byt $90,$AB,$CD,$EF
  byt $12,$34,$56,$78
  byt $90,$AB,$CD,$EF
  byt $12,$34,$56,$78
  byt $90,$AB,$CD,$EF

; ================================================

  org $200

  ldy #0

COPY_K

  ; copy the 32 byte key to the first 
  ; 32 bytes of the key schedule

  lda THE_KEY,y
  sta KEY_SCHEDULE,y

  iny
  cpy #32
  bne COPY_K

  ; generate the key schedule

  jsr GENERATE_KS

  jsr SUB_KS

  ldy #0

COPY_P

  ; copy the 16 byte plain text to
  ; |WORD_0|WORD_1|WORD_2|WORD_3|

  lda P_TEXT,y
  sta WORD_0,y

  iny
  cpy #16
  bne COPY_P

  ; do the encryption

  jsr ENCRYPT

  ldy #0

COPY_C

  ; copy |WORD_0|WORD_1|WORD_2|WORD_3|
  ; back to the cipher text

  lda WORD_0,y
  sta C_TEXT,y

  iny
  cpy #16
  bne COPY_C

  jmp STOP

; ================================================

ENCRYPT

  ; encrypt the message in:

  ; |WORD_0|WORD_1|WORD_2|WORD_3|

  ; initialise the pointers to the sub-keys

  lda #KEY_SCHEDULE+32
  sta PTR_KS_0
  lda /KEY_SCHEDULE+32
  sta PTR_KS_0+1

  lda #KEY_SCHEDULE+36
  sta PTR_KS_1
  lda /KEY_SCHEDULE+36
  sta PTR_KS_1+1	

  lda #KEY_SCHEDULE+40
  sta PTR_KS_2
  lda /KEY_SCHEDULE+40
  sta PTR_KS_2+1	

  lda #KEY_SCHEDULE+44
  sta PTR_KS_3
  lda /KEY_SCHEDULE+44
  sta PTR_KS_3+1

  ; 32 rounds - ROUND = 0 to 31

  lda #0
  sta ROUND

LOOP

  ; xor the current sub-keys into the message

  jsr SUBKEY_XOR

  ; s-box index = ROUND mod 8 (SHL 4 bits)

  lda ROUND
  asl
  asl
  asl
  asl
  and #$70 
  sta S_INDEX

  ; apply the s-box

  jsr CALC_S

  ; skip the linear transform for the last round

  lda ROUND
  cmp #31
  beq LAST	

  ; apply the linear transform

  jsr LIN_TRANS

  ; next round

  inc ROUND

  jmp LOOP

LAST

  ; do the final xor of the sub-key

  jsr SUBKEY_XOR

  rts

; ================================================

SUBKEY_XOR

  ; xor the current 16 byte sub-key into the text

  ldy #0

  ; the first byte of each word

  lda (PTR_KS_0),y
  eor WORD_0
  sta WORD_0

  lda (PTR_KS_1),y
  eor WORD_1
  sta WORD_1

  lda (PTR_KS_2),y
  eor WORD_2
  sta WORD_2

  lda (PTR_KS_3),y
  eor WORD_3
  sta WORD_3

  iny

  ; the second byte of each word

  lda (PTR_KS_0),y
  eor WORD_0+1
  sta WORD_0+1

  lda (PTR_KS_1),y
  eor WORD_1+1
  sta WORD_1+1

  lda (PTR_KS_2),y
  eor WORD_2+1
  sta WORD_2+1

  lda (PTR_KS_3),y
  eor WORD_3+1
  sta WORD_3+1

  iny

  ; the third byte of each word

  lda (PTR_KS_0),y
  eor WORD_0+2
  sta WORD_0+2

  lda (PTR_KS_1),y
  eor WORD_1+2
  sta WORD_1+2

  lda (PTR_KS_2),y
  eor WORD_2+2
  sta WORD_2+2

  lda (PTR_KS_3),y
  eor WORD_3+2
  sta WORD_3+2

  iny

  ; the fourth byte of each word

  lda (PTR_KS_0),y
  eor WORD_0+3
  sta WORD_0+3

  lda (PTR_KS_1),y
  eor WORD_1+3
  sta WORD_1+3

  lda (PTR_KS_2),y
  eor WORD_2+3
  sta WORD_2+3

  lda (PTR_KS_3),y
  eor WORD_3+3
  sta WORD_3+3

  ; increment the pointers to the sub-key

  lda PTR_KS_0
  clc
  adc #16
  sta PTR_KS_0
  lda #0
  adc PTR_KS_0+1
  sta PTR_KS_0+1

  lda PTR_KS_1
  clc
  adc #16
  sta PTR_KS_1
  lda #0
  adc PTR_KS_1+1
  sta PTR_KS_1+1

  lda PTR_KS_2
  clc
  adc #16
  sta PTR_KS_2
  lda #0
  adc PTR_KS_2+1
  sta PTR_KS_2+1

  lda PTR_KS_3
  clc
  adc #16
  sta PTR_KS_3
  lda #0
  adc PTR_KS_3+1
  sta PTR_KS_3+1

  rts

; ================================================

LIN_TRANS

  ; the linear transformation

  ; LT: |WORD_0|WORD_1|WORD_2|WORD_3|

  ; w0 = ROL(w0,13)  

  ldx #0

ROL_13

  asl WORD_0
  rol WORD_0+1
  rol WORD_0+2
  rol WORD_0+3

  php
  pla
  and #1
  ora WORD_0
  sta WORD_0

  inx
  cpx #13
  bne ROL_13

  ; w2 = ROL(w2,3)

  ldx #0

ROL_3

  asl WORD_2
  rol WORD_2+1
  rol WORD_2+2
  rol WORD_2+3

  php
  pla
  and #1
  ora WORD_2
  sta WORD_2

  inx
  cpx #3
  bne ROL_3

  ; w1 = w1 xor w0 xor w2

  lda WORD_1
  eor WORD_0
  eor WORD_2
  sta WORD_1

  lda WORD_1+1
  eor WORD_0+1
  eor WORD_2+1
  sta WORD_1+1

  lda WORD_1+2
  eor WORD_0+2
  eor WORD_2+2
  sta WORD_1+2

  lda WORD_1+3
  eor WORD_0+3
  eor WORD_2+3
  sta WORD_1+3

  ; w3 = w3 xor w2 xor SHL(w0,3)

  lda WORD_0
  sta TEMP_W
  lda WORD_0+1
  sta TEMP_W+1
  lda WORD_0+2
  sta TEMP_W+2
  lda WORD_0+3
  sta TEMP_W+3

  ldx #0

SHL_3

  asl TEMP_W
  rol TEMP_W+1
  rol TEMP_W+2
  rol TEMP_W+3

  inx
  cpx #3
  bne SHL_3

  lda WORD_3
  eor WORD_2
  eor TEMP_W
  sta WORD_3

  lda WORD_3+1
  eor WORD_2+1
  eor TEMP_W+1
  sta WORD_3+1

  lda WORD_3+2
  eor WORD_2+2
  eor TEMP_W+2
  sta WORD_3+2

  lda WORD_3+3
  eor WORD_2+3
  eor TEMP_W+3
  sta WORD_3+3

  ; w1 = ROL(w1,1)

ROL_1

  asl WORD_1
  rol WORD_1+1
  rol WORD_1+2
  rol WORD_1+3

  php
  pla
  and #1
  ora WORD_1
  sta WORD_1

  ; w3 = ROL(w3,7)

  ldx #0

ROL_7

  asl WORD_3
  rol WORD_3+1
  rol WORD_3+2
  rol WORD_3+3

  php
  pla
  and #1
  ora WORD_3
  sta WORD_3

  inx
  cpx #7
  bne ROL_7

  ; w0 = w0 xor w1 xor w3

  lda WORD_0
  eor WORD_1
  eor WORD_3
  sta WORD_0

  lda WORD_0+1
  eor WORD_1+1
  eor WORD_3+1
  sta WORD_0+1

  lda WORD_0+2
  eor WORD_1+2
  eor WORD_3+2
  sta WORD_0+2

  lda WORD_0+3
  eor WORD_1+3
  eor WORD_3+3
  sta WORD_0+3

  ; w2 = w2 xor w3 xor SHL(w1,7)

  lda WORD_1
  sta TEMP_W
  lda WORD_1+1
  sta TEMP_W+1
  lda WORD_1+2
  sta TEMP_W+2
  lda WORD_1+3
  sta TEMP_W+3

  ldx #0

SHL_7

  asl TEMP_W
  rol TEMP_W+1
  rol TEMP_W+2
  rol TEMP_W+3

  inx
  cpx #7
  bne SHL_7

  lda WORD_2
  eor WORD_3
  eor TEMP_W
  sta WORD_2

  lda WORD_2+1
  eor WORD_3+1
  eor TEMP_W+1
  sta WORD_2+1

  lda WORD_2+2
  eor WORD_3+2
  eor TEMP_W+2
  sta WORD_2+2

  lda WORD_2+3
  eor WORD_3+3
  eor TEMP_W+3
  sta WORD_2+3

  ; w0 = ROL(w0,5)
 
  ldx #0

ROL_5

  asl WORD_0
  rol WORD_0+1
  rol WORD_0+2
  rol WORD_0+3

  php
  pla
  and #1
  ora WORD_0
  sta WORD_0

  inx
  cpx #5
  bne ROL_5

  ; w2 = ROL(w2,22)

  ldx #0

ROL_22

  asl WORD_2
  rol WORD_2+1
  rol WORD_2+2
  rol WORD_2+3

  php
  pla
  and #1
  ora WORD_2
  sta WORD_2

  inx
  cpx #22
  bne ROL_22

  rts

; ================================================

CALC_S

  ; apply the s-box to the 16 byte input block

  ; |WORD_0|WORD_1|WORD_2|WORD_3|

TO_BITSLICE

  ; break up the input block into 32 x 4-bit bitslices

  ldx #0

BYTE_1

  asl WORD_3
  rol BIT_SLICE,x
  asl WORD_2
  rol BIT_SLICE,x
  asl WORD_1
  rol BIT_SLICE,x
  asl WORD_0
  rol BIT_SLICE,x

  inx
  cpx #8
  bne BYTE_1

BYTE_2

  asl WORD_3+1
  rol BIT_SLICE,x
  asl WORD_2+1
  rol BIT_SLICE,x
  asl WORD_1+1
  rol BIT_SLICE,x
  asl WORD_0+1
  rol BIT_SLICE,x

  inx
  cpx #16
  bne BYTE_2
  
BYTE_3

  asl WORD_3+2
  rol BIT_SLICE,x
  asl WORD_2+2
  rol BIT_SLICE,x
  asl WORD_1+2
  rol BIT_SLICE,x
  asl WORD_0+2
  rol BIT_SLICE,x

  inx
  cpx #24
  bne BYTE_3
  
BYTE_4

  asl WORD_3+3
  rol BIT_SLICE,x
  asl WORD_2+3
  rol BIT_SLICE,x
  asl WORD_1+3
  rol BIT_SLICE,x
  asl WORD_0+3
  rol BIT_SLICE,x

  inx
  cpx #32
  bne BYTE_4

  ldx #0

SUB

  ; put each of the 32 bitslices through the s-box

  lda BIT_SLICE,x
  ora S_INDEX
  tay
  lda S_BOX,y
  sta BIT_SLICE,x

  inx
  cpx #32
  bne SUB

TO_WORD

  ; put the results back into the input block

  ldx #0

WD_1

  lsr BIT_SLICE,x
  rol WORD_0
  lsr BIT_SLICE,x
  rol WORD_1
  lsr BIT_SLICE,x
  rol WORD_2
  lsr BIT_SLICE,x
  rol WORD_3

  inx
  cpx #8
  bne WD_1

WD_2

  lsr BIT_SLICE,x
  rol WORD_0+1
  lsr BIT_SLICE,x
  rol WORD_1+1
  lsr BIT_SLICE,x
  rol WORD_2+1
  lsr BIT_SLICE,x
  rol WORD_3+1

  inx
  cpx #16
  bne WD_2

WD_3

  lsr BIT_SLICE,x
  rol WORD_0+2
  lsr BIT_SLICE,x
  rol WORD_1+2
  lsr BIT_SLICE,x
  rol WORD_2+2
  lsr BIT_SLICE,x
  rol WORD_3+2

  inx
  cpx #24
  bne WD_3

WD_4

  lsr BIT_SLICE,x
  rol WORD_0+3
  lsr BIT_SLICE,x
  rol WORD_1+3
  lsr BIT_SLICE,x
  rol WORD_2+3
  lsr BIT_SLICE,x
  rol WORD_3+3

  inx
  cpx #32
  bne WD_4

  rts

; ================================================

GENERATE_KS

  ; generate the key schedule from the 32 byte key

  ; initialise the pointers to the 4 byte words
  ; within the key schedule

  ; Key[i-8]

  lda #KEY_SCHEDULE
  sta PTR_KS_4
  lda /KEY_SCHEDULE
  sta PTR_KS_4+1

  ; Key[i-5]

  lda #KEY_SCHEDULE+12
  sta PTR_KS_3
  lda /KEY_SCHEDULE+12
  sta PTR_KS_3+1

  ; Key[i-3]

  lda #KEY_SCHEDULE+20
  sta PTR_KS_2
  lda /KEY_SCHEDULE+20
  sta PTR_KS_2+1	

  ; Key[i-1]

  lda #KEY_SCHEDULE+28
  sta PTR_KS_1
  lda /KEY_SCHEDULE+28
  sta PTR_KS_1+1	

  ; Key[i]

  lda #KEY_SCHEDULE+32
  sta PTR_KS_0
  lda /KEY_SCHEDULE+32
  sta PTR_KS_0+1

  ; FOR INDEX = 0 TO INDEX = 131

  lda #0
  sta INDEX

NEXT_KS

  ldy #0

  lda (PTR_KS_4),y
  eor (PTR_KS_3),y
  eor (PTR_KS_2),y
  eor (PTR_KS_1),y
  eor #$b9
  eor INDEX	
  sta (PTR_KS_0),y

  iny

  lda (PTR_KS_4),y
  eor (PTR_KS_3),y
  eor (PTR_KS_2),y
  eor (PTR_KS_1),y
  eor #$79
  sta (PTR_KS_0),y

  iny

  lda (PTR_KS_4),y
  eor (PTR_KS_3),y
  eor (PTR_KS_2),y
  eor (PTR_KS_1),y
  eor #$37
  sta (PTR_KS_0),y

  iny

  lda (PTR_KS_4),y
  eor (PTR_KS_3),y
  eor (PTR_KS_2),y
  eor (PTR_KS_1),y
  eor #$9e
  sta (PTR_KS_0),y

  ldx #0

ROL_11

  ldy #0

  ; ROTL Key[i] by 11 bits

  lda (PTR_KS_0),y
  asl 
  sta (PTR_KS_0),y
  iny
  lda (PTR_KS_0),y
  rol 
  sta (PTR_KS_0),y
  iny
  lda (PTR_KS_0),y
  rol 
  sta (PTR_KS_0),y
  iny
  lda (PTR_KS_0),y
  rol 
  sta (PTR_KS_0),y

  ldy #0

  php
  pla
  and #1
  ora (PTR_KS_0),y
  sta (PTR_KS_0),y

  inx
  cpx #11
  bne ROL_11

  ; increment the pointers to the 4 byte
  ; words within the key schedule

  ; Key[i-8]

  lda PTR_KS_4
  clc
  adc #4
  sta PTR_KS_4
  lda #0
  adc PTR_KS_4+1
  sta PTR_KS_4+1

  ; Key[i-5]

  lda PTR_KS_3
  clc
  adc #4
  sta PTR_KS_3
  lda #0
  adc PTR_KS_3+1
  sta PTR_KS_3+1  

  ; Key[i-3]

  lda PTR_KS_2
  clc
  adc #4
  sta PTR_KS_2
  lda #0
  adc PTR_KS_2+1
  sta PTR_KS_2+1 

  ; Key[i-1]

  lda PTR_KS_1
  clc
  adc #4
  sta PTR_KS_1
  lda #0
  adc PTR_KS_1+1
  sta PTR_KS_1+1

  ; Key[i]

  lda PTR_KS_0
  clc
  adc #4
  sta PTR_KS_0
  lda #0
  adc PTR_KS_0+1
  sta PTR_KS_0+1

  ; increment the index counter
  ; exit if index = 132

  inc INDEX
  lda INDEX
  eor #132
  beq DONE

  jmp NEXT_KS

DONE

  rts

; ================================================

SUB_KS

  ; apply the s-box to each 16 byte
  ; sub-key within the key schedule

  ; initialise the pointers to each
  ; 4 byte word within the sub-key

  lda #KEY_SCHEDULE+32
  sta PTR_KS_0
  lda /KEY_SCHEDULE+32
  sta PTR_KS_0+1

  lda #KEY_SCHEDULE+36
  sta PTR_KS_1
  lda /KEY_SCHEDULE+36
  sta PTR_KS_1+1

  lda #KEY_SCHEDULE+40
  sta PTR_KS_2
  lda /KEY_SCHEDULE+40
  sta PTR_KS_2+1

  lda #KEY_SCHEDULE+44
  sta PTR_KS_3
  lda /KEY_SCHEDULE+44
  sta PTR_KS_3+1

  ; the s-box index is initialised to 3

  lda #$30
  sta S_INDEX

  ; FOR INDEX = 0 TO INDEX = 32 (33 sub-keys)

  lda #0
  sta INDEX	

NEXT_BLOCK

  ; copy the 16 byte sub-key to

  ; |WORD_0|WORD_1|WORD_2|WORD_3|

  ldy #0

  lda (PTR_KS_0),y
  sta WORD_0
  lda (PTR_KS_1),y
  sta WORD_1
  lda (PTR_KS_2),y
  sta WORD_2
  lda (PTR_KS_3),y
  sta WORD_3

  iny

  lda (PTR_KS_0),y
  sta WORD_0,y
  lda (PTR_KS_1),y
  sta WORD_1,y
  lda (PTR_KS_2),y
  sta WORD_2,y
  lda (PTR_KS_3),y
  sta WORD_3,y

  iny

  lda (PTR_KS_0),y
  sta WORD_0,y
  lda (PTR_KS_1),y
  sta WORD_1,y
  lda (PTR_KS_2),y
  sta WORD_2,y
  lda (PTR_KS_3),y
  sta WORD_3,y

  iny

  lda (PTR_KS_0),y
  sta WORD_0,y
  lda (PTR_KS_1),y
  sta WORD_1,y
  lda (PTR_KS_2),y
  sta WORD_2,y
  lda (PTR_KS_3),y
  sta WORD_3,y

  ; apply the s-box

  jsr CALC_S

  ; the result is in: |WORD_0|WORD_1|WORD_2|WORD_3|

  ; copy back to the sub-key

  ldy #0

  lda WORD_0
  sta (PTR_KS_0),y
  lda WORD_1
  sta (PTR_KS_1),y
  lda WORD_2
  sta (PTR_KS_2),y
  lda WORD_3
  sta (PTR_KS_3),y

  iny

  lda WORD_0,y
  sta (PTR_KS_0),y
  lda WORD_1,y
  sta (PTR_KS_1),y
  lda WORD_2,y
  sta (PTR_KS_2),y
  lda WORD_3,y
  sta (PTR_KS_3),y

  iny

  lda WORD_0,y
  sta (PTR_KS_0),y
  lda WORD_1,y
  sta (PTR_KS_1),y
  lda WORD_2,y
  sta (PTR_KS_2),y
  lda WORD_3,y
  sta (PTR_KS_3),y

  iny

  lda WORD_0,y
  sta (PTR_KS_0),y
  lda WORD_1,y
  sta (PTR_KS_1),y
  lda WORD_2,y
  sta (PTR_KS_2),y
  lda WORD_3,y
  sta (PTR_KS_3),y

  ; update the s-box index

  lda S_INDEX

  cmp #0
  bne SKIP
  lda #$70
  jmp INC_BLOCK

SKIP

  sec
  sbc #$10

INC_BLOCK

  sta S_INDEX

  ; increment to the next 16 byte sub-key

  lda PTR_KS_0
  clc
  adc #16
  sta PTR_KS_0
  lda #0
  adc PTR_KS_0+1
  sta PTR_KS_0+1 

  lda PTR_KS_1
  clc
  adc #16
  sta PTR_KS_1
  lda #0
  adc PTR_KS_1+1
  sta PTR_KS_1+1 

  lda PTR_KS_2
  clc
  adc #16
  sta PTR_KS_2
  lda #0
  adc PTR_KS_2+1
  sta PTR_KS_2+1 

  lda PTR_KS_3
  clc
  adc #16
  sta PTR_KS_3
  lda #0
  adc PTR_KS_3+1
  sta PTR_KS_3+1 

  ; update the counter

  inc INDEX
  lda INDEX
  eor #33
  beq QUIT
  jmp NEXT_BLOCK

QUIT

  rts

; ================================================

STOP

  brk

; ================================================

  org $800

  ; the block containing the 16 byte input message

  ; the encryption, linear transform and s-box 
  ; calculations are directly applied to this block

WORD_0 byt 0,0,0,0
WORD_1 byt 0,0,0,0
WORD_2 byt 0,0,0,0
WORD_3 byt 0,0,0,0

  ; the array of the 32 x 4-bit bitslices

BIT_SLICE dfs 32,0

  ; the upper 4-bits of s_index is the s-box number (0-7)

  ; this is ORed into a bitslice to get an offset
  ; from the start of the s-box array

S_INDEX byt 0

  ; the 8 s-box arrays

S_BOX

  byt 3,8,15,1,10,6,5,11,14,13,4,2,7,0,9,12
  byt 15,12,2,7,9,0,5,10,1,11,14,8,6,13,3,4
  byt 8,6,7,9,3,12,10,15,13,1,14,4,0,11,5,2
  byt 0,15,11,8,12,9,6,3,13,1,2,4,10,7,5,14
  byt 1,15,8,3,12,0,11,6,2,5,4,10,9,14,7,13
  byt 15,5,2,11,4,10,9,12,0,3,14,8,13,6,7,1
  byt 7,2,12,5,8,4,6,11,14,9,1,15,13,3,10,0
  byt 1,13,15,0,14,8,2,11,7,4,12,10,9,3,5,6

; ================================================

  ; the 560 byte key schedule

  ; the first 32 bytes are the actual key

  ; the next 528 bytes are the 33 x 16 byte sub-keys

  org $900

KEY_SCHEDULE dfs 560

; ================================================

GOST 28147-89 ECB

The 32 byte key stored at KDS is used to encrypt the 8 byte input block stored at N1 and N2. Once the program has finished execution N1 and N2 store the result. 

; ================================================

KDS epz 0
N1 epz 48
N2 epz 52
CM epz 80
P_XR epz 96
ROUND epz 98
TEMP epz 100

; ================================================

  org KDS

  hex 75713134 
  hex B60FEC45 
  hex A607BB83 
  hex AA3746AF 
  hex 4FF99DA6 
  hex D1B53B5B 
  hex 1B402A1B 
  hex AA030D1B

  org N1

  hex 11223344 
  hex 55667788 

; ================================================

  org $200

; ================================================

  lda #0
  sta ROUND

RND_1_24

  ; rounds 1 to 24

  ; set the pointer to the round subkey X(R)

  ; P_XR = KDS + 4(ROUND mod 8)

  lda ROUND
  and #7
  asl
  asl
  clc
  adc #KDS
  sta P_XR

  jsr CALC_ROUND

  ; update N1 and N2

  jsr N1_TO_N2
  jsr CM_TO_N1

  inc ROUND
  lda ROUND
  cmp #24
  bne RND_1_24

  ; for the last 8 rounds, set ROUND = 7 and count down

  lda #7
  sta ROUND
  
RND_25_32

  ; rounds 25 to 32

  ; set the pointer to the round subkey X(R)

  ; P_XR = KDS + 4(ROUND mod 8)

  lda ROUND
  asl
  asl
  clc
  adc #KDS
  sta P_XR

  jsr CALC_ROUND

  dec ROUND
  lda ROUND
  cmp #$FF
  beq CM_TO_N2

  ; update N1 and N2

  jsr N1_TO_N2
  jsr CM_TO_N1

  jmp RND_25_32

CM_TO_N2

  ; set N2 = CM

  lda CM
  sta N2
  lda CM+1
  sta N2+1
  lda CM+2
  sta N2+2
  lda CM+3
  sta N2+3

  jmp STOP

; ================================================

CALC_ROUND

  ; CM = N1
  ; CM = CM + X(R)
  ; CM = S_BOXES(CM)
  ; CM = ROTL(CM,11)
  ; CM = CM xor N2

  jsr N1_TO_CM
  jsr CALC_CM1
  jsr SUB_CM
  jsr ROTL_CM
  jsr CALC_CM2

  rts

; ================================================

N1_TO_CM

  ; set CM = N1

  lda N1
  sta CM
  lda N1+1
  sta CM+1
  lda N1+2
  sta CM+2
  lda N1+3
  sta CM+3

  rts

; ================================================

CALC_CM1

  ; calc CM = N1 + X(R)

  ; X(R) is the subkey for round R

  ; P_XR points to X(R)

  ldy #0

  lda CM
  clc
  adc (P_XR),y	
  sta CM

  iny
  lda CM+1
  adc (P_XR),y	
  sta CM+1

  iny
  lda CM+2
  adc (P_XR),y	
  sta CM+2

  iny
  lda CM+3
  adc (P_XR),y	
  sta CM+3

  rts

; ================================================

SUB_CM

  ; apply the S boxes

  ; apply K8 to the upper 4 bits of CM

  lda CM+3
  and #$F0
  lsr
  lsr
  lsr
  lsr
  tax
  lda K8,x
  asl
  asl
  asl
  asl
  pha

  ; apply K7 to the next 4 bits of CM
  
  lda CM+3
  and #$F
  tax
  lda K7,x

  ; recombine the nibbles and write back to CM

  sta CM+3
  pla
  ora CM+3
  sta CM+3

  ; apply K6 to the next 4 bits of CM

  lda CM+2
  and #$F0
  lsr
  lsr
  lsr
  lsr
  tax
  lda K6,x
  asl
  asl
  asl
  asl
  pha

  ; apply K5 to the next 4 bits of CM
  
  lda CM+2
  and #$F
  tax
  lda K5,x

  ; recombine the nibbles and write back to CM

  sta CM+2
  pla
  ora CM+2
  sta CM+2

  ; apply K4 to the next 4 bits of CM

  lda CM+1
  and #$F0
  lsr
  lsr
  lsr
  lsr
  tax
  lda K4,x
  asl
  asl
  asl
  asl
  pha

  ; apply K3 to the next 4 bits of CM
  
  lda CM+1
  and #$F
  tax
  lda K3,x

  ; recombine the nibbles and write back to CM

  sta CM+1
  pla
  ora CM+1
  sta CM+1

  ; apply K2 to the next 4 bits of CM

  lda CM
  and #$F0
  lsr
  lsr
  lsr
  lsr
  tax
  lda K2,x
  asl
  asl
  asl
  asl
  pha

  ; apply K1 to the lower 4 bits of CM
  
  lda CM
  and #$F
  tax
  lda K1,x

  ; recombine the nibbles and write back to CM

  sta CM
  pla
  ora CM
  sta CM

  rts

; ================================================

ROTL_CM

  ; ROTL CM by 11 bits

  ; copy up by 1 byte (8 bits)

  lda CM+3
  pha
  lda CM+2
  sta CM+3
  lda CM+1
  sta CM+2
  lda CM
  sta CM+1
  pla
  sta CM

  ; ROTL by 1 bit

  asl CM
  rol CM+1
  rol CM+2
  rol CM+3
  php
  pla
  and #1
  ora CM
  sta CM

  ; ROTL by 1 bit

  asl CM
  rol CM+1
  rol CM+2
  rol CM+3
  php
  pla
  and #1
  ora CM
  sta CM

  ; ROTL by 1 bit

  asl CM
  rol CM+1
  rol CM+2
  rol CM+3
  php
  pla
  and #1
  ora CM
  sta CM

  rts

; ================================================

CALC_CM2

  ; calc CM = CM xor N2

  lda CM
  eor N2
  sta CM
  lda CM+1
  eor N2+1
  sta CM+1
  lda CM+2
  eor N2+2
  sta CM+2
  lda CM+3
  eor N2+3
  sta CM+3

  rts

; ================================================

N1_TO_N2

  ; set N2 = N1

  lda N1
  sta N2
  lda N1+1
  sta N2+1
  lda N1+2
  sta N2+2
  lda N1+3
  sta N2+3

  rts

; ================================================

CM_TO_N1

  ; set N1 = CM

  lda CM
  sta N1
  lda CM+1
  sta N1+1
  lda CM+2
  sta N1+2
  lda CM+3
  sta N1+3

  rts

; ================================================

  ; the S boxes

K8 byt $1,$F,$D,$0,$5,$7,$A,$4,$9,$2,$3,$E,$6,$B,$8,$C
K7 byt $D,$B,$4,$1,$3,$F,$5,$9,$0,$A,$E,$7,$6,$8,$2,$C
K6 byt $4,$B,$A,$0,$7,$2,$1,$D,$3,$6,$8,$5,$9,$C,$F,$E
K5 byt $6,$C,$7,$1,$5,$F,$D,$8,$4,$A,$9,$E,$0,$3,$B,$2
K4 byt $7,$D,$A,$1,$0,$8,$9,$F,$E,$4,$6,$C,$B,$2,$5,$3
K3 byt $5,$8,$1,$D,$A,$3,$4,$2,$E,$F,$C,$7,$6,$0,$9,$B
K2 byt $E,$B,$4,$C,$6,$D,$F,$A,$2,$3,$8,$1,$0,$7,$5,$9
K1 byt $4,$A,$9,$2,$D,$8,$0,$E,$6,$B,$1,$C,$7,$F,$5,$3

; ================================================

STOP

  brk

; ================================================

Blog at WordPress.com.

%d bloggers like this: