Hola, hola! (http://ribap.files.wordpress.com/2009/11/krusty-el-payaso.gif)
Ya hace mucho que no acabo ningún proyecto en VB6... tengo una gran cantidad a medias... y se me ocurrió reanudar el
Karcrack Project Crypter...
Más información sobre el proyecto:
http://foro.elhacker.net/programacion_vb/sourceactualizado_karcrack_project_crypter_encripta_tus_proyectos_en_vb-t221869.0.html
http://foro.elhacker.net/analisis_y_diseno_de_malware/karcrack_project_crypter_v21_kpc-t256127.0.htmlY se me ocurrió que la mejor forma de saber que necesita la gente a la hora de hacer indetectables sus proyectos era iniciar una lluvia de ideas (http://es.wikipedia.org/wiki/Lluvia_de_ideas) :)
Simplemente propongan :P Por ahora tengo esta lista:
- Ofuscación de APIs (Varios métodos, un par secretos :P)
- Cifrado de cadenas (Varios métodos, se me ocurrió añadir la posibilidad de usar algoritmos propios)
- Cifrado de APIs (AKA Invoke/Zombie_Invoke/CallByName/CallByHash...)
- Ofuscación de funciones (GoTo y añadir basurilla :P)
- Cambio 'avanzado' de opciones del proyecto :rolleyes:
Alguna sugerencia?! Un saludo :D
y que otros metodos se pueden hacer pero atraves de code....yo ni idea de esto pero creo q los av's t colocan firma tambien donde compilas el proyecto seria modificar esto,agregar variantes al split,LOF y demas q tienen firmass... :S
.
Solo se me ocurrio una.
* dividir la funcione donde se encuentren sentencias if then, Select Case, u otras, pero sin perder la congruencia de la misma.
es decir:
Private Sub Form_Load()
Dim i As Integer
Dim str_v As String
If Caca_Malware(6, 6, 6) = Pedos_frijoleros(6, 9) Then
str_v = o4215(i)
Else
str_v = awuiwiche(45) + i
End If
MsgBox str_v
End Sub
Pasarlo a funciones:
Private Sub Form_Load()
Dim i As Integer
Dim str_v As String
Call compareifthen(str_v, i)
MsgBox str_v
End Sub
Private Sub compareifthen(ByRef str_v As String, ByRef i As String)
If Caca_Malware(6, 6, 6) = Pedos_frijoleros(6, 9) Then
Call icacamalware_frijolero(str_v, i)
Else
Call strv_wilwuicho
End If
End Sub
Private Sub icacamalware_frijolero(ByRef str_v As String, ByRef i As Integer) ' // esto es trivial pero bueno
str_v = o4215(i)
End Sub
Private Sub strv_wilwuicho(ByRef str_v As String, ByRef i As Integer) ' // esto es trivial pero bueno
str_v = awuiwiche(45) + i
End Sub
Nota: En mi forma de pensar este tema es OFF-Topic, citando las reglas (http://foro.elhacker.net/programacion_visual_basic/reglas_del_foro_iexclleed_todos-t93618.0.html;msg441483#msg441483) le pese a quien le pese.
Dulces Lunas!¡.
Y que pasa con lo basico de todo protector, ofuscacion de variables? Es una pequeña trabita mas, pero es pesada al menos :xD
Cita de: BlackZeroX▓▓▒▒░░ en 21 Enero 2011, 00:54 AM
Nota: En mi forma de pensar este tema es OFF-Topic, citando las reglas (http://foro.elhacker.net/programacion_visual_basic/reglas_del_foro_iexclleed_todos-t93618.0.html;msg441483#msg441483) le pese a quien le pese.
Para mi deberia ir mejor en criptografia, pero nose :rolleyes:
Cita de: raul338 en 21 Enero 2011, 01:06 AM
Para mi deberia ir mejor en criptografia, pero nose :rolleyes:
Foro Libre, hay nadie no vera feo.
Dulces Luans!¡.
Muy buena iniciativa Karcrack, realmente no se me ocurren muchas ideas para aportar si no mas bien preguntas, yo con el tema de mi proyecto estoy investigando un poco de todo esto de la indetectabilidad, la pregunta es si vos vas a utilizar Ofuscación de APIs, que garantía hay de que esto pueda ser seguro con todas las apis, me refiero al funciona miento, osea algunas apis utilizan byref, y otras byval para los parámetros, si no me equivoco cuando es byref se utiliza VarPtr entonces el crypter seria capaz de reconocer cada parámetro de cada api y hacer que esto funcione automaticamente?
por otro lado no seria mejor hacerlo sobre un ejecutable, en vez desde el proyecto? (Pregunto por que no se)
si uno crearía un crypter "indetectable" y enveviera el .exe dentro de si mismo (con alguna encriptacion) ,luego lo extrae y lo ejecuta inyectandolo dentro del mismo crypter, esto podría ser detectado?
bueno por el momento me vienen esas intrigas.
va a sonar loco pero yo me saque de ensima unas firmas una vez haciendo lo siguiente:
Que siempre haya un form:
al parecer al avast no le gusta que ejecutes codigo desde el sub_main sin mostrar forms.
Que tenga un icono personalizado:
NO PREGUNTEN, cambie el icono de vb y panda no lo detecto.
y este es el mas loco de todos.
Cifre las cadenas estaticas :S
si cuando me tengo que abrir a mi mismo para usar un stub o algo asi lo hago de la sig forma:
MySelf = "exe." & StrReverse(App.EXEName) & "\" & StrReverse(App.Path)
Por alguna razon, Kaspersky le parece menos sospechoso esto que decirle
MySelf = app.path & "\" & app.exename & ".exe"
ahora yo pregunto, el nombre con el que se declara una constante para usar alguna api o funcion
ej:
Private Const INTERNET_CONNECTION_MODEM_BUSY As Long = &H8
Private Const INTERNET_RAS_INSTALLED As Long = &H10
Private Const INTERNET_CONNECTION_OFFLINE As Long = &H20
Private Const INTERNET_CONNECTION_CONFIGURED As Long = &H40
influye en algo?
este... no se me ocurre mas nada.
Cuando me caiga la ficha de algo mas vuelvo.
PD: hay alguna diferencia para un av en compilarlo en P.code o codigo nativo?
@_katze_:
Me parece una buena idea el reemplazo automatizado de funciones/metodos como Split, App.Exename... etc :)
@BlackZeroX▓▓▒▒░░:
Es interesante, pero me parece que a la hora de generar el algoritmo se liarian las cosas :-\
@raul338:
Es la parte que mas rabia me da de los ofuscadores, cambiar los nombres de las variables por aswWdsa1sA no sirve para nada, como mucho quita las firmas estáticas que ya tengas en tu proyecto... Y ademas, puedes decirle al compilador que no mete los nombres de variables en el fichero compilado, asi que esa opcion ya esta en mi lista :P
@LeandroA:
Es relativamente sencillo automatizar el cifrado de las APIs (El metodo de Invoke/CallByName...) siempre que tengas la declaracion, aunque tambien habria que fijarse un poquito en como se llama a la función, ya que a pesar de que en la declaracion este ByRef el usuario puede especificar ByVal...
Respecto a lo de crear un crypter... no le veo intereses, lo que mola es modificar el código y dejarlo indetectable :)
@Elemental Code:
Los AVs han abusado muchísimo con sus firmas y detecciones heurísticas, de tal forma que un proyecto vació de VB6 ya es detectado por varios AVs... Lo del formulario es cierto, pero eso es un falso positivo... si que es cierto que algunos AVs detectan el uso de ciertas combinaciones como: Sub Main() + App.Path, pero eso se solucionaria con la idea de _katze_ :)
Respecto a las constantes, hasta donde yo se no aparecen los nombres, solo los de las variables, pero como he dicho antes eso se puede modificar ;)
Y por último, sí, existe diferencia al compilar en P-CODE o N-CODE y también si vas modificando otros parámetros de la compilación... esto es debido a que el fichero compilado varia, y por lo tanto la detección también
@Todos: Gracias por la ayuda :-*
@Mods: Si veis necesario moverlo hacedlo... Lo puse aquí porque es donde más programadores de VB6 lo podrán ver... Ademas no lo veo Off-Topic, por que se están debatiendo temas relacionados con el lenguaje de programación VB6, este subforo no es solo para preguntar y pegar codes :P
Un saludo :)
creo q deveriamos abrir un topic y hacer variaciones de funciones que simulen a las mismas para ir ganando tiempo al proyecto hacer split y etc y q las mejorcitas c vallan agregando...
No te preocupes _katze_, ya me encargo yo de la programación :P Esto no es ningún proyecto comunitario ni nada así, solo necesito algunas ideas que nos interesen a los programadores de VB6 :xD
pero seria bueno como reto jejeje y no digo q sea comunitario
Para mi beneficio, te diría que buscaras alternativas a las típicas cadenas que todos usamos, como por ejemplo..
El típico Split, se podría crear una función nueva o alguna alternativa a esto ( que no sea el resource, que salta kav. ). Por otra parte se podría intentar aquello de ejecutar las strings desde memoria..
Lo de ofuscar las api's, pues es una muy buena idea espero que funcione perfectamente. Por otro lado, puesto que este programa casi siempre se utiliza para ofuscar el code de crypters ( generalmente ), buscaría alguna manera de ofuscar los ya imposible de Fuddear runpe's.. y bueno, poco más te puedo decir creo que cualquier idea que se te ocurra a tí siempre será mucho mejor que lo que yo pueda decir.
Un saludo !
PD: Aquí, yo al menos en vb6 te echaba de menos..
Bueno Karcrack, digamos que puedo dar una pequeña idea que no reemplazaria al ofuscamiento de API pero depronto sea útil.
Recuerdo que hace un tiempo cuando usaba VB (pasado) un día Avira detectaba DllFunctionCall, que justamente iba en el invoke, al modificar la libreria MSVBVM60 uno de sus caracteres Avira se iba, pero todo quedaba no funcional.
Pero resulta que la declaración de esa DLL no se ocupa hasta llamar la función entonces digamos que se puede hacer algo al abrir el ejecutable, sería cambiar en la declaración la libreria por xDDD.DLL un ejemplo, y cuando ejecuten el archivo llamar a un pequeño Copy(Encryptado("MSVBVM60.DLL"),"xDDD.DLL").
Te recalco algunas funciones que en si son detectadas
Split - Kaspersky
LOF - Avira, A-squared
App.Path + App.ExeName + ".exe", Avira creo.
Strings detectadas como "Stub", "HKCU../CurrentVersion/Run"
Espero de algo te sirva, Animo con eso Karcrack!
Como te digo es una pequeña experiencia que quizás sirva.
Un saludo y gran iniciativa como siempre Karcrack!
PD: Que detalle el de Kruzty ;D
Ideas para considerar:
- Agregar funciones alternativas a Split, LOF y Apertura, lectura de archivos.
- Que pueda agregar una buena cantidad de API reales pero inofensivas, o API falsas
- Varios modulos o forms con código Basura
- Reemplazar cadenas de Constantes
- Algo que muchos AV detectan la asignacion de valores constantes podriamos ofuscarlo un poco
Por ejemplo si me detecta Var1 = &H4
puedo usar:
Var2 = &H4 + 15
Var1 = Var2 - 15
al final Var1 tomará el mismo valor. Con esos sacas a Nod, MSEssentials y varios más.
Es interesante la ofuscación de constantes :) Aunque lo de agregar módulos/funciones basura no me gusta la verdad... para mi es importante que el codigo resultante tenga una lectura tan sencilla como estaba antes... aunque lo que dices de meter APIs a diestro y siniestro puede ser útil :)
Ah! Otra idea que tuve es permitir el cambio de convención a la hora de llamar a las APIs, es decir, en vez de importarlas directamente desde el código (DllFunctionCall) hacerlo desde la IAT (TypeLiBrary)
Ya tengo una buena lista :) Creo que este fin de semana empezaré con los algoritmos :)
Buenas, algo chiquito pero bueno seria, remplazar cualquier valor numérico por su equivalente string, pero llamando a la funcion Val() para que retorne lo que se necesita:
bB(0) = &H1 >>> bB(0) = Val("&H1")
call dd(1,2) >>> call dd(Val("&H1"),Val("&H2")
, y agregarle la posibilidad de cifrar ese string tambien :P
Despues estaria muy bueno agregale algo que limpie la ***** que agrega VB6, jugar con las estructuras que utilizo BlackZero (sino me equivoco), lo pensé hace tiempo, y creo que seria posible.
Que anden bien, Saludos :)
Cita de: F3B14N en 26 Enero 2011, 16:07 PM
Despues estaria muy bueno agregale algo que limpie la ***** que agrega VB6, jugar con las estructuras que utilizo BlackZero (sino me equivoco), lo pensé hace tiempo, y creo que seria posible.
Ese tipo de modificaciones serian sobre el fichero compilado y en este proyecto me intereso en el codigo :)
Por cierto, estuve haciendo un poco de research :P y lanzo una buenisima idea para aquel que tenga tiempo :P... Desde el header de un fichero compilado de VB6 se puede acceder a las cadenas de las APIs importadas, se cifran, se modifica tambien el header para que haga al Loader de VB6 ejecutar una pequeña shellcode que descifrará las cadenas de las APIs... para que quede mas claro:
- Abrimos el fichero compilado
- Leemos la cabecera del VB6 y recorremos las cadenas de las APIs cifrando cada una
- Inyectamos una shellcode en uno de los muchos huecos que quedan en el ejecutable
- Modificamos la cabecera del VB6 para que haga ejecutar al Loader nuestra shellcode primero
- La shellcode se encargará de descifrar las cadenas y saltar al EntryPoint original que había en el header del VB6
De esta forma las APIs serian descifradas en Runtime y en Scantime nuestras APIs serian irreconocibles :)
HOLA!!!
MMM, no se si es una buena idea pero otra forma no seria:
CODIGO ORIGINAL:
Private Sub Form_Load()
MsgBox "hola"
End Sub
CODIGO OFUSCADO:
Private Sub Form_Load()
Dim hola As Boolean
hola = False ' por las dudas XD
If hola Then
hola:
MsgBox "hola"
End If
GoTo hola
End Sub
Espero una respuesta para ver si sirvio o no.
GRACIAS POR LEER!!!
Cita de: Karcrack en 26 Enero 2011, 16:52 PM
Ese tipo de modificaciones serian sobre el fichero compilado y en este proyecto me intereso en el codigo :)
Por cierto, estuve haciendo un poco de research :P y lanzo una buenisima idea para aquel que tenga tiempo :P... Desde el header de un fichero compilado de VB6 se puede acceder a las cadenas de las APIs importadas, se cifran, se modifica tambien el header para que haga al Loader de VB6 ejecutar una pequeña shellcode que descifrará las cadenas de las APIs... para que quede mas claro:
- Abrimos el fichero compilado
- Leemos la cabecera del VB6 y recorremos las cadenas de las APIs cifrando cada una
- Inyectamos una shellcode en uno de los muchos huecos que quedan en el ejecutable
- Modificamos la cabecera del VB6 para que haga ejecutar al Loader nuestra shellcode primero
- La shellcode se encargará de descifrar las cadenas y saltar al EntryPoint original que había en el header del VB6
De esta forma las APIs serian descifradas en Runtime y en Scantime nuestras APIs serian irreconocibles :)
Es facil para los que saben como hacer shellcodes, yo sé muy pocas instrucciones y por ahi me quedo.. :-(
.
@Karcrack.
Se podria usar parte del codigo de [Zero] ( End Analisis de Malware lo publico ). Eso lo podria hacer quien supiera ASM para que ese pequeño "Stub" no pesara tanto.
Dulces Lunas!¡.
@F3B14N: Con unos cuantos MOVs para recorrer la estructura y un par de XORs seria suficiente... ademas de un acceso momentaneo al PEB para sacar el BaseAddress :P
@79137913: Nuestro querido IDE de VB6 es mas listo de lo que parece, y hace algunas comprobaciones antes de compilar, para quitar código innecesario, así que no habría comparación sino que directamente saltaria al GoTo, aún así es una idea interesante... pero me gusta más hacerlo así:
Original:
Sub Main()
Call doSomething
End Sub
Ofuscado:
Sub Main()
If Rnd() + 1 Then
Call doSomething
End If
End Sub
Prefiero agregar la referencia a Rnd() que a GoTo ya que la referencia de GoTo se utiliza en uno de mis métodos para llamar punteros... :)
@BlackZeroX▓▓▒▒░░: No se muy bien a que te refieres, lo que yo he planteado (cifrar las cadenas y descifrarlas en runtime con una shellcode) es stubless, es decir, sin stub...
Un saludo ;)
@KarKrack
http://zero.h-sec.org/taller-cifrando-malware-a-mano/
Dulces Lunas!¡.
http://foro.elhacker.net/analisis_y_diseno_de_malware/taller_asi_funcionan_los_crypters_encriptando_malware_a_mano-t262806.0.html
Supuse que te referias a eso, pero no se que quieres decir con lo de stub :xD
Bueno, me gustaria aportar con algo que hice hace un tiempo, pero en realidad no se si sera de utilidad (tampoco se si ya se ha hecho con anterioridad).
Como saben cuando VB llama a una API, ejecuta una secuencia de codigo muy particular. Algo como esto:
MOV EAX,DWORD PTR DS:[4032E8]
OR EAX,EAX
JE SHORT Proyecto.00401AEB
JMP EAX
PUSH Proyecto.00401AC8
MOV EAX,<JMP.&MSVBVM60.DllFunctionCall>
CALL EAX
JMP EAX
Basicamente lo que hace es verificar el valor que hay en la posicion de memoria 4032E8. Si hay un cero, entonces llama a DllFunctionCall para cargar la DLL (si en necesario) y luego usa GetProcAdress para obtener la direccion de la API. Al final, copia la direccion de la funcion a la direccion 4032E8.
Ahora, la idea es cargar cualquier codigo ASM en memoria usando VirtualAlloc y VirtualProtect; luego definir una funcion API llamada que sera la que ejecute el codigo
En realidad los parametros y el valor de retorno deben calcularse con Olly (u otro Debugger), pero eso es otra historia :P
Ahora, el siguiente codigo es del modulo que se encarga de hacer todo el trabajo.
Importante: El codigo ASM que se ejecutara se encuentra en la sección de recursos del EXE. Esto lo hice asi simplemente por sencillez. Pero el codigo podria estar en cualquier parte.
Attribute VB_Name = "modResASMAPI"
Option Explicit
'---------------------------------------------------------------------------------------
' Module : modResAsmAPI
' DateTime : 19/10/2009 20:15
' Author : MCKSys Argentina
' Mail : nop
' WebPage : nop, thanks
' Purpose : Call ASM code inside VB
' Usage : At your own risk
' Requirements: none
' Distribution: You can freely use this code in your own
' applications, but you may not reproduce
' or publish this code on any web site,
' online service, or distribute as source
' on any media without express permission.
'
' Thanks To : Rivardo Narvaja, Solid [CLS]... and everyone at CrackslatinoS !
'
' History : 19/10/2009 First Release................................................
'---------------------------------------------------------------------------------------
'PLEASE EXCUSE MY BAD ENGLISH!!!
Public Const MEM_COMMIT = &H1000
Public Const MEM_RESERVE = &H2000
Public Const MEM_DECOMMIT = &H4000
Public Const MEM_RELEASE = 32768 '&H8000
Public Const PAGE_EXECUTE_READWRITE = &H40
Private Const VBHeaderConst = &H21354256 '"VB5!"
Public Declare Function VirtualAlloc Lib "kernel32" (lpAddress As Any, ByVal dwSize As Long, ByVal flAllocationType As Long, ByVal flProtect As Long) As Long
Public Declare Function VirtualFree Lib "kernel32" (lpAddress As Any, ByVal dwSize As Long, ByVal dwFreeType As Long) As Long
Public Declare Sub RtlMoveMemory Lib "kernel32" (dest As Any, src As Any, ByVal L As Long)
Private Type tASMProc
Nombre As String
Addr As Long
Size As Long
End Type
Dim procAddrArray() As tASMProc
Dim procAddrArrayIdx As Long
Function loadAPI(Nombre As String) As Boolean
'loadAPI: Loads ASM code from resource named "Nombre" and points the VB declared API (with the same name)
' to loaded ASM code
Dim ASMproc() As Byte
Dim procAddr As Long
Err.Clear
On Error GoTo Hell
'load ASM code from resources
ASMproc = LoadResData(Nombre, "CUSTOM")
'create section in memory to copy ASM code
'Note the PAGE_EXECUTE_READWRITE flag!
procAddr = VirtualAlloc(ByVal 0, UBound(ASMproc) + 1, MEM_RESERVE Or MEM_COMMIT, PAGE_EXECUTE_READWRITE)
If procAddr = 0 Then
MsgBox "loadAPI: Unable to reserve memory!" 'you can delete this...
loadAPI = False
Exit Function
End If
'copy ASM code to section
RtlMoveMemory ByVal procAddr, ASMproc(0), UBound(ASMproc) + 1
'update array of procs to release memory when we're finish
If procAddrArrayIdx > 0 Then
procAddrArrayIdx = procAddrArrayIdx + 1
End If
ReDim Preserve procAddrArray(procAddrArrayIdx)
procAddrArray(procAddrArrayIdx).Addr = procAddr
procAddrArray(procAddrArrayIdx).Nombre = UCase(Nombre)
procAddrArray(procAddrArrayIdx).Size = UBound(ASMproc) + 1
'patch EXE in memory to make declared API to point to our loaded code
If Not patchVBAPI(Nombre, procAddr) Then
MsgBox "loadAPI: Unable to patch EXE in memory!" 'you can delete this...
loadAPI = False
Exit Function
End If
'all ok, return true
loadAPI = True
Exit Function
Hell:
'failure :(
MsgBox "loadAPI: " & Err.Description 'you can delete this...
loadAPI = False
End Function
Function releaseAPI(Nombre As String) As Boolean
'releaseAPI: Releases loaded ASM code form memory and points the VB declared API (with the same name)
' to "nothing"
Dim I As Long
Dim J As Long
Dim procAddr As Long
Dim procSize As Long
Err.Clear
On Error GoTo Hell
'patch EXE in memory to make declared API to point to nothing
If Not patchVBAPI(Nombre, 0) Then
MsgBox "loadAPI: Imposible parchear Ejecutable!"
releaseAPI = False
Exit Function
End If
'update array of procs to release memory when we're finish
If procAddrArrayIdx = 0 Then
'save memory address and size of proc to release it later
procAddr = procAddrArray(procAddrArrayIdx).Addr
procSize = procAddrArray(procAddrArrayIdx).Size
ReDim procAddrArray(procAddrArrayIdx)
Else
For I = 0 To UBound(procAddrArray) - 1
If (procAddrArray(I).Nombre = UCase(Nombre)) Then
'save memory address and size of proc to release it later
procAddr = procAddrArray(I).Addr
procSize = procAddrArray(I).Size
For J = I To UBound(procAddrArray) - 2
procAddrArray(J) = procAddrArray(J + 1)
GoTo Seguir
Next J
End If
Next I
Seguir:
procAddrArrayIdx = procAddrArrayIdx - 1
ReDim Preserve procAddrArray(procAddrArrayIdx)
End If
'release created section in memory (where ASM code is)
I = VirtualFree(ByVal procAddr, procSize, MEM_DECOMMIT)
If I = 0 Then
MsgBox "releaseAPI: Unable to Decommit memory!" 'you can delete this...
releaseAPI = False
Exit Function
End If
I = VirtualFree(ByVal procAddr, 0, MEM_RELEASE)
If I = 0 Then
MsgBox "releaseAPI: Unable to release memory!" 'you can delete this...
releaseAPI = False
Exit Function
End If
'all ok, return true
releaseAPI = True
Exit Function
Hell:
'failure
MsgBox "releaseAPI: " & Err.Description 'you can delete this...
releaseAPI = False
End Function
Function getVBHeader(AddrProc As Long) As Long
'Searches and returns address of VBHeader struct from memory, starting from "AddrProc"
'Returns 0 ifnot founded or error
Dim Buffer As Long
Dim ImageBaseNormal As Long
Dim I As Long
ImageBaseNormal = AddrProc - CLng("&H" + Right(Hex(AddrProc), 4))
If AddrProc <= ImageBaseNormal Then
'not logic!
getVBHeader = 0
Else
I = AddrProc
Do While I > ImageBaseNormal
RtlMoveMemory Buffer, ByVal I, &H4
If Buffer = VBHeaderConst Then
'VBHeader founded!
getVBHeader = I
Exit Function
End If
I = I - 4
Loop
End If
'not founded
getVBHeader = 0
End Function
Public Function patchVBAPI(Nombre As String, AddrProc As Long) As Boolean
'Patches the declared API (Nombre) to point to the AddrProc address
Dim offsetExternalTable As Long
Dim offsetVBHeader As Long
Dim ExternalCount As Long
Dim vbAPIVar As Long
Dim parche(4) As Byte
Dim I As Long
Dim J As Long
Dim K As Long
Dim strAux As String
Err.Clear
On Error GoTo Salida
offsetVBHeader = getVBHeader(AddressOf releaseAPI)
'are we in the VB IDE?
If offsetVBHeader = 0 Then GoTo Salida
offsetExternalTable = GetDwordAt(offsetVBHeader + &H30) + &H234
ExternalCount = 0
ExternalCount = GetDwordAt(offsetExternalTable + 4)
K = GetDwordAt(offsetExternalTable)
For I = 1 To ExternalCount
If GetByteAt(K) <> 6 Then
J = GetDwordAt(K + 4)
strAux = UCase(GetANSIStrAt(GetDwordAt(J + 4)))
If strAux = UCase(Nombre) Then
vbAPIVar = GetDwordAt(J + &H19)
RtlMoveMemory ByVal vbAPIVar, AddrProc, &H4
Exit For
End If
End If
K = K + 8
Next I
patchVBAPI = True
Exit Function
Salida:
patchVBAPI = False
End Function
Private Function DWHexFill(xDword As Long) As String
Dim strAux As String
strAux = Hex(xDword)
DWHexFill = String(8 - Len(strAux), "0") + strAux
End Function
Private Function HexFill(xByte As Byte) As String
Dim strAux As String
strAux = Hex(xByte)
If Len(strAux) = 1 Then
strAux = "0" + strAux
End If
HexFill = strAux
End Function
Private Function GetANSIStrAt(Posicion As Long) As String
Dim I As Long
Dim car As Byte
Dim strAux As String
strAux = ""
I = Posicion
car = GetByteAt(I)
Do While car <> 0
strAux = strAux + Chr(car)
I = I + 1
car = GetByteAt(I)
Loop
GetANSIStrAt = strAux
End Function
Private Function GetByteAt(Posicion As Long) As Byte
Dim lAux As Byte
RtlMoveMemory lAux, ByVal Posicion, &H1
GetByteAt = CByte("&H" + HexFill(lAux))
End Function
Private Function GetDwordAt(Posicion As Long) As Long
Dim lAux As Long
RtlMoveMemory lAux, ByVal Posicion, &H4
GetDwordAt = CLng("&H" + DWHexFill(lAux))
End Function
Ahora, en otro modulo (o en el mismo) definimos la funcion que lo llamara:
Declare Sub VBSHL Lib "invisible.dll" (dest as Long, ByVal count as Byte)
'VBSHL: Hace lo mismo que SHL en ASM. Corre hacia la izquierda el valor de dest, la cantidad definida por count
Por ultimo, se llamaria a la funcion asi:
Private Sub Command1_Click()
Dim Numero As Long
'Carga API en VB
If Not loadAPI("VBSHL") Then
MsgBox "No se pudo cargar la API! (Esto no funciona en el IDE de VB 6!)"
Exit Sub
End If
'carga los parametros de la API'
Numero = 10
'Llamamos a la API como la declaramos :)
VBSHL Numero, 1
If Numero = 20 Then
MsgBox "Funciona bien! :)"
Else
MsgBox "Error. No funciono :("
End If
'Liberar API
releaseAPI "VBSHL"
End Sub
Bueno, lo dejo por aca, a ver si sirve de algo...
Saludos!
Si habia pensado eso hace tiempo, pero en vez de para llamar codigo ASM (Ya que para hacer eso hay formas mas simples) para hacer un Invoke :)
Muy buen codigo :) Aunque usando Arrays para meter el codigo ASM te ahorras VirtualAlloc/VirtualFree ;)
PD: Por favor del codigo largo desactiva el Geshi, sino llena una pagina completa... mejor por solo [code][/code]
che se me ocurrio otra idea.
Es rebuscada y no se si servira para algo :-[
Supongamos que mi code es este:
Dim unavariable as long
unavariable = timer
unavariable = unavariable - 356
debug.print unavariable
Ahora supongamos que por algo remotamente ilogico mi codigo es detectado por los av.
Literalmente MEZCLO el codigo añadiendo saltos para preservar integridad.
asi:
'Arranca el soft
goto Arranca
AsigVar:
unavariable = timer
Goto Opera
ShowRes:
debug.print unavariable
Opera:
unavariable = unavariable - 356
goto ShowRes
arranca:
Dim unavariable as long
goto AsigVar
el codigo deberia (DEBERIA ojo) funcionar exactamente igual, pero ahora esta todo re enquilombado y no se si esto cambia en algo al final de cuentas.
Tampoco se si se podra hacer con cadenas mas complejas como condicionales o repetitivas.
Espero que sirva ^^
Esa técnica es bastante utilizada por los ofuscadores de código :) Aun así a mi no me gusta demasiado, ya que aumenta considerablemente el tamaño del código...
Por cierto, no seria necesario crear labels para los saltos si no me equivoco se puede indicar el número de linea o algo similar :)
HOLA!!!
@KarCrack:
Si se puede indicar el numero de linea el problema de eso es que no se pueden agregar mas lineas al codigo con GoTos a numero de linea... Osea, aca el problema seria que una vez el codigo se ofusco no se lo podria tocar mas.
Igual podrias hacer un ofuscador y des-ofuscador de tal manera que "des-ofusque" las lineas con el comentario " ' Ofuscado por KPC".
Creo que eso es todo al respecto del GoTo y el numero de linea, es lo que no me gusta del GoTo.
Suerte!
GRACIAS POR LEER!!!
es bastante al cuete eso porque (por lo menos en la version vieja) pone como comentario la linea original o que cambios hizo.
Cita de: mixer en 25 Enero 2011, 21:56 PM
Por ejemplo si me detecta Var1 = &H4
puedo usar:
Var2 = &H4 + 15
Var1 = Var2 - 15
al final Var1 tomará el mismo valor. Con esos sacas a Nod, MSEssentials y varios más.
Cita de: Second Part To Hell's
2.1) Splitting Algorithm
-> The virus code is splitted to 3 to ~5.000 part (depending on the
code size)
-> A nonlinear algorithm combines the splitted parts. It does not
create trash-lines, all created lines are actually functional.
For example: MyCode='Hello VXers!!';
var5=' ';
var8='r';
var5=[var5 'VX'];
var5=['o' var5];
var2='e';
var7='e';
var9='s!';
var1='H';
var9=[var8 var9];
var3='ll';
var3=[var3 var5];
var7=[var7 var9];
var2=[var1 var2];
var3=[var3 var7];
var2=[var2 var3]; % var2 contains the right string now
or
var1='H';
var3='l';
var5=' V';
var6='Xer';
var6=[var6 's!'];
var4='lo';
var3=['e' var3];
var1=[var1 var3];
var4=[var4 var5];
var6=[var4 var6];
var1=[var1 var6]; % var1 contains the right string now
Esperemos que este proyecto llegue a buen fin.. ;-)
Me too :D, abronsius released is fourth edition of his ACO and it really good, with ur one all vb6 coder will just be king of the world lol
Can't wait for the release! Any idea when this will be done?
Cita de: Swellow en 27 Marzo 2011, 15:07 PM
Can't wait for the release! Any idea when this will be done?
Well, I'm not coding it atm, so till I get some free time I won't finish it.. hope it will done by next month.
OK. Can't wait to be the next month then lol.
no anda mas la pagina :c