View source for Frecon code: sha.pal

<pre>
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SHA256 Routines for Frecon
% Author: Mark R. Bannister
% Date: 19/Dec/2017
%
% Provides routines for calculating SHA-256 checksums
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
~Module
EQUS {[frecon]}

~square_prime
EQUD { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
       0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 }

~cube_prime
EQUD { 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
       0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
       0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
       0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
       0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
       0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
       0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
       0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
       0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
       0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
       0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
       0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
       0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
       0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
       0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
       0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 }

._init
attr/load       P0, [psString], P1, [psPointer]
func/def        [sha256], &[.sha256], P0, P1, [file]
func/def        [sha256_convert], &[.sha256_convert], P0, P0, [bin]
error/def	[BadFileObject], [Argument is not a file object]
local/rtn

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Calculate SHA-256 checksum of given file object
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
.sha256
var/addr	P10, [file]
attr/addr	P10, P10, [psPointer]

%
% Check that this is a psFile object and that
% it has the psStatUnix class
%
class/load	P8, [psStatUnix]
class/test	P10, [psFile], P8
reg/jmplt	&[.bad_file], SFLG, #2
ne: class/add	P10, P8

%
% Only possible for regular files
%
attr/index	A, P10, [statMode]
opa/and		#0170000
reg/jmpeq	&[.init_hash], A, #0100000

reg/copy	P10, []
reg/save	P10, (#64)
func/rtn	P10

.init_hash
%
% Initialise hash values h0 to h7 (P0-P7) from square_prime data segment
%
attr/load	P8, [psIndex]
reg/load	P12, (&[~square_prime])
reg/load	P0, (P12)
reg/load	P1, (P12)
reg/load	P2, (P12)
reg/load	P3, (P12)
reg/load	P4, (P12)
reg/load	P5, (P12)
reg/load	P6, (P12)
reg/load	P7, (P12)

%
% Initialise array k from cube_prime data segment
%
mtx/local	P14, P8, [w], #64
mtx/local	P15, P8, [k], #64
reg/clr		A
reg/load	P12, (&[~cube_prime])

.init_loop
reg/load	P13, (P12)
reg/jmpeq	&[.read_file], P13, NULL
mtx/set		P15, A, P13
op/incr
reg/jmplt	&[.init_loop], A, #64

.read_file
%
% Process file in 512-bit chunks
%
obj/edit	P10, P10
class/add	P10, [psStreamOpen]
attr/add	P10, [psStreamMode], [r],
		     [psStreamBufferSize], #1048576,    % buffer in 1MB blocks
		     [psStreamReadSize], #64
obj/commitref	P10, P10
attr/load	P11, [psByteStream]
attr/def        P8, [psInteger], #0     % length of original message in bits

.process
reg/jmpne	&[.read_next], P8, NULL % read from file if not reached EOF
reg/jmpeq	&[.digest], PEEK, LOCK	% finished, compute digest
stack/pull	P12			% pull last chunk from stack
local/jmp	&[.process_chunk]

.read_next
%
% Read next 512 bits from input file
%
attr/copy	P12, P10, P11
reg/jmpeq	&[.append_bits_eof], P12, NULL
reg/xload	P13, (P12)
op/mult		PUSH, P13, #8          % convert to number of bits
opx/add         P8, P8, PULL           % add onto message length counter
reg/jmplt	&[.append_bits], P13, #64

.process_chunk
%
% Copy first 16 words into work array w
% At this point, register P12 will contain exactly 512 bits of data
%
reg/clr		A
reg/load	P13, A
.copy16
reg/load	PUSH, (P12, A)         % read 32 bits at offset A, push to stack
mtx/set		P14, P13, PULL         % store in w[0..15]
opa/add		#4                     % increment A by 32 bits
op/incr		P13                    % increment array index
reg/jmplt	&[.copy16], P13, #16   % continue while array index < 16

%
% Extend first 16 words into remaining 48 words of the work array
%
.extend                                % for i (P13) from 16 to 63
reg/load	A, P13
opa/sub		#15
mtx/get		P9, P14, A             % w[i-15]
attr/index	P9, P9                 % convert XVALUE to raw index
op/ror		PUSH, P9, #7           % rightrotate 7, push to stack
op/ror		PUSH, P9, #18          % rightrotate 18, push to stack
op/shr		PUSH, P9, #3           % rightshift 3, push to stack
op/xor		PUSH, PULL, PULL, PULL % xor top 3 items on stack and push back

reg/load	A, P13
opa/sub		#2
mtx/get		P9, P14, A             % w[i-2]
attr/index	P9, P9                 % convert XVALUE to raw index
op/ror		PUSH, P9, #17          % rightrotate 17, push to stack
op/ror		PUSH, P9, #19          % rightrotate 19, push to stack
op/shr		PUSH, P9, #10          % rightshift 10, push to stack
op/xor		PUSH, PULL, PULL, PULL % xor top 3 items on stack and push back

reg/load	A, P13
opa/sub		#16
mtx/get		P9, P14, A             % w[i-16]
attr/index	PUSH, P9               % convert XVALUE to raw index and push

reg/load	A, P13
opa/sub		#7
mtx/get		P9, P14, A             % w[i-7]
attr/index	PUSH, P9               % convert XVALUE to raw index and push

op/add		PUSH, PULL, PULL, PULL, PULL
mtx/set		P14, P13, PULL         % w[i] = sum of top 4 items on stack

op/incr		P13
reg/jmplt	&[.extend], P13, #64   % loop while i < 64

%
% Save current hash value
%
reg/load	PUSH, P7, PUSH, P6, PUSH, P5, PUSH, P4,
		PUSH, P3, PUSH, P2, PUSH, P1, PUSH, P0

%
% Compression loop
%
stack/push	P10                    % save P10
reg/clr		A
.compress
op/ror		PUSH, P4, #6           % e rightrotate 6, push to stack
op/ror		PUSH, P4, #11          % e rightrotate 11, push to stack
op/ror		PUSH, P4, #25          % e rightrotate 25, push to stack
op/xor		PUSH, PULL, PULL, PULL % xor top 3 items on stack and push back
op/and		PUSH, P4, P5           % e and f
op/not		PUSH, P4               % not e
op/and		PUSH, PULL, P6         % and g
op/xor		PUSH, PULL, PULL       % xor top 2 items on stack and push back
mtx/get		PUSH, P15, A           % k[i]
attr/index	PUSH, PULL             % convert XVALUE to raw index
mtx/get		PUSH, P14, A           % w[i]
attr/index	PUSH, PULL             % convert XVALUE to raw index
op/add		P9, P7, PULL, PULL,    % temp1 (P9) = sum of h with top
                    PULL, PULL         %              4 items on stack

op/ror		PUSH, P0, #2           % a rightrotate 2
op/ror		PUSH, P0, #13          % a rightrotate 13
op/ror		PUSH, P0, #22          % a rightrotate 22
op/xor		PUSH, PULL, PULL, PULL % xor top 3 items on stack and push back
op/and		PUSH, P0, P1           % a and b
op/and		PUSH, P0, P2           % a and c
op/and		PUSH, P1, P2           % b and c
op/xor		PUSH, PULL, PULL, PULL % xor top 3 items on stack and push back
op/add		P10, PULL, PULL        % temp2 (P10) = sum of top 2 stack items

reg/roll	#-1, #8                % roll registers P0-P7 right
op/add		P0, P9, P10            % a = temp1 + temp2
op/add		P4, P4, P9             % e += temp1

op/incr
reg/jmplt	&[.compress], A, #64   % loop while i < 64

stack/pull	P10                    % restore register P10

%
% Add the compressed chunk to the current hash value pushed on stack earlier
%
op/add		P0, P0, PULL
op/add		P1, P1, PULL
op/add		P2, P2, PULL
op/add		P3, P3, PULL
op/add		P4, P4, PULL
op/add		P5, P5, PULL
op/add		P6, P6, PULL
op/add		P7, P7, PULL

local/jmp	&[.process]

.append_bits_eof
%
% Reached EOF with no new data, we now require 0x80
% followed by 55 null bytes then the length of the
% original message as a 64-bit big endian integer
%
reg/copy	P12, []
reg/save	P12, (#64)		% set-up new zeroed 512-bit chunk
reg/save	P12, (#0x80000000, #0)	% set the first bit

.end_chunk
attr/export	PUSH, P8, #9		% export data size in bits as big endian
reg/copy	PUSH, (PULL, #1)	% discard the sign byte
reg/save	P12, (PULL, #56)	% write to end of 512-bit chunk
reg/load	P8, NULL		% set P8 to NULL to indicate last chunk
local/jmp	&[.process_chunk]

.append_bits
%
% Reached final chunk of file which is less than 512 bits
%
% If there are at least 9 bytes remaining before the end of the chunk
% then we write 0x80 ... null bytes ... 64-bit integer (message length)
% and finish, otherwise we write 0x80 ... null bytes ... and go round again
%
reg/save	P12, (#64)		% expand current chunk to 512 bits
reg/save	P12, (#0x80000000, P13) % set the first bit of the expansion
reg/jmple	&[.end_chunk], P13, #55 % last chunk to process

.two_more_chunks
attr/export	PUSH, P8, #64		% push 2nd chunk to stack for later
reg/load	P8, NULL		% set P8 to NULL to indicate last chunk
local/jmp	&[.process_chunk]

.digest
%
% Generate the final hash value
%
reg/copy	P8, []
reg/save	P8, (#32)

reg/save	P8, (P0, #0x00)
reg/save	P8, (P1, #0x04)
reg/save	P8, (P2, #0x08)
reg/save	P8, (P3, #0x0c)
reg/save	P8, (P4, #0x10)
reg/save	P8, (P5, #0x14)
reg/save	P8, (P6, #0x18)
reg/save	P8, (P7, #0x1c)
func/rtn	P8

.bad_file
error/now	![.prose.error.frecon.BadFileObject]

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Convert SHA-256 in binary format to a hexadecimal string
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
.sha256_convert
var/addr        P0, [bin]
attr/copy       P0, P0, [psString]
reg/copy        P1, []
reg/save        P1, (#64)
attr/load       P15, [psIndex]
reg/clr         A

.convert_loop
reg/copy        P2, (P0, A, #4)
attr/import     P3, P15, P2
attr/index      P3, P3
reg/conv        P3, P3, #16
op/shl          P4, A, #1
reg/save        P1, (P3, P4)
opa/add         #4
reg/jmplt       &[.convert_loop], A, #32
func/rtn        P1
</pre>