Hola

Depura el programa con gdb o cualquier otra herramienta, para saber donde esta la violacion de segmento. Aunque diria que en la linea 154-155.

Tendrias que hacer la comparacion antes de incrementar el puntero de %esi. Ya que me has dado a entender de que puedes ingresar los numeros no?

Por otra parte, por que no haces una funcion imprimir mensaje? y no tener tanto codigo?

Por que no tomas los numeros por argv?

Saludos.

Hola

Crea un directorio para el montaje de la particion. Con chown asigna a que grupo quieres que pertenezca ese directorio.

Da los permisos necesarios con chmod, luego monta la particion al directorio.

Si lo quieres hacer automatico, puedes editar tu fstab.

saludos.

Hola, cuanto tiempo ha pasado, deje de lado el problema por otros asuntos pero ya lo tengo resuelto, y de vez en cuando leo el foro y me acorde de este problema que publique. Y no me gusta dejar las cosas colgadas.

Bien, el ultimo codigo que comparti esta mal, interprete erroneamente el algoritmo y la multiplicacion de galois de GCM.

Lo que sucede es que GCM toma los bytes en little-endian y los bits en big-endian, hay estaba el problema a parte de algunas tonterias mas.

Por ejemplo el polinomio f = 1 + α + α2 + α7 = 0x87(10000111) pero en realidad es  0xe1 (11100001) ya que como dije anteriormente los bit son representados en big-endian.

Pues podemos aplicar todo eso al algoritmo de multiplicacion, que sucede que el bit menos significativo 0 es realidad es 127, si por ejemplo 0x80, se representa como 0x01. Aqui el codigo donde se puede ver todo lo que digo:

.section .data
 
R: .quad 0xb32b6656a05b40b6,0x952b2a56a5604ac0
S: .quad 0xffcaff95f830f061,0xdfa6bf4ded81db03
 
.section .text
.globl _start
.align 16
 
_start:
 
pxor %xmm0, %xmm0                        # xmm0 | Z
movdqu R, %xmm1
movdqu S, %xmm2
movdqu %xmm1, (%rsp)                     # rsp  | Y
movdqu %xmm2, -16(%rsp)                  # rsp-16  | V
 
_l02:
 
movq $15, %rax                           # byte position
 
_l01:
 
movq $7, %r8
 
_l0:
 
btq %r8, (%rsp, %rax)                 # check the bit posotion 0 - 7
jnc _l1                                 # bit equal to 0,  jump to _l1
 
movdqu -16(%rsp), %xmm3
pxor %xmm3, %xmm0                        # bit equal to 1, Z xor V
 
_l1:
 
btq $0, -16(%rsp)                        # check V[127] equal to 1 V = rightshift(V) xor R
jc _l2                                   # equal to 0, V = rightshift(V)
 
 
movq -8(%rsp), %rbx
shlq $63,%rbx
shrq $1, -8(%rsp)
shrq $1, -16(%rsp)                       #Rightshift V in memory
orq %rbx, -16(%rsp)
 
jmp _l3
 
_l2:
 
movq -8(%rsp), %rbx
shlq $63, %rbx
shrq $1, -8(%rsp)
shrq $1, -16(%rsp)                       #Rightshift V in memory and xored by R
orq %rbx, -16(%rsp)
xorb $0xe1, -1(%rsp)
 
_l3:
 
decq %r8                                   #next bit position
jns _l0                                     #r9 equal to 0, jump to next byte
 
decq %rax                                  #byte addition, rax equal to 0, block finished
jns _l01
 
 
//RET Z IN XMM0

R Y S son los valores a multiplicar sacados de un Test vector. Bueno lo dejo aqui. Seguramente que tenga las tablas para algun dia... voy haciendo cuando puedo.

Saludos.

P.D:Cualquier pregunta ya saben.

Hola

Cuanto tiempo ha pasado ya, disculpas por abandonar el tema pero he tenido que ocuparme de otras cosas.

Aqui dejo el codigo, lo he testeado a mano siguiendo el algoritmo del PDF del NIST el 1. Testeado con 1 byte.

Se que se puede mejorar, pero no he encontrado un TEST VECTOR para este algoritmo, como los que hay en el PDF de AES al final de todo.

He pensado en contruir todo el PAPER del NIST y luego retomar esto de las las tablas, no se o ire tirando.

.section .text
.globl _start
.align 16
 
_start:
 
pxor %xmm0, %xmm0                        # xmm0 | Z
movdqu %xmm1, (%rsp)                     # rsp  | x
movdqu %xmm1, -16(%rsp)                  # rsp  | V
 
_l02:
 
movq $-16, %rax                           # contador byte
 
_l01:
 
xorq %r8, %r8                          # contador bit 
movq $-8, %r9
 
_l0:
 
btq %r8, 16(%rsp, %rax)                 # compruebo el bit  de el primer byte
jnc _l1                                  # si el bit es 0,  paso a LSB
 
movdqu -16(%rsp), %xmm3
pxor %xmm3, %xmm0                        # si el bit es 1, Z xor V, paso a LSB
 
_l1:
 
btq $63, -8(%rsp)                        # compruebo el ultimo bit 127 LSB 1 (V)
jc _l2
 
movq -8(%rsp), %rbx
shlq $63, %rbx
shrq $1, -8(%rsp)
shrq $1, -16(%rsp)                       # LSB(V)=0
orq %rbx, -16(%rsp)
 
jmp _l3
 
_l2:
 
movq -8(%rsp), %rbx
shlq $63, %rbx
shrq $1, -8(%rsp)                        #LSB(V)=1
shrq $1, -16(%rsp)
orq %rbx, -16(%rsp)
xorq $0x00000000000000e1, -16(%rsp)
 
_l3:
 
incq %r8
incq %r9
js _l0
 
incq %rax
js _l01

El codigo en realidad no es muy bueno, comparandolo con las tablas GCM, y ni hablar del paso de parametros. Y todas las operaciones las realizo en memoria.

Me gustaria encontrar un test vector de este algoritmo, si alguien sabe algo por favor que me lo diga, o que me confirme que el codigo opera bien.

Saludos.

Mediana-Grande empresa, es un maldito caos, llegaba a los sitios desinformado, en plan buscate la vida...


Estaria bien "educar" a los usuarios, el ejemplo del usuario @Reent esta bien.

Increible eso que dices, de las copias de seguridad con los ordenadores apagados...

A saber de donde se han infectado, tal y como estaba la cosa montada de bien, exactamente los AV no sirven practicamente para nada, en la maqueta que puse tenia el ATP, pero todo lo demas nada de nada.

Gracias a todos por los comentarios, ya veo que no ha sido una malinterpretacion mala por mi parte del trabajo y era un autentico desastre.

Saludos.

Hola

He estado una temporada trabajando para una empresa que mantenia unas sedes de una aseguradora, haciendo el mantenimiento de equipos etc...

El otro dia nos enviaron a X sede para, para maquetar los PC, ya que como no era de extrañar estaban infectados por un ransomware y tenian los archivos cifrados.

El primer problema que veo, es que tenian una copia de seguridad del 18 de agosto y ellos fueron infectados a finales de agosto, eso significa que entre el 18 y el 31, han perdido todo esos datos por no tener respaldo.

Es lo que me dice la oficinista, yo en plan "que quieres que te diga", la seguridad brilla por su ausencia, almacenan los archivos en los mismos pc con los que trabajan, abren cualquier mail desde esos pc, y se extrañan de que pasen esas cosas??? Estaban navegando con el IE9 si señores con el IE9.

Aparte que las maquetas eran una *****, pero eso es otra historia.

Pero no es mejor tener un server dedicado para los mail? Hacer copias de seguridad de los archivos cada dia o hora, a un equipo externo dedicado a ello? Directamente se podrian usar Jails de FreeBSD para arreglar esos problemas, o con una politica de permisos adecuada. Por que coño no hacen eso?

Es eso normal en las empresas? Estoy flipando con todo lo que he visto, y creo que me quedo corto con todo lo que he dicho. Hoy he dejado el trabajo, estaba cansado aun que no sea el momento adecuado para esas cosas.

Si eso es una empresa seria, no se como seran las otras. Pensais que lo mismo que yo, o creeis que esta todo bien?

Saludos.

P.D: El unico sistema de seguridad, era MCafee, que se evade con unas cuantas lineas de codigo, tener solo eso no es seguridad.

Hola

Agradezco el apoyo, ya tengo algo terminado, cuando tenga todo listo lo subire, yo tambien hace tiempo que no digo nada por el echo que ahora mismo estoy haciendo otra cosa, como arreglarme la moto xD, no es broma.

A el codigo que subi esta mal, en casi todo, no se que me fumaria aquel dia, ya pondre el bueno.

Saludos.

Hola

Está bien, creo que lo has entendido mal. En los dos primeros printf muestra el valor de la variable y su dirección. En los dos segundos el primer printf muestra el valor de la variable ya que está apuntando a esta (almacena su dirección), el por qué no te muestra la dirección de la variable es por qué el mismo puntero tiene su dirección, es una dirección que almacena otra.

Saludos.

Voy a dejar mis avances, creo que ya casi lo tengo, el algoritmo numero 3 el de la creacion de la tabla M0 es de la siguiente manera:


Eso crearia la tabla M0 de 4096 bytes a partir de H, pero tengo la siguente duda, ya que me quedaria por crear la tabla de R que son 1024 bytes. Supongo que se refiere a esto:


Otra cosa que aun no he entendido es en el algoritmo 2 a la hora de usar las tablas M0, en la directiva byte(X,i), no la he encontrado documentada en el paper, pero supongo que tomara el byte de X segun el valor de i, pero no entiendo lo siguiente, en el caso de ser el valor de X "0xff" se haria un XOR a Z con esa tabla, pero como estan las tablas enumeradas? No se si me explico.

Saludos.

Hola

Parace que voy entendiendo mas el paper, voy a explicarlo:

Cuando tengo que multiplicar por la variable P no es mas que un shift a los indices (creo que eso ya me lo has explicado @kub0x). Arriba de la pag 10 tengo el ejemplo de la multiplicacion por X · P y supongo que le de abajo es para multiplicar dos elementos.


Practicamente es lo mismo que el algoritmo 1, que explique en mi anterior duda de la sintaxis, si no me equivoco:


Por lo que entiendo:


Segun los ejemplos de la pag 9 en las formulas (3) (5), serian lo mismo no?

Bien ya en la pag 11 en el ejemplo de la desconposicion de X (7), xi hace referencia a 1 byte de X, pero mi duda esta en P^8i, en el primer for 8·i daria cero y al final cuando i es 15 daria 120. Esa parte no la entiendo mucho la verdad.

Creo que la respuesta esta en estos parrafos:


Pasando al algorimo 3 y a su explicacion arriba, vale creo que entiendo la funcion, en la explicacion cuando dice esto:



Partiendo de que el valor de i es 64, Ese ciclo multiplicaria por P ocho veces si no me equivoco.

Bien y en la parte de la multiplicacion por P:


Y las 247 adiciones seria:


Estoy en lo cierto?

Creo que con eso ya bastaria para crear la tabla M0, pero no entiendo lo de las elevacion a P a 8, 128 o i.

Saludos y gracias.