792 lines
25 KiB
Text
792 lines
25 KiB
Text
/* ARM assembly AARCH64 Raspberry PI 3B */
|
|
/* program adfgvx64.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 this file see task include a file in language AArch64 assembly*/
|
|
.include "../includeConstantesARM64.inc"
|
|
|
|
.equ SIZE, 6
|
|
.equ SIZEC, SIZE * SIZE
|
|
.equ KEYSIZE, 9
|
|
.equ FSTAT, 80
|
|
.equ O_RDWR, 0x0002 // open for reading and writing
|
|
|
|
/*******************************************/
|
|
/* Structures **/
|
|
/*******************************************/
|
|
/* structure de type stat 64 bits : infos fichier */
|
|
.struct 0
|
|
Stat_dev_t: // ID of device containing file
|
|
.struct Stat_dev_t + 8
|
|
Stat_ino_t: // inode
|
|
.struct Stat_ino_t + 4
|
|
Stat_mode_t: // File type and mode
|
|
.struct Stat_mode_t + 4
|
|
Stat_nlink_t: // Number of hard links
|
|
.struct Stat_nlink_t + 4
|
|
Stat_uid_t: // User ID of owner
|
|
.struct Stat_uid_t + 8
|
|
Stat_gid_t: // Group ID of owner
|
|
.struct Stat_gid_t + 8
|
|
Stat_rdev_t: // Device ID (if special file)
|
|
.struct Stat_rdev_t + 8
|
|
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 64 bits start.\n"
|
|
szCarriageReturn: .asciz "\n"
|
|
.align 4
|
|
|
|
qGraine: .quad 1234567 // random init
|
|
|
|
/*********************************/
|
|
/* UnInitialized data */
|
|
/*********************************/
|
|
.bss
|
|
sKeyWord: .skip 16
|
|
sKeyWordSorted: .skip 16
|
|
tabPolybius: .skip SIZE * SIZE + 4
|
|
sBuffer: .skip 1000
|
|
sBuffex1: .skip 1000
|
|
sBuffex2: .skip 1000
|
|
tabPosit: .skip 16
|
|
tabPositInv: .skip 16
|
|
/*********************************/
|
|
/* code section */
|
|
/*********************************/
|
|
.text
|
|
.global main
|
|
main: // entry of program
|
|
ldr x0,qAdrszMessStart
|
|
bl affichageMess
|
|
bl createPolybius // create 6*6 polybius
|
|
|
|
ldr x0,qAdrsKeyWord
|
|
bl generateKey // generate key
|
|
cmp x0,#-1 // file error ?
|
|
beq 100f
|
|
bl affichageMess // display key
|
|
ldr x0,qAdrszCarriageReturn
|
|
bl affichageMess
|
|
|
|
ldr x0,qAdrszMessCryptText
|
|
bl affichageMess
|
|
ldr x0,qAdrszText // text encrypt
|
|
ldr x1,qAdrtabPolybius
|
|
ldr x2,qAdrsKeyWord
|
|
ldr x3,qAdrsBuffer // result buffer
|
|
bl encryption
|
|
cmp x0,#-1 // error if unknow character in text
|
|
beq 100f
|
|
bl affichageMess // display text encrypted
|
|
ldr x0,qAdrszCarriageReturn
|
|
bl affichageMess
|
|
ldr x0,qAdrszCarriageReturn
|
|
bl affichageMess
|
|
|
|
ldr x0,qAdrszMessDecryptText
|
|
bl affichageMess
|
|
ldr x0,qAdrsBuffer // text decrypt
|
|
ldr x1,qAdrtabPolybius
|
|
ldr x2,qAdrsKeyWord
|
|
ldr x3,qAdrsBuffex1 // result buffer
|
|
bl decryption
|
|
bl affichageMess
|
|
ldr x0,qAdrszCarriageReturn
|
|
bl affichageMess
|
|
|
|
100: // standard end of the program
|
|
mov x0, #0 // return code
|
|
mov x8, #EXIT // request to exit program
|
|
svc #0 // perform the system call
|
|
|
|
qAdrszCarriageReturn: .quad szCarriageReturn
|
|
qAdrszMessDecryptText: .quad szMessDecryptText
|
|
qAdrszMessCryptText: .quad szMessCryptText
|
|
qAdrszMessStart: .quad szMessStart
|
|
qAdrsKeyWord: .quad sKeyWord
|
|
qAdrszText: .quad szText
|
|
/***************************************************/
|
|
/* create 6 * 6 polybius */
|
|
/***************************************************/
|
|
createPolybius:
|
|
stp x1,lr,[sp,-16]! // save registers
|
|
stp x2,x3,[sp,-16]!
|
|
stp x4,x5,[sp,-16]!
|
|
ldr x0,qAdrszListChar // character list address
|
|
mov x1,#LGLISTCHAR // character list size
|
|
ldr x2,qAdrtabPolybius
|
|
bl shufflestrings // shuffle list
|
|
ldr x0,qAdrszMessPolybius
|
|
bl affichageMess
|
|
ldr x0,qAdrszTitle // display polybius lines
|
|
bl affichageMess
|
|
ldr x0,qAdrszLine1
|
|
mov x3,#0
|
|
mov x4,#4
|
|
1:
|
|
ldrb w1,[x2,x3]
|
|
strb w1,[x0,x4]
|
|
add x4,x4,#2
|
|
add x3,x3,#1
|
|
cmp x3,#SIZE
|
|
blt 1b
|
|
bl affichageMess
|
|
ldr x0,qAdrszLine2
|
|
mov x3,#SIZE
|
|
mov x4,#4
|
|
2:
|
|
ldrb w1,[x2,x3]
|
|
strb w1,[x0,x4]
|
|
add x4,x4,#2
|
|
add x3,x3,#1
|
|
cmp x3,#SIZE * 2
|
|
blt 2b
|
|
bl affichageMess
|
|
ldr x0,qAdrszLine3
|
|
mov x3,#SIZE * 2
|
|
mov x4,#4
|
|
3:
|
|
ldrb w1,[x2,x3]
|
|
strb w1,[x0,x4]
|
|
add x4,x4,#2
|
|
add x3,x3,#1
|
|
cmp x3,#SIZE * 3
|
|
blt 3b
|
|
bl affichageMess
|
|
ldr x0,qAdrszLine4
|
|
mov x3,#SIZE * 3
|
|
mov x4,#4
|
|
4:
|
|
ldrb w1,[x2,x3]
|
|
strb w1,[x0,x4]
|
|
add x4,x4,#2
|
|
add x3,x3,#1
|
|
cmp x3,#SIZE * 4
|
|
blt 4b
|
|
bl affichageMess
|
|
ldr x0,qAdrszLine5
|
|
mov x3,#SIZE * 4
|
|
mov x4,#4
|
|
5:
|
|
ldrb w1,[x2,x3]
|
|
strb w1,[x0,x4]
|
|
add x4,x4,#2
|
|
add x3,x3,#1
|
|
cmp x3,#SIZE * 5
|
|
blt 5b
|
|
bl affichageMess
|
|
ldr x0,qAdrszLine6
|
|
mov x3,#SIZE * 5
|
|
mov x4,#4
|
|
6:
|
|
ldrb w1,[x2,x3]
|
|
strb w1,[x0,x4]
|
|
add x4,x4,#2
|
|
add x3,x3,#1
|
|
cmp x3,#SIZE * 6
|
|
blt 6b
|
|
bl affichageMess
|
|
|
|
100:
|
|
ldp x4,x5,[sp],16
|
|
ldp x2,x3,[sp],16
|
|
ldp x1,lr,[sp],16
|
|
ret
|
|
qAdrszListChar: .quad szListChar
|
|
qAdrtabPolybius: .quad tabPolybius
|
|
qAdrszMessPolybius: .quad szMessPolybius
|
|
qAdrszTitle: .quad szTitle
|
|
qAdrszLine1: .quad szLine1
|
|
qAdrszLine2: .quad szLine2
|
|
qAdrszLine3: .quad szLine3
|
|
qAdrszLine4: .quad szLine4
|
|
qAdrszLine5: .quad szLine5
|
|
qAdrszLine6: .quad szLine6
|
|
/***************************************************/
|
|
/* generate key word */
|
|
/***************************************************/
|
|
/* x0 key word address */
|
|
generateKey:
|
|
stp x1,lr,[sp,-16]!
|
|
stp x2,x3,[sp,-16]!
|
|
stp x4,x5,[sp,-16]!
|
|
stp x6,x7,[sp,-16]!
|
|
stp x8,x9,[sp,-16]!
|
|
stp x10,x11,[sp,-16]!
|
|
stp x12,x13,[sp,-16]!
|
|
mov x9,x0
|
|
mov x0,AT_FDCWD
|
|
ldr x1,qAdrszFileName // file name
|
|
mov x2,#O_RDWR // flags
|
|
mov x3,#0 // mode
|
|
mov x8,#OPEN // file open
|
|
svc 0
|
|
cmp x0,#0 // error ?
|
|
ble 99f
|
|
mov x11,x0 // FD save
|
|
ldr x1,qAdrsBuffer // buffer address
|
|
mov x8, #FSTAT // call systeme NEWFSTAT
|
|
svc 0
|
|
cmp x0,#0
|
|
blt 98f
|
|
// load file size
|
|
ldr x1,qAdrsBuffer // buffer address
|
|
ldr w6,[x1,#Stat_size_t] // file size
|
|
//ldr w6,[x1,mbox_data_size]
|
|
lsr x12,x6,#5 // align size to multiple 16 for stack alignement
|
|
lsl x12,x12,#5
|
|
add x12,x12,#32 // add for great buffer
|
|
sub sp,sp,x12 // reserve buffer on stack
|
|
mov fp,sp // address save
|
|
mov x0,x11
|
|
mov x1,fp
|
|
mov x2,x12
|
|
mov x8,#READ // call system read file
|
|
svc 0
|
|
cmp x0,#0 // error read ?
|
|
blt 97f
|
|
mov x0,x11
|
|
mov x8,#CLOSE // call system close file
|
|
svc 0
|
|
cmp x0,#0 // error close ?
|
|
blt 96f
|
|
sub sp,sp,#0x1000 // create array word address on stack
|
|
mov x10,sp // save address array
|
|
mov x1,#0
|
|
mov x2,fp
|
|
mov x5,#0 // index word ok
|
|
mov x3,#0 // word length
|
|
1:
|
|
ldrb w4,[fp,x1] // load character
|
|
cmp w4,#0x0D // end word ?
|
|
beq 2f // yes
|
|
add x1,x1,#1
|
|
add x3,x3,#1
|
|
b 1b
|
|
2:
|
|
cmp x3,#KEYSIZE // word length = key length ?
|
|
bne 3f // no ?
|
|
mov x0,x2
|
|
bl wordControl // contril if all letters are différent ?
|
|
cmp x0,#1
|
|
bne 3f
|
|
str x2,[x10,x5,lsl #3] // if ok store word address in array on stack
|
|
add x5,x5,#1 // increment word counter
|
|
3:
|
|
add x1,x1,#2
|
|
cmp x1,x6 // end ?
|
|
beq 4f
|
|
add x2,fp,x1 // new word begin
|
|
mov x3,#0 // init word length
|
|
b 1b // and loop
|
|
4:
|
|
mov x0,x5 // number random to total words
|
|
bl genereraleas
|
|
ldr x2,[x10,x0,lsl #3] // load address word
|
|
mov x1,#0
|
|
5: // copy random word in word result
|
|
ldrb w3,[x2,x1]
|
|
strb w3,[x9,x1]
|
|
add x1,x1,#1
|
|
cmp x1,#KEYSIZE
|
|
blt 5b
|
|
strb wzr,[x9,x1] // zero final
|
|
mov x0,x9
|
|
b 100f
|
|
// display errors
|
|
96:
|
|
ldr x0,qAdrszMessClose
|
|
bl affichageMess
|
|
mov x0,#-1 // error
|
|
b 100f
|
|
97:
|
|
ldr x0,qAdrszMessRead
|
|
bl affichageMess
|
|
mov x0,#-1 // error
|
|
b 100f
|
|
98:
|
|
ldr x0,qAdrszMessStat
|
|
bl affichageMess
|
|
mov x0,#-1 // error
|
|
b 101f
|
|
99:
|
|
ldr x0,qAdrszMessOpen
|
|
bl affichageMess
|
|
mov x0,#-1 // error
|
|
b 101f
|
|
100:
|
|
add sp,sp,x12
|
|
add sp,sp,#0x1000
|
|
101:
|
|
ldp x12,x13,[sp],16
|
|
ldp x10,x11,[sp],16
|
|
ldp x8,x9,[sp],16
|
|
ldp x6,x7,[sp],16
|
|
ldp x4,x5,[sp],16
|
|
ldp x2,x3,[sp],16
|
|
ldp x1,lr,[sp],16
|
|
ret
|
|
qAdrszFileName: .quad szFileName
|
|
qAdrszMessOpen: .quad szMessOpen
|
|
qAdrszMessRead: .quad szMessRead
|
|
qAdrszMessStat: .quad szMessStat
|
|
qAdrszMessClose: .quad szMessClose
|
|
qAdrsBuffer: .quad sBuffer
|
|
/******************************************************************/
|
|
/* control if letters are diferents */
|
|
/******************************************************************/
|
|
/* x0 contains the address of the string */
|
|
/* x0 return 1 if Ok else return 0 */
|
|
wordControl:
|
|
stp x1,lr,[sp,-16]!
|
|
stp x2,x3,[sp,-16]!
|
|
stp x4,x5,[sp,-16]!
|
|
mov x1,#0 // init index 1
|
|
1:
|
|
ldrb w3,[x0,x1] // load one character
|
|
cmp x3,#0x0D // end word ?
|
|
mov x5,#1
|
|
csel x0,x5,x0,eq // yes is ok
|
|
//moveq x0,#1 // yes is ok
|
|
beq 100f // -> end
|
|
add x2,x1,#1 // init index two
|
|
2:
|
|
ldrb w4,[x0,x2] // load one character
|
|
cmp w4,#0x0D // end word ?
|
|
add x5,x1,1
|
|
csel x1,x5,x1,eq // yes increment index 1
|
|
beq 1b // and loop1
|
|
cmp x3,x4 // caracters equals ?
|
|
csel x0,xzr,x0,eq // yes is not good
|
|
beq 100f // and end
|
|
add x2,x2,#1 // else increment index 2
|
|
b 2b // and loop 2
|
|
100:
|
|
ldp x4,x5,[sp],16
|
|
ldp x2,x3,[sp],16
|
|
ldp x1,lr,[sp],16
|
|
ret
|
|
/******************************************************************/
|
|
/* key sort by insertion sort */
|
|
/******************************************************************/
|
|
/* x0 contains the address of String */
|
|
/* x1 contains the first element */
|
|
/* x2 contains the number of element */
|
|
/* x3 contains result address */
|
|
keySort:
|
|
stp x1,lr,[sp,-16]!
|
|
stp x2,x3,[sp,-16]!
|
|
stp x4,x5,[sp,-16]!
|
|
stp x6,x7,[sp,-16]!
|
|
stp x8,x9,[sp,-16]!
|
|
stp x10,x11,[sp,-16]!
|
|
ldr x7,qAdrtabPosit
|
|
mov x10,x3
|
|
mov x3,#0
|
|
0: // init position array and copy key
|
|
strb w3,[x7,x3] // in result array
|
|
ldrb w4,[x0,x3]
|
|
strb w4,[x10,x3]
|
|
add x3,x3,#1
|
|
cmp x3,#KEYSIZE
|
|
blt 0b
|
|
|
|
add x3,x1,#1 // start index i
|
|
1: // start loop
|
|
ldrb w4,[x10,x3] // load value A[i]
|
|
ldrb w8,[x7,x3] // load position
|
|
sub x5,x3,#1 // index j
|
|
2:
|
|
ldrb w6,[x10,x5] // load value A[j]
|
|
ldrb w9,[x7,x5] // load position
|
|
cmp x6,x4 // compare value
|
|
ble 3f
|
|
add x5,x5,#1 // increment index j
|
|
strb w6,[x10,x5] // store value A[j+1]
|
|
strb w9,[x7,x5] // store position
|
|
subs x5,x5,#2 // j = j - 1
|
|
bge 2b // loop if j >= 0
|
|
3:
|
|
add x5,x5,#1 // increment index j
|
|
strb w4,[x10,x5] // store value A[i] in A[j+1]
|
|
strb w8,[x7,x5]
|
|
add x3,x3,#1 // increment index i
|
|
cmp x3,x2 // end ?
|
|
blt 1b // no -> loop
|
|
|
|
ldr x1,qAdrtabPositInv // inverse position
|
|
mov x2,#0 // index
|
|
4:
|
|
ldrb w3,[x7,x2] // load position index
|
|
strb w2,[x1,x3] // store index in position
|
|
add x2,x2,#1 // increment index
|
|
cmp x2,#KEYSIZE // end ?
|
|
blt 4b
|
|
mov x0,x10
|
|
100:
|
|
ldp x10,x11,[sp],16
|
|
ldp x8,x9,[sp],16
|
|
ldp x6,x7,[sp],16
|
|
ldp x4,x5,[sp],16
|
|
ldp x2,x3,[sp],16
|
|
ldp x1,lr,[sp],16 // TODO: retaur à completer
|
|
ret
|
|
qAdrtabPosit: .quad tabPosit
|
|
qAdrtabPositInv: .quad tabPositInv
|
|
/******************************************************************/
|
|
/* text encryption */
|
|
/******************************************************************/
|
|
/* x0 contains the address of text */
|
|
/* x1 contains polybius address
|
|
/* x2 contains the key address */
|
|
/* x3 contains result buffer address */
|
|
encryption:
|
|
stp x1,lr,[sp,-16]!
|
|
stp x2,x3,[sp,-16]!
|
|
stp x4,x5,[sp,-16]!
|
|
stp x6,x7,[sp,-16]!
|
|
stp x8,x9,[sp,-16]!
|
|
stp x10,x11,[sp,-16]!
|
|
mov x9,x0 // save text address
|
|
mov x8,x3
|
|
mov x10,x1 // save address polybius
|
|
mov x0,x2 // key address
|
|
mov x1,#0 // first character
|
|
mov x2,#KEYSIZE // key length
|
|
ldr x3,qAdrsKeyWordSorted // result address
|
|
bl keySort // sort leters of key
|
|
// bl affichageMess // if you want display sorted key
|
|
// ldr x0,qAdrszCarriageReturn
|
|
// bl affichageMess
|
|
ldr x3,qAdrsBuffex1
|
|
mov x5,#0 // init text index
|
|
mov x4,#0 // init result index
|
|
1:
|
|
ldrb w0,[x9,x5] // load a byte to text
|
|
cmp x0,#0 // end ?
|
|
beq 4f
|
|
mov x6,#0 // init index polybius
|
|
2:
|
|
ldrb w7,[x10,x6] // load character polybius
|
|
cmp x7,x0 // equal ?
|
|
beq 3f
|
|
add x6,x6,#1 // increment index
|
|
cmp x6,#SIZEC // not find -> error
|
|
bge 99f
|
|
b 2b // and loop
|
|
3:
|
|
mov x0,x6
|
|
bl convPosCode // convert position in code character
|
|
strb w0,[x3,x4] // line code character
|
|
add x4,x4,#1
|
|
strb w1,[x3,x4] // column code character
|
|
add x4,x4,#1
|
|
|
|
add x5,x5,#1 // increment text index
|
|
b 1b
|
|
4:
|
|
mov x0,#0 // zero final -> text result
|
|
strb w0,[x3,x4]
|
|
mov x5,x3
|
|
mov x1,#0 // index position column
|
|
mov x7,#0 // index text
|
|
ldr x2,qAdrtabPositInv
|
|
5:
|
|
ldrb w0,[x2,x1] // load position text
|
|
7: // loop to characters transposition
|
|
|
|
ldrb w6,[x5,x0] // load character
|
|
strb w6,[x8,x7] // store position final
|
|
add x7,x7,#1 // increment final index
|
|
add x0,x0,#KEYSIZE // add size key
|
|
cmp x0,x4 // end ?
|
|
blt 7b
|
|
add x1,x1,#1 // add index column
|
|
cmp x1,#KEYSIZE // < key size
|
|
blt 5b // yes -> loop
|
|
|
|
mov x6,#0 // zero final
|
|
strb w6,[x8,x7]
|
|
mov x0,x8 // return address encrypted text
|
|
|
|
b 100f
|
|
99: // display error
|
|
ldr x0,qAdrszMessErrorChar
|
|
bl affichageMess
|
|
mov x0,#-1
|
|
100:
|
|
ldp x10,x11,[sp],16
|
|
ldp x8,x9,[sp],16
|
|
ldp x6,x7,[sp],16
|
|
ldp x4,x5,[sp],16
|
|
ldp x2,x3,[sp],16
|
|
ldp x1,lr,[sp],16
|
|
ret
|
|
qAdrsBuffex1: .quad sBuffex1
|
|
qAdrsKeyWordSorted: .quad sKeyWordSorted
|
|
qAdrszMessErrorChar: .quad szMessErrorChar
|
|
/******************************************************************/
|
|
/* text decryption */
|
|
/******************************************************************/
|
|
/* x0 contains the address of text */
|
|
/* x1 contains polybius address
|
|
/* x2 contains the key */
|
|
/* x3 contains result buffer */
|
|
/* x0 return decoded text */
|
|
decryption:
|
|
stp x1,lr,[sp,-16]!
|
|
stp x2,x3,[sp,-16]!
|
|
stp x4,x5,[sp,-16]!
|
|
stp x6,x7,[sp,-16]!
|
|
stp x8,x9,[sp,-16]!
|
|
stp x10,x11,[sp,-16]!
|
|
stp x12,x13,[sp,-16]!
|
|
mov x4,#0
|
|
1: // compute text length
|
|
ldrb w5,[x0,x4]
|
|
cmp x5,#0
|
|
add x11,x4,1
|
|
csel x4,x11,x4,ne
|
|
bne 1b
|
|
mov x12,x0
|
|
mov x11,x1
|
|
mov x10,x2
|
|
mov x13,x3
|
|
// compute line number and remainder
|
|
mov x1,#KEYSIZE // compute line number and remainder
|
|
udiv x8,x4,x1 // line number
|
|
msub x7,x8,x1,x4 // remainder characters last line
|
|
mov x0,x10 // key address
|
|
mov x1,#0 // first character
|
|
mov x2,#KEYSIZE // size
|
|
ldr x3,qAdrsKeyWordSorted // result address
|
|
bl keySort // sort key
|
|
ldr x10,qAdrtabPositInv // inverse position
|
|
mov x2,#0 // index colonne tabposit
|
|
mov x5,#0 // text index
|
|
mov x0,#0 // index line store text
|
|
mov x1,#0 // counter line
|
|
|
|
ldr x9,qAdrsBuffex2
|
|
1:
|
|
ldrb w3,[x10,x2] // load position
|
|
ldrb w6,[x12,x5] // load text character
|
|
add x3,x3,x0 // compute position with index line
|
|
strb w6,[x9,x3] // store character in good position
|
|
|
|
add x5,x5,#1 // increment index text
|
|
cmp x5,x4 // end ?
|
|
bge 4f
|
|
add x1,x1,#1 // increment line
|
|
cmp x1,x8 // line < line size
|
|
blt 2f
|
|
bgt 11f // line = line size
|
|
sub x3,x3,x0 // restaure position column
|
|
cmp x3,x7 // position < remainder so add character other line
|
|
blt 2f
|
|
11:
|
|
mov x1,#0 // init ligne
|
|
mov x0,#0 // init line shift
|
|
add x2,x2,#1 // increment index array position inverse
|
|
cmp x2,#KEYSIZE // end ?
|
|
csel x2,xzr,x2,ge // init index
|
|
b 3f
|
|
2:
|
|
add x0,x0,#KEYSIZE
|
|
3:
|
|
b 1b
|
|
4: // convertir characters with polybius
|
|
mov x3,#0
|
|
mov x5,#0
|
|
|
|
5:
|
|
mov x0,x11
|
|
ldrb w1,[x9,x3] // load a first character
|
|
add x3,x3,#1
|
|
ldrb w2,[x9,x3] // load a 2ieme character
|
|
bl decodPosCode // decode
|
|
strb w0,[x13,x5] // store result in final result
|
|
add x5,x5,#1 // increment final result index
|
|
add x3,x3,#1 // increment index text
|
|
cmp x3,x4 // end ?
|
|
blt 5b
|
|
mov x0,#0 // final zero
|
|
strb w0,[x13,x5]
|
|
mov x0,x13 // return final result address
|
|
100:
|
|
ldp x12,x13,[sp],16
|
|
ldp x10,x11,[sp],16
|
|
ldp x8,x9,[sp],16
|
|
ldp x6,x7,[sp],16
|
|
ldp x4,x5,[sp],16
|
|
ldp x2,x3,[sp],16
|
|
ldp x1,lr,[sp],16 // TODO: retaur à completer
|
|
ret
|
|
qAdrsBuffex2: .quad sBuffex2
|
|
/******************************************************************/
|
|
/* convertir position en code */
|
|
/******************************************************************/
|
|
/* x0 contains the position in polybius */
|
|
/* x0 return code1 */
|
|
/* x1 return code2 */
|
|
convPosCode:
|
|
stp x2,lr,[sp,-16]!
|
|
stp x3,x4,[sp,-16]!
|
|
ldr x4,qAdrszListCharCode
|
|
mov x1,#SIZE
|
|
udiv x2,x0,x1
|
|
msub x3,x2,x1,x0
|
|
//bl division
|
|
ldrb w0,[x4,x2]
|
|
ldrb w1,[x4,x3]
|
|
100:
|
|
ldp x3,x4,[sp],16
|
|
ldp x2,lr,[sp],16
|
|
ret
|
|
qAdrszListCharCode: .quad szListCharCode
|
|
/******************************************************************/
|
|
/* convertir code en character */
|
|
/******************************************************************/
|
|
/* x0 polybius address */
|
|
/* x1 code 1 */
|
|
/* x2 code 2 */
|
|
/* x0 return character */
|
|
decodPosCode:
|
|
stp x1,lr,[sp,-16]!
|
|
stp x2,x3,[sp,-16]!
|
|
stp x4,x5,[sp,-16]!
|
|
ldr x4,qAdrszListCharCode
|
|
mov x3,#0
|
|
1:
|
|
ldrb w5,[x4,x3]
|
|
cmp x5,#0
|
|
beq 2f
|
|
cmp x5,x1
|
|
csel x1,x3,x1,eq
|
|
cmp x5,x2
|
|
csel x2,x3,x2,eq
|
|
add x3,x3,#1
|
|
b 1b
|
|
2:
|
|
mov x5,#SIZE
|
|
mul x1,x5,x1
|
|
add x1,x1,x2
|
|
ldrb w0,[x0,x1]
|
|
100:
|
|
ldp x4,x5,[sp],16
|
|
ldp x2,x3,[sp],16
|
|
ldp x1,lr,[sp],16
|
|
ret
|
|
|
|
/******************************************************************/
|
|
/* shuffle strings algorithme Fisher-Yates */
|
|
/******************************************************************/
|
|
/* x0 contains the address of the string */
|
|
/* x1 contains string length */
|
|
/* x2 contains address result string */
|
|
shufflestrings:
|
|
stp x1,lr,[sp,-16]! // TODO: save à completer
|
|
stp x2,x3,[sp,-16]!
|
|
stp x4,x5,[sp,-16]!
|
|
mov x3,#0
|
|
1: // loop copy string in result
|
|
ldrb w4,[x0,x3]
|
|
strb w4,[x2,x3]
|
|
add x3,x3,#1
|
|
cmp x3,x1
|
|
ble 1b
|
|
sub x1,x1,#1 // last element
|
|
2:
|
|
mov x0,x1
|
|
bl genereraleas // call random
|
|
ldrb w4,[x2,x1] // load byte string index loop
|
|
ldrb w3,[x2,x0] // load byte string random index
|
|
strb w3,[x2,x1] // and exchange
|
|
strb w4,[x2,x0]
|
|
subs x1,x1,#1
|
|
cmp x1,#1
|
|
bge 2b
|
|
|
|
100:
|
|
ldp x4,x5,[sp],16
|
|
ldp x2,x3,[sp],16
|
|
ldp x1,lr,[sp],16
|
|
ret
|
|
|
|
/***************************************************/
|
|
/* Generation random number */
|
|
/***************************************************/
|
|
/* x0 contains limit */
|
|
genereraleas:
|
|
stp x1,lr,[sp,-16]! // save registers
|
|
stp x2,x3,[sp,-16]! // save registers
|
|
ldr x1,qAdrqGraine
|
|
ldr x2,[x1]
|
|
ldr x3,qNbDep1
|
|
mul x2,x3,x2
|
|
ldr x3,qNbDep2
|
|
add x2,x2,x3
|
|
str x2,[x1] // maj de la graine pour l appel suivant
|
|
cmp x0,#0
|
|
beq 100f
|
|
udiv x3,x2,x0
|
|
msub x0,x3,x0,x2 // résult = remainder
|
|
|
|
100: // end function
|
|
ldp x2,x3,[sp],16 // restaur 2 registers
|
|
ldp x1,lr,[sp],16 // restaur 2 registers
|
|
ret // return to address lr x30
|
|
qAdrqGraine: .quad qGraine
|
|
qNbDep1: .quad 0x0019660d
|
|
qNbDep2: .quad 0x3c6ef35f
|
|
|
|
/***************************************************/
|
|
/* ROUTINES INCLUDE */
|
|
/***************************************************/
|
|
.include "../includeARM64.inc"
|