0votos

Cifrado César en Assembly

por josejuan hace 6 años

¡Que tiempos! XD XD (buena idea nRikee). Cifrado y descifrado para x86_64 en 64bits. También conteo de cadena e impresión de zstrings.

Implementar funciones para el cifrado César (cifrado por desplazamiento, código de César o desplazamiento de César)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
.data 
hw: 
        .string "Todo lo que se preguntaba\0" 
eol: 
        .string "\n\0" 
.text 
.globl _start 
_start: 
 
        movq $hw,%rcx               # la cadena a procesar 
         
        call _putStrLn              # imprimimos la versión original 
 
        movq $3,%rdx                # encriptar césar con 3 desplazamientos 
        call _cesar 
        call _putStrLn              # mostramos encriptada 
 
        movq $-3,%rdx               # desencriptar césar con -3 desplazamientos 
        call _cesar 
        call _putStrLn              # mostramos descrifrada 
 
        movq $1,%rax         # bye! 
        xorq %rbx,%rbx 
        int  $0x80 
 
# ===== encriptar/desencriptar césar ================================== 
_cesar: # ( %rcx [@str], %rdx [offset] ) 
        pushq %rbx 
        pushq %rax 
         
        movq %rcx, %rbx 
_c0: 
        xorq %rax, %rax         # a cero 
        movb (%rbx), %al        # movemos byte 
        test %rax, %rax         # ¿es cero? 
        jz   _c1                #  
        cmpq $0x20, %rax        # ¿es un espacio? 
        je   _c2                #  
        addq %rdx,%rax          # añadimos desplazamiento 
        movb %al, (%rbx)        # y nos quedamos con el lsb (como un N % 255 o un N & 0xff) 
_c2: 
        inc  %rbx 
        jmp  _c0 
_c1: 
 
        popq %rax 
        popq %rbx 
        ret 
 
# ==== putStrLn =================================== 
_putStrLn: # ( %rcx [@str] ) 
        call  _putStr 
        pushq %rcx 
        movq  $eol,%rcx 
        call  _putStr 
        popq  %rcx 
        ret 
         
# ==== putStr ===================================== 
_putStr: # ( %rcx [@str] ) 
        pushq %rcx 
        pushq %rbx 
        pushq %rdx 
        pushq %rax 
         
        movq %rcx, %rbx 
        xorq %rdx, %rdx 
        xorq %rax, %rax 
_l0: 
        movb (%rbx), %al 
        test %rax, %rax 
        jz   _l1 
        inc  %rdx 
        inc  %rbx 
        jmp  _l0 
_l1: 
        movq $4, %rax 
        movq $1, %rbx 
        int  $0x80 
 
        popq %rax 
        popq %rdx 
        popq %rbx 
        popq %rcx 
        ret 
1 comentario
0votos

Escrito por josejuan hace 6 años

¡Ops! compilación y ejecución:

solveet$ gcc -c cesar.s && ld -s -o cesar cesar.o && ./cesar
Todo lo que se preguntaba
Wrgr or txh vh suhjxqwded
Todo lo que se preguntaba
solveet$ _

Comenta la solución

Tienes que identificarte para poder publicar tu comentario.