¿Hay algún virus en el controlador?

es problemático. Puede usar el código que compré de un experto antes (ya encapsulado como una función para facilitar la llamada):

//Obtener la ruta completa del proceso basada en EPROCESS

VOID GetFullPathByEprocess(ULONG eprocess, PCHAR ProcessImageName)

{

ULONG objeto;

PFILE_OBJECT FileObject;

UNICODE_STRING FilePath;

UNICODE_STRING DosName;

STRING AnsiString;

FileObject = NULL;

FilePath.Buffer = NULL;

FilePath.Length = 0;

*ProcessImageName = 0;

// Eprocess-gt; objeto de sección(offset_SectionObject)

if(MmIsAddressValid((PULONG)(eprocess offset_SectionObject)))

{

object=(*(PULONG) (eprocess offset_SectionObject));

p>

//KdPrint(("[GetProcessFileName] objeto de sección: 0xx\n", objeto));

if(MmIsAddressValid(( PULONG)((ULONG)objeto 0x014)))

{

objeto=*(PULONG)((ULONG)objeto 0x014);

//KdPrint (("[GetProcessFileName] Segmento: 0xx\n", objeto));

if(MmIsAddressValid((PULONG)((ULONG)objeto 0x0)))

{

object=*(PULONG)(( ULONG_PTR)objeto 0x0);

//KdPrint(("[GetProcessFileName]

ControlAera: 0xx\n", objeto ));

if(MmIsAddressVali

d((PULONG)((ULONG)objeto 0x024)))

{

objeto=*(PULONG)((ULONG)objeto 0x024);

if (NtBuildNumber gt;= 6000) object=((ULONG)object amp;

0xfffffff8);

//KdPrint(("[GetProcessFileName]

FilePointer: 0xx\n", objeto));

}

else

return;

}

de lo contrario

regresar;

}

de lo contrario

regresar;

}

else

return;

FileObject=(PFILE_OBJECT)objeto;

FilePath.Buffer = ExAllocatePool(PaggedPool, 0x200);

FilePath.MaximumLength = 0x200;

//KdPrint(("[GetProcessFileName]

FilePointer:wZ\n",&FilePointer-gt;FileName));

ObReferenceObjectByPointer((PVOID)FileObject, 0, NULL, KernelMode);

RtlVolumeDeviceToDosName(FileObject-gt; DeviceObject, & DosName);

RtlCopyUnicodeString(amp; FilePath, amp; DosName);

RtlAppendUnicodeStringToString(amp;FilePath, amp;FileObject-gt;FileName);

ObDereferenceObject(FileObject);

RtlUnicodeStringToAnsiString(amp; AnsiString, & FilePath, TRUE);

if (AnsiString.Length >= 216)

{

memcpy(ProcessImageName, AnsiString.Buffer, 0x100u );

*(ProcessImageName 215) = 0;

}

else

{

memcpy( ProcessImageName, AnsiString. Búfer, AnsiString.Length);

ProcessImageName[AnsiString.Length] = 0;

}

RtlFreeAnsiString(amp; AnsiString);

ExFreePool(DosName.Buffer);

ExFreePool(FilePath.Buff

er);

}

El código anterior requiere tres códigos físicos, a saber, NtBuildNumber (número de versión del sistema),

elementoSectionObject y elemento UniqueProcessId en el desplazamiento de EPROCESS. El sistema operativo que probé fue Windows 2003. Entonces

Lo definí de la siguiente manera en el código:

#define offset_SectionObject 0x124

#define offset_UniqueProcessId 0x94

ULONG NtBuildNumber=3790 ;

Después de obtener la ruta del proceso, verifique la firma.

Como el proceso se ha explicado claramente, el código se proporciona directamente:

VOID CalcChar(PUNICODE_STRING logFileUnicodeString, LONG *XorChar, LONG

*AnSChar)

{

OBJECT_ATTRIBUTES objectAttributes;

IO_STATUS_BLOCK iostatus;

HANDLE hfile;

NTSTATUS ntStatus;

FILE_STANDARD_INFORMATION fsi;

PUCHAR pBuffer;

ULONG i=0, y1=0, y2=0;

//Inicializar atributos de objeto

Inicializar atributos de objeto( amp ;objectAttributes,

logFileUnicodeString,

OBJ_CASE_INSENSITIVE, //distingue entre mayúsculas y minúsculas

NULL,

NULL);

//Crear archivo

ntStatus = ZwCreateFile(amp;hfile,

GENERIC_READ,

amp;objectAttributes,

amp ; iostatus,

NULL,

FILE_ATTRIBUTE_NORMAL,

FILE_SHARE_READ,

FILE_OPEN, //Crear incluso si el archivo existe

FILE_SYNCHRONOUS_IO_NONALERT,

NULL,

0 );

if (!NT_SUCCESS(ntStatus))

{

dprintf("¡El archivo no existe!\n");

return;

}

//Leer la longitud del archivo.

ntStatus = ZwQueryInformationFile(hfile,

amp;iostatus,

amp;fsi,

tamañoof(FILE_STANDARD_INFORMATION),

FileStandardInformation);

dprintf("El programa quiere leer d bytes\n", fsi.EndOfFile.QuadPart);

//Asignar el búfer del archivo de lectura

pBuffer = (PUCHAR)ExAllocatePool(PaggedPool,

(LONG)fsi.EndOfFile.QuadPart);

//Leer archivo

ZwReadFile(hfile, NULL,

NULL, NULL,

amp;iostatus,

pBuffer,

(LONG )fsi. EndOfFile.QuadPart,

NULL, NULL);

dprintf("Th);

El programa realmente leyó d bytes\n",iostatus.Information);

//Cálculo XOR

for(i=0;ilt;iostatus.Information;i)

y1=y1^(LONG)(*(pBuffer i));

*XorChar=y1;

//Cálculo de sumas y restas

for(i=0; ilt; iostatus.Information; i )

{

if(i2==0)

y2=y2 (LARGO) (*(pBuffer i));

else

y2=y2-(LONG)(*(pBuffer i));

}

*AnSChar=y2;

//Cerrar el identificador del archivo

ZwClose(hfile);

//Liberar el búfer

ExFreePool(pBuffer);

}

El siguiente paso es llamarlo. Necesitamos escribir una función VerifyCaller, y hay dos valores requeridos en esta función<. /p>

Solidificados en el conductor, son los dos valores característicos de las personas que llaman legalmente.

Para facilitar el cálculo de estos dos valores característicos, escribí especialmente una aplicación. El código principal es el siguiente:

Opción explícita

Función privada ReadFile(ByVal strFileName As String, Opcional ByVal

lngStartPos Mientras = 1, Opcional ByVallngFileSize Mientras = -1) Como Byte()

Dim FilNum Mientras

FilNum = FreeFile

Abrir strFileName para binario como #FilNum

Si lngFileSize = -1 entonces

ReDim ReadFile(LOF(FilNum) - lngStartPos)

De lo contrario

ReDim ReadFile(lngFileSize - 1)

Finalizar si

Obtener #FilNum, lngStartPos, ReadFile

Cerrar #FilNum

Función final

Función privada WriteFile(ByVal strFileName como cadena, bytData() como byte,

ByVal lngStartPos opcional mientras = -1, ByVal sobreescritura opcional como booleano =

Verdadero)

En caso de error, Ir a erx

Atenuar FilNum mientras

FilNum = FreeFile

Si se sobrescribe = True y Dir(strFileName) lt;gt; "" Entonces

Eliminar strFileName

Finalizar si

Abrir strFileName para binario como #FilNum

Si lngStartPos = -1 entonces

Pon #FilNum, LOF(FilNum) 1, bytData

De lo contrario

Pon #FilNum, lngStartPos, bytData

Finalizar si

Cerrar #FilNum

erx:

Finalizar función

Subcomando privado1_Click( )

Dim buff() As Byte, i As Long, y As Long, ub As Long

'text1.text es el nombre del archivo

buff = ReadFile(Text1 .Text, 1, -1)

ub = UBound(buff)

'calc xor char

y = 0

Para i = 0 A ub

y = y Xor buff(i)

Siguiente

p>

Text2.Text = CLng(y)

DoEvents

'calc add/sub char

y = 0

Para i = 0 To ub

Si i Mod 2 = 0 Entonces

y = y CLng(buff(i))

De lo contrario

y = y - CLng(buff(i))

Finalizar si

Siguiente

Texto3.Text = CLng(y)

End Sub

Sub privado Form_Load()

Me.Icon = LoadPicture("")

End Sub

Controlador El código de VerifyCaller es el siguiente:

LONG VerifyCaller(void)

{

PEPROCESS cur_ep;

char cur_pp[260] ;

char *nt_cur_pp;

ANSI_STRING asCur_pp;

UNICODE_STRING usCur_pp;

LONG xorc, ansc;

cur_ep =PsGetCurrentProcess();

GetFullPathByEprocess((ULONG)cur_ep, cur_pp);

//Agrega \?\ delante del nombre del archivo

nt_cur_pp=cs ("\\?\\", cur_pp);

DbgPrint("s", nt_cur_pp);

RtlInitAnsiString(amp; asCur_pp, nt_cur_pp);

RtlAnsiStringToUnicodeString(amp;usCur_pp, amp;asCur_pp, TRUE);

DbgPrint("wZ", amp;usCur_pp);

CalcChar(amp;usCur_pp, amp; xorc, amp ;ansc);

DbgPrint("XorChar: ld; AnSChar: ld", xorc, ansc);

//Este es el código característico del programa legal calculado ¡De antemano y debe solidificarse en el controlador!

if(xorc==186 amp; amp; ansc==136176)

devuelve 1;

else

devuelve 0;

}

Antes de ejecutar cada función de la función DispatchIoctl, se llama a VerifyCaller() para verificar la persona que llama:

switch(uIoControlCode)

{

caso IOCTL_VERIFY:

{

DbgPrint("[MyDriver] DispatchIoctl - IOCTL_VERIFY");

si ( VerifyCaller()==1)

DbgPrint("[MyDriver] {IOCTL_VERIFY} ¡Código de función ejecutado ahora!");

else

DbgPrint("[MyDriver] {IOCTL_VERIFY} ¡Eres una persona que llama ilegalmente!");

status = STATUS_SUCCESS