dije "por ahi estara", queriendo decir que puede estar el codigo dentro de la funcion (no es la primera vez que lo he visto) o un puntero a los bytes reales, como dije depende del soft hay que estudiarlo y es practicamente sencillo obtener la direccion para no tener que pasar por el hook. pero vamos eso es otro tema.



Logicamente y pasar por un sitio no es entrar por la puerta, puedes pasar por delante de mi casa sin entrar o puedes entrar por la ventana, de todos modos has pasado por ahi. o lo que es lo mismo, puedo comer huevo frito, en tortilla, con patatas o como a cada uno mas le guste, pero termina comiendo huevo.


Vale entonces un pequeño programa NO LINKADO a una sola dll, tampoco vale obtener con getprocaddress. que cree un fichero, escriba algo muestre un MessageBox y salga. cuando vea eso sin usar una sola dll entonces admitire que si puede usarla de forma opcional o con mas trabajo pasar olimpicamente del sistema.

logicamente que la api de windows lo hace, pero no es el caso y terminas en el kernel pasandole el servicio X y el kernel es API del mismo sistema, por lo tanto lo que quiero decir es que terminara usandola de algun modo. ese ejemplo es "valido" pq lo hace el propio sistema asi y no es dependiente de ninguna otra funcion, falta la escritura al fichero y el MessageBox sin tocar una sola dll del sistema.

es lo mismo que isdebuggerpresent que existe la funcion, pero simplemente retorna un campo del peb y listo, cosa que puedes hacer perfectamente desde tu propia aplicacion sin llamar a dll alguna. vale entonces cedo pero un poquito, se puede hacer con alguna funcion en concreto, pero no puedes hacer una aplicacion sin pasar por la api del sistema.

yo crro que no entiendes tu, pero bueno. el cito explicitamente MessagesBox, crear ficheros,carpetas haciendo alusion a un posible metodo de programar paralelamente a lo que el sistema permite. igual que lo de la dll no es igual pero es un ejemplo valido, ya que es algo que se permite hacer por la forma en que esta diseñado, pero te digo falta el messagebox por ejemplo o una simple ventana. hasta el momento solo he visto como es posible usar una funcion, solo pedi 3 cosas y faltan 2.

Que es como digo en la informatica se puede rizar el rizo tanto como quieras, del mismo modo que puedo hacerlo yo para no admitir que sea posible programar en un sistema sin usar las funciones que este nos ofrece como norma general. no se, que puedas ejecutar una funcion y (por como esta esta construida) afirmar a una pregunta general que si, como te digo cuando vea el programa completo con las 3 funciones que pedi, entonces perfecto se puede programar.


a la pregunta tal cual esta, la respuesta es NO. y repito mi invitacion a terminar el programa con la escritura y el messagebox para englobar asi un poco las funciones especificas que se nombran en la pregunta, dejando a un lado el etc.


Nunca he dicho que le kernel es una dll, creo que te confundes, hasta eso llego.


¿cuales servicios?, perdona pero estas confundiendo cosas. aun sin saber de cuales son los servicios que estas nombrando, ¿que api no se puede usar?.


Lo que esta AMPLIAMENTE demostrado es que te has ceñido al unico punto que te interesa ignorando el resto de la pregunta para demostrar que si se puede. por ejemplo el como se pasa de modo usuario al kernel estan ahi las funciones, solo que como se puede hacer con codigo ensamblador tal cual (por como esta construida) escribes las mismas instrucciones y logicamente que hace lo mismo, seria estupido negar lo contrario.


aparte de todo eso, cito tal cual mi ofrecimiento:


ahora bien, el numero de servicio para  no estar hardcodeado se podria leer en el propio archivo, pero entonces pregunto ¿que fue primer el huevo o l la gallina? pq la condicion es no usar una sola dll, de momento no veo que se cumpla ninguna condicion de la peticion, simplemente una parte de esta (siendo flexibe por no alargar mas el tema), pero seria mas interesante ver la implementacion sin hardcodear el numero de servicio.

.386
.model flat, stdcall
option casemap :none   ; case sensitive
 
include \masm32\include\windows.inc
include \masm32\include\user32.inc
include \masm32\include\kernel32.inc
include \masm32\include\gdi32.inc
 
CLSMENUNAME STRUCT
    ANSIPtr DWORD ?
    WIDEPtr DWORD ?
    UStrPtr DWORD ?
CLSMENUNAME ENDS
 
OBJECT_ATTRIBUTES STRUCT
	Len DWORD ?
	RootDirectory DWORD ?
	ObjectName	DWORD ?
	Attributes DWORD ?
	SecurityDescriptor DWORD ?
	SecurityQualityOfService DWORD ?
OBJECT_ATTRIBUTES ENDS
 
UNICODE_STRING STRUCT
	Len WORD ?
	MaxLen WORD ?
	Buffer DWORD ?
UNICODE_STRING ENDS
 
LARGE_UNICODE_STRING STRUCT
    Len DWORD ?
    MaxLenBAnsi DWORD ? ;  ULONG MaximumLength:31  ULONG bAnsi:1
    Buffer DWORD ?
LARGE_UNICODE_STRING ENDS
 
 
IO_STATUS_BLOCK STRUCT
	Status DWORD ?
	Information DWORD ?
IO_STATUS_BLOCK ENDS
 
NTUSERGETMESSAGEINFO STRUCT
  Msg MSG  <>
  LParamSize DWORD ?
NTUSERGETMESSAGEINFO ENDS
 
.data
hFile dd 0
ob OBJECT_ATTRIBUTES <>
;\??\i:\f.txt
;13*2=26
fileBuff db '\',0,'?',0,'?',0,'\',0,'i',0,':',0,'\',0,'f',0,'.',0,'t',0,'x',0,'t',0,0,0
fName UNICODE_STRING <>
cNameWU UNICODE_STRING <>
mNameWU UNICODE_STRING <>
 
classLUS LARGE_UNICODE_STRING <>
titleLUS LARGE_UNICODE_STRING <>
 
isb IO_STATUS_BLOCK <>
 
buffer db "¿Ves como escribe? No es tan dificil de aceptar", 0
 
wcx WNDCLASSEX <>
 
mName db "MainMenu", 0
cName db "MainWClass", 0
 
tName db 'S',0,'H',0,'H',0,'H',0,'H',0,'H',0,'H',0,'H',0,'H',0,'H',0,0
hWnd dd 0
 
msg MSG <>
ntMsg NTUSERGETMESSAGEINFO <>
 
mNameW db 'M',0,'a',0,'i',0,'n',0,'M',0,'e',0,'n',0,'u',0,0,0
cNameW db 'M',0,'a',0,'i',0,'n',0,'W',0,'C',0,'l',0,'a',0,'s',0,'s',0,0,0
 
cStruct CLSMENUNAME <>
 
ps PAINTSTRUCT <>
 
pedantic db 0
 
.code
main:
 
mov wcx.cbSize, SIZEOF(WNDCLASSEX)
mov wcx.style, CS_HREDRAW or CS_VREDRAW
mov wcx.lpfnWndProc, MainWndProc
mov wcx.cbClsExtra, 0
mov wcx.cbWndExtra, 0
mov wcx.hInstance, 00400000h
 
mov wcx.hIcon, 0
mov wcx.hCursor, 0
mov wcx.hIconSm, 0
 
push GRAY_BRUSH
call myZwGdiGetStockObject
 
mov wcx.hbrBackground, eax
mov wcx.lpszMenuName, offset mNameW
mov wcx.lpszClassName, offset cNameW
 
 
mov cNameWU.Len, 014h
mov cNameWU.MaxLen, 016h
mov cNameWU.Buffer, offset cNameW
 
mov mNameWU.Len, 010h
mov mNameWU.MaxLen, 012h
mov mNameWU.Buffer, offset mNameW
 
mov cStruct.ANSIPtr, offset mName
mov cStruct.WIDEPtr, offset mNameW
mov cStruct.UStrPtr, offset mNameWU
 
mov classLUS.Len, 014h
mov classLUS.MaxLenBAnsi, 016h
mov classLUS.Buffer, offset cNameW
 
mov titleLUS.Len, 4
mov titleLUS.MaxLenBAnsi, 6
mov titleLUS.Buffer, offset tName
 
push 0
push 0180h
push 0
push offset cStruct
push offset cNameWU
push offset cNameWU
push offset wcx
call myZwUserRegisterClassExWOW
 
push 0
push 040000400h 
push 0
push 00400000h
push 0
push 0
push 200; CW_USEDEFAULT
push 200; CW_USEDEFAULT
push 150
push 150
push WS_OVERLAPPEDWINDOW
push offset titleLUS
push offset classLUS
push offset classLUS
push 0
call myZwUserCreateWindowEx
mov hWnd, eax
 
push SW_SHOW
push hWnd
call myZwUserShowWindow
 
;1ra funcion: GUI visible!
 
bucle:
push 0
push 0
push 0
push offset ntMsg
call myZwUserGetMessage
.if eax != 0 && eax != -1
 
.if !pedantic
    push offset ntMsg.Msg
    call DispatchMessageW
.else
  .if  ntMsg.Msg.message == WM_SYSCOMMAND
   push  33h
   push 0
   call myZwUserCallOneParam
    jmp basta
  .endif
.endif
 
jmp bucle
.endif
 
basta:
;Boton derecho en el taskbar, cerrar, y llega aca
 
mov fName.Len, 24
mov fName.MaxLen, 24
mov fName.Buffer, offset fileBuff
 
mov ob.Len, 018h
mov ob.RootDirectory, 0
mov ob.ObjectName, offset fName
mov ob.Attributes, 00000040h
mov ob.SecurityDescriptor, 0
mov ob.SecurityQualityOfService, 0
 
push 00000060h  
push 0
push offset isb
push offset ob
push 010100080h
push offset hFile
call myZwOpenFile
;2da funcion apertura de archivo en hFile tenes el HANDLE al archivo
 
push 0
push 0
push 47
push offset buffer
push offset isb
push 0
push 0
push 0
mov eax, hFile
push eax
call myZwWriteFile
;3ra funcion, escritura en archivo
 
 
ret
 
myZwOpenFile:
mov     eax,74h
call    SystemCallStub
ret     18h
 
myZwWriteFile:
mov     eax,112h
call    SystemCallStub
ret     24h
 
myZwUserCreateWindowEx:
mov     eax,1157h
call    SystemCallStub
ret     3Ch
 
myZwUserRegisterClassExWOW:
mov     eax,11E8h
call    SystemCallStub
ret     1Ch
 
myZwGdiGetStockObject:
mov     eax,10C8h
call    SystemCallStub
ret     4
 
myZwUserShowWindow:
mov     eax,122Bh
call    SystemCallStub
ret     8
 
myZwUserGetMessage:
mov     eax,11A5h
call    SystemCallStub
ret     10h
 
myZwUserCallOneParam:
mov     eax,1143h
call    SystemCallStub
ret     8
 
myZwUserMessageCall:
mov     eax,11CCh
call    SystemCallStub
ret     1Ch
 
 
myZwUserBeginPaint:
mov     eax,1134h
call    SystemCallStub
ret     8
 
myZwUserEndPaint:
mov     eax,1172h
call    SystemCallStub
ret     8
 
SystemCallStub:
mov     edx,esp
;sysenter
dw 340fh
ret
 
MainWndProc:
 
.if dword ptr [esp+8] == WM_NCCREATE
    push 0
    push 029Eh
    push 0
    push [esp+16+12]
    push [esp+12+16]
    push [esp+8+20]
    push [esp+4+24]
    call myZwUserMessageCall
    xor eax, eax
    inc eax
    ret 10h
.endif
 
.if dword ptr [esp+8] == WM_NCPAINT
    push 0
    push 029Eh
    push 0
    push [esp+16+12]
    push [esp+12+16]
    push [esp+8+20]
    push [esp+4+24]
    call myZwUserMessageCall
    xor eax, eax
    ret 10h
.endif
 
.if dword ptr [esp+8] == WM_DESTROY
   push  33h
   push 0
   call myZwUserCallOneParam
   ;   call PostQuitMessage
   xor eax, eax
   ret 010h
.endif
 
.if dword ptr [esp+8] == WM_PAINT
    push offset ps
    push dword ptr [esp+8]
    call myZwUserBeginPaint
    .if !pedantic
        invoke SetBkMode, ps.hdc, TRANSPARENT
        invoke SetTextColor, ps.hdc, 0
        invoke TextOutA, ps.hdc, 5,25, offset buffer, 19
    .endif
    push offset ps
    push dword ptr [esp+8]
    call myZwUserEndPaint
    xor eax, eax
    ret 010h
.endif
 
.if !pedantic
    jmp DefWindowProcW
.endif
 
push 0
push 029Eh
push 0
push [esp+16+12]
push [esp+12+16]
push [esp+8+20]
push [esp+4+24]
call myZwUserMessageCall
xor eax, eax
ret 10h
 
end main

pedantic=0:


pedantic=1:



theghost_te: como habras visto en algun caso como el GUI puede ser mas complejo que trabajar con archivos (obviar la NTDLL.dll es MUY simple) pero siempre que haya transicion al Kernel con paciencia y tiempo podes saltarte las DLLs desde tu programa.