Hola
Pues eso me gustaria rotar un byte en los cuatro doublewords que tiene un registro XMM. Hay una instruccion llamada vprotd pero no dispongo de la bandera XOP.
Como podria hacer ese tipo de rotacion, lo mas eficiente posible. Este es lo que pretendo.
0x63cab704ffed010408040cffee4488dd rot 1 ----> 0xcab70463ed0104ff040cff084488ddee
Un saludo.
Siento el doble post.
Ya solucione el problema, mire un fragmento de codigo por la red y lo adapte un poco a mis necesidades, pero no es valido para sign bytes, no funciono.
movl $0x102f5c2c, %ebx
movd %ebx, %xmm0
movdqa %xmm0, %xmm1
pslld $0x8, %xmm0 ; 0x2f5c2c00
psrld $0x18, %xmm1 ; 0x00000010
por %xmm0, %xmm1
Creo poder optimizarlo, pudiendo copiar el byte 0x10 del registro xmm1 podria ahorrarme el psrld y el por, creo que hay instrucciones que copian bytes a doblewords, lo bueno seria especificar en que posicion quieres copiar el byte.
Un saludo.
Si lo que quieres es rotar un solo byte a la izquierda sería más sencillo hacer:
shufps xmm0, xmm0, $93
Y en sintaxis AT&T:
shufps $0x93, %xmm0, %xmm0
Eso no es lo que quiero, lo que hace esa instruccion es rotar los Doubleword, y yo lo que quiero es rotar un byte a la izquierda de cada Doubleword, con esa instruccion que citaste quedaria de esta forma:
0x0000000000000000102f5c2c00000000
Lo que quiero hacer en una funcion Shiftrows del cifrado AES. Ya comprendo bien el cifrado lo que pasa es que lo quiero optimizar al maximo y no tengo las instrucciones AES-ni pero tampoco me valen de mucho por que el codigo ya no seria compatible, con otras maquinas. No puedo hacer una funcion como la que aparece en este codigo, seria muy comodo utilizar punteros y utilizar rotate de SSE.
http://comp.ist.utl.pt/ec-csc/Code/Ciphers/AES_Encrypt.cpp
Un saludo.
P.D: Tambien me gustaria saber como diseñar un buen encode para los ids, es que los de ShellStorm ya los entiendo todos, te digo esto porque eres el mod de malware, ire a molestar un rato ;D . Simplemente para aprender.
Viendo la función ShiftRows()... No sería equivalente a hacer 3 rol? O es que quieres hacerlo todo con sse?
No, con SSE2 y SSE3, ya que hacer esa funcion con punteros es mas pesado en ciclos que en los registros XMM.
Un saludo.
Sería genial poder ver el resultado final :D
Descuida, cuando este listo aqui estara.
Un saludo.
Edito:
Esta seria en SSE, lo que comentabas.
movdqu %xmm0, (%rsp)
roll $0x8, 0x4(%rsp)
roll $0x10, 0x8(%rsp)
roll $0x18, 0x0c(%rsp)
Pero deja mucho que desear, pero dejo otra pregunta, este cifrado es demasiado pesado para un malware?
No me refiero a un crypter sino en cifrar conexiones. Por eso lo quiero optimizar al maximo.
P.D: E visto malware que exportaba todo la libreria de openssl, si todo...
P.D2: No dispongo de la instruccion pshufb, esa estaria genial...
En cuanto a seguridad AES de 128bits y 8 rondas sería suficiente para estar tranquilo un par de años y teniendo en cuenta la implementación que estás haciendo dudo mucho que cree overhead.
Yo hago uso de AES 128 con CBC usando el API de W$ (Mi prioridad es minimizar el tamaño) y la latencia de la red supera con creces al tiempo de cifrar un paquete...
Cita de: Karcrack en 18 Septiembre 2013, 22:48 PM
En cuanto a seguridad AES de 128bits y 8 rondas sería suficiente para estar tranquilo un par de años y teniendo en cuenta la implementación que estás haciendo dudo mucho que cree overhead.
Vale, eso era lo que me preocupa los ciclos que consume.
Cita de: Karcrack en 18 Septiembre 2013, 22:48 PM
Yo hago uso de AES 128 con CBC usando el API de W$ (Mi prioridad es minimizar el tamaño) y la latencia de la red supera con creces al tiempo de cifrar un paquete...
Tambien tenia pensado implementar AES con CBC, aqui mismo tengo el pdf que habla de los bloques que descarge del nist.
Bueno supongo que al final de esta semana ya tendre algo, no he podido hacer nada.
Un saludo.
De momento no soy capaz de hacer nada estoy bloqueado, he estado mirando la instruccion punpckhw y de momento nada, tambien podria mirar de hacerla con xors, cualquier ayuda es bienvenida.
Solo optimize una la mas facil claro, rotword.
pshuflw $0xb1, %xmm0, %xmm0
pshufhw $0xb1, %xmm0, %xmm0
Le saque bastante en diferencia a la del codigo no?
Un saludo.
He leído de un ingeniero de Intel que no hay forma fácil de hacer ror/rol desde SSE ya que no está diseñado en la arquitectura y la forma que he visto recomendada es la de hacer una máscara or duplicando el registro, usando shift sin rotación... Exactamente lo que hacías en un inicio.
Cuando acabes de hacerlo para SSE hazlo para CUDA jaja :P
Si ya tengo una idea de como hacerlo con shift, pero entendi mal shiftrows no funciona de la manera que lo explique, bueno cuando tenga el codigo ya veras.
Bueno y sobre la funcion rotword creo que me quedo bastante mejor, este es del codigo de exemplo.
k = temp[0];
temp[0] = temp[1];
temp[1] = temp[2];
temp[2] = temp[3];
temp[3] = k;
Y este ejemplo lo saque de unos de los pdf de intel.
RotWord(X) = (X >> 8) | (X << 24)Y solo rotan uno, yo con esas dos instrucciones todos y sin usar direcciones de memoria, le saco bastante, pero bueno es la mas facil que hay jeje.
Cita de: Karcrack en 29 Octubre 2013, 09:24 AM
Cuando acabes de hacerlo para SSE hazlo para CUDA jaja :P
jajaja pero en realidad seria bueno hacerlo, se desperdicia mucha potencia de las tarjetas graficas, ejemplo mi HD 5870 tiene unos 2,7 TeraFlops, y sin contar los modelos nuevos que comercializaron Nvidia y AMD. Tesla FireGL...
Un saludo.
Edito:
Se rota un byte en rotword, tendre que corregirlo.
Como te prometi aqui tienes el codigo. Esta programado con la extension SSE2 asi que es bastante compatible con mas CPU's.
La funcion son unos 158 bytes seguro que no es una buena funcion para tus bichos jaja, bueno tambien mire que OPS y latencias podria consumir, lei unos documentos de Agner Fog que explicaba los OPS y las latencias que consumia cada instruccion de la CPU especifica. Tengo un K10 segun ese documento son unos
34 OPS y unas
77 Latencias, es lo que me importa, de verdad como lo ves?
Si quieres posteo el dissasembler de la funcion del codigo en C++, y me dices si esta implementacion es mas rapida.
Bueno aqui el codigo.
movdqa %xmm0, %xmm1
movdqa %xmm0, %xmm2
movdqa %xmm0, %xmm3
movdqa %xmm0, %xmm4
movdqa %xmm0, %xmm5
movdqa %xmm0, %xmm6
pslld $0x18, %xmm0
psrld $0x18, %xmm0
pslldq $0x4, %xmm1
psrld $0x18, %xmm1
pslld $0x18, %xmm1
psrld $0x18, %xmm2
psrldq $0x9, %xmm2
psrlw $0x8, %xmm3
psllw $0x8, %xmm3
pslld $0x8, %xmm3
psrldq $0x5, %xmm3
psllw $0x8, %xmm4
psrlw $0x8, %xmm4
psrld $0x10, %xmm4
pslldq $0xa, %xmm4
psllw $0x8, %xmm5
psrlw $0x8, %xmm5
psrld $0x10, %xmm5
psrldq $0x6, %xmm5
psrlw $0x8, %xmm6
pslld $0x10, %xmm6
pslldq $0xb, %xmm6
pxor %xmm1, %xmm0
pxor %xmm2, %xmm0
pxor %xmm3, %xmm0
pxor %xmm4, %xmm0
pxor %xmm5, %xmm0
pxor %xmm6, %xmm0Seguro que se puede mejorar algo, pero de momento paso.
Bueno hilo solucionado, y cualquier mejora sobre el codigo pues bienvenida.
Un saludo y siento el doble post.
Bueno, aqui les dejo la optimizacion, el anterior codigo parece una p**a chapuza al lado de este, esta 100% escrito por mi, lo sorprendente es que no vi ninguna implementacion en SSE2 para este tipo de funcion solo en SSSE3.
OPS 13 &
Latencia 30.5 en un K10.
.section .data
sldw:
.quad 0x000000ff000000ff,0x000000ff000000ff
slw:
.quad 0x0000ff000000ff00,0x0000ff000000ff00
shw:
.quad 0x00ff000000ff0000,0x00ff000000ff0000
shdw:
.quad 0xff000000ff000000,0xff000000ff000000
.section .text
.globl _start
_start:
movdqa %xmm0, %xmm1
movdqa %xmm1, %xmm2
movdqa %xmm2, %xmm3
andpd sldw, %xmm0
andpd slw, %xmm1
pshufd $0x39, %xmm1, %xmm1
pxor %xmm1, %xmm0
andpd shw, %xmm2
pshufd $0x4e, %xmm2, %xmm2
pxor %xmm2, %xmm0
andpd shdw, %xmm3
pshufd $0x93, %xmm3, %xmm3
pxor %xmm3, %xmm0En xmm0 es donde esta la matriz logico.
Un saludo.
Menudo cambio :D Todavía tengo que analizar ese código para ver que hace :laugh: Cuantos bytes ocupa con la lookup table esa?
El code son unos 75 bytes mas la tabla son unos 139 bytes algo se bajo, pero no es el peso si no la optimizacion, le saco el doble por lo menos, y ya no te digo lo que le saco a la de C++ jeje.
Bueno creo que esta bastante bien, ahora tengo que ir a por otra ya tengo shiftrows y rotword, ya las ire publicando en el subforo de criptografia que es el sitio mas indicado.
Y sobre el peso, creo que cuando lo tenga todo acabado no pasara de 1.3kB, ya dije anteriormente para que lo queria, tampoco pesa tanto no?
Un saludo.
El peso es algo anecdótico teniendo en cuenta que tú buscabas velocidad ^^
Bueno, le baje el peso en 10 bytes ahora son 129 bytes, simplemente copie la direccion a un registro de general purpose rsi creo que es el mejor para ese trabajo y quedo de esta forma, segun el manual que estoy leyendo mover una constante a un registro son 1 ops y 1 latencia, asi que se queda al final en 14 OPS & 31.5 Latencias, por 10 bytes creo que esta bien.
.section .data
sldw:
.quad 0x000000ff000000ff,0x000000ff000000ff
slw:
.quad 0x0000ff000000ff00,0x0000ff000000ff00
shw:
.quad 0x00ff000000ff0000,0x00ff000000ff0000
shdw:
.quad 0xff000000ff000000,0xff000000ff000000
.section .text
.globl _start
_start:
movq $sldw, %rsi
movdqa %xmm0, %xmm1
movdqa %xmm1, %xmm2
movdqa %xmm2, %xmm3
andpd (%rsi), %xmm0
andpd 16(%rsi), %xmm1
pshufd $0x39, %xmm1, %xmm1
pxor %xmm1, %xmm0
andpd 32(%rsi), %xmm2
pshufd $0x4e, %xmm2, %xmm2
pxor %xmm2, %xmm0
andpd 48(%rsi), %xmm3
pshufd $0x93, %xmm3, %xmm3
pxor %xmm3, %xmm0
Si alguien quiere probarlo que mueva la matriz de 4 x 4 a xmm0, aqui se da por sentado de que ya esta, cualquier pregunta o duda pues ya saben, bueno no me enrrollo mas y ahora si que doy el tema por cerrado.
Un saludo.