Mensajes

entonces, para crear un programa de escritorio con un fondo personalizado y una barra de título, menus, controles, etc que utilicen un tema personalizado, deberé dibujar todo desde cero con OpenGL o que?

me dices que Win32 basta para hacer un diseño más agradable? cómo lo haces?



Por el consumo de GPU/CPU en principio no te preocupes mucho, porque no tengo planeado nada demasiado complicado.

Eso que necesitas hacer es suficiente la W32, generalmente la gente tiene la barra dibujada ( si lo es tan personalizada, aunque incluso
se puede hacer con las GDI, GDI+ pero la gente por comodidad hace con photoshop la barra botones y fondo y sus demás personalizaciones)
y tendrás que jugar un poco con los contexto de dispositivos que ofrece windows; esto es, las famosas mascaras así poder ocultar un
X color ( el cual windows se encarga que establecer a 0 cada bit de tu aplicación por supuesto ) y quedan visible el resto de los bits de las
demás aplicaciones, con ese metodo tambíen sirve para hacer formularios con "formas", etc.

Podes empezarte mirándote las funciones GDI que ofrece Windows, Más específicamente win32k.sys que es el controlador que manipula las funciones graficas y mensajes
de windows. por ejemplo: http://msdn.microsoft.com/en-us/library/windows/desktop/dd183370(v=vs.85).aspx esta funcion es la nativa para esas tareas, con ella
puedes hacer graficos 2D muy facilmente y no es complicada de usar simplemente tienes que pasarle una mascara de bits indicandole un contexto de dispositivo de
entrada y un contexto de dispositivo de destino.

Wikipedia lo deja claro:
http://es.wikipedia.org/wiki/Bit_blit

Todo eso es muy optimizada y facil de editar y organizar usando C++ ( no C) debido a que estamos hablando de POO.

Una introducción al tema:
http://www.winprog.org/tutorial/bitmaps.html

Trucos de introduction:
http://tipsandtricks.runicsoft.com/Cpp/BitmapTutorial.html

Dudas, publicarlas aquí en el foro.

Gracias era tan facil 

Hey chicos alguien sabe como puedo pasarle argumentos a un archivo bat y que los recibe y puedo manipularlos en ejecucion?
por ejemplo lo que quiero hacer es por tomar varios archivos de texto, y arrastrarlos hacia el bat y luego en mi bat poder manipularlos.

por ejemplo en mi bat llamo a un programa pasandole como parametros el nombre del archivo de texto

\xxx\xxx\programa textfile.txt

normalmente escribo los nombres de los archivos de texto que quiero modificar cada vez que quiero manipularlos pero me gustaria saber si esto es posible y como para ahorrarme mucho tiempo, cualquier ayuda gracias chicos 

Aprovecho este hilo para preguntaros otra cosa.

Desde este código, ahora es posible que diga la multiplicación de todos los números imprimidos?

Por ejemplo si escribes 5 la salida será : 5*4*3*2*1 = 120

cuando decis "la salida sera: ..." te referis a que lo muestre en una cadena no?
bueno muy facil, primero calcularia la factorizacion del numero, luego como podreis fijarte el codigo de los numeros empieza de 0x30 a 0x39 entonces podeis hacer un incremento a 0x30 a la variable que contiene el numero así se convierte en el codigo
que representa al numero. luego copiarlos en un buffer, yo haria un pequeño parser por cierto. muy facil.

El compilador es GCC, haciendo algunas pruebas he comprobado que si a una variable de tipo char le sumo 1 pasa a valer -128.

Pues claro,estamos hablando de un signed char, es porque el MSB valdra 1 si es un numero con negativo, y el rango sera de
-128 - 127, son cosas basicas ¬¬

Pero respondiendo a tu pregunta, creo que estas buscando es un unsigned char no? el rango es 0-255.

con W32 podeis hacer todo lo que se puede hacer con cualquier libreria y todo lo que puedesde mirar sobre el monitor, otra cosa
es que tu no tengas los conocimientos suficientes para hacerlo, esas librerias hacen un poco más facil tu trabajo, pero en contraparte agregan miles de lineas de codigo que con w32 seria mucho menos, aparte que hacen lento tu programa, bueno
si quereis algo optimo hacedlo con w32 de lo contrario con cualquier otra libreria, esto no incluye OpenGL, o asuntos de graficos 3D,
donde requiere el uso de GPU,GPU2.
aunque con un procesador avanzado se podrían hacer muchas algunas figuras 3D utilizando la tecnologia SSE4 y MMX + W32
sin necesidad de esas libreria, alfin y al cabo esas librerias terminan usando siempre la CPU o GPU.

alguien sabe xq me come el ultimo caracter de la primer cadena??


void strcat (char* cad1,char * cad2)
{
   int i=0;

   while(cad1!='\0')
   {
       i++;
   }
    int j=0;

    while(cad2[j]!='\0')
    {cad1=cad2[j];
        i++;
        j++;
    }

      cad1=cad2[j];
}

strcat une las string cad2 a cad1 al buffer destino eliminando el caracter nulo de lo contrario no formarian una sola cadena pero si quereis que no borre el
caracter nulo entonces agregar esta linea justo despues del primer bucle while:

Código [Seleccionar] Expandir

i++;

Si usa registros no es stdcall. Lo mas probable es que se de cuenta de que la  funcion es interna (osea, solo va a ser llamada por el mismo EXE) y use ese tipo de optimizacion.

Pero para eso necesita saber si o si el entrypoint.

Lo que he visto son optimizaciones pero referentes a las variables locales, las cuales si son definidas como registros sin usar stack (aunque depende del uso que tengan).

Por lo que me dices, está mezclando todos los tipos de convenciones de llamadas que hay en 32 bits, lo cual es un dilema bastante dificil de resolver.. 

Bueno en x64 es fastcall y si hace pre reserva, aquí esta mi código por si las dudas:

00000001`3f3d1050 4883ec48        sub     rsp,48h
00000001`3f3d1054 c744242880000000 mov     dword ptr [rsp+28h],80h
00000001`3f3d105c c744242060000000 mov     dword ptr [rsp+20h],60h
00000001`3f3d1064 41b950000000    mov     r9d,50h
00000001`3f3d106a 41b840000000    mov     r8d,40h
00000001`3f3d1070 ba30000000      mov     edx,30h
00000001`3f3d1075 b910000000      mov     ecx,10h
00000001`3f3d107a e881ffffff      call    image00000001_3f3d0000+0x1000 (00000001`3f3d1000)
00000001`3f3d107f 89442430        mov     dword ptr [rsp+30h],eax
00000001`3f3d1083 8b442430        mov     eax,dword ptr [rsp+30h]
00000001`3f3d1087 4883c448        add     rsp,48h
00000001`3f3d108b c3              ret

00000001`3f3d1000:
00000001`3f3d1000 44894c2420      mov     dword ptr [rsp+20h],r9d
00000001`3f3d1005 4489442418      mov     dword ptr [rsp+18h],r8d
00000001`3f3d100a 89542410        mov     dword ptr [rsp+10h],edx
00000001`3f3d100e 894c2408        mov     dword ptr [rsp+8],ecx
00000001`3f3d1012 4883ec18        sub     rsp,18h
00000001`3f3d1016 8b442428        mov     eax,dword ptr [rsp+28h]
00000001`3f3d101a 8b4c2420        mov     ecx,dword ptr [rsp+20h]
00000001`3f3d101e 03c8            add     ecx,eax
00000001`3f3d1020 8bc1            mov     eax,ecx
00000001`3f3d1022 03442430        add     eax,dword ptr [rsp+30h]
00000001`3f3d1026 89442404        mov     dword ptr [rsp+4],eax
00000001`3f3d102a 8b442440        mov     eax,dword ptr [rsp+40h]
00000001`3f3d102e 8b4c2438        mov     ecx,dword ptr [rsp+38h]
00000001`3f3d1032 03c8            add     ecx,eax
00000001`3f3d1034 8bc1            mov     eax,ecx
00000001`3f3d1036 03442404        add     eax,dword ptr [rsp+4]
00000001`3f3d103a 03442448        add     eax,dword ptr [rsp+48h]
00000001`3f3d103e 890424          mov     dword ptr [rsp],eax
00000001`3f3d1041 8b0424          mov     eax,dword ptr [rsp]
00000001`3f3d1044 4883c418        add     rsp,18h
00000001`3f3d1048 c3              ret

como podréis ver hace una pre reserva que es parte de la función y no hace marco de la pila, y eso que desactivo Omit Frame Pointer, y el compilador
omite muchos comandos por las optimizaciones, así que estoy buscando una forma de hacerlo con las optimizaciones activadas, lo mismo pasa con
programas de 32 bit, me omite muchos comandos como podréis ver.

La verdad es que C no C ( ), pero se me ocurre que podrias compilar la función como quieres que quede. Luego buscas los bytes del codigo generado en el EXE y los metes en el EXE final.

Sería lo mismo que meter un shellcode en un EXE...

Aunque no estoy seguro de si esto es lo que quieres hacer.

Pues para lo quiero haha, además nosé si sabeis bro, pero el compilador de VC cuando tiene todas las opciones de optimizacion activadas, pasa parametros en registros ( y eso que es stdcall ), hace pre reserva de variables locales dentro del llamador que son
parte de la funcion para no hacer doble reserva, etc, etc. no funciona eso.

Saludos eso se llama metaprogramacion los mejores ejemplos son los compiladores.

para hacer lo que dices tendras que crear un archivo de texto con base a unas variables que resibas
y usar system() para compilar dicho archivo

hay varias formas, por ejemplo podes hardcodear las direcciones del segmento de datos en el PE, otra es usando la sección de
recursos, el troyano guarda la configuracion en la sección de recursos del server, y otras formas más, por ejemplo, reprogramar
las instrucciones del PE, este metodo es el más optimo pero necesitas un buen conocimiento de ASM y C/C++, cuando digo bueno, es
bueno.

Saludos eso se llama metaprogramacion los mejores ejemplos son los compiladores.

para hacer lo que dices tendras que crear un archivo de texto con base a unas variables que resibas
y usar system() para compilar dicho archivo

vos no tenes ni una idea de lo que el usuario esta preguntando



PS: Yo hice un pequeño reprogramador de PE, y te lo digo me tomo 20 horas hacerlo algo basico, vendria siendo un pequeño
desensamblador y leyendo las instrucciones de archivo y tener cuidado de no sobreescribir más de la longitud de cada instruccion,
calculando direcciones relativas, alinear direccion, y muchas cosas más.  
Un ejemplo claro de ello, es el Poison Ivy, este utliza un motor para generar el tamaño del server de acuerdo  a las funciones habilitadas.