716 lines
23 KiB
Plaintext
716 lines
23 KiB
Plaintext
/* ARM assembly Raspberry PI */
|
|
/* program adfgvx.s */
|
|
/* remark 1 : At each launch, the random values are identical.
|
|
To change them, modify the value of the seed (graine) */
|
|
/* remark 2 : this program not run in android with termux
|
|
because the call system stats is not find */
|
|
|
|
/************************************/
|
|
/* Constantes */
|
|
/************************************/
|
|
/* for constantes see task include a file in arm assembly */
|
|
.include "../constantes.inc"
|
|
|
|
.equ SIZE, 6
|
|
.equ SIZEC, SIZE * SIZE
|
|
.equ KEYSIZE, 9
|
|
.equ READ, 3
|
|
.equ WRITE, 4
|
|
.equ OPEN, 5
|
|
.equ CLOSE, 6
|
|
.equ FSTAT, 0x6C
|
|
.equ O_RDWR, 0x0002 @ open for reading and writing
|
|
|
|
/**********************************************/
|
|
/* structure de type stat : infos fichier */
|
|
/**********************************************/
|
|
.struct 0
|
|
Stat_dev_t: @ ID of device containing file
|
|
.struct Stat_dev_t + 4
|
|
Stat_ino_t: @ inode
|
|
.struct Stat_ino_t + 2
|
|
Stat_mode_t: @ File type and mode
|
|
.struct Stat_mode_t + 2
|
|
Stat_nlink_t: @ Number of hard links
|
|
.struct Stat_nlink_t + 2
|
|
Stat_uid_t: @ User ID of owner
|
|
.struct Stat_uid_t + 2
|
|
Stat_gid_t: @ Group ID of owner
|
|
.struct Stat_gid_t + 2
|
|
Stat_rdev_t: @ Device ID (if special file)
|
|
.struct Stat_rdev_t + 2
|
|
Stat_size_deb: @ la taille est sur 8 octets si gros fichiers
|
|
.struct Stat_size_deb + 4
|
|
Stat_size_t: @ Total size, in bytes
|
|
.struct Stat_size_t + 4
|
|
Stat_blksize_t: @ Block size for filesystem I/O
|
|
.struct Stat_blksize_t + 4
|
|
Stat_blkcnt_t: @ Number of 512B blocks allocated
|
|
.struct Stat_blkcnt_t + 4
|
|
Stat_atime: @ date et heure fichier
|
|
.struct Stat_atime + 8
|
|
Stat_mtime: @ date et heure modif fichier
|
|
.struct Stat_atime + 8
|
|
Stat_ctime: @ date et heure creation fichier
|
|
.struct Stat_atime + 8
|
|
Stat_Fin:
|
|
|
|
/*********************************/
|
|
/* Initialized data */
|
|
/*********************************/
|
|
.data
|
|
szText: .asciz "ATTACKAT1200AM"
|
|
//szText: .asciz "ABCDEFGHIJ"
|
|
szMessOpen: .asciz "File open error.\n"
|
|
szMessStat: .asciz "File information error.\n"
|
|
szMessRead: .asciz "File read error.\n"
|
|
szMessClose: .asciz "File close error.\n"
|
|
szMessDecryptText: .asciz "Decrypted text :\n"
|
|
szMessCryptText: .asciz "Encrypted text :\n"
|
|
szMessErrorChar: .asciz "Character text not Ok!\n"
|
|
szFileName: .asciz "unixdict.txt"
|
|
szMessPolybius: .asciz "6 x 6 Polybius square:\n"
|
|
szTitle: .asciz " | A D F G V X\n---------------\n"
|
|
szLine1: .asciz "A | \n"
|
|
szLine2: .asciz "D | \n"
|
|
szLine3: .asciz "F | \n"
|
|
szLine4: .asciz "G | \n"
|
|
szLine5: .asciz "V | \n"
|
|
szLine6: .asciz "X | \n"
|
|
szListCharCode: .asciz "ADFGVX"
|
|
szListChar: .asciz "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
|
|
.equ LGLISTCHAR, . - szListChar - 1
|
|
szMessStart: .asciz "Program 32 bits start.\n"
|
|
szCarriageReturn: .asciz "\n"
|
|
.align 4
|
|
|
|
iGraine: .int 1234567 // random init
|
|
|
|
/*********************************/
|
|
/* UnInitialized data */
|
|
/*********************************/
|
|
.bss
|
|
sKeyWord: .skip 16
|
|
sKeyWordSorted: .skip 16
|
|
tabPolybius: .skip SIZE * SIZE + 4
|
|
sBuffer: .skip 1000
|
|
sBuffer1: .skip 1000
|
|
sBuffer2: .skip 1000
|
|
tabPosit: .skip 16
|
|
tabPositInv: .skip 16
|
|
/*********************************/
|
|
/* code section */
|
|
/*********************************/
|
|
.text
|
|
.global main
|
|
main: @ entry of program
|
|
ldr r0,iAdrszMessStart
|
|
bl affichageMess
|
|
bl createPolybius @ create 6*6 polybius
|
|
|
|
ldr r0,iAdrsKeyWord
|
|
bl generateKey @ generate key
|
|
cmp r0,#-1 @ file error ?
|
|
beq 100f
|
|
bl affichageMess @ display key
|
|
ldr r0,iAdrszCarriageReturn
|
|
bl affichageMess
|
|
|
|
ldr r0,iAdrszMessCryptText
|
|
bl affichageMess
|
|
ldr r0,iAdrszText @ text encrypt
|
|
ldr r1,iAdrtabPolybius
|
|
ldr r2,iAdrsKeyWord
|
|
ldr r3,iAdrsBuffer @ result buffer
|
|
bl encryption
|
|
cmp r0,#-1 @ error if unknow character in text
|
|
beq 100f
|
|
bl affichageMess @ display text encrypted
|
|
ldr r0,iAdrszCarriageReturn
|
|
bl affichageMess
|
|
ldr r0,iAdrszCarriageReturn
|
|
bl affichageMess
|
|
|
|
ldr r0,iAdrszMessDecryptText
|
|
bl affichageMess
|
|
ldr r0,iAdrsBuffer @ text decrypt
|
|
ldr r1,iAdrtabPolybius
|
|
ldr r2,iAdrsKeyWord
|
|
ldr r3,iAdrsBuffer1 @ result buffer
|
|
bl decryption
|
|
bl affichageMess
|
|
ldr r0,iAdrszCarriageReturn
|
|
bl affichageMess
|
|
|
|
100: @ standard end of the program
|
|
mov r0, #0 @ return code
|
|
mov r7, #EXIT @ request to exit program
|
|
svc #0 @ perform the system call
|
|
|
|
iAdrszCarriageReturn: .int szCarriageReturn
|
|
iAdrszMessDecryptText: .int szMessDecryptText
|
|
iAdrszMessCryptText: .int szMessCryptText
|
|
iAdrszMessStart: .int szMessStart
|
|
iAdrsKeyWord: .int sKeyWord
|
|
iAdrszText: .int szText
|
|
/***************************************************/
|
|
/* create 6 * 6 polybius */
|
|
/***************************************************/
|
|
createPolybius:
|
|
push {r1-r4,lr} @ save des registres
|
|
ldr r0,iAdrszListChar @ character list address
|
|
mov r1,#LGLISTCHAR @ character list size
|
|
ldr r2,iAdrtabPolybius
|
|
bl shufflestrings @ shuffle list
|
|
ldr r0,iAdrszMessPolybius
|
|
bl affichageMess
|
|
ldr r0,iAdrszTitle @ display polybius lines
|
|
bl affichageMess
|
|
ldr r0,iAdrszLine1
|
|
mov r3,#0
|
|
mov r4,#4
|
|
1:
|
|
ldrb r1,[r2,r3]
|
|
strb r1,[r0,r4]
|
|
add r4,r4,#2
|
|
add r3,r3,#1
|
|
cmp r3,#SIZE
|
|
blt 1b
|
|
bl affichageMess
|
|
ldr r0,iAdrszLine2
|
|
mov r3,#SIZE
|
|
mov r4,#4
|
|
2:
|
|
ldrb r1,[r2,r3]
|
|
strb r1,[r0,r4]
|
|
add r4,r4,#2
|
|
add r3,r3,#1
|
|
cmp r3,#SIZE * 2
|
|
blt 2b
|
|
bl affichageMess
|
|
ldr r0,iAdrszLine3
|
|
mov r3,#SIZE * 2
|
|
mov r4,#4
|
|
3:
|
|
ldrb r1,[r2,r3]
|
|
strb r1,[r0,r4]
|
|
add r4,r4,#2
|
|
add r3,r3,#1
|
|
cmp r3,#SIZE * 3
|
|
blt 3b
|
|
bl affichageMess
|
|
ldr r0,iAdrszLine4
|
|
mov r3,#SIZE * 3
|
|
mov r4,#4
|
|
4:
|
|
ldrb r1,[r2,r3]
|
|
strb r1,[r0,r4]
|
|
add r4,r4,#2
|
|
add r3,r3,#1
|
|
cmp r3,#SIZE * 4
|
|
blt 4b
|
|
bl affichageMess
|
|
ldr r0,iAdrszLine5
|
|
mov r3,#SIZE * 4
|
|
mov r4,#4
|
|
5:
|
|
ldrb r1,[r2,r3]
|
|
strb r1,[r0,r4]
|
|
add r4,r4,#2
|
|
add r3,r3,#1
|
|
cmp r3,#SIZE * 5
|
|
blt 5b
|
|
bl affichageMess
|
|
ldr r0,iAdrszLine6
|
|
mov r3,#SIZE * 5
|
|
mov r4,#4
|
|
6:
|
|
ldrb r1,[r2,r3]
|
|
strb r1,[r0,r4]
|
|
add r4,r4,#2
|
|
add r3,r3,#1
|
|
cmp r3,#SIZE * 6
|
|
blt 6b
|
|
bl affichageMess
|
|
|
|
100:
|
|
pop {r1-r4,pc}
|
|
iAdrszListChar: .int szListChar
|
|
iAdrtabPolybius: .int tabPolybius
|
|
iAdrszMessPolybius: .int szMessPolybius
|
|
iAdrszTitle: .int szTitle
|
|
iAdrszLine1: .int szLine1
|
|
iAdrszLine2: .int szLine2
|
|
iAdrszLine3: .int szLine3
|
|
iAdrszLine4: .int szLine4
|
|
iAdrszLine5: .int szLine5
|
|
iAdrszLine6: .int szLine6
|
|
/***************************************************/
|
|
/* generate key word */
|
|
/***************************************************/
|
|
/* r0 key word address */
|
|
generateKey:
|
|
push {r1-r12,lr} @ save registers
|
|
mov r9,r0
|
|
ldr r0,iAdrszFileName @ file name
|
|
mov r1,#O_RDWR @ flags
|
|
mov r2,#0 @ mode
|
|
mov r7,#OPEN @ file open
|
|
svc 0
|
|
cmp r0,#0 @ error ?
|
|
ble 99f
|
|
mov r8,r0 @ FD save
|
|
ldr r1,iAdrsBuffer @ buffer address
|
|
mov r7, #FSTAT @ call systeme NEWFSTAT
|
|
svc 0
|
|
cmp r0,#0
|
|
blt 98f
|
|
@ load file size
|
|
ldr r1,iAdrsBuffer @ buffer address
|
|
ldr r6,[r1,#Stat_size_t] @ file size
|
|
lsr r12,r6,#3 @ align size to multiple 4
|
|
lsl r12,#3
|
|
add r12,#8 @ add for great buffer
|
|
sub sp,sp,r12 @ reserve buffer on stack
|
|
mov fp,sp @ address save
|
|
mov r0,r8
|
|
mov r1,fp
|
|
mov r2,r12
|
|
mov r7,#READ @ call system read file
|
|
svc 0
|
|
cmp r0,#0 @ error read ?
|
|
blt 97f
|
|
mov r0,r8
|
|
mov r7,#CLOSE @ call system close file
|
|
svc 0
|
|
cmp r0,#0 @ error close ?
|
|
blt 96f
|
|
sub sp,sp,#0x1000 @ create array word address on stack
|
|
mov r10,sp @ save address array
|
|
mov r1,#0
|
|
mov r2,fp
|
|
mov r5,#0 @ index word ok
|
|
mov r3,#0 @ word length
|
|
1:
|
|
ldrb r4,[fp,r1] @ load character
|
|
cmp r4,#0x0D @ end word ?
|
|
beq 2f @ yes
|
|
add r1,r1,#1
|
|
add r3,r3,#1
|
|
b 1b
|
|
2:
|
|
cmp r3,#KEYSIZE @ word length = key length ?
|
|
bne 3f @ no ?
|
|
mov r0,r2
|
|
bl wordControl @ contril if all letters are différent ?
|
|
cmp r0,#1
|
|
streq r2,[r10,r5,lsl #2] @ if ok store word address in array on stack
|
|
addeq r5,r5,#1 @ increment word counter
|
|
3:
|
|
add r1,r1,#2
|
|
cmp r1,r6 @ end ?
|
|
beq 4f
|
|
add r2,fp,r1 @ new word begin
|
|
mov r3,#0 @ init word length
|
|
b 1b @ and loop
|
|
4:
|
|
mov r0,r5 @ number random to total words
|
|
bl genereraleas
|
|
ldr r2,[r10,r0,lsl #2] @ load address word
|
|
mov r1,#0
|
|
5: @ copy random word in word result
|
|
ldrb r3,[r2,r1]
|
|
strb r3,[r9,r1]
|
|
add r1,r1,#1
|
|
cmp r1,#KEYSIZE
|
|
blt 5b
|
|
mov r3,#0 @ zero final
|
|
strb r3,[r9,r1]
|
|
mov r0,r9
|
|
b 100f
|
|
@ display errors
|
|
96:
|
|
ldr r0,iAdrszMessClose
|
|
bl affichageMess
|
|
mov r0,#-1 @ error
|
|
b 100f
|
|
97:
|
|
ldr r0,iAdrszMessRead
|
|
bl affichageMess
|
|
mov r0,#-1 @ error
|
|
b 100f
|
|
98:
|
|
ldr r0,iAdrszMessStat
|
|
bl affichageMess
|
|
mov r0,#-1 @ error
|
|
b 101f
|
|
99:
|
|
ldr r0,iAdrszMessOpen
|
|
bl affichageMess
|
|
mov r0,#-1 @ error
|
|
b 101f
|
|
100:
|
|
add sp,sp,r12
|
|
add sp,sp,#0x1000
|
|
101:
|
|
pop {r1-r12,pc}
|
|
iAdrszFileName: .int szFileName
|
|
iAdrszMessOpen: .int szMessOpen
|
|
iAdrszMessRead: .int szMessRead
|
|
iAdrszMessStat: .int szMessStat
|
|
iAdrszMessClose: .int szMessClose
|
|
iAdrsBuffer: .int sBuffer
|
|
/******************************************************************/
|
|
/* control if letters are diferents */
|
|
/******************************************************************/
|
|
/* r0 contains the address of the string */
|
|
/* r0 return 1 if Ok else return 0 */
|
|
wordControl:
|
|
push {r1-r4,lr} @ save registers
|
|
mov r1,#0 @ init index 1
|
|
1:
|
|
ldrb r3,[r0,r1] @ load one character
|
|
cmp r3,#0x0D @ end word ?
|
|
moveq r0,#1 @ yes is ok
|
|
beq 100f @ -> end
|
|
add r2,r1,#1 @ init index two
|
|
2:
|
|
ldrb r4,[r0,r2] @ load one character
|
|
cmp r4,#0x0D @ end word ?
|
|
addeq r1,r1,#1 @ yes increment index 1
|
|
beq 1b @ and loop1
|
|
cmp r3,r4 @ caracters equals ?
|
|
moveq r0,#0 @ yes is not good
|
|
beq 100f @ and end
|
|
add r2,r2,#1 @ else increment index 2
|
|
b 2b @ and loop 2
|
|
100:
|
|
pop {r1-r4,pc}
|
|
/******************************************************************/
|
|
/* key sort by insertion sort */
|
|
/******************************************************************/
|
|
/* r0 contains the address of String */
|
|
/* r1 contains the first element */
|
|
/* r2 contains the number of element */
|
|
/* r3 contains result address */
|
|
keySort:
|
|
push {r2-r10,lr} @ save registers
|
|
ldr r7,iAdrtabPosit
|
|
mov r10,r3
|
|
mov r3,#0
|
|
0: @ init position array and copy key
|
|
strb r3,[r7,r3] @ in result array
|
|
ldrb r4,[r0,r3]
|
|
strb r4,[r10,r3]
|
|
add r3,r3,#1
|
|
cmp r3,#KEYSIZE
|
|
blt 0b
|
|
|
|
add r3,r1,#1 @ start index i
|
|
1: @ start loop
|
|
ldrb r4,[r10,r3] @ load value A[i]
|
|
ldrb r8,[r7,r3] @ load position
|
|
sub r5,r3,#1 @ index j
|
|
2:
|
|
ldrb r6,[r10,r5] @ load value A[j]
|
|
ldrb r9,[r7,r5] @ load position
|
|
cmp r6,r4 @ compare value
|
|
ble 3f
|
|
add r5,#1 @ increment index j
|
|
strb r6,[r10,r5] @ store value A[j+1]
|
|
strb r9,[r7,r5] @ store position
|
|
subs r5,#2 @ j = j - 1
|
|
bge 2b @ loop if j >= 0
|
|
3:
|
|
add r5,#1 @ increment index j
|
|
strb r4,[r10,r5] @ store value A[i] in A[j+1]
|
|
strb r8,[r7,r5]
|
|
add r3,#1 @ increment index i
|
|
cmp r3,r2 @ end ?
|
|
blt 1b @ no -> loop
|
|
|
|
ldr r1,iAdrtabPositInv @ inverse position
|
|
mov r2,#0 @ index
|
|
4:
|
|
ldrb r3,[r7,r2] @ load position index
|
|
strb r2,[r1,r3] @ store index in position
|
|
add r2,r2,#1 @ increment index
|
|
cmp r2,#KEYSIZE @ end ?
|
|
blt 4b
|
|
mov r0,r10
|
|
100:
|
|
pop {r2-r10,pc}
|
|
iAdrtabPosit: .int tabPosit
|
|
iAdrtabPositInv: .int tabPositInv
|
|
/******************************************************************/
|
|
/* text encryption */
|
|
/******************************************************************/
|
|
/* r0 contains the address of text */
|
|
/* r1 contains polybius address
|
|
/* r2 contains the key address */
|
|
/* r3 contains result buffer address */
|
|
encryption:
|
|
push {r2-r10,lr} @ save registers
|
|
mov r9,r0 @ save text address
|
|
mov r8,r3
|
|
mov r10,r1 @ save address polybius
|
|
mov r0,r2 @ key address
|
|
mov r1,#0 @ first character
|
|
mov r2,#KEYSIZE @ key length
|
|
ldr r3,iAdrsKeyWordSorted @ result address
|
|
bl keySort @ sort leters of key
|
|
//bl affichageMess @ if you want display sorted key
|
|
//ldr r0,iAdrszCarriageReturn
|
|
//bl affichageMess
|
|
ldr r3,iAdrsBuffer1
|
|
mov r5,#0 @ init text index
|
|
mov r4,#0 @ init result index
|
|
1:
|
|
ldrb r0,[r9,r5] @ load a byte to text
|
|
cmp r0,#0 @ end ?
|
|
beq 4f
|
|
mov r6,#0 @ init index polybius
|
|
2:
|
|
ldrb r7,[r10,r6] @ load character polybius
|
|
cmp r7,r0 @ equal ?
|
|
beq 3f
|
|
add r6,r6,#1 @ increment index
|
|
cmp r6,#SIZEC @ not find -> error
|
|
bge 99f
|
|
b 2b @ and loop
|
|
3:
|
|
mov r0,r6
|
|
bl convPosCode @ convert position in code character
|
|
strb r0,[r3,r4] @ line code character
|
|
add r4,r4,#1
|
|
strb r1,[r3,r4] @ column code character
|
|
add r4,r4,#1
|
|
|
|
add r5,r5,#1 @ increment text index
|
|
b 1b
|
|
4:
|
|
mov r0,#0 @ zero final -> text result
|
|
strb r0,[r3,r4]
|
|
mov r5,r3
|
|
mov r1,#0 @ index position column
|
|
mov r7,#0 @ index text
|
|
ldr r2,iAdrtabPositInv
|
|
5:
|
|
ldrb r0,[r2,r1] @ load position text
|
|
7: @ loop to characters transposition
|
|
|
|
ldrb r6,[r5,r0] @ load character
|
|
strb r6,[r8,r7] @ store position final
|
|
add r7,r7,#1 @ increment final index
|
|
add r0,r0,#KEYSIZE @ add size key
|
|
cmp r0,r4 @ end ?
|
|
blt 7b
|
|
add r1,r1,#1 @ add index column
|
|
cmp r1,#KEYSIZE @ < key size
|
|
blt 5b @ yes -> loop
|
|
|
|
mov r6,#0 @ zero final
|
|
strb r6,[r8,r7]
|
|
mov r0,r8 @ return address encrypted text
|
|
|
|
b 100f
|
|
99: @ display error
|
|
ldr r0,iAdrszMessErrorChar
|
|
bl affichageMess
|
|
mov r0,#-1
|
|
100:
|
|
pop {r2-r10,pc}
|
|
iAdrsBuffer1: .int sBuffer1
|
|
iAdrsKeyWordSorted: .int sKeyWordSorted
|
|
iAdrszMessErrorChar: .int szMessErrorChar
|
|
/******************************************************************/
|
|
/* text decryption */
|
|
/******************************************************************/
|
|
/* r0 contains the address of text */
|
|
/* r1 contains polybius address
|
|
/* r2 contains the key */
|
|
/* r3 contains result buffer */
|
|
/* r0 return decoded text */
|
|
decryption:
|
|
push {r1-r12,lr} @ save registers
|
|
mov r4,#0
|
|
1: @ compute text length
|
|
ldrb r5,[r0,r4]
|
|
cmp r5,#0
|
|
addne r4,r4,#1
|
|
bne 1b
|
|
mov r12,r0
|
|
mov r11,r1
|
|
mov r10,r2
|
|
mov r9,r3
|
|
mov r0,r4 @ compute line number and remainder
|
|
mov r1,#KEYSIZE
|
|
bl division
|
|
mov r8,r2 @ line number
|
|
mov r7,r3 @ remainder characters last line
|
|
mov r0,r10 @ key address
|
|
mov r1,#0 @ first character
|
|
mov r2,#KEYSIZE @ size
|
|
ldr r3,iAdrsKeyWordSorted @ result address
|
|
bl keySort @ sort key
|
|
ldr r10,iAdrtabPositInv @ inverse position
|
|
mov r2,#0 @ index colonne tabposit
|
|
mov r5,#0 @ text index
|
|
mov r0,#0 @ index line store text
|
|
mov r1,#0 @ counter line
|
|
push {r9} @ save final result address
|
|
ldr r9,iAdrsBuffer2
|
|
1:
|
|
ldrb r3,[r10,r2] @ load position
|
|
ldrb r6,[r12,r5] @ load text character
|
|
add r3,r3,r0 @ compute position with index line
|
|
strb r6,[r9,r3] @ store character in good position
|
|
|
|
add r5,r5,#1 @ increment index text
|
|
cmp r5,r4 @ end ?
|
|
bge 4f
|
|
add r1,r1,#1 @ increment line
|
|
cmp r1,r8 @ line < line size
|
|
blt 2f
|
|
bgt 11f @ line = line size
|
|
sub r3,r3,r0 @ restaure position column
|
|
cmp r3,r7 @ position < remainder so add character other line
|
|
blt 2f
|
|
11:
|
|
mov r1,#0 @ init ligne
|
|
mov r0,#0 @ init line shift
|
|
add r2,r2,#1 @ increment index array position inverse
|
|
cmp r2,#KEYSIZE @ end ?
|
|
movge r2,#0 @ init index
|
|
b 3f
|
|
2:
|
|
add r0,#KEYSIZE
|
|
3:
|
|
b 1b
|
|
4: @ convertir characters with polybius
|
|
mov r3,#0
|
|
mov r5,#0
|
|
pop {r6} @ restaur final address result
|
|
5:
|
|
mov r0,r11
|
|
ldrb r1,[r9,r3] @ load a first character
|
|
add r3,r3,#1
|
|
ldrb r2,[r9,r3] @ load a 2ieme character
|
|
bl decodPosCode @ decode
|
|
strb r0,[r6,r5] @ store result in final result
|
|
add r5,r5,#1 @ increment final result index
|
|
add r3,r3,#1 @ increment index text
|
|
cmp r3,r4 @ end ?
|
|
blt 5b
|
|
mov r0,#0 @ final zero
|
|
strb r0,[r6,r5]
|
|
mov r0,r6 @ return final result address
|
|
100:
|
|
pop {r1-r12,pc}
|
|
iAdrsBuffer2: .int sBuffer2
|
|
/******************************************************************/
|
|
/* convertir position en code */
|
|
/******************************************************************/
|
|
/* r0 contains the position in polybius */
|
|
/* r0 return code1 */
|
|
/* r1 return code2 */
|
|
convPosCode:
|
|
push {r2-r4,lr} @ save registers
|
|
ldr r4,iAdrszListCharCode
|
|
mov r1,#SIZE
|
|
bl division
|
|
ldrb r0,[r4,r2]
|
|
ldrb r1,[r4,r3]
|
|
100:
|
|
pop {r2-r4,pc}
|
|
iAdrszListCharCode: .int szListCharCode
|
|
/******************************************************************/
|
|
/* convertir code en character */
|
|
/******************************************************************/
|
|
/* r0 polybius address */
|
|
/* r1 code 1 */
|
|
/* r2 code 2 */
|
|
/* r0 return character */
|
|
decodPosCode:
|
|
push {r1-r5,lr} @ save registers
|
|
ldr r4,iAdrszListCharCode
|
|
mov r3,#0
|
|
1:
|
|
ldrb r5,[r4,r3]
|
|
cmp r5,#0
|
|
beq 2f
|
|
cmp r5,r1
|
|
moveq r1,r3
|
|
cmp r5,r2
|
|
moveq r2,r3
|
|
add r3,r3,#1
|
|
b 1b
|
|
2:
|
|
mov r5,#SIZE
|
|
mul r1,r5,r1
|
|
add r1,r1,r2
|
|
ldrb r0,[r0,r1]
|
|
100:
|
|
pop {r1-r5,pc}
|
|
|
|
/******************************************************************/
|
|
/* shuffle strings algorithme Fisher-Yates */
|
|
/******************************************************************/
|
|
/* r0 contains the address of the string */
|
|
/* r1 contains string length */
|
|
/* r2 contains address result string */
|
|
shufflestrings:
|
|
push {r1-r4,lr} @ save registers
|
|
mov r3,#0
|
|
1: @ loop copy string in result
|
|
ldrb r4,[r0,r3]
|
|
strb r4,[r2,r3]
|
|
add r3,r3,#1
|
|
cmp r3,r1
|
|
ble 1b
|
|
sub r1,r1,#1 @ last element
|
|
2:
|
|
mov r0,r1 @ limit random number
|
|
bl genereraleas @ call random
|
|
ldrb r4,[r2,r1] @ load byte string index loop
|
|
ldrb r3,[r2,r0] @ load byte string random index
|
|
strb r3,[r2,r1] @ and exchange
|
|
strb r4,[r2,r0]
|
|
subs r1,r1,#1
|
|
cmp r1,#1
|
|
bge 2b
|
|
|
|
100:
|
|
pop {r1-r4,pc} @ restaur registers
|
|
|
|
/***************************************************/
|
|
/* Generation random number */
|
|
/***************************************************/
|
|
/* r0 contains limit */
|
|
genereraleas:
|
|
push {r1-r4,lr} @ save registers
|
|
ldr r4,iAdriGraine
|
|
ldr r2,[r4]
|
|
ldr r3,iNbDep1
|
|
mul r2,r3,r2
|
|
ldr r3,iNbDep1
|
|
add r2,r2,r3
|
|
str r2,[r4] @ save seed for next call
|
|
cmp r0,#0
|
|
beq 100f
|
|
mov r1,r0 @ divisor
|
|
mov r0,r2 @ dividende
|
|
bl division
|
|
mov r0,r3 @ résult = remainder
|
|
|
|
100: @ end function
|
|
pop {r1-r4,pc} @ restaur registers
|
|
iAdriGraine: .int iGraine
|
|
iNbDep1: .int 0x343FD
|
|
iNbDep2: .int 0x269EC3
|
|
|
|
/***************************************************/
|
|
/* ROUTINES INCLUDE */
|
|
/***************************************************/
|
|
.include "../affichage.inc"
|