Mensajes

Si yo le puedo enviar comandos a la aplicación para pinchar con el raton pero si luego la aplcación me devuelve algo... como puedo filtrar este algo? si es en uno de los controles? el control es una ventana que pone Dialog Window y es parecido a una shell... yo lo que quiero es enviar desde VB6 comandos a esta "shell"  y recibir la salida y poder procesarla, estoy viendo que con sendkeys y sendmessage me puedo defender pero no se por que me da que no es una manera... limpia de hacerla jeje... existe una manera de enviarle un comando con sendmessage y  recibir el contenido del control de la ventana dialog window? Un saludo y perdona las molestas!

Existe alguna manera de conseguir los valores de la ventana de otra aplicación? Me refiero hacer poco con
Hndl = FindWindow(vbNullString, "Clips 6.3")
Hndl = FindWindowEx(Hndl, 0, "Dialog "BUTTON", "&silencio")

recogiendo con findwindowEx podía coger el valor de un check button, existe la manera de poder escribir en la ventana de otro programa o ejecutar sus short cuts o  ejecutar un menu? Si alguien pudiera ayudarme se lo agradeceria...Gracias!

Hola gente, se me está planteando un problema, necesito hacer una practica para la universidad y no encuentro donde tengo el problema...
se rata de pasarle imagenes donde en algun lugar de la imagen existe un cubo de rubik en cualquier anguloy cualquier cara de color las cuales pueden ser (rojo,verde,azul... y creo que con estos colores valdria para la deteccion). se plantea el problema de la siguiente manera. Hay que hacer un algoritmo de crecimiento de regiones el cual se encarga de meter en una lista de regiones todas aquellas que encuentra un pixel coincidente con otro porque tienen el color parecido. Bueno les entrego mi codigo y me dicen que hago mal, creo que me quedo sin memoria, nuestro profesor dijo que teniamos que usar la STL por lo mismo, yo no la uso por que no se usarla . a ver si me pueden ayudar unpoquito enfocar por donde puedo ir. les dejo mi codigo:

Código (c) [Seleccionar] Expandir


#include <cstdlib>
#include <iostream>
#include <cv.h>
#include <highgui.h>
#include <stdio.h>
#include <math.h>




struct Tpixel
{     
       int b;//Cantidad de AZUL
       int g;//Cantidad de Verde
       int r;//Cantidad de rojo
       int i;//Coordenadas en i
       int j;//Coordenadas en j
       };

struct Timagen
{
       Tpixel *pixels;
       int anchura;
       int altura;
       int numPixels;
       };
struct Tregion
{       
       Tpixel *pixels;
       int numPixels;
       int xe;
       int yn;
       int ys;
       int xw;
       float percent;
     
       };

struct Tregiones
{
      Tregion *regiones;
      int numRegiones;
      };
uchar *data;
int esColorParecido(Tpixel p1,Tpixel p2)
{
    if (((p1.b==0)&&(p1.g==0)&&(p1.r==0))
       |((p2.b==0)&&(p2.g==0)&&(p2.r==0)))
       return 0;
    else
    //printf("distancia:%f\n",(sqrt(pow(p1.b-p2.b,2)+pow(p1.g-p2.g,2)+pow(p1.r-p2.r,2))));
    return (7>sqrt(pow(p1.b-p2.b,2)+pow(p1.g-p2.g,2)+pow(p1.r-p2.r,2)));
    //return (40>=())
}

int esAmarillo (int B,int G,int R)
{
    return( (R>20)& (G<R) &(B<R*0.20)
           
           );
}
int esAzul (int B,int G,int R)
{
   return((B>80)&(R<B*0.50)&(G<B*0.50));
}

int esNaranja (int B,int G,int R)
{
    return((R>200)&(B<40)&(G<150)&(G>100));
}
int esDeColor(int B,int G,int R)
{
    return((R>20)&(G>20)&(B>20));
}

int esNegro(int B,int G,int R)
{
    return((R<15)&(G<15)&(B<15));
}
int esRojo(int B,int G,int R)
{
    return((R>80)&(B<R/2)&(G<R/2));
}
int esVerde(int B,int G,int R)
{
  return((G>80)&(B<G/2)&(R<G/2));
 
}
int esBlanco (int B,int G,int R)
{
    return((R>210)&(B>210)&(G>210));
}
int copiaRegion(Tregion *region1,Tregion region2)
{
       region1->numPixels=region2.numPixels;
       region1->xe=region2.xe;
       region1->yn=region2.yn;
       region1->ys=region2.ys;
       region1->xw=region2.xw;
       region1->percent=region2.percent;
       region1->pixels=region2.pixels;
}   
int nuevaRegion(  Tregion *regionNueva)
{
    regionNueva->numPixels=0;
       regionNueva->xe=0;
       regionNueva->yn=0;
       regionNueva->ys=0;
       regionNueva->xw=0;
       regionNueva->percent=0.0;
       regionNueva->pixels=0;//
}
int encolaRegion(Tregion regionNueva,Tregiones *regiones)
{

    if (regiones->numRegiones==0)
       {
           regiones->regiones = (Tregion *)malloc(sizeof(struct Tregion));
           copiaRegion(&regiones->regiones[regiones->numRegiones],regionNueva);
           regiones->numRegiones++;
       }
    else
        {
         
         regiones->regiones=(Tregion *) realloc(regiones->regiones,(regiones->numRegiones+1)*sizeof(struct Tregion));
         copiaRegion(&regiones->regiones[regiones->numRegiones],regionNueva);
         regiones->numRegiones++;
        }
       
       
     
       
     
       
}
int pintaPixel(Tpixel pixel)
{
      printf("Azul:%d\n",pixel.b);
      printf("Verde:%d\n",pixel.g);
      printf("Rojo:%d\n",pixel.r);
      printf("Coordenada i:%d\n",pixel.i);
      printf("Coordenada j:%d\n",pixel.j);
}
int nuevaImagen(Timagen *imagen,int altura,int anchura)
{
imagen->altura=altura;
imagen->anchura=anchura;
imagen->numPixels=0;
}
int copiaPixel(Tpixel *pixel1,Tpixel pixel2)
{
       pixel1->b=pixel2.b;
       pixel1->g=pixel2.g;
       pixel1->r=pixel2.r;
       pixel1->i=pixel2.i;
       pixel1->j=pixel2.j;
}
int encolaPixelFoto(Tpixel pixelNuevo,Timagen *imagen)
{
    if (imagen->numPixels==0)
       {
           imagen->pixels = (Tpixel *)malloc(sizeof(struct Tpixel));
           copiaPixel(&imagen->pixels[imagen->numPixels],pixelNuevo);
         
           imagen->numPixels++;
       }
    else
        {
         
         imagen->pixels=(Tpixel *) realloc(imagen->pixels,(imagen->numPixels+1)*sizeof(struct Tpixel));
         copiaPixel(&imagen->pixels[imagen->numPixels],pixelNuevo);
         imagen->numPixels++;
        }
}
int encolaPixel(Tpixel pixelNuevo,Tregion *region)
{
     if (region->numPixels==0)
       {
           region->pixels = (Tpixel *)malloc(sizeof(Tpixel));
           copiaPixel(&region->pixels[region->numPixels],pixelNuevo);
           region->xe=pixelNuevo.j;     
           region->xw=pixelNuevo.j;
           region->yn=pixelNuevo.i;     
           region->ys=pixelNuevo.i;
           region->numPixels++;
       }
    else
        {
         
         region->pixels=(Tpixel *) realloc(region->pixels,(region->numPixels+1)*sizeof(Tpixel));
         copiaPixel(&region->pixels[region->numPixels],pixelNuevo);
         region->numPixels++;
        }
}

int pintaRegion(Tregion region)
{
printf("numPixels:%d\n",region.numPixels);
printf("XEste%d\n",region.xe);
printf("YNorte:%d\n",region.yn);
printf("YSur:%d\n",region.ys);
printf("EOste:%d\n",region.xw);
printf("Porciento de cuadrado:%f\n",region.percent);
     
}
int nuevoPixel(Tpixel *pixel)
{
    pixel->r=0;   
    pixel->g=0;
    pixel->b=0;
    pixel->i=0;
    pixel->j=0;       
   
}
int buscaPixel(Tpixel pixel,Tregion *region,int altura, int anchura,int anchura_fila,int canales)
{
    Tpixel pixelAux;
    int id=0;


if (pixel.i-1>=0)
{
    encolaPixel(pixelAux,region);               
    data[(pixel.i)*anchura_fila+(pixel.j)*canales+0]=0;
    data[(pixel.i)*anchura_fila+(pixel.j)*canales+1]=0;
    data[(pixel.i)*anchura_fila+(pixel.j)*canales+2]=0;
    pixelAux.b=(int)data[(pixel.i-1)*anchura_fila+(pixel.j)*canales+0];
    pixelAux.g=(int)data[(pixel.i-1)*anchura_fila+(pixel.j)*canales+1];
    pixelAux.r=(int)data[(pixel.i-1)*anchura_fila+(pixel.j)*canales+2];
    pixelAux.i=pixel.i-1;
    pixelAux.j=pixel.j;
    //printf("color PixelAzul:%d,color PixelVerde:%d,color PixelRojo:%d\n",pixel.b,pixel.g,pixel.r);
    //printf("color pixelAuxAzul:%d,color pixelAuxVerde:%d,color pixelAuxRojo:%d\n",pixelAux.b,pixelAux.g,pixelAux.r);
    //system("PAUSE");
    if (esColorParecido(pixel,pixelAux))
     {
        buscaPixel(pixelAux,region,altura,anchura,anchura_fila,canales);       
     }                       
                                   
}
 
if (pixel.j-1>=0)
{
    pixelAux.b=(int)data[(pixel.i)*anchura_fila+(pixel.j-1)*canales+0];
    pixelAux.g=(int)data[(pixel.i)*anchura_fila+(pixel.j-1)*canales+1];
    pixelAux.r=(int)data[(pixel.i)*anchura_fila+(pixel.j-1)*canales+2];
    pixelAux.i=pixel.i;
    pixelAux.j=pixel.j-1;
    if (esColorParecido(pixel,pixelAux))
     {
         buscaPixel(pixelAux,region,altura,anchura,anchura_fila,canales);                                 
     }
}
if (pixel.i +1<=altura)
{
    pixelAux.b=(int)data[(pixel.i+1)*anchura_fila+(pixel.j)*canales+0];
    pixelAux.g=(int)data[(pixel.i+1)*anchura_fila+(pixel.j)*canales+1];
    pixelAux.r=(int)data[(pixel.i+1)*anchura_fila+(pixel.j)*canales+2];
    pixelAux.i=pixel.i+1;
    pixelAux.j=pixel.j;
    if (esColorParecido(pixel,pixelAux))
     {
         buscaPixel(pixelAux,region,altura,anchura,anchura_fila,canales);       
      }
}
  if (pixel.j+1<=anchura)
  {
    pixelAux.b=(int)data[(pixel.i)*anchura_fila+(pixel.j+1)*canales+0];
    pixelAux.g=(int)data[(pixel.i)*anchura_fila+(pixel.j+1)*canales+1];
    pixelAux.r=(int)data[(pixel.i)*anchura_fila+(pixel.j+1)*canales+2];
    pixelAux.i=pixel.i;
    pixelAux.j=pixel.j+1;
    if (esColorParecido(pixel,pixelAux))
     {
          buscaPixel(pixelAux,region,altura,anchura,anchura_fila,canales);       
 
     }
}
}
int llenaRegiones (Tregiones *regiones,int altura, int anchura,int anchura_fila,int canales)
{int i,j;
int numPixeles=0;
Tregion regionAux;
Tpixel pixelAux;
nuevaRegion(&regionAux);
nuevoPixel(&pixelAux);

for (i=10;i<altura;i++)

    for(j=10;j<anchura;j++)
       {               
            if((esVerde(data[i*anchura_fila+j*canales+0],
                        data[i*anchura_fila+j*canales+1],
                        data[i*anchura_fila+j*canales+2]))
               |(esAzul(data[i*anchura_fila+j*canales+0],
                        data[i*anchura_fila+j*canales+1],
                        data[i*anchura_fila+j*canales+2]))
               |(esRojo(data[i*anchura_fila+j*canales+0],
                        data[i*anchura_fila+j*canales+1],
                        data[i*anchura_fila+j*canales+2]))
               )
               {
                      nuevaRegion(&regionAux);                       
                      pixelAux.b=(INT)data[i*anchura_fila+j*canales+0];
                      pixelAux.g=(INT)data[i*anchura_fila+j*canales+1];
                      pixelAux.r=(INT)data[i*anchura_fila+j*canales+2];
                      pixelAux.i=i;
                      pixelAux.j=j;
                      encolaPixel(pixelAux,&regionAux);
                      data[(i)*anchura_fila+(j)*canales+0]=0;
                      data[(i)*anchura_fila+(j)*canales+1]=0;
                      data[(i)*anchura_fila+(j)*canales+2]=0;
                      buscaPixel(pixelAux,&regionAux,altura,anchura,anchura_fila,canales);
                      if (regionAux.numPixels>1000)
                         encolaRegion(regionAux,regiones);
                      printf("numero de pixeles en region %d:%d\n",regiones->numRegiones,regiones->regiones[regiones->numRegiones].numPixels); 
                      system("PAUSE");

               }
       }
    //printf("numpixeles:%d",numPixeles);
       



   

}
void PintaRectangulo(int x1,int y1,int x2, int y2, IplImage* img)
{
     CvPoint pt1, pt2;
     pt1.x = x1-10;
     pt1.y = y1-10;
     pt2.x = x2+10;
     pt2.y = y2+10;

cvRectangle( img, pt1 , pt2 , CV_RGB(0,0,255),15, 8, 0 ); //Dibujamos el rectangulo

     
}

int main(int argc, char *argv[])
{
IplImage* img = 0;
IplImage* img2 = 0;
int altura,anchura,anchura_fila,canales;


Tregiones bufferRegiones;
bufferRegiones.numRegiones=0;
int xCerca=10000;
int xLejos=0;
int yCerca=10000;
int yLejos=0;
Tregiones regiones;
Tregion regionAux;
int i;



char name0[]="C:\\VC\\Practicas\\Cubo5.JPG";

img=cvLoadImage(name0,1);

if(!img){
  printf("No se ha podido cargar la imagen: %s\n",argv[1]);
  exit(0);
}



altura    = img->height;
anchura     = img->width;
anchura_fila  = img->widthStep;
canales  = img->nChannels;
data   =(uchar*) img->imageData;
Timagen imagen;
printf("Procesando una imagen de %dx%d píxeles con %d canales\n",
    altura, anchura, canales);
    Tpixel pixelAux;
nuevaImagen(&imagen,altura,anchura);

img2=cvCloneImage(img);

cvNamedWindow( "Cubo0", 2 );
cvNamedWindow( "Cubo1", 2 );
llenaRegiones(&bufferRegiones,altura,anchura,anchura_fila,canales);
for (i=0;i<bufferRegiones.numRegiones;i++)
{   printf("Numero Region:%d",i);
    pintaRegion(bufferRegiones.regiones[i]);
}
//PintaRectangulo(xCerca,yCerca,xLejos,yLejos,img2);
//PintaRectangulo(2650,1125,3050,1600,img2);
printf("xCerca:%d\nyCerca:%d\nxLejos:%d\nyLejos:%d\n",xCerca,yCerca,xLejos,yLejos);
cvShowImage("Cubo0", img );
cvShowImage("Cubo1", img2 );

cvWaitKey(0); // se pulsa tecla para terminar
cvDestroyAllWindows(); // destruimos todas las ventanas
cvReleaseImage(&img);

    system("PAUSE");
    return EXIT_SUCCESS;
}



Bueno pos cuando ejecuto el codigo, se ejecuta el programa y se cierra rapidamente. voy depurandolo, y es como si se quedara sin memoria. Lo que hago practicamente es:

- Busco en la imagen un pixel que sea rojo,azul o verde
- si lo encuentra... aplica el algoritmo de crecimiento de regiones que consiste en:
  *si el pixel de encima es de color parecido haz el algoritmo de busqueda en el y pinta de negro el pixel actual
 *si el pixel de la izquierda es de color parecido haz el algoritmo de busqueda en el y pinta de negro el pixel actual
  *si el pixel de abajo es de color parecido haz el algoritmo de busqueda en el y pinta de negro el pixel actual
  *si el pixel de la derecha es de color parecido haz el algoritmo de busqueda en el y pinta de negro el pixel actual

si acaba la llamada recursiva de buscapixel mete en el puntero de regiones una nueva region  ponte a buscar mas pixeles hasta que no haya mas pixeles rojos verdes y azules.

Si alguien pudiera ayudarme estaria totalmente agradecido.Se acepta todo tipo de criticas y comentarios. Un saludo

Hay alguna manera de activar la mezcla estereo que no sea accediendo a las propiedades del dispositivo? ya sea por programación o comandos?
SndVol32.exe /rec
activar mezcla estereo
desactivar silencio en mezcla estereo

hay algun comando que realice esto o alguna manera de programarlo?Un saludo

guau que bien me va a venir

y dejar la dirección MAC bien grabada? No es muy buena idea.

OK jeje supongo que ante eso existen herramientas para camuflar tu MAC un poquito no? jeje encontre esto por aqui:

http://foro.elhacker.net/hacking_avanzado/como_cambiar_mac_address_en_windows_xp_iquest-t48630.15.html

Si te conectas Via Wifi a la Red de tu vecino y desde ahi redireccionas los puertos del router de tu vecino a tu ordenador...tambien te pueden detectar? es una duda que he tenido siempre....

Caray otro que quiere modificar el bifrsot
por que no simplemente consigues un crypter no tan viejo y lo modeas esque modear el bifrost creo qu eno te sera facil ya esta completamente detectado firmas por donde quiera

Creo que si quiero crear un crypter no es la mejor solucion, me gustaría seguir buenos pasos para poder empezar el proyecto, mi finalidad no es dejar indetectable el bifrost o el posion, mi finalidad es poder crear un crypter que haga FUD a todo stub que le pase..... si alguien pudiera ayudarme un poquito se lo agradecería. Un saludo!

Has dicho programar, en cambio leo que has estado intentando quitar firmas...
Si lo que quieres decir es que a un Crypter que tu has programado se le esta detectando con ciertas firmas dependera del tipo de deteccion lo que has de hacer para eliminarla...

Si lo has programado tu; Que detecciones te saltan?

Todavia no he programado nada , me gustaria empezar a programarlo, hasta ahora he estado mirando manuales que estan bastante bien de como meter RC1 o distintos algoritmos de encriptacion en aquellos offset donde salta la firma, bueno el problema es que estuve mirando en que offset saltaba la firma del kaspersky en el bifrost, y detecte mediante editores hexadecimales y tambien con ayuda de "signature zero" aquellos sitios donde kaspersky detectaba la firma del bifrost. conseguí sacar 4 firmas
diferentes que eran estas:

BIFROSE.ADP
6A 02 68 BC 73 40 00 BF 28 70 40 00 68 59 03 00 00 57 E8 B4 FF FF FF 6A 02 68 B8 73 40 00 BE 28 10 40 00 68 00 60 00 00 56 E8 9D FF FF FF 83 C4 20 68 A8 73 40 00 FF 15 04 10 40 00 8B 1D 00 10

BIFROSE.ACI
80 86 22 EE 61 64 C7 97 00 E2 EC B3 97 FF 45 92 EA E4 BE B6 00 3E A2 33 44 08 C4 FE 45 FF 71 DB 24 85 A3 35 86 29 72 46 E0 85 28 DE F7 22 27 94 83 15 D8 8F 2E 96 BF CE A5 36 63 A5 A4 B3 9A 92 BA B1 35 16 A4 C7 76 A3 1F D3 40 43 80 17 D9 98 91 A7 83 D3 8F A0 A4 F0 4F 2E 95 19 D8 E7 66 BD 93 8F FA 94 88 19 4B 73 EA B8 EB E6 84 A3 85 DC F4 A4 64 9A 32 54 27 F8 79 D7 9B F1 65 33 8D 35

BIFROSE.ACI
D4 D1 FD 88 C5 FA C6 FA BF F8 F8 E3 E7 E1 FB ED 09 29 08 89 D7 ED E4 E2 F1 B8 F2 F0 E8 F1 E4 FD C8 91 DE E4 FE F0 F1 FE F8 DA 58 FD D3 D7 00 09 00 49 FB FF E4 D5 91 EE F9 C5 0A E2 B5 C1 EB E6 EF FF D6 FB EC D6 08 09 20 D8 41 DE FE E1 CF FC C5 91 FD FA DF D0 EC E2 C5 97 41 F9 FD BF D5 B5 F1 E2 F9 E6 FC F6 17 29 98 41 01 F1 E6 EE F0 E5 1A F9 D0 F0 FE F3 FE E3 F1 40 0B 5B 86 B5 BC 99

BIFROSE.ACI
C6 F6 F6 82 D6 85 93 95 F6 66 F6 F6 F6 E6 F6 F6 F6 F6 F6 F6 F6 F2 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 76 F6 F6 16 C7 F6 F6 82 D6 85 93 95 F6 96 F6 F6 F6 56 F6 F6 F6 AE F6 F6 F6 F2 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 B6 F6 F6 16 C4 F6 F6 82 D6 85 93 95 F6 E6 F6 F6 F6 F6 F7 F6 F6 F2 F6 F6 F6 AA F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 F6 B6 F6 F6 36 F6 F6 F6 F6 F6 F6 F6 F6

entonce compile de nuevo y sustitui esas firmas por 00( se que no funcionaria el server pero por simple curiosidad de dejar indetectado kaspersky), entonces me salta con que detecta otra firma: bifrose.acs

cuando me pongo a detectar la firma resulta que no era igual que las otras firmas, cogia un rango de bytes bastante grande donde si eliminaba entre medias algunos bytes seguia detectando la firma, pero si eliminaba  hasta abajo ya no al detectaba, era bastante extraño, y no es una deteccion por heuristica por que creo que el antivirus lo pone cuando detecta algo por heuristica, es el kaspersky11. El caso es que estoy intentando coger todas las firmas para luego con olly meter algun codigo en ASM y poder burlar al antivirus, ya sabiendo esto me dispondre de programar un crypter, que me gustaria bastante la idea.Sólo que me he quedado estancado por que la ultima firma me dejado un poco :S y creo que no voy por buen camino, alguien me puede echar una mano y decirme que estoy haciendo mal y por donde tengo que ir? Un saludo y sigo diciendo que perdoneis mi ignorancia, hasta ahora no me habia metido nunca con este tema, de todas formas seguire leyendo manuales...

Buenas me gustaria programar un crypter, pero esto un poco PEZ en algunos aspectos, he leido manuales por aqui por el foro y aun asi de seguirlos creo que se quedan ya obsoletos ante las firmas de KAspersky por ejemplo...
he estado probando con la herramienta Signature Zero para bucar las firmas del kaspersky en el bifrost, y llevo varios dias con editores hexadecimales y cuando creo que todo acaba vuelve a aparecer una que ya me rompe los esquemas, existe alguna manera de conseguir estas firmas de otra forma? Un saludo y perdonad mi ignorancia en esto...