ADFGVX cipher: Difference between revisions
Content added Content deleted
VincentARM (talk | contribs) (add task to arm assembly raspberry pi) |
VincentARM (talk | contribs) (add task to aarch64 assembly raspberry pi 3) |
||
Line 116: | Line 116: | ||
Decrypted : ATTACKAT1200AM |
Decrypted : ATTACKAT1200AM |
||
</pre> |
|||
=={{header|AArch64 Assembly}}== |
|||
{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> }} |
|||
<syntaxhighlight lang AArch64 Assembly> |
|||
/* 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 |
|||
.include "../../ficmacros64.s" |
|||
/*******************************************/ |
|||
/* 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" |
|||
</syntaxhighlight> |
|||
{{Out}} |
|||
<pre> |
|||
Program 64 bits start. |
|||
6 x 6 Polybius square: |
|||
| A D F G V X |
|||
--------------- |
|||
A | Q A M C 0 X |
|||
D | 1 S O Y R E |
|||
F | H 7 J T U W |
|||
G | V F 3 Z 4 I |
|||
V | 8 B 9 K 6 2 |
|||
X | P D L G 5 N |
|||
hailstorm |
|||
Encrypted text : |
|||
DVXAGVFFGAGAVDDDAAAGFVAGAFDA |
|||
Decrypted text : |
|||
ATTACKAT1200AM |
|||
</pre> |
</pre> |
||
=={{header|ARM Assembly}}== |
=={{header|ARM Assembly}}== |