mirror of
https://github.com/zellyn/a2audit.git
synced 2024-11-22 13:33:35 +00:00
54710c10a0
Added tests for 0x1ff- and 0x200-length inputs. Also changed code that sets k constants to use constant values, rather than copying, to save a few bytes.
618 lines
7.0 KiB
Plaintext
618 lines
7.0 KiB
Plaintext
!to "shasum.o", plain
|
|
* = $6000
|
|
jmp main
|
|
|
|
;; clear addresses:
|
|
;; (http://apple2.org.za/gswv/a2zine/faqs/csa2pfaq.html#017)
|
|
;; 06-09
|
|
;; EB-EF
|
|
;; FA-FD
|
|
|
|
!addr SRC = $06
|
|
!addr DST = $08
|
|
!addr INPUT = $eb
|
|
!addr LENGTH = $ee
|
|
!addr TMP1 = $fa
|
|
!addr TMP2 = $fb
|
|
|
|
!addr PRBYTE = $FDDA
|
|
!addr COUT = $FDED
|
|
|
|
h0: !32 0 ; return value (hash)
|
|
h1: !32 0
|
|
h2: !32 0
|
|
h3: !32 0
|
|
h4: !32 0
|
|
h5:
|
|
ml: !32 0, 0 ; message length
|
|
w: !fill 64, 0
|
|
w_next: !fill 64, 0
|
|
a: !32 0
|
|
b: !32 0
|
|
c: !32 0
|
|
d: !32 0
|
|
e: !32 0
|
|
f: !32 0
|
|
temp: !32 0
|
|
k: !32 0
|
|
kh0: !be32 $67452301 ; initial values for h0..h4
|
|
kh1: !be32 $EFCDAB89
|
|
kh2: !be32 $98BADCFE
|
|
kh3: !be32 $10325476
|
|
kh4: !be32 $C3D2E1F0
|
|
k1 = $5A827999 ; k constants
|
|
k2 = $6ED9EBA1
|
|
k3 = $8F1BBCDC
|
|
k4 = $CA62C1D6
|
|
|
|
!macro set32 .target, .value {
|
|
lda #<(.value >> 24)
|
|
sta .target
|
|
lda #<(.value >> 16)
|
|
sta .target+1
|
|
lda #<(.value >> 8)
|
|
sta .target+2
|
|
lda #<(.value)
|
|
sta .target+3
|
|
}
|
|
|
|
!macro setSRC .source {
|
|
lda #<.source
|
|
sta SRC
|
|
lda #>.source
|
|
sta SRC+1
|
|
}
|
|
!macro setDST .dest {
|
|
lda #<.dest
|
|
sta DST
|
|
lda #>.dest
|
|
sta DST+1
|
|
}
|
|
|
|
;;; Print a string of bytes, as hex.
|
|
;;; Address in SRC, count in A.
|
|
;;; Burns A,Y.
|
|
prbytes:
|
|
ldy #0
|
|
- pha
|
|
lda (SRC),y
|
|
jsr PRBYTE
|
|
iny
|
|
pla
|
|
adc #$ff
|
|
bne -
|
|
rts
|
|
|
|
main:
|
|
;; Test shasum ""
|
|
lda #0
|
|
sta INPUT
|
|
lda #$fe
|
|
sta INPUT+1
|
|
lda #0
|
|
sta LENGTH+1
|
|
lda #0 ; da39a3ee5e6b4b0d3255bfef95601890afd80709
|
|
sta LENGTH
|
|
jsr shasum
|
|
|
|
; lda #$8d
|
|
; jsr COUT
|
|
|
|
+setSRC h0
|
|
lda #(h5-h0)
|
|
jsr prbytes
|
|
|
|
;; Test shasum FE00[:0x37]
|
|
lda #0
|
|
sta INPUT
|
|
lda #$fe
|
|
sta INPUT+1
|
|
lda #0
|
|
sta LENGTH+1
|
|
lda #$37 ; 1CF73FC6156B548A949D315120B5256245EAA33E
|
|
sta LENGTH
|
|
jsr shasum
|
|
|
|
; lda #$8d
|
|
; jsr COUT
|
|
|
|
+setSRC h0
|
|
lda #(h5-h0)
|
|
jsr prbytes
|
|
|
|
;; Test shasum FE00[:0x100]
|
|
lda #0
|
|
sta INPUT
|
|
lda #$fe
|
|
sta INPUT+1
|
|
lda #1
|
|
sta LENGTH+1
|
|
lda #0 ; 7B3D05347B52210065E27054FDFD0B8B699F0965
|
|
sta LENGTH
|
|
jsr shasum
|
|
|
|
; lda #$8d
|
|
; jsr COUT
|
|
|
|
+setSRC h0
|
|
lda #(h5-h0)
|
|
jsr prbytes
|
|
|
|
;; Test shasum FE00[:0x1ff]
|
|
lda #0
|
|
sta INPUT
|
|
lda #$fe
|
|
sta INPUT+1
|
|
lda #$1
|
|
sta LENGTH+1
|
|
lda #$ff ; 269CA6B0C644DAC01D908B20C10C0D5B19C52ABF
|
|
sta LENGTH
|
|
jsr shasum
|
|
|
|
; lda #$8d
|
|
; jsr COUT
|
|
|
|
+setSRC h0
|
|
lda #(h5-h0)
|
|
jsr prbytes
|
|
|
|
;; Test shasum FE00[:0x200]
|
|
lda #0
|
|
sta INPUT
|
|
lda #$fe
|
|
sta INPUT+1
|
|
lda #2
|
|
sta LENGTH+1
|
|
lda #0 ; D5AC71D5EE76E31CC82CF5136151BF4CDA503601
|
|
sta LENGTH
|
|
jsr shasum
|
|
|
|
; lda #$8d
|
|
; jsr COUT
|
|
|
|
+setSRC h0
|
|
lda #(h5-h0)
|
|
jsr prbytes
|
|
|
|
rts
|
|
|
|
shasum:
|
|
;; Initialize h0..h4
|
|
ldy #(h5-h0-1)
|
|
- lda kh0,y
|
|
sta h0,y
|
|
dey
|
|
bpl -
|
|
;; Initialize message length (ml)
|
|
lda #0
|
|
ldy #4
|
|
- sta ml, y
|
|
dey
|
|
bpl -
|
|
lda LENGTH
|
|
sta ml+7
|
|
lda LENGTH+1
|
|
sta ml+6
|
|
|
|
;; Message length is in bits
|
|
ldy #3
|
|
- asl ml+7
|
|
rol ml+6
|
|
rol ml+5
|
|
dey
|
|
bne -
|
|
|
|
;; Initialize chunk counter
|
|
;; ldy #0 ; already zero
|
|
|
|
;; Invert length so we can inc instead of dec
|
|
lda LENGTH
|
|
sec
|
|
lda #0
|
|
sbc LENGTH
|
|
sta LENGTH
|
|
lda #0
|
|
sbc LENGTH+1
|
|
sta LENGTH+1
|
|
ora LENGTH
|
|
beq .msgdone
|
|
|
|
.loop lda (INPUT),y
|
|
sta w,y
|
|
iny
|
|
cpy #$40
|
|
bne +
|
|
|
|
;; Call do_chunk
|
|
jsr do_chunk
|
|
ldy #0
|
|
|
|
clc
|
|
lda INPUT
|
|
adc #$40
|
|
sta INPUT
|
|
bcc +
|
|
inc INPUT+1
|
|
|
|
+ inc LENGTH
|
|
bne .loop
|
|
inc LENGTH+1
|
|
bne .loop
|
|
|
|
.msgdone:
|
|
lda #$80
|
|
sta w,y
|
|
iny
|
|
cpy #$40
|
|
bne .zeros
|
|
jsr do_chunk
|
|
ldy #0
|
|
|
|
.zeros
|
|
cpy #$38
|
|
beq .length
|
|
lda #0
|
|
sta w,y
|
|
iny
|
|
cpy #$40
|
|
bne .zeros
|
|
jsr do_chunk
|
|
ldy #0
|
|
jmp .zeros
|
|
.length
|
|
ldy #7
|
|
- lda ml,y
|
|
sta w+$38,y
|
|
dey
|
|
bpl -
|
|
jsr do_chunk
|
|
rts
|
|
|
|
;;; do_chunk processes a chunk of input. It burns A,X,Y,TMP1,TMP2.
|
|
do_chunk:
|
|
;; Copy a..e from h0..h4
|
|
|
|
ldy #(f-a-1)
|
|
- lda h0,y
|
|
sta a,y
|
|
dey
|
|
bpl -
|
|
|
|
ldy #0 ; y is index into w
|
|
|
|
;; First 20: k1
|
|
+set32 k, k1
|
|
|
|
ldx #16
|
|
- jsr kind1
|
|
dex
|
|
bne -
|
|
jsr fill
|
|
ldx #4
|
|
- jsr kind1
|
|
dex
|
|
bne -
|
|
;; Second 20: k2
|
|
+set32 k, k2
|
|
|
|
ldx #12
|
|
- jsr kind2
|
|
dex
|
|
bne -
|
|
jsr fill
|
|
ldx #8
|
|
- jsr kind2
|
|
dex
|
|
bne -
|
|
|
|
;; Third 20: k3
|
|
+set32 k, k3
|
|
|
|
ldx #8
|
|
- jsr kind3
|
|
dex
|
|
bne -
|
|
jsr fill
|
|
ldx #12
|
|
- jsr kind3
|
|
dex
|
|
bne -
|
|
|
|
;; Fourth 20: k4
|
|
+set32 k, k4
|
|
|
|
ldx #4
|
|
- jsr kind2
|
|
dex
|
|
bne -
|
|
jsr fill
|
|
ldx #16
|
|
- jsr kind2
|
|
dex
|
|
bne -
|
|
|
|
+setSRC a
|
|
+setDST h0
|
|
ldx #5
|
|
- jsr add32
|
|
clc
|
|
lda SRC
|
|
adc #4
|
|
sta SRC
|
|
lda DST
|
|
adc #4
|
|
sta DST
|
|
dex
|
|
bne -
|
|
rts
|
|
|
|
kind1:
|
|
sty TMP1
|
|
stx TMP2
|
|
;; f = d xor (b and (c xor d))
|
|
+setDST f
|
|
+setSRC d
|
|
jsr cp32
|
|
+setSRC c
|
|
jsr xor32
|
|
+setSRC b
|
|
jsr and32
|
|
+setSRC d
|
|
jsr xor32
|
|
|
|
jmp common
|
|
kind2:
|
|
sty TMP1
|
|
stx TMP2
|
|
;; f = b xor c xor d
|
|
+setDST f
|
|
+setSRC d
|
|
jsr cp32
|
|
+setSRC c
|
|
jsr xor32
|
|
+setSRC b
|
|
jsr xor32
|
|
|
|
jmp common
|
|
kind3:
|
|
sty TMP1
|
|
stx TMP2
|
|
;; f = (b and c) or (d and (b or c))
|
|
+setSRC c
|
|
+setDST f
|
|
jsr cp32
|
|
+setDST temp
|
|
jsr cp32
|
|
+setSRC b
|
|
jsr and32
|
|
+setDST f
|
|
jsr or32
|
|
+setSRC d
|
|
jsr and32
|
|
+setSRC temp
|
|
jsr or32
|
|
; jmp common
|
|
|
|
common:
|
|
|
|
;; temp = (a leftrotate 5) + f + e + k + w[i]
|
|
+setDST temp
|
|
+setSRC a
|
|
jsr cp32
|
|
jsr rol8
|
|
|
|
jsr ror1
|
|
jsr ror1
|
|
jsr ror1
|
|
|
|
+setSRC f
|
|
jsr add32
|
|
+setSRC e
|
|
jsr add32
|
|
+setSRC k
|
|
jsr add32
|
|
|
|
;; !setSRC w[i], and call add32
|
|
ldy TMP1
|
|
clc
|
|
tya
|
|
adc #<w
|
|
sta SRC
|
|
lda #0
|
|
adc #>w
|
|
sta SRC+1
|
|
jsr add32
|
|
|
|
;; e = d
|
|
+setSRC d
|
|
+setDST e
|
|
jsr cp32
|
|
|
|
;; d = c
|
|
+setSRC c
|
|
+setDST d
|
|
jsr cp32
|
|
|
|
;; c = b leftrotate 30
|
|
+setSRC b
|
|
+setDST c
|
|
jsr cp32
|
|
jsr ror1
|
|
jsr ror1
|
|
|
|
;; b = a
|
|
+setSRC a
|
|
+setDST b
|
|
jsr cp32
|
|
|
|
;; a = temp
|
|
+setSRC temp
|
|
+setDST a
|
|
jsr cp32
|
|
|
|
ldy TMP1
|
|
ldx TMP2
|
|
iny
|
|
iny
|
|
iny
|
|
iny
|
|
rts
|
|
|
|
;; Replace w[i:i+16] with w[i+16:i+32]. Burns a. Sets y=0.
|
|
fill:
|
|
+setDST w_next
|
|
+setSRC w
|
|
ldx #0x10
|
|
|
|
- sec
|
|
lda DST
|
|
sbc #16*4
|
|
sta SRC
|
|
jsr cp32 ; w[i] = w[i-16]
|
|
clc
|
|
lda SRC
|
|
adc #2*4
|
|
sta SRC
|
|
jsr xor32 ; ^ w[i-14]
|
|
lda SRC
|
|
adc #6*4
|
|
sta SRC
|
|
jsr xor32 ; ^ w[i-8]
|
|
lda SRC
|
|
adc #5*4
|
|
sta SRC
|
|
jsr xor32 ; ^ w[i-3]
|
|
jsr rol1
|
|
clc
|
|
lda DST
|
|
adc #4 ; i++
|
|
sta DST
|
|
|
|
dex
|
|
bne -
|
|
|
|
ldx #w_next-w-1
|
|
- lda w_next,x
|
|
sta w,x
|
|
dex
|
|
bpl -
|
|
|
|
ldy #0
|
|
rts
|
|
|
|
;;; 32-bit, big-endian math routines.
|
|
;;; Result goes in DST. Second operand (if any)
|
|
;;; comes from SRC.
|
|
|
|
;; Rotate-left DST. Burns a,y.
|
|
rol1:
|
|
ldy #0
|
|
lda (DST),y
|
|
rol
|
|
ldy #3
|
|
- lda (DST),y
|
|
rol
|
|
sta (DST),y
|
|
dey
|
|
bpl -
|
|
rts
|
|
|
|
;; Rotate-right DST. Burns a,y.
|
|
ror1:
|
|
ldy #3
|
|
lda (DST),y
|
|
ror
|
|
ldy #0
|
|
php
|
|
- lda (DST),y
|
|
plp
|
|
ror
|
|
php
|
|
sta (DST),y
|
|
iny
|
|
cpy #4
|
|
bne -
|
|
plp
|
|
rts
|
|
|
|
;; Xor SRC into DST. Burns a,y.
|
|
xor32:
|
|
ldy #3
|
|
- lda (SRC),y
|
|
eor (DST),y
|
|
sta (DST),y
|
|
dey
|
|
bpl -
|
|
rts
|
|
|
|
;; Copy DST to SRC. Burns a,y.
|
|
cp32:
|
|
ldy #3
|
|
- lda (SRC),y
|
|
sta (DST),y
|
|
dey
|
|
bpl -
|
|
rts
|
|
|
|
add32:
|
|
clc
|
|
ldy #3
|
|
- lda (SRC),y
|
|
adc (DST),y
|
|
sta (DST),y
|
|
dey
|
|
bpl -
|
|
rts
|
|
|
|
and32:
|
|
clc
|
|
ldy #3
|
|
- lda (SRC),y
|
|
and (DST),y
|
|
sta (DST),y
|
|
dey
|
|
bpl -
|
|
rts
|
|
|
|
or32:
|
|
clc
|
|
ldy #3
|
|
- lda (SRC),y
|
|
ora (DST),y
|
|
sta (DST),y
|
|
dey
|
|
bpl -
|
|
rts
|
|
|
|
;; Rotate DST right by 8 bits. Burns a,x,y.
|
|
rol8:
|
|
ldy #0
|
|
lda (DST),y
|
|
tax
|
|
- iny
|
|
lda (DST),y
|
|
dey
|
|
sta (DST),y
|
|
iny
|
|
cpy #3
|
|
bne -
|
|
txa
|
|
sta (DST),y
|
|
rts
|
|
|
|
!eof
|
|
TODOs
|
|
[X] Routine to print n hex bytes (address, length (byte))
|
|
[X] Routine to get the next 16 values (64 bytes) of input
|
|
[X] Routine to get w[i] one i at a time, and rebuild next 16 values
|
|
|
|
Needed arithmetic routines for sha1sum:
|
|
- [X] add32
|
|
- [X] and32
|
|
- [X] or32
|
|
- [X] xor32
|
|
- [X] ROL1
|
|
- [X] ROR1
|
|
- [X] ROL5 --> ROL8, (ROR1,ROR1,ROR1)
|
|
- [X] ROL30 --> (ROR1,ROR1)
|