Bootloader encriptado para Attiny88

[Picuino]

Cuento los avances:

He conseguido enlazar un programa en c para bootloader con las rutinas en ensamblador para decodificar XTEA y para comunicar con UART.
El programa recibe 8 bytes por UART, los guarda en un buffer SRAM, los decodifica y los vuelve a transmitir por UART.

Me interesaba saber cómo sincronizar la memoria entre el C y el ensamblador. Por ahora, para sincronizar los programas he utilizado  direcciones absolutas a partir de la 0x100 en ensamblador para salvar el valor de los registros. Supongo que el linker utilizará las primeras posiciones de memoria SRAM y no se solaparán
También utilizo un puntero para acceder a los datos del buffer.

Más adelante programaré todo en ensamblador y no tendré el problema de salvar registros ni el de sincronizar RAM.

Por último he utilizado el programa en Python para codificar un texto y enviarlo por la UART. A continuación recibe el mensaje de vuelta del microcontrolador y lo imprime.


El primer programa ha funcionado, pero el mensaje decodificado no se entiende.
Creo que puede ser un problema de el endianess entre Python y el microcontrolador. Voy a seguir depurando hasta que funcione.

Un saludo.

[Picuino]

a ver si esto te sirve
http://www.groupes.polymtl.ca/inf1995/logiciel/progAvr/avr-libc-user-manual-1.8.0.pdf
https://ez.analog.com/thread/10607
http://www.nongnu.org/avr-libc/user-manual/mem_sections.html

El primero lo conozco. Solo habla de ensamblador metido dentro de código c, no en archivos separados.
El segundo creo que es para micros más avanzados.
El tercero también lo conocía. Habla de secciones de memoria, pero no dice cómo reservar.

Yo lo que quiero es muy simple.
Es que el linker se encargue de situar las variables en SRAM para que se sincronicen los códigos C y ensamblador.
Es equivalente a esto del ensamblador de Atmel:

Código: [Seleccionar]

.DSEG
var1:  .BYTE 1      ; reserve 1 byte to var1

Pero que sirva para el ensamblador de GNU:

Código: [Seleccionar]

.data
?????

Un saludo.

[KILLERJC]

.comm

Syntax: .comm symbol, length

.comm declares a common symbol named symbol. When linking, a common symbol in one object file may be merged with a defined or common symbol of the same name in another object file. If ld does not see a definition for the symbol - just one or more common symbols - then it will allocate length bytes of uninitialized memory. length must be an absolute expression. If ld sees multiple common symbols with the same name, and they do not all have the same size, it will allocate space using the largest size.

y

.lcomm

Syntax: .lcomm symbol, length

Reserve length (an absolute expression) bytes for a local common denoted by symbol. The section and value of symbol are those of the new local common. The addresses are allocated in the bss section, so that at run-time the bytes start off zeroed. Symbol is not declared global (see .global), so is normally not visible to ld.

Normalmente uno lo que haria es:

Código: [Seleccionar]

.global Variable
.bss
Variable: .byte 64
Tambien otra que vi es la de definir el lugar

Código: [Seleccionar]

.global Variable
.bss
Variable:  .space 64
Pero parece que se debe usar .comm el cual permite el paso a C de los datos y lo pone en bss.  Lo que no se es si es necesario poner el .bss antes, y el .comm ya lo declara global para que lo use el linker.

Código: [Seleccionar]

.comm Variable,64(Aunque vi que hablan sobre que esto lo crea en una seccion "common" en algunos otros casos, todo depende del OS que se trate)

o

Código: [Seleccionar]

.global Variable
.lcomm Variable,64(El cual crea la variable en bss, pero por no lo hace global.)


Espero que alguna de estas te de una idea o te sirva. Y ojo que .data es para los datos inicializados, .bss es para datos NO inicializados.

[Picuino]

He probado con:

Código: [Seleccionar]

.data
save_reg:  .byte  20

Y no funciona. Cuando salvo los registros en la zona de memoria 'save_reg' se borra el buffer de datos definido en c.
Se solapan los dos.

Voy a declararlo global a ver si el linker se da por enterado.

Un saludo.

[Picuino]

Falta el icono de "pegarse un tiro"
Llevo horas con esta tontería.
Al final parece que ha funcionado uno de los ejemplos de Killer, añadiendo la sección .data en vez de .bss:

Código: [Seleccionar]

.data
.comm save_reg, 20
Ha pasado la primera prueba y no borra el buffer del c
A ver si sigue funcionando.

Un saludo.

[KILLERJC]

Pero lo feo es que data es inicializado :/... Y no era mi objetivo  . yo quiero no inicializado ! pero si funciona  


No probaste el de .bss y .lcomm ? O directamente .lcomm solo sin invocar .data o .bss ? Creo que es el mas seguro..
Yo por que si no el compilador trataria de inicializarlo a esa variable. Con lo que llevaria mas espacio ocupado para alojar el valor de la variable a inicializar.

Una cosa mas que me causa duda. Como estas probando todo esto ? (si se puede saber obvio)

EDIT:

Aca encontre un ejemplo, no de Attiny pero si de un MSP430 de TI que usa gcc. y usa el .lcomm directamente.
https://gist.github.com/RickKimball/1303030

[Picuino]

He probado con .bss y me daba error.
Con .lcomm no he probado aún.

Estoy probando desde el pc con un programa Python que codifica con XTEA una cadena de texto y la envía al micro por UART.

El micro recibe la cadena, la decodifica con XTEA y la vuelve a enviar. Por último el programa Python recibe la cadena y la muestra.

Todo funciona OK si quito la codificación. Lo que no funciona por ahora es la rutina de decodificación XTEA del microcontrolador.

[KILLERJC]

Puede que sea que la rutina sea distinta en ambos ?

Podrias hacer que te envie los valores intermedios para ver que esta ocurriendo.
Especialmente el de la suma.


Que te envie esos 32 valores para ver si son correctos. o hicimos mal la resta. y luego comprobarlo con el de python.

[Picuino]

Sospecho de la key almacenada en flash. Voy a probarla primero.

El programa en asm es este:

Código: ASM

1. ;
2. ;  XTEA decipher routine
3. ;
4.  
5. ; *******************************************************************
6. ;   DECLARACIONES
7. ; *******************************************************************
8. #include <avr/io.h>
9.  
10. #define  XTEA_ROUNDS  1   // 32
11. #define  DELTA        0x0 // 0x9E3779B9
12.  
13. #define  XTEA_KEY1    0x0 // 0x87654321
14. #define  XTEA_KEY2    0x0 // 0x87654321
15. #define  XTEA_KEY3    0x0 // 0x87654321
16. #define  XTEA_KEY4    0x0 // 0x87654321
17.  
18. #define  DELTA_SUMA   (DELTA*XTEA_ROUNDS)
19.  
20. // Call saved registers
21. #define  data0       r2
22. #define  data1       r3
23. #define  data2       r4
24. #define  data3       r5
25. #define  data4       r6
26. #define  data5       r7
27. #define  data6       r8
28. #define  data7       r9
29. #define  temp0       r10
30. #define  temp1       r11
31. #define  temp2       r12
32. #define  temp3       r13
33. #define  buff0       r14
34. #define  buff1       r15
35.  
36. #define  ZL          r30
37.  
38.  
39. // Free registers
40. #define  rounds      r17
41. #define  suma0       r18
42. #define  suma1       r19
43. #define  suma2       r20
44. #define  suma3       r21
45. #define  r_index     r22
46.  
47. #define  temp4       r24
48. #define  temp5       r25
49. #define  temp6       r26
50. #define  temp7       r27
51.  
52. #define  ZH          r31
53.  
54.  
55. ; *******************************************************************
56. ;   DATOS EN RAM
57. ; *******************************************************************
58. .data
59. .comm save_reg, 20
60.  
61.  
62. ; *******************************************************************
63. ;   PROGRAMA
64. ; *******************************************************************
65. .text
66.  
67. ; xtea_decode
68. ;
69. ; Inputs:
70. ;   data0 ... data7 = 8 bytes of coded data
71. ;
72. ; Outputs:
73. ;   data0 ... data7 = 8 bytes of decoded data
74. ;
75.  
76. .global xtea_decode
77. xtea_decode:
78.  
79.    ; Save registers
80.    rcall  xtea_save_reg
81.  
82.  
83.    ; suma = 0xC6EF3720 = DELTA*32
84.    ldi    suma0, lo8(DELTA_SUMA)
85.    ldi    suma1, hi8(DELTA_SUMA)
86.    ldi    suma2, hlo8(DELTA_SUMA)
87.    ldi    suma3, hhi8(DELTA_SUMA)
88.  
89.  
90.    ; rounds = 64
91.    ldi   rounds, XTEA_ROUNDS*2
92.  
93.  
94.    ; do {
95. xtea_decode_loop:
96.  
97.    ; temp_a = data0
98.    movw  temp0, data0
99.    movw  temp2, data2
100.  
101.    ; temp_b = data0
102.    movw  temp4, data0
103.    movw  temp6, data2
104.  
105.    ; data0 = data1
106.    movw  data0, data4
107.    movw  data2, data6
108.  
109.    ; data1 = temp_a
110.    movw  data4, temp0
111.    movw  data6, temp2
112.  
113.  
114.    ; temp_a <<= 4
115.    ldi   r_index, 4
116. xtea_shift_left:
117.    lsl   temp0
118.    rol   temp1
119.    rol   temp2
120.    rol   temp3
121.    dec   r_index
122.    brne  xtea_shift_left
123.  
124.  
125.    ; temp_b >>= 5
126.    ldi   r_index, 5
127. xtea_shift_right:
128.    lsr   temp0
129.    ror   temp1
130.    ror   temp2
131.    ror   temp3
132.    dec   r_index
133.    brne  xtea_shift_right
134.  
135.  
136.    ; temp_a ^= temp_b
137.    eor   temp0, temp4
138.    eor   temp1, temp5
139.    eor   temp2, temp6
140.    eor   temp3, temp7
141.  
142.  
143.    ; temp_a += data1
144.    add   temp0, data4
145.    adc   temp1, data5
146.    adc   temp2, data6
147.    adc   temp3, data7
148.  
149.  
150.    ; if ((rounds & 1) == 0):
151.    ;    r1 = ((suma>>11) & 3)*4
152.    sbrc  rounds, 0
153.    rjmp  xtea_label_1
154.    mov   r_index, suma1
155.    lsr   r_index
156.    rjmp  xtea_label_2
157.  
158.    ; else:
159.    ;    r1 = (suma & 3)*4
160. xtea_label_1:
161.    mov   r_index, suma0
162.    lsl   r_index
163.    lsl   r_index
164. xtea_label_2:
165.    andi  r_index, 0b00001100
166.  
167.  
168.    ; temp_b = xtea_key[r1*4]
169.    ldi   ZL, lo8(xtea_key_table)
170.    ldi   ZH, hi8(xtea_key_table)
171.    add   ZL, r_index
172.    ldi   r_index, 0
173.    adc   ZH, r_index
174.    lpm   temp4, Z+
175.    lpm   temp5, Z+
176.    lpm   temp6, Z+
177.    lpm   temp7, Z+
178.  
179.  
180.    ; temp_b += suma
181.    add   temp4, suma0
182.    adc   temp5, suma1
183.    adc   temp6, suma2
184.    adc   temp7, suma3
185.  
186.  
187.    ; temp_a ^= temp_b
188.    eor   temp0, temp4
189.    eor   temp1, temp5
190.    eor   temp2, temp6
191.    eor   temp3, temp7
192.  
193.  
194.    ; data0 -= temp_a
195.    sub   data0, temp0
196.    sbc   data1, temp1
197.    sbc   data2, temp2
198.    sbc   data3, temp3
199.  
200.  
201.    ; if ((rounds & 1) == 0):
202.    ;    suma -= 0x9E3779B9
203.    sbrc  rounds, 0
204.    rjmp  xtea_label_3
205.    subi  suma0, lo8(DELTA)
206.    sbci  suma1, hi8(DELTA)
207.    sbci  suma2, hlo8(DELTA)
208.    sbci  suma3, hhi8(DELTA)
209. xtea_label_3:
210.  
211.    ;    rounds -= 1
212.    ; } while(rounds);
213.    dec   rounds
214.    breq  xtea_end_loop
215.    rjmp  xtea_decode_loop
216.  
217. xtea_end_loop:
218.    ; Load registers
219.    rcall  xtea_load_reg
220.    ret
221.  
222.  
223. ; *******************************************************************
224. ;   FUNCIONES DE APOYO
225. ; *******************************************************************
226.  
227.  
228. xtea_save_reg:
229.    ; Save registers in sram
230.    sts    save_reg+1,  data0
231.    sts    save_reg+1,  data1
232.    sts    save_reg+2,  data2
233.    sts    save_reg+3,  data3
234.    sts    save_reg+4,  data4
235.    sts    save_reg+5,  data5
236.    sts    save_reg+6,  data6
237.    sts    save_reg+7,  data7
238.    sts    save_reg+8,  temp0
239.    sts    save_reg+9,  temp1
240.    sts    save_reg+10, temp2
241.    sts    save_reg+11, temp3
242.    sts    save_reg+12, buff0
243.    sts    save_reg+13, buff1
244.    sts    save_reg+14, ZL
245.    sts    save_reg+15, ZH
246.  
247.    movw   buff0, r24
248.    movw   ZL, buff0
249.    ld     data0, Z+
250.    ld     data1, Z+
251.    ld     data2, Z+
252.    ld     data3, Z+
253.    ld     data4, Z+
254.    ld     data5, Z+
255.    ld     data6, Z+
256.    ld     data7, Z+
257.    ret
258.    
259.  
260. xtea_load_reg:
261.  
262.    ; Load registers from sram  
263.    movw   ZL, buff0
264.    st     Z+, data0
265.    st     Z+, data1
266.    st     Z+, data2
267.    st     Z+, data3
268.    st     Z+, data4
269.    st     Z+, data5
270.    st     Z+, data6
271.    st     Z+, data7
272.  
273.    lds    data0, save_reg+1  
274.    lds    data1, save_reg+1  
275.    lds    data2, save_reg+2  
276.    lds    data3, save_reg+3  
277.    lds    data4, save_reg+4  
278.    lds    data5, save_reg+5  
279.    lds    data6, save_reg+6  
280.    lds    data7, save_reg+7
281.    lds    temp0, save_reg+8  
282.    lds    temp1, save_reg+9  
283.    lds    temp2, save_reg+10
284.    lds    temp3, save_reg+11
285.    lds    buff0, save_reg+12
286.    lds    buff1, save_reg+13
287.    lds    ZL,    save_reg+14
288.    lds    ZH,    save_reg+15
289.  
290.    ret
291.  
292.  
293. ; *******************************************************************
294. ;   DATOS EN FLASH
295. ; *******************************************************************
296. xtea_key_table:
297.    .long  XTEA_KEY1
298.    .long  XTEA_KEY2
299.    .long  XTEA_KEY3
300.    .long  XTEA_KEY4

Las rutinas para salvar y restaurar registros son temporales. En la versión final las quitaré

[KILLERJC]

Una pregunta.....

La llave en python lo estas haciendo

0x12345678
0x12345678
0x12345678
0x12345678

De esa forma ?

Si lo guardas en little endian es

0x78563412
y no
0x87654321

Espero que no sea eso xD

Sino en python deberias probar con
0x21436587

[Picuino]

Para evitar problemas de ese tipo he comenzado con una llave = 0 y un delta = 0

La rutina sigue dando errores.

Voy a enviar un dato = 0 y si sigue dando errores, le pongo un ramo a la Virgen de la Candelaria, una vela a San José y me tomo un descanso, porque no sé qué más hacer.

[juaperser1]

Voy a enviar un dato = 0 y si sigue dando errores, le pongo un ramo a la Virgen de la Candelaria, una vela a San José y me tomo un descanso, porque no sé qué más hacer.

te propongo ir a ver al señor roca, y ademas de que te olvides del problema haciendo otras cosas que no ocupen tu cerebro, en cuanto te des cuenta te llegará la inspiración.

a mi me funciona

[Picuino]

Bueno, no ha hecho falta echar mano del santo patrón.
He simplificado al máximo haciendo sólo una ronda con shift y nada más.
Como eso también funcionaba mal, me he dado cuenta de que el shift era lo que fallaba.

Corregido. Ahora mismo envío 8 bytes cifrados al microcontrolador y los recibo descifrados. La rutina XTEA funciona. 

Lo siguiente es implementar un protococo que reciba datos de 8 en 8, los agrupe y los grabe en flash

Un saludo.

[Picuino]

Código: [Seleccionar]

;
;  XTEA decipher routine
;

; *******************************************************************
;   DECLARACIONES
; *******************************************************************
#include <avr/io.h>

#define  XTEA_ROUNDS  32
#define  DELTA        0x9E3779B9

#define  XTEA_KEY1    0x87654321
#define  XTEA_KEY2    0x87654321
#define  XTEA_KEY3    0x87654321
#define  XTEA_KEY4    0x87654321

#define  DELTA_SUMA   (DELTA*XTEA_ROUNDS)

// Call saved registers
#define  data0       r2
#define  data1       r3
#define  data2       r4
#define  data3       r5
#define  data4       r6
#define  data5       r7
#define  data6       r8
#define  data7       r9
#define  temp0       r10
#define  temp1       r11
#define  temp2       r12
#define  temp3       r13
#define  buff0       r14
#define  buff1       r15

#define  ZL          r30


// Free registers
#define  rounds      r17
#define  suma0       r18
#define  suma1       r19
#define  suma2       r20
#define  suma3       r21
#define  r_index     r22

#define  temp4       r24
#define  temp5       r25
#define  temp6       r26
#define  temp7       r27

#define  ZH          r31


; *******************************************************************
;   DATOS EN RAM
; *******************************************************************
.data
.comm save_reg, 20


; *******************************************************************
;   PROGRAMA
; *******************************************************************
.text

; xtea_decode
;
; Inputs:
;   data0 ... data7 = 8 bytes of coded data
;
; Outputs:
;   data0 ... data7 = 8 bytes of decoded data
;

.global xtea_decode
xtea_decode:

   ; Save registers
   rcall  xtea_save_reg


   ; suma = 0xC6EF3720 = DELTA*32
   ldi    suma0, lo8(DELTA_SUMA)
   ldi    suma1, hi8(DELTA_SUMA)
   ldi    suma2, hlo8(DELTA_SUMA)
   ldi    suma3, hhi8(DELTA_SUMA)


   ; rounds = 64
   ldi   rounds, XTEA_ROUNDS*2


   ; do {
xtea_decode_loop:

   ; temp_a = data0
   movw  temp0, data0
   movw  temp2, data2

   ; temp_b = data0
   movw  temp4, data0
   movw  temp6, data2

   ; data0 = data1
   movw  data0, data4
   movw  data2, data6

   ; data1 = temp_a
   movw  data4, temp0
   movw  data6, temp2


   ; temp_a <<= 4
   ldi   r_index, 4
xtea_shift_left:
   lsl   temp0
   rol   temp1
   rol   temp2
   rol   temp3
   dec   r_index
   brne  xtea_shift_left


   ; temp_b >>= 5
   ldi   r_index, 5
xtea_shift_right:
   lsr   temp7
   ror   temp6
   ror   temp5
   ror   temp4
   dec   r_index
   brne  xtea_shift_right


   ; temp_a ^= temp_b
   eor   temp0, temp4
   eor   temp1, temp5
   eor   temp2, temp6
   eor   temp3, temp7


   ; temp_a += data1
   add   temp0, data4
   adc   temp1, data5
   adc   temp2, data6
   adc   temp3, data7


   ; if ((rounds & 1) == 0):
   ;    r1 = ((suma>>11) & 3)*4
   sbrc  rounds, 0
   rjmp  xtea_label_1
   mov   r_index, suma1
   lsr   r_index
   rjmp  xtea_label_2

   ; else:
   ;    r1 = (suma & 3)*4
xtea_label_1:
   mov   r_index, suma0
   lsl   r_index
   lsl   r_index
xtea_label_2:
   andi  r_index, 0x0C


   ; temp_b = xtea_key[r1*4]
   ldi   ZL, lo8(xtea_key_table)
   ldi   ZH, hi8(xtea_key_table)
   add   ZL, r_index
   ldi   r_index, 0
   adc   ZH, r_index
   lpm   temp4, Z+
   lpm   temp5, Z+
   lpm   temp6, Z+
   lpm   temp7, Z+


   ; temp_b += suma
   add   temp4, suma0
   adc   temp5, suma1
   adc   temp6, suma2
   adc   temp7, suma3


   ; temp_a ^= temp_b
   eor   temp0, temp4
   eor   temp1, temp5
   eor   temp2, temp6
   eor   temp3, temp7


   ; data0 -= temp_a
   sub   data0, temp0
   sbc   data1, temp1
   sbc   data2, temp2
   sbc   data3, temp3


   ; if ((rounds & 1) == 0):
   ;    suma -= 0x9E3779B9
   sbrc  rounds, 0
   rjmp  xtea_label_3
   subi  suma0, lo8(DELTA)
   sbci  suma1, hi8(DELTA)
   sbci  suma2, hlo8(DELTA)
   sbci  suma3, hhi8(DELTA)
xtea_label_3:


   ;    rounds -= 1
   ; } while(rounds);
   dec   rounds
   breq  xtea_end_loop
   rjmp  xtea_decode_loop

xtea_end_loop:
   ; Load registers
   rcall  xtea_load_reg
   ret


; *******************************************************************
;   FUNCIONES DE APOYO
; *******************************************************************


xtea_save_reg:
   ; Save registers in sram
   sts    save_reg+1,  data0
   sts    save_reg+1,  data1
   sts    save_reg+2,  data2
   sts    save_reg+3,  data3
   sts    save_reg+4,  data4
   sts    save_reg+5,  data5
   sts    save_reg+6,  data6
   sts    save_reg+7,  data7
   sts    save_reg+8,  temp0
   sts    save_reg+9,  temp1
   sts    save_reg+10, temp2
   sts    save_reg+11, temp3
   sts    save_reg+12, buff0
   sts    save_reg+13, buff1
   sts    save_reg+14, ZL
   sts    save_reg+15, ZH

   movw   buff0, r24
   movw   ZL, buff0
   ld     data0, Z+
   ld     data1, Z+
   ld     data2, Z+
   ld     data3, Z+
   ld     data4, Z+
   ld     data5, Z+
   ld     data6, Z+
   ld     data7, Z+
   ret
   

xtea_load_reg:

   ; Load registers from sram 
   movw   ZL, buff0
   st     Z+, data0
   st     Z+, data1
   st     Z+, data2
   st     Z+, data3
   st     Z+, data4
   st     Z+, data5
   st     Z+, data6
   st     Z+, data7

   lds    data0, save_reg+1 
   lds    data1, save_reg+1 
   lds    data2, save_reg+2 
   lds    data3, save_reg+3 
   lds    data4, save_reg+4 
   lds    data5, save_reg+5 
   lds    data6, save_reg+6 
   lds    data7, save_reg+7
   lds    temp0, save_reg+8 
   lds    temp1, save_reg+9 
   lds    temp2, save_reg+10
   lds    temp3, save_reg+11
   lds    buff0, save_reg+12
   lds    buff1, save_reg+13
   lds    ZL,    save_reg+14
   lds    ZH,    save_reg+15

   ret


; *******************************************************************
;   DATOS EN FLASH
; *******************************************************************
xtea_key_table:
   .long  XTEA_KEY1
   .long  XTEA_KEY2
   .long  XTEA_KEY3
   .long  XTEA_KEY4


[KILLERJC]

No me quedo claro, tenias un problema en el shift de ASM o en el shift de python?

Bueno de todas formas como que ya casi lo tenes terminado. no le falta mucho, hacer que espere por 8 es lo de menos