Temas

Buenas, escribo para preguntar si alguien ya tubo algun tipo de experiencia automatizando una solucion para resolver los captcha. Algun tipo de modo de interpretar las imagenes y escribirlas en autoamatico o algo por el estilo.


Gracias!

Hola A todos,
Escribo para comentarles a cerca de una idea interesante, que tiene que ver con el poder ejecutar mas rapido en CPU un proceso informatico, filtrando solo las funciones/procesos que me sirven o quiero ejecutar de un programa, y evitando los demas.

Antes que nada una introduccion de como funciona un proceso en un sistema operativo que encontre en la web:
_______________________________________________________

COMO SE CARGA Y EJECUTA UN EXE EN WINDOS?

Se que los programas compilados para Windows nativos tienen un formato llamado Portable executable (PE) y que permite que el sistema operativo cargue el programa a la memoria.



El proceso es relativamente sencillo de explicar, pero no tanto de llevar a cabo.

Lo primero: las CPU tienen una serie de requisitos para poder ejecutar un trozo de código cualquiera: ciertos registros tienen que apuntar a direcciones de memoria válidas.

Adicionalmente, se han de cumplir las normas que imponga el Sistema Operativo de turno: cierto trozo de memoria solo puede ser accedido por cierto programa, y en cierto modo (lectura, escritura, ejecución).

El proceso básico de ejecución (que no de carga) consiste en preparar la memoria y los registros de la CPU para que cumplan los requisitos impuestos. Esto es llevado a cabo por el Sistema Operativo.

Para lo anterior, se consultan ciertos datos del archivo a ejecutar.

Una vez la memoria preparada, se carga el código en si, cada porción en la parte necesaria. Los segmentos de datos del programa se cargan en la zona de memoria dedicada para datos, los segmentos de código ejecutable en la zona de código, ...

Aquí, lo de carga puede ser engañoso. Mediante el proceso de mapeo de archivos en memoria, la antedicha carga se puede posponer hasta que la CPU no necesite acceder realmente a la zona de memoria en cuestión.

Una vez el código cargado, se procede a su enlazado dinámico. Es decir, se consulta el segmento del archivo que contiene el nombre de las librerías .dll que se necesitan. Algunas ya estarán cargadas (en zonas de memoria compartida, con ejecución para todo el mundo). Otras no, y será necesario repetir el proceso de carga para ellas (con sus peculiaridades; por ejemplo, las librerías no necesitan pila (stack).

Por fin, está todo cargado (o *mapeado en memoria). Ahora, hay que sobre-escribir los puntos del código del programa en los que se llama a ciertas funciones importadas, por las direcciones reales de las mismas.

Esto también es engañoso. Hay mecanismos para no tener que recorrer toda la memoria, usando unas zonas de memoria como tablas intermedias. El resultado final, no obstante, es el mismo: todas las llamadas a .dll apuntan al código deseado.

Ahora, ya sí, se puede comenzar la ejecución del programa, forzando a la CPU a crear un nuevo proceso, y usando para ello las zonas de memoria que con tanto mimo se han preparado.

Normalmente, la ejecución en si misma no pasa directamente a la función WinMain, o main, o lo que sea. Se llama primero a un trozo de código colocado por el compilador, que se encarga de realizar tareas de inicialización de los datos. En C++, por ejemplo, es este código pre-main el que se encarga de llamar a los constructores de instancias estáticas.

Ahora si; por fin, llamamos a nuestra WinMain( ).

Una de las cosas que podemos hacer dentro de WinMain( ) es registrar nuestra función de ventana, que será usada por Windows para entregar los mensajes. Estos mensajes se generan independientemente de nosotros, la mayoría de ellos son artificiales (generados por el propio sistema). Pero eso ya es otro tema, y será contada en otra ocasión ...

_______________________________________________________


Ahora bien, mi idea y la que quisera compartir es justamente la de decompilar un programa a nivel HEXA/Binario para poder determinar cual direccion de memoria asigna en cada momento a los procesos de cada una de las funciones especificas que se van a ejecutar, poder filtrar solo las que me interesan en tiempo real y ejecutar solo esas, de forma tal que el proceamiento sera siempre mas rapido y el cpu me devuelva una respuesta mas veloz que ejecutar todo el bloque entero de datos.

Para dejarlo mas claro agrego una imagen:


Ahora bien quisiera saber si alguien tiene algun tipo de experiencia en esto y que les parece??? si alguno de ustedes intento algo parecido o si estan en condicione de ayudarme con un proyecto que me gustaria iniciar con un amigo.

Quizas me falto informacion o puse informacion erronea, si es asi pido disculpas por la ignorancia! je