Autor Tema: Bootloader encriptado para Attiny88  (Leído 7639 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Conectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5109
Re: Bootloader encriptado para Attiny88
« Respuesta #30 en: 22 de Septiembre de 2015, 13:19:17 »
Muchas gracias Killer.
Yo creo que con eso ya está bien. Si en asm ocupa unos 250 bytes, por ahora es suficiente.
En c me ocupaba 250 bytes antes de empezar y se iva a 1k con el tratamiento por I2C, así que lo abandoné.

Un saludo.

Conectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5109
Re: Bootloader encriptado para Attiny88
« Respuesta #31 en: 22 de Septiembre de 2015, 14:35:23 »
Vos me diste este valor XTEA_DELTA 0x9E3779B9

Ese es el valor 'oficial'. Aparece en el código original. No sé si se podrá cambiar.


Conectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5109
Re: Bootloader encriptado para Attiny88
« Respuesta #32 en: 22 de Septiembre de 2015, 14:36:26 »
Código optimizado:

Código: Python
  1. def xor_ta_tb():
  2.    global Ta, Tb
  3.    Ta ^= Tb
  4.  
  5.    
  6. def xtea_decode(data):
  7.    global Ta, Tb
  8.    data0 = data[0]
  9.    data1 = data[1]
  10.  
  11.    suma = 0xC6EF3720
  12.    rounds = 64
  13.    while(rounds):
  14.       Ta = data0
  15.       Tb = data1
  16.       data1 = Ta
  17.       data0 = Tb
  18.       Tb = Ta    
  19.       Ta <<= 4
  20.       Tb >>= 5
  21.       xor_ta_tb()
  22.       Ta += data1
  23.       if not (rounds & 1):
  24.          r1 = (suma>>11) & 3    
  25.       else:
  26.          r1 = suma & 3
  27.       Tb = xtea_key[r1]
  28.       Tb += suma
  29.       xor_ta_tb()
  30.       data0 -= Ta
  31.       data0 = uint32(data0)
  32.       if not (rounds & 1):
  33.          suma -= 0x9E3779B9
  34.          suma = uint32(suma)
  35.       rounds -= 1
  36.      
  37.    data[0] = data0
  38.    data[1] = data1

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7231
Re: Bootloader encriptado para Attiny88
« Respuesta #33 en: 22 de Septiembre de 2015, 15:09:30 »
Te cuelgo mi ultima actualizacion Picuino, ya con un poco mas de codigo de AVR, segun el PDF "AVR Assembler User Guide"
Aunque le falta un poco de trabajo, ya note unas cosas que podria mejorar todavia, pero te hago las preguntas asi ya directamente hago todo de una sola ves

Código: ASM
  1. BUFF_SIZE               EQU     64      ; En bytes, y Multiplo de 8 debe ser
  2.  
  3. NUM_ROUND               EQU     32      ; Cantidad de Rondas
  4.  
  5. ADDRESS_BUFFER_HIGH     EQU     0x00    ; Direccion de base del buffer de datos, Solo si se usa direccion absoluta
  6. ADDRESS_BUFFER_LOW      EQU     0x00    ;
  7.  
  8. ADDRESS_KEY_HIGH        EQU     0x00    ; Direccion de base de llaves,
  9. ADDRESS_KEY_LOW         EQU     0x00    ; Unica restriccion: 0x00 <= ZL <= 0xC0
  10.  
  11. XTEA_DELTA[3]           EQU     0x9E    ; MSB
  12. XTEA_DELTA[2]           EQU     0x37    ; Si XTEA < (0x100000000 / NUM_ROUND) no se produce Overflow, para caso de 32
  13. XTEA_DELTA[1]           EQU     0x79    ; es XTEA < 0x8000000 o que es lo mismo que XTEA <= 0x7FFFFFF
  14. XTEA_DELTA[0]           EQU     0xB9
  15.  
  16. SUM[3]                  EQU     0xC6    ; MSB, Precalculado con XTEA_DELTA * NUM_ROUND
  17. SUM[2]                  EQU     0xEF    ; Hecho asi para ahorrar espacio en instrucciones
  18. SUM[1]                  EQU     0x37
  19. SUM[0]                  EQU     0x20
  20.  
  21.  
  22. .def Loop_Buff  = r4
  23. .def Round      = r5
  24. .def sum[0]     = r6
  25. .def sum[1]     = r7
  26. .def sum[2]     = r8
  27. .def sum[3]     = r9
  28. .def V0[0]      = r10
  29. .def V0[1]      = r11
  30. .def V0[2]      = r12
  31. .def V0[3]      = r13
  32. .def V1[0]      = r14
  33. .def V1[1]      = r15
  34. .def V1[2]      = r16
  35. .def V1[3]      = r17
  36. .def Vtemp0[0]  = r18
  37. .def Vtemp0[1]  = r19
  38. .def Vtemp0[2]  = r20
  39. .def Vtemp0[3]  = r21
  40. .def Vtemp1[0]  = r22
  41. .def Vtemp1[1]  = r23
  42. .def Vtemp1[2]  = r24
  43. .def Vtemp1[3]  = r25
  44. .def XL         = r26
  45. .def XH         = r27
  46. .def YL         = r28
  47. .def YH         = r29
  48. .def ZL         = r30
  49. .def ZH         = r31
  50.  
  51.  
  52.  
  53. ; Declaracion de espacio reservado en RAM para el Buffer, Aunque esto deberia haberse realizado antes con la UART
  54.  
  55. .DSEG
  56.  
  57.         Buffer: .BYTE   BUFF_SIZE
  58.  
  59. .CSEG
  60.  
  61.  
  62.  
  63. ; ******************************************************************************
  64. ;       XTAE_Init - Llamar antes de Iniciar la conversion, setea los punteros para el algortimo
  65. ;
  66. ;       Entradas:
  67. ;       ADDRES_KEY_* - CONST - Puntero a base de las llaves
  68. ;
  69. ;       Salidas:
  70. ;       -
  71. ;
  72. ;       Pre-Requisitos:
  73. ;       Haber creado una variable Buffer, y haberla llenado de datos.
  74. ;
  75. ; *****************************************************************************
  76.  
  77.  
  78.  
  79. XTEA_Init:
  80.  
  81.         LDI     YL,ADDRESS_BUFFER_LOW   ;       Y: Puntero de lectura/escritura, Y permite direccionamiento por offset
  82.         LDI     YH,ADDRESS_BUFFER_HIGH
  83.         LDI     ZH,ADDRESS_KEY_HIHG     ;       Z: Puntero a base de llave
  84.         LDI     ZL,ADDRESS_KEY_LOW
  85.  
  86. ;o, Aca hay que elegir si va a ser aboluta la direccion (arriba) o que lo maneje el linker (abajo)
  87.  
  88.         LDI     YL,low(Buffer)          ;       Y: Puntero de lectura/escritura, Y permite direccionamiento por offset
  89.         LDI     YH,high(Buffer)
  90.         LDI     ZH,ADDRESS_KEY_HIHG     ;       Z: Puntero a base de llave
  91.         LDI     ZL,ADDRESS_KEY_LOW
  92.         RET
  93.  
  94. ; ******************************************************************************
  95. ;       Decodificacion XTEA, desencripta con XTEA un bloque de BUFF_SIZE bytes
  96. ;
  97. ;       Entradas:
  98. ;       Y - Puntero a base del Buffer en la SRAM
  99. ;
  100. ;       Salidas:
  101. ;       Y -> Reescribe el buffer de BUFF_SIZE de entrada
  102. ;
  103. ;       Pre-Requisitos:
  104. ;       Valor Inicial SUM pre-calculado
  105. ;
  106. ; *****************************************************************************
  107.  
  108. XTEA_Dec:
  109.  
  110.         LDI     Loop_Buff,(BUFF_SIZE/8)         ;Recargamos el contador para saber cuando termino de recorrer el Buffer
  111.         LDI     sum[3],SUM[3]                   ;Recargamos el valor de suma ya pre-calculada.
  112.         LDI     sum[2],SUM[2]
  113.         LDI     sum[1],SUM[1]
  114.         LDI     sum[0],SUM[0]
  115.  
  116. XTEA_Dec_Aux:
  117.  
  118.         LDD     V0[0],Y+0       ; Cargo valores de V0
  119.         LDD     V0[1],Y+1
  120.         LDD     V0[2],Y+2
  121.         LDD     V0[3],Y+3
  122.  
  123.         LDD     V1[0],Y+4       ; Cargo valores de V1
  124.         LDD     V1[1],Y+5
  125.         LDD     V1[2],Y+6
  126.         LDD     V1[3],Y+7
  127.  
  128.         RCALL   Decodificacion  ; Decodificacion
  129.  
  130.         ST      Y+,V0[0]        ; Guardo los valores ya tratados
  131.         ST      Y+,V0[1]
  132.         ST      Y+,V0[2]
  133.         ST      Y+,V0[3]
  134.  
  135.         ST      Y+,V1[0]
  136.         ST      Y+,V1[1]
  137.         ST      Y+,V1[2]
  138.         ST      Y+,V1[3]        ; Me deja Y ya preparado para los proximos 8 bytes
  139.  
  140.         DEC     Loop_Buff
  141.         BRNE    XTEA_Dec_Aux
  142.         RET
  143.  
  144.  
  145. ; ******************************************************************************
  146. ;       Subrutina de XTEA_Dec, While en C, Realiza las NUM_ROUND sobre 8 bytes
  147. ;
  148. ;       Entradas:
  149. ;       V0[4] - 4 bytes del primer valor
  150. ;       v1[4] - 4 bytes del segundo valor
  151. ;       NUM_ROUND - CONST - Indica la cantidad de veces que se produce el arlgoritmo
  152. ;
  153. ;       Salidas:
  154. ;       Y -> Reescribe 8 bytes del Buffer de entrada
  155. ;
  156. ;       Pre-Requisitos:
  157. ;       -
  158. ;
  159. ; *****************************************************************************
  160.  
  161. Decodificacion:
  162.  
  163.         LDI     Count,(NUM_ROUND*2)
  164.  
  165. Loop_while_aux:
  166.  
  167.         RCALL   Termino
  168.  
  169.         SUB     sum[0],XTEA_DELTA[0]    ; sum -= XTEA_DELTA;
  170.         SBC     sum[1],XTEA_DELTA[1]
  171.         SBC     sum[2],XTEA_DELTA[2]
  172.         SBC     sum[3],XTEA_DELTA[3]
  173.  
  174.         MOVW    Vtemp0[0],V1[0]         ;Cambio de lugar v0 y v1
  175.         MOVW    Vtemp0[2],V1[2]
  176.         MOVW    V1[0],V0[0]
  177.         MOVW    V1[2],V0[2]
  178.         MOVW    V0[0],Vtemp0[0]
  179.         MOVW    V0[2],Vtemp0[2]
  180.  
  181.         RCALL   Termino
  182.  
  183.         MOVW    Vtemp0[0],V1[0]         ;Cambio de lugar v0 y v1 , para la proxima ronda, o para cuando hay que depositarlo
  184.         MOVW    Vtemp0[2],V1[2]
  185.         MOVW    V1[0],V0[0]
  186.         MOVW    V1[2],V0[2]
  187.         MOVW    V0[0],Vtemp0[0]
  188.         MOVW    V0[2],Vtemp0[2]
  189.  
  190.         DEC     Count
  191.         BRNE    Loop_while_aux
  192.         RET
  193.  
  194. ; ******************************************************************************
  195. ;       Subrutina de Decodificacion, procede a realizar lo siguiente:
  196. ;      
  197. ;       v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3])       Para Count Par
  198. ;       v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[sum & 3])             Para Count Impar
  199. ;
  200. ;       Entradas:
  201. ;       V[4] - 4 bytes
  202. ;       Z - Puntero a base de las llaves en la SRAM
  203. ;       Count - Indicador de que ronda va
  204. ;
  205. ;       Salidas:
  206. ;       v[4] - 4 bytes
  207. ;
  208. ;       Pre-Requisitos:
  209. ;       -
  210. ;
  211. ; *****************************************************************************
  212.  
  213. Termino:
  214.         LDI     ZL,ADDRESS_KEY_LOW      ; Recargo valor de Z con el valor original, para el proximo termino, lo hago aca para ahorrar espacio, ademas al comienzo para que se mas facil verlo para cambiarlo
  215.  
  216.         MOVW    Vtemp0[0],V0[0] ; Vtemp0 para (v0<<4) y Vtemp1 para (V0 >> 5)
  217.         MOVW    Vtemp0[2],V0[2]
  218.         MOVW    Vtemp1[0],V0[0]
  219.         MOVW    Vtemp1[2],V0[2]
  220.  
  221.         LDI     R0,4
  222. RotateLeftv0:                   ; (v0 << 4)
  223.         LSL     Vtemp0[0]
  224.         ROL     Vtemp0[1]
  225.         ROL     Vtemp0[2]
  226.         ROL     Vtemp0[3]       ; Por ser de 32 bits se deberian perder los bits que salgan de aca
  227.         DEC     R0
  228.         BRNE    RotateLeftv0
  229.  
  230.         LDI     R0,5
  231. RotateRightv0:                  ; (V0 >> 5 )
  232.         LSR     Vtemp1[3]
  233.         ROR     Vtemp1[2]
  234.         ROR     Vtemp1[1]
  235.         ROR     Vtemp1[0]
  236.         DEC     R0
  237.         BRNE    RotateRightv0
  238.  
  239.         EOR     Vtemp0[0],Vtemp1[0]     ;  (v0 << 4) ^ (v0 >> 5)
  240.         EOR     Vtemp0[1],Vtemp1[1]
  241.         EOR     Vtemp0[2],Vtemp1[2]
  242.         EOR     Vtemp0[3],Vtemp1[3]
  243.  
  244.         ADD     Vtemp0[0],V0[0]         ;  ((v0 << 4) ^ (v0 >> 5)) + v0
  245.         ADC     Vtemp0[1],V0[1]         ; Vtemp0 = ((v0 << 4) ^ (v0 >> 5)) + v0
  246.         ADC     Vtemp0[2],V0[2]
  247.         ADC     Vtemp0[3],V0[3]
  248.  
  249.         SBRS    Count,0
  250.         RJMP    Primer_t                ; Si es Par indica que es el primero. Si es impar es el segundo
  251.  
  252.         MOV     R0,sum[0]               ; sum & 3
  253.         LSL     R0
  254.         LSL     R0
  255.         RJMP    Save_Sum
  256. Primer_t:
  257.         MOV     R0,sum[1]               ; sum>>11 & 3
  258.         LSR     R0
  259. Save_Sum:
  260.         ANDI    R0,0x0C                 ; 0000 aa00
  261.         ADD     ZL,R0                   ; Le sumo el valor de R0 o lo que es igual a 4 * index
  262.         LD      Vtemp1[0],Z+            ; key[sum&3] o key[(key>>11) & 3]
  263.         LD      Vtemp1[1],Z+
  264.         LD      Vtemp1[2],Z+
  265.         LD      Vtemp1[3],Z+
  266.  
  267.         ADD     Vtemp1[0],sum[0]        ; sum + key[(sum>>11) & 3]
  268.         ADC     Vtemp1[1],sum[1]        ; Aux = sum + key[(sum>>11) & 3]
  269.         ADC     Vtemp1[2],sum[2]
  270.         ADC     Vtemp1[3],sum[3]
  271.  
  272.         EOR     Vtemp0[0],Vtemp1[0]     ;  (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3])
  273.         EOR     Vtemp0[1],Vtemp1[1]     ;   Vtemp[0]
  274.         EOR     Vtemp0[2],Vtemp1[2]
  275.         EOR     Vtemp0[3],Vtemp1[3]
  276.  
  277.         SUB     V1[0],Vtemp0[0]         ; v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3])
  278.         SBC     V1[1],Vtemp0[1]
  279.         SBC     V1[2],Vtemp0[2]
  280.         SBC     V1[3],Vtemp0[3]         ; si ocurrio overflow, lo lamento
  281.         RET    

Tengo una serie de preguntas mas por hacerte. Tanto a vos como a planeta que tiene mas experiencia.

1-
XTEA_DELTA si se puede seleccionar un valor tal que XTEA_DELTA <= 0x7FFFFFF
Ahi no se produciria un overflow, tendria que ver si es que realmente implica algo el que no exista ese ultimo byte, ya que si lo pensas en una resta a la sumo te queda el carry a restarle a la parte "superior", asi que se podria decir que no afectaria
Vos decidiras si es que deseas cambiarlo o no

2-
La llave donde va a ir? Memoria de programa, o RAM con unas "constantes" tal cual ves los EQU en el codigo?
Si es Memoria de programa debo cambiar algunas instrucciones (creo que achicando en 2 instrucciones), y tenes que pensar que van a ir 16 bytes mas en la FLASH
Si es la RAM, se debe agregar muchas mas instrucciones para inicializar esos datos en la RAM y poder tomarlos desde alli, no quitaria nada y agregaria unas 18 instrucciones
Velocidad vs Espacio

3-
Que tipo de direccionamiento queres? Podes elegir que el linker te "reserve" el espacio en la RAM y obtener la direccion con high(variable) y low(variable) o.. podes hacerlo con un direccionamiento absoluto a traves de los EQU
Si te fijas en XTEA_Init, hay 2 ejemplos, tengo que arreglarlo a eso para que quede 1 solo, y tambien lo de las llaves, Por eso cree un XTEA_Init, segun sea el caso que elijas de  estas preguntas, desapareceria esa funcion o no.
Definir el buffer lo deberias hacer con la UART (me refiero a lo de "reservar" el espacio de la RAM ), y directamente desde aca pedis la direccion de inicio para comenzar.

4-
Tenes pensado poner los valores de las llaves en algun valor de direccion en particular? se puede usar el .ORG para eso, y .DW para almacenar los valores en la FLASH , fijate que hay una restriccion asi como esta realizado el codigo sobre los valroes de direccion de las llaves, si lo queres para que este en cualquier posicion, entonces deberia agregar unas 2 instrucciones mas. Lo hice asi por el espacio :/

5-
Debo salvar algun registro a la pila por algun valor que estes utilizando ?
Por que no se me ocurre alguno, tal ves el de Z, o Y, que son los punteros, pero no creo que los necesites ya que una ves que pasas la decodificacion, fue por que recibiste todo.

6-
Vas a crear solamente 1 Buffer de 64 bytes o mas?, Si tenes pensado crear 4 buffer solo cambia el valor de BUFFER_SIZE a 4*64 , Solo prestar atencion que debe ser multiplo de 8

7-
Como estan guardados los datos? Ya que de tomarlo de otra punta terminaria mal, esto para acomodar cuando los cargo/grabo a la RAM.
Ejemplo, los pimeros 8 bytes 0x12345678  0x12345678

Guardados asi:
0x12 0x34 0x56 0x78 0x12 0x34 0x56 0x78

o asi:
0x78 0x56 0x34 0x12 0x78 0x56 0x34 0x12

Esto va a depender de tu UART y cmo los envies

8-
Tenes idea si se permiten los corchetes en los nombres? Yo lo hize asi por que era mas facil para mi darme cuenta


Resuelta estas dudas creo que termino el codigo, Aunque sin probarlo :/
Y ya reviso tu codigo haber si me das una mejor idea o si es lo mismo realizado en ASM
« Última modificación: 22 de Septiembre de 2015, 15:45:51 por KILLERJC »

Desconectado juaperser1

  • Colaborador
  • DsPIC30
  • *****
  • Mensajes: 2680
Re: Bootloader encriptado para Attiny88
« Respuesta #34 en: 22 de Septiembre de 2015, 16:19:14 »
Solo quiero decir que estoy siguiendo el hilo, no contribuyo por que no entiendo del tema, pero sigo muy atento a los avances  ;-) pronto migraré de microchip y todas estas cosas me ayudarán a decidirme por una marca u otra.
Visita mi canal para aprender sobre electrónica y programación:

https://www.youtube.com/channel/UCxOYHcAMLCVEtZEvGgPQ6Vw

Conectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5109
Re: Bootloader encriptado para Attiny88
« Respuesta #35 en: 22 de Septiembre de 2015, 18:20:34 »
1-
XTEA_DELTA si se puede seleccionar un valor tal que XTEA_DELTA <= 0x7FFFFFF
Ahi no se produciria un overflow, tendria que ver si es que realmente implica algo el que no exista ese ultimo byte, ya que si lo pensas en una resta a la sumo te queda el carry a restarle a la parte "superior", asi que se podria decir que no afectaria
Vos decidiras si es que deseas cambiarlo o no
Yo creo que ese valor es fijo y no se puede cambiar. Forma parte de la rutina de encriptación.

2-
La llave donde va a ir? Memoria de programa, o RAM con unas "constantes" tal cual ves los EQU en el codigo?
Si es Memoria de programa debo cambiar algunas instrucciones (creo que achicando en 2 instrucciones), y tenes que pensar que van a ir 16 bytes mas en la FLASH
Si es la RAM, se debe agregar muchas mas instrucciones para inicializar esos datos en la RAM y poder tomarlos desde alli, no quitaria nada y agregaria unas 18 instrucciones
Velocidad vs Espacio
Yo estoy intentando ponerla en la memoria de programa (flash) y leerla con el puntero Z. Creo que es lo más sencillo y pequeño.


3-
Que tipo de direccionamiento queres? Podes elegir que el linker te "reserve" el espacio en la RAM y obtener la direccion con high(variable) y low(variable) o.. podes hacerlo con un direccionamiento absoluto a traves de los EQU
Si te fijas en XTEA_Init, hay 2 ejemplos, tengo que arreglarlo a eso para que quede 1 solo, y tambien lo de las llaves, Por eso cree un XTEA_Init, segun sea el caso que elijas de  estas preguntas, desapareceria esa funcion o no.
Definir el buffer lo deberias hacer con la UART (me refiero a lo de "reservar" el espacio de la RAM ), y directamente desde aca pedis la direccion de inicio para comenzar.
Lo mejor es ponerlo a mano para poder controlar bien la memoria. Tampoco es muy complicado el programa.


4-
Tenes pensado poner los valores de las llaves en algun valor de direccion en particular? se puede usar el .ORG para eso, y .DW para almacenar los valores en la FLASH , fijate que hay una restriccion asi como esta realizado el codigo sobre los valroes de direccion de las llaves, si lo queres para que este en cualquier posicion, entonces deberia agregar unas 2 instrucciones mas. Lo hice asi por el espacio :/
Quiero poner todo al final de la memoria. Se puede inicializar Z = dirección de la llave + r1*4 y luego leer con "LMP   temp0, Z+"


5-
Debo salvar algun registro a la pila por algun valor que estes utilizando ?
Por que no se me ocurre alguno, tal ves el de Z, o Y, que son los punteros, pero no creo que los necesites ya que una ves que pasas la decodificacion, fue por que recibiste todo.
Lo mejor es que el bootloader guarde sus variables antes del rcall.


6-
Vas a crear solamente 1 Buffer de 64 bytes o mas?, Si tenes pensado crear 4 buffer solo cambia el valor de BUFFER_SIZE a 4*64 , Solo prestar atencion que debe ser multiplo de 8
Sólo un buffer de 64 bytes por ahora. Es el tamaño de página de la Flash para escritura. No necesito más.


7-
Como estan guardados los datos? Ya que de tomarlo de otra punta terminaria mal, esto para acomodar cuando los cargo/grabo a la RAM.
Ejemplo, los pimeros 8 bytes 0x12345678  0x12345678

Guardados asi:
0x12 0x34 0x56 0x78 0x12 0x34 0x56 0x78

o asi:
0x78 0x56 0x34 0x12 0x78 0x56 0x34 0x12

Esto va a depender de tu UART y cmo los envies
Voy a utilizar la notación little-endian, que es la del Attiny. Primero el byte menos significativo. Byte menos significativo en posiciones más bajas (primera opción).

8-
Tenes idea si se permiten los corchetes en los nombres? Yo lo hize asi por que era mas facil para mi darme cuenta
No lo sé.


Otro problema que he notado es que no se pueden enviar todas las posiciones de memoria encriptadas.
Si se envían varios bloques de 4bytes todos a cero (o todos con 0xFF), se va a notar porque el archivo encriptado tendrá bloques de 4 bytes iguales. A partir de esto es posible iniciar un ataque.
La complejidad de la llave se puede reducir en 32 bits.

El autor recomienda hacer una encriptación de todo un bloque (64 bytes), pero es más compleja.

Otra solución es enviar paquetes de datos de tamaño variable y eliminar los huecos a cero. Complica un poco el bootloader, pero da mayor seguridad.


Estoy peleándome con el ensamblador para eliminar los fallos. Me estoy fijando en tu código para conseguirlo. Cuando lo tenga lo posteo.
Un saludo.

Conectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5109
Re: Bootloader encriptado para Attiny88
« Respuesta #36 en: 22 de Septiembre de 2015, 18:42:29 »
AVR Assembler User Guide:
http://www.atmel.com/Images/doc1022.pdf

Creo que está escrito para el compilador de Atmel. Me gustaría utilizar el ensamblador GNU, pero no hay apenas documentación.


Manual del ensamblador GNU:
https://sourceware.org/binutils/docs/as/
« Última modificación: 22 de Septiembre de 2015, 18:55:52 por Picuino »

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7231
Re: Bootloader encriptado para Attiny88
« Respuesta #37 en: 22 de Septiembre de 2015, 19:20:03 »
Ya veo lo del compilador GNU Picuino.

Citar
Quiero poner todo al final de la memoria. Se puede inicializar Z = dirección de la llave + r1*4 y luego leer con "LMP   temp0, Z+"

No lo decia por eso es que el codigo que habia pasado practicamente habia realizado la suma del valor del registro con la parte baja de Z, pero no traslade eso a la parte superior, por eso preguntaba si ibas a ponerlo en un algun lado en especial. Sino ya lo arregle agregando 2 lineas como te habia dicho, permitiendo que cualquier cosa que ocurra y la key se encuentre en una posicion comprometida no afecte al programa.

Citar
Yo creo que ese valor es fijo y no se puede cambiar. Forma parte de la rutina de encriptación.

Busque y en un paper que hablaba sobre XTEA, decia que uno debia elegir la llave Y el valor del delta. Por que dejando fijo el valor del delta estas practicamente entregando la mitad del codigo, mas cuando es sacado de wikipedia :P
Y sino habria que probar si es que encriptando y desencriptando con otro delta no produce los resultados que uno espera.

Citar
Otro problema que he notado es que no se pueden enviar todas las posiciones de memoria encriptadas.
Si se envían varios bloques de 4bytes todos a cero (o todos con 0xFF), se va a notar porque el archivo encriptado tendrá bloques de 4 bytes iguales. A partir de esto es posible iniciar un ataque.
La complejidad de la llave se puede reducir en 32 bits.

Y cual es el problema ? llenalos de valores random si no te da multiplo de 64 bytes, si total ahi no deberia llegar NUNCA

--------------------------------------

Despues de todo se me ocurrio otro problema, mas que un problema una situacion.

Por ejemplo, en el caso que la otra persona se ponga a meter mano y "borre" el bootloader, como te vas a enfrentar a eso?
Por que esto sirve muy bien como para una "actualizacion" pero cuando se borra completamente todo, te vas a enfrentar con el tema de que hay que cargarle el firmware completo. Y esto ya no se puede hacer mas encriptado.


---------------------------------------

Nuevamente creo que termine el mio, solo me faltaria acomodarlo para GNU

Código: ASM
  1. .EQU    BUFF_SIZE               = 64    ; En bytes, y Multiplo de 8 debe ser
  2.  
  3. .EQU    NUM_ROUND               = 32    ; Cantidad de Rondas
  4.  
  5. .EQU    ADDRESS_BUFFER_HIGH     = 0x10  ; Direccion de base del buffer de datos, Solo si se usa direccion absoluta
  6. .EQU    ADDRESS_BUFFER_LOW      = 0x00  ; Recordar que debe sere mayor a 0x1000 la direccion
  7.  
  8. .EQU    XTEA_DELTA[3]           = 0x9E  ; MSB
  9. .EQU    XTEA_DELTA[2]           = 0x37  ;
  10. .EQU    XTEA_DELTA[1]           = 0x79  ;
  11. .EQU    XTEA_DELTA[0]           = 0xB9
  12.  
  13. .EQU    SUM[3]                  = 0xC6  ; MSB, Precalculado con XTEA_DELTA * NUM_ROUND
  14. .EQU    SUM[2]                  = 0xEF  ; Hecho asi para ahorrar espacio en instrucciones
  15. .EQU    SUM[1]                  = 0x37
  16. .EQU    SUM[0]                  = 0x20
  17.  
  18.  
  19. .def Loop_Buff  = r4
  20. .def Round      = r5
  21. .def sum[0]     = r6
  22. .def sum[1]     = r7
  23. .def sum[2]     = r8
  24. .def sum[3]     = r9
  25. .def V0[0]      = r10
  26. .def V0[1]      = r11
  27. .def V0[2]      = r12
  28. .def V0[3]      = r13
  29. .def V1[0]      = r14
  30. .def V1[1]      = r15
  31. .def V1[2]      = r16
  32. .def V1[3]      = r17
  33. .def Vtemp0[0]  = r18
  34. .def Vtemp0[1]  = r19
  35. .def Vtemp0[2]  = r20
  36. .def Vtemp0[3]  = r21
  37. .def Vtemp1[0]  = r22
  38. .def Vtemp1[1]  = r23
  39. .def Vtemp1[2]  = r24
  40. .def Vtemp1[3]  = r25
  41. .def XL         = r26
  42. .def XH         = r27
  43. .def YL         = r28
  44. .def YH         = r29
  45. .def ZL         = r30
  46. .def ZH         = r31
  47.  
  48.  
  49.  
  50. ; Inicializacion de llaves en Flash
  51. Keys:   .DW     0x1234, 0x5678          ; [0]
  52.         .DW     0x1234, 0x5678          ; [1]
  53.         .DW     0x1234, 0x5678          ; [2]
  54.         .DW     0x1234, 0x5678          ; [3]
  55.  
  56.  
  57. ; ******************************************************************************
  58. ;       Decodificacion XTEA, desencripta con XTEA un bloque de BUFF_SIZE bytes
  59. ;
  60. ;       Entradas:
  61. ;       Y - Puntero a base del Buffer en la SRAM
  62. ;
  63. ;       Salidas:
  64. ;       Y -> Reescribe el buffer de BUFF_SIZE de entrada
  65. ;
  66. ;       Pre-Requisitos:
  67. ;       Valor Inicial SUM pre-calculado
  68. ;
  69. ;
  70. ;       Registros usados:
  71. ;       R0, R4-R25 , R28-R31
  72. ;
  73. ; *****************************************************************************
  74.  
  75. XTEA_Dec:
  76.  
  77.         LDI     YL,ADDRESS_BUFFER_LOW   ;       Y: Puntero de lectura/escritura, Y permite direccionamiento por offset
  78.         LDI     YH,ADDRESS_BUFFER_HIGH
  79.  
  80.         LDI     Loop_Buff,(BUFF_SIZE/8)         ;Recargamos el contador para saber cuando termino de recorrer el Buffer
  81.         LDI     sum[3],SUM[3]                   ;Recargamos el valor de suma ya pre-calculada.
  82.         LDI     sum[2],SUM[2]
  83.         LDI     sum[1],SUM[1]
  84.         LDI     sum[0],SUM[0]
  85.  
  86. XTEA_Dec_Aux:
  87.  
  88.         ; Carga realizada en Little Endian
  89.  
  90.         LDD     V0[0],Y+0       ; Cargo valores de V0
  91.         LDD     V0[1],Y+1
  92.         LDD     V0[2],Y+2
  93.         LDD     V0[3],Y+3
  94.  
  95.         LDD     V1[0],Y+4       ; Cargo valores de V1
  96.         LDD     V1[1],Y+5
  97.         LDD     V1[2],Y+6
  98.         LDD     V1[3],Y+7
  99.  
  100.         RCALL   Decodificacion  ; Decodificacion
  101.  
  102.         ST      Y+,V0[0]        ; Guardo los valores ya tratados
  103.         ST      Y+,V0[1]
  104.         ST      Y+,V0[2]
  105.         ST      Y+,V0[3]
  106.  
  107.         ST      Y+,V1[0]
  108.         ST      Y+,V1[1]
  109.         ST      Y+,V1[2]
  110.         ST      Y+,V1[3]        ; Me deja Y ya preparado para los proximos 8 bytes
  111.  
  112.         DEC     Loop_Buff
  113.         BRNE    XTEA_Dec_Aux
  114.         RET
  115.  
  116.  
  117. ; ******************************************************************************
  118. ;       Subrutina de XTEA_Dec, While en C, Realiza las NUM_ROUND sobre 8 bytes
  119. ;
  120. ;       Entradas:
  121. ;       V0[4] - 4 bytes del primer valor
  122. ;       v1[4] - 4 bytes del segundo valor
  123. ;       NUM_ROUND - CONST - Indica la cantidad de veces que se produce el arlgoritmo
  124. ;
  125. ;       Salidas:
  126. ;       Y -> Reescribe 8 bytes del Buffer de entrada
  127. ;
  128. ;       Pre-Requisitos:
  129. ;       -
  130. ;
  131. ; *****************************************************************************
  132.  
  133. Decodificacion:
  134.  
  135.         LDI     Count,(NUM_ROUND*2)
  136.  
  137. Loop_while_aux:
  138.  
  139.         RCALL   Termino
  140.  
  141.         SUB     sum[0],XTEA_DELTA[0]    ; sum -= XTEA_DELTA;
  142.         SBC     sum[1],XTEA_DELTA[1]
  143.         SBC     sum[2],XTEA_DELTA[2]
  144.         SBC     sum[3],XTEA_DELTA[3]
  145.  
  146.         MOVW    Vtemp0[0],V1[0]         ;Cambio de lugar v0 y v1
  147.         MOVW    Vtemp0[2],V1[2]
  148.         MOVW    V1[0],V0[0]
  149.         MOVW    V1[2],V0[2]
  150.         MOVW    V0[0],Vtemp0[0]
  151.         MOVW    V0[2],Vtemp0[2]
  152.  
  153.         RCALL   Termino
  154.  
  155.         MOVW    Vtemp0[0],V1[0]         ;Cambio de lugar v0 y v1 , para la proxima ronda, o para cuando hay que depositarlo
  156.         MOVW    Vtemp0[2],V1[2]
  157.         MOVW    V1[0],V0[0]
  158.         MOVW    V1[2],V0[2]
  159.         MOVW    V0[0],Vtemp0[0]
  160.         MOVW    V0[2],Vtemp0[2]
  161.  
  162.         DEC     Count
  163.         BRNE    Loop_while_aux
  164.         RET
  165.  
  166. ; ******************************************************************************
  167. ;       Subrutina de Decodificacion, procede a realizar lo siguiente:
  168. ;      
  169. ;       v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3])       Para Count Par
  170. ;       v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[sum & 3])             Para Count Impar
  171. ;
  172. ;       Entradas:
  173. ;       V[4] - 4 bytes
  174. ;       Z - Puntero a base de las llaves en la SRAM
  175. ;       Count - Indicador de que ronda va
  176. ;
  177. ;       Salidas:
  178. ;       v[4] - 4 bytes
  179. ;
  180. ;       Pre-Requisitos:
  181. ;       -
  182. ;
  183. ; *****************************************************************************
  184.  
  185. Termino:
  186.         LDI     ZH,high(Keys)   ; Recargo valor de Z, por que lo modifique anteriormente
  187.         LDI     ZL,low(Keys)
  188.  
  189.         MOVW    Vtemp0[0],V0[0] ; Vtemp0 para (v0<<4) y Vtemp1 para (V0 >> 5)
  190.         MOVW    Vtemp0[2],V0[2]
  191.         MOVW    Vtemp1[0],V0[0]
  192.         MOVW    Vtemp1[2],V0[2]
  193.  
  194.         LDI     R0,4
  195. RotateLeftv0:                   ; (v0 << 4)
  196.         LSL     Vtemp0[0]
  197.         ROL     Vtemp0[1]
  198.         ROL     Vtemp0[2]
  199.         ROL     Vtemp0[3]       ; Por ser de 32 bits se deberian perder los bits que salgan de aca
  200.         DEC     R0
  201.         BRNE    RotateLeftv0
  202.  
  203.         LDI     R0,5
  204. RotateRightv0:                  ; (V0 >> 5 )
  205.         LSR     Vtemp1[3]
  206.         ROR     Vtemp1[2]
  207.         ROR     Vtemp1[1]
  208.         ROR     Vtemp1[0]
  209.         DEC     R0
  210.         BRNE    RotateRightv0
  211.  
  212.         EOR     Vtemp0[0],Vtemp1[0]     ;  (v0 << 4) ^ (v0 >> 5)
  213.         EOR     Vtemp0[1],Vtemp1[1]
  214.         EOR     Vtemp0[2],Vtemp1[2]
  215.         EOR     Vtemp0[3],Vtemp1[3]
  216.  
  217.         ADD     Vtemp0[0],V0[0]         ;  ((v0 << 4) ^ (v0 >> 5)) + v0
  218.         ADC     Vtemp0[1],V0[1]         ; Vtemp0 = ((v0 << 4) ^ (v0 >> 5)) + v0
  219.         ADC     Vtemp0[2],V0[2]
  220.         ADC     Vtemp0[3],V0[3]
  221.  
  222.         SBRS    Count,0
  223.         RJMP    Primer_t                ; Si es Par indica que es el primero. Si es impar es el segundo
  224.  
  225.         MOV     R0,sum[0]               ; sum & 3
  226.         LSL     R0
  227.         LSL     R0
  228.         RJMP    Save_Sum
  229. Primer_t:
  230.         MOV     R0,sum[1]               ; sum>>11 & 3
  231.         LSR     R0
  232. Save_Sum:
  233.         ANDI    R0,0x0C                 ; 0000 aa00
  234.         ADD     ZL,R0                   ; Le sumo el valor de R0 o lo que es igual a 4 * index
  235.         CLR     R0                      ; Me aseguro que por mas que caiga donde sea la llave en el programa no se produzca algun error
  236.         ADC     ZH,R0                   ; Sumandole el carry
  237.         LPM     Vtemp1[0],Z+            ; key[sum&3] o key[(key>>11) & 3]
  238.         LPM     Vtemp1[1],Z+
  239.         LPM     Vtemp1[2],Z+
  240.         LPM     Vtemp1[3],Z+
  241.  
  242.         ADD     Vtemp1[0],sum[0]        ; sum + key[(sum>>11) & 3]
  243.         ADC     Vtemp1[1],sum[1]        ; Aux = sum + key[(sum>>11) & 3]
  244.         ADC     Vtemp1[2],sum[2]
  245.         ADC     Vtemp1[3],sum[3]
  246.  
  247.         EOR     Vtemp0[0],Vtemp1[0]     ;  (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3])
  248.         EOR     Vtemp0[1],Vtemp1[1]     ;   Vtemp[0]
  249.         EOR     Vtemp0[2],Vtemp1[2]
  250.         EOR     Vtemp0[3],Vtemp1[3]
  251.  
  252.         SUB     V1[0],Vtemp0[0]         ; v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3])
  253.         SBC     V1[1],Vtemp0[1]
  254.         SBC     V1[2],Vtemp0[2]
  255.         SBC     V1[3],Vtemp0[3]         ; si ocurrio overflow, lo lamento
  256.         RET

GNU, creo que no requirio tanto cambio:

Código: ASM
  1. ; Constantes
  2.  
  3.  
  4. .EQU    BUFF_SIZE               , 64    ; En bytes, y Multiplo de 8 debe ser
  5.  
  6. .EQU    NUM_ROUND               , 32    ; Cantidad de Rondas
  7.  
  8. .EQU    ADDRESS_BUFFER_HIGH     , 0x10  ; Direccion de base del buffer de datos, Solo si se usa direccion absoluta
  9. .EQU    ADDRESS_BUFFER_LOW      , 0x00  ; Recordar que debe sere mayor a 0x1000 la direccion
  10.  
  11. .EQU    XTEA_DELTA[3]           , 0x9E  ; MSB
  12. .EQU    XTEA_DELTA[2]           , 0x37  ;
  13. .EQU    XTEA_DELTA[1]           , 0x79  ;
  14. .EQU    XTEA_DELTA[0]           , 0xB9
  15.  
  16. .EQU    SUM[3]                  , 0xC6  ; MSB, Precalculado con XTEA_DELTA * NUM_ROUND
  17. .EQU    SUM[2]                  , 0xEF  ; Hecho asi para ahorrar espacio en instrucciones
  18. .EQU    SUM[1]                  , 0x37
  19. .EQU    SUM[0]                  , 0x20
  20.  
  21.  
  22.  
  23. ; Registros
  24.  
  25. .def Loop_Buff  , r4
  26. .def Round      , r5
  27. .def sum[0]     , r6
  28. .def sum[1]     , r7
  29. .def sum[2]     , r8
  30. .def sum[3]     , r9
  31. .def V0[0]      , r10
  32. .def V0[1]      , r11
  33. .def V0[2]      , r12
  34. .def V0[3]      , r13
  35. .def V1[0]      , r14
  36. .def V1[1]      , r15
  37. .def V1[2]      , r16
  38. .def V1[3]      , r17
  39. .def Vtemp0[0]  , r18
  40. .def Vtemp0[1]  , r19
  41. .def Vtemp0[2]  , r20
  42. .def Vtemp0[3]  , r21
  43. .def Vtemp1[0]  , r22
  44. .def Vtemp1[1]  , r23
  45. .def Vtemp1[2]  , r24
  46. .def Vtemp1[3]  , r25
  47. .def XL         , r26
  48. .def XH         , r27
  49. .def YL         , r28
  50. .def YH         , r29
  51. .def ZL         , r30
  52. .def ZH         , r31
  53.  
  54.  
  55. ; Seccion, para acomodar en el linker
  56.  
  57. .section bootloader
  58.  
  59. ; Inicializacion de llaves en Flash
  60.  
  61. Keys:   .hword  0x1234, 0x5678          ; [0]
  62.         .hword  0x1234, 0x5678          ; [1]
  63.         .hword  0x1234, 0x5678          ; [2]
  64.         .hword  0x1234, 0x5678          ; [3]
  65.  
  66.  
  67. ; ******************************************************************************
  68. ;       Decodificacion XTEA, desencripta con XTEA un bloque de BUFF_SIZE bytes
  69. ;
  70. ;       Entradas:
  71. ;       Y - Puntero a base del Buffer en la SRAM
  72. ;
  73. ;       Salidas:
  74. ;       Y -> Reescribe el buffer de BUFF_SIZE de entrada
  75. ;
  76. ;       Pre-Requisitos:
  77. ;       Valor Inicial SUM pre-calculado
  78. ;
  79. ;
  80. ;       Registros usados:
  81. ;       R0, R4-R25 , R28-R31
  82. ;
  83. ; *****************************************************************************
  84.  
  85. XTEA_Dec:
  86.  
  87.         LDI     YL,ADDRESS_BUFFER_LOW           ;       Y: Puntero de lectura/escritura, Y permite direccionamiento por offset
  88.         LDI     YH,ADDRESS_BUFFER_HIGH
  89.  
  90.         LDI     Loop_Buff,(BUFF_SIZE/8)         ;Recargamos el contador para saber cuando termino de recorrer el Buffer
  91.         LDI     sum[3],SUM[3]                   ;Recargamos el valor de suma ya pre-calculada.
  92.         LDI     sum[2],SUM[2]
  93.         LDI     sum[1],SUM[1]
  94.         LDI     sum[0],SUM[0]
  95.  
  96. XTEA_Dec_Aux:
  97.  
  98.         ; Carga realizada en Little Endian
  99.  
  100.         LDD     V0[0],Y+0       ; Cargo valores de V0
  101.         LDD     V0[1],Y+1
  102.         LDD     V0[2],Y+2
  103.         LDD     V0[3],Y+3
  104.  
  105.         LDD     V1[0],Y+4       ; Cargo valores de V1
  106.         LDD     V1[1],Y+5
  107.         LDD     V1[2],Y+6
  108.         LDD     V1[3],Y+7
  109.  
  110.         RCALL   Decodificacion  ; Decodificacion
  111.  
  112.         ST      Y+,V0[0]        ; Guardo los valores ya tratados
  113.         ST      Y+,V0[1]
  114.         ST      Y+,V0[2]
  115.         ST      Y+,V0[3]
  116.  
  117.         ST      Y+,V1[0]
  118.         ST      Y+,V1[1]
  119.         ST      Y+,V1[2]
  120.         ST      Y+,V1[3]        ; Me deja Y ya preparado para los proximos 8 bytes
  121.  
  122.         DEC     Loop_Buff
  123.         BRNE    XTEA_Dec_Aux
  124.         RET
  125.  
  126.  
  127. ; ******************************************************************************
  128. ;       Subrutina de XTEA_Dec, While en C, Realiza las NUM_ROUND sobre 8 bytes
  129. ;
  130. ;       Entradas:
  131. ;       V0[4] - 4 bytes del primer valor
  132. ;       v1[4] - 4 bytes del segundo valor
  133. ;       NUM_ROUND - CONST - Indica la cantidad de veces que se produce el arlgoritmo
  134. ;
  135. ;       Salidas:
  136. ;       Y -> Reescribe 8 bytes del Buffer de entrada
  137. ;
  138. ;       Pre-Requisitos:
  139. ;       -
  140. ;
  141. ; *****************************************************************************
  142.  
  143. Decodificacion:
  144.  
  145.         LDI     Count,(NUM_ROUND*2)
  146.  
  147. Loop_while_aux:
  148.  
  149.         RCALL   Termino
  150.  
  151.         SUB     sum[0],XTEA_DELTA[0]    ; sum -= XTEA_DELTA;
  152.         SBC     sum[1],XTEA_DELTA[1]
  153.         SBC     sum[2],XTEA_DELTA[2]
  154.         SBC     sum[3],XTEA_DELTA[3]
  155.  
  156.         MOVW    Vtemp0[0],V1[0]         ;Cambio de lugar v0 y v1
  157.         MOVW    Vtemp0[2],V1[2]
  158.         MOVW    V1[0],V0[0]
  159.         MOVW    V1[2],V0[2]
  160.         MOVW    V0[0],Vtemp0[0]
  161.         MOVW    V0[2],Vtemp0[2]
  162.  
  163.         RCALL   Termino
  164.  
  165.         MOVW    Vtemp0[0],V1[0]         ;Cambio de lugar v0 y v1 , para la proxima ronda, o para cuando hay que depositarlo
  166.         MOVW    Vtemp0[2],V1[2]
  167.         MOVW    V1[0],V0[0]
  168.         MOVW    V1[2],V0[2]
  169.         MOVW    V0[0],Vtemp0[0]
  170.         MOVW    V0[2],Vtemp0[2]
  171.  
  172.         DEC     Count
  173.         BRNE    Loop_while_aux
  174.         RET
  175.  
  176. ; ******************************************************************************
  177. ;       Subrutina de Decodificacion, procede a realizar lo siguiente:
  178. ;      
  179. ;       v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3])       Para Count Par
  180. ;       v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[sum & 3])             Para Count Impar
  181. ;
  182. ;       Entradas:
  183. ;       V[4] - 4 bytes
  184. ;       Z - Puntero a base de las llaves en la SRAM
  185. ;       Count - Indicador de que ronda va
  186. ;
  187. ;       Salidas:
  188. ;       v[4] - 4 bytes
  189. ;
  190. ;       Pre-Requisitos:
  191. ;       -
  192. ;
  193. ; *****************************************************************************
  194.  
  195. Termino:
  196.         LDI     ZH,pm_hi8(Keys) ; Recargo valor de Z, por que lo modifique anteriormente
  197.         LDI     ZL,pm_lo8(Keys)
  198.  
  199.         MOVW    Vtemp0[0],V0[0] ; Vtemp0 para (v0<<4) y Vtemp1 para (V0 >> 5)
  200.         MOVW    Vtemp0[2],V0[2]
  201.         MOVW    Vtemp1[0],V0[0]
  202.         MOVW    Vtemp1[2],V0[2]
  203.  
  204.         LDI     R0,4
  205. RotateLeftv0:                   ; (v0 << 4)
  206.         LSL     Vtemp0[0]
  207.         ROL     Vtemp0[1]
  208.         ROL     Vtemp0[2]
  209.         ROL     Vtemp0[3]       ; Por ser de 32 bits se deberian perder los bits que salgan de aca
  210.         DEC     R0
  211.         BRNE    RotateLeftv0
  212.  
  213.         LDI     R0,5
  214. RotateRightv0:                  ; (V0 >> 5 )
  215.         LSR     Vtemp1[3]
  216.         ROR     Vtemp1[2]
  217.         ROR     Vtemp1[1]
  218.         ROR     Vtemp1[0]
  219.         DEC     R0
  220.         BRNE    RotateRightv0
  221.  
  222.         EOR     Vtemp0[0],Vtemp1[0]     ;  (v0 << 4) ^ (v0 >> 5)
  223.         EOR     Vtemp0[1],Vtemp1[1]
  224.         EOR     Vtemp0[2],Vtemp1[2]
  225.         EOR     Vtemp0[3],Vtemp1[3]
  226.  
  227.         ADD     Vtemp0[0],V0[0]         ;  ((v0 << 4) ^ (v0 >> 5)) + v0
  228.         ADC     Vtemp0[1],V0[1]         ; Vtemp0 = ((v0 << 4) ^ (v0 >> 5)) + v0
  229.         ADC     Vtemp0[2],V0[2]
  230.         ADC     Vtemp0[3],V0[3]
  231.  
  232.         SBRS    Count,0
  233.         RJMP    Primer_t                ; Si es Par indica que es el primero. Si es impar es el segundo
  234.  
  235.         MOV     R0,sum[0]               ; sum & 3
  236.         LSL     R0
  237.         LSL     R0
  238.         RJMP    Save_Sum
  239. Primer_t:
  240.         MOV     R0,sum[1]               ; sum>>11 & 3
  241.         LSR     R0
  242. Save_Sum:
  243.         ANDI    R0,0x0C                 ; 0000 aa00
  244.         ADD     ZL,R0                   ; Le sumo el valor de R0 o lo que es igual a 4 * index
  245.         CLR     R0                      ; Me aseguro que por mas que caiga donde sea la llave en el programa no se produzca algun error
  246.         ADC     ZH,R0                   ; Sumandole el carry
  247.         LPM     Vtemp1[0],Z+            ; key[sum&3] o key[(key>>11) & 3]
  248.         LPM     Vtemp1[1],Z+
  249.         LPM     Vtemp1[2],Z+
  250.         LPM     Vtemp1[3],Z+
  251.  
  252.         ADD     Vtemp1[0],sum[0]        ; sum + key[(sum>>11) & 3]
  253.         ADC     Vtemp1[1],sum[1]        ; Aux = sum + key[(sum>>11) & 3]
  254.         ADC     Vtemp1[2],sum[2]
  255.         ADC     Vtemp1[3],sum[3]
  256.  
  257.         EOR     Vtemp0[0],Vtemp1[0]     ;  (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3])
  258.         EOR     Vtemp0[1],Vtemp1[1]     ;   Vtemp[0]
  259.         EOR     Vtemp0[2],Vtemp1[2]
  260.         EOR     Vtemp0[3],Vtemp1[3]
  261.  
  262.         SUB     V1[0],Vtemp0[0]         ; v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3])
  263.         SBC     V1[1],Vtemp0[1]
  264.         SBC     V1[2],Vtemp0[2]
  265.         SBC     V1[3],Vtemp0[3]         ; si ocurrio overflow, lo lamento
  266.         RET    

.equ xx,xx
.def xx,xx

agregue un:

.section bootloader

Aunque eso lo debes hacer en todo el bootloader

Cambie los high() y low() por los pm_hi8() y pm_lo8() , que es lo mismo que hi8() y lo8() nomas que tenia el PM de Program Memory y parecia mas en concordancia.

Y por ultimo cambiar el .DW por unos .hword (16 bits)
« Última modificación: 22 de Septiembre de 2015, 19:50:59 por KILLERJC »

Desconectado juaperser1

  • Colaborador
  • DsPIC30
  • *****
  • Mensajes: 2680
Re: Bootloader encriptado para Attiny88
« Respuesta #38 en: 23 de Septiembre de 2015, 05:55:13 »
Perdón por la intromisión, pero me gustaría preguntar algo:

Citar
Creo que está escrito para el compilador de Atmel. Me gustaría utilizar el ensamblador GNU, pero no hay apenas documentación

Por que no quieres usar el de atmel? Es por algo en especial, algún problema que tenga o no te guste, o simplemente es porque quieres trabajar con el de GNU. O es que estas trabajando en linux y no hay IDE de atmel para sistemas linux?

Perdón por el offtopic
Visita mi canal para aprender sobre electrónica y programación:

https://www.youtube.com/channel/UCxOYHcAMLCVEtZEvGgPQ6Vw

Desconectado stk500

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 4851
Re: Bootloader encriptado para Attiny88
« Respuesta #39 en: 23 de Septiembre de 2015, 06:59:49 »
Yo de verdad que de Assemble se muy poco, pero en visto en pagina de Alemanas muchos Bootloader por ejemplo el famoso programador Peter Dannegger,
Aqui http://www.mikrocontroller.net/articles/AVR_Bootloader_FastBoot_von_Peter_Dannegger
espero que esto te ayude
Saludos

Conectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5109
Re: Bootloader encriptado para Attiny88
« Respuesta #40 en: 23 de Septiembre de 2015, 07:55:44 »
Gracias stk500, le estoy echando un vistazo (a lo que consigo entender).

Me gusta el compilador de GNU porque es más genérico. Sirve para muchos micros.

Además, cuando compilas C y miras el listado producido en assembler, utiliza el mismo estilo que el ensamblador.

También puedes utilizar el compilador c avr-gcc para procesar ensamblador.
Si alguna vez combino ensamblador y c, prefiero no mezclar herramientas.

Por último, es una cuestión de apoyo a las herramientas open-source.


Killer: voy a mirar lo de la delta.
Yo estoy estudiando todavía las directivas de ensamblador.
He conseguido que ensamble sin problemas, pero como lo estoy haciendo con el avr-gcc me pide una rutina main que tengo que añadir.
Voy a intentar hacer un programa que desencripte una palabra conocida y que la envíe por la UART todo el tiempo para probar juntas todas las funciones.

Un saludo.

Conectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5109
Re: Bootloader encriptado para Attiny88
« Respuesta #41 en: 23 de Septiembre de 2015, 08:10:31 »
« Última modificación: 23 de Septiembre de 2015, 08:13:19 por Picuino »

Desconectado juaperser1

  • Colaborador
  • DsPIC30
  • *****
  • Mensajes: 2680
Re: Bootloader encriptado para Attiny88
« Respuesta #42 en: 23 de Septiembre de 2015, 10:01:39 »
Citar
Por último, es una cuestión de apoyo a las herramientas open-source.   

Pues para mi es un punto a tu favor, yo también apoyo las herramientas open-source.

Un saludo
Visita mi canal para aprender sobre electrónica y programación:

https://www.youtube.com/channel/UCxOYHcAMLCVEtZEvGgPQ6Vw

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 7231
Re: Bootloader encriptado para Attiny88
« Respuesta #43 en: 23 de Septiembre de 2015, 10:13:28 »
Citar
Me gusta el compilador de GNU porque es más genérico. Sirve para muchos micros.

Eso y que sigue el "standart" de las secciones .text /.data / .bss , etc. Lo cual hace que si te moves a un dsPIC/MIPS/ARM vas a seguir con el mismo manejo..
Y uno de los dolores de cabeza que tuve fue el de aprender eso a la fuerza cuando pase de mis PIC12/16/18 a un dsPIC o demas...
« Última modificación: 23 de Septiembre de 2015, 10:17:26 por KILLERJC »

Desconectado juaperser1

  • Colaborador
  • DsPIC30
  • *****
  • Mensajes: 2680
Re: Bootloader encriptado para Attiny88
« Respuesta #44 en: 23 de Septiembre de 2015, 11:13:30 »
Lo mejor, es que algunas empresas, como microchip, cogen el gcc, y te lo venden, poniendo alguna excusa, como la de la optimización.

Umm...no me gusta, es una de las cosas por las que voy a cambiar de marca.

Un saludo
Visita mi canal para aprender sobre electrónica y programación:

https://www.youtube.com/channel/UCxOYHcAMLCVEtZEvGgPQ6Vw


 

anything