Bueno, quisiera preguntar que formas de infección se les ocurren usando las redes sociales.
Seria interesante para aprender como evitar ataques y mejorar la seguridad.

A mi me vienen a la cabeza varias, pero parecen poco efectivas.

-subir un archivo bindeado a un ejecutable cualquiera no sospechoso, colgarlo en la web, y mandar el típico enlace a la victima

-Crear una página falsa de un video, y poner un mensaje, "Tienes que actualizar tu flas player para ver el video",y cuando le den a descargar, descargaran un flas player junto a troyano.

Edito:

A partir de ahora las futuras versiones de Demonio solo verán la luz en forma de código fuente. No publicaré más ejecutables para ningún sistema operativo ni del cliente ni del servidor, debido a numerosos post de gente que no aprecia el trabajo de los demás, la gran cantidad de gente que espera que se lo den todo hecho a cambio de nada y el esfuerzo extra que conlleva el tener que hacer tantas compilaciones.


Video mostrando como configurar un servidor

VERSIÓN 2.0 FINAL LANZADA!!!!

Lanzada la última beta, beta 2 con correción de errores y manual de compilación del servidor en Windows.

Después de dos meses desde mi versión 1.0
NUEVA VERSIÓN DE MI TROYANO CON GRANDES MEJORAS

Fase Beta: Por favor, comunicadme los errores que encontreis para una vesión final estable. Gracias.

Cliente de Demonio 2.0b en Windows Vista y servidor en Windows 7


Cliente de Demonio 2.0b en Windows Vista y servidor en Kubuntu 10.10


Cliente de Demonio 2.0b en Kubuntu 10.10 y servidor en Windows 7



Cliente de Demonio 2.0b en Mac OS X y servidor en Linux



El troyano tiene:
-Conexión inversa.
-Conexión mediante servidor intermédio ( Demoxy )
-Multiples servidores se pueden conectar al mismo cliente a la vez.
-Escucha en 4 puertos.
-Generador del servidor.
-Escritorio remoto
-Administrador de archivos remoto (con transferencias de archivos comprimidas y previsualación de imágenes)
-Enviar mensajes emergentes.
-Consola remota
-MULTIPLATAFORMA Tanto Cliente como Servidor (sí funciona en GNU/Linux también!)
-Chat
-Captura de Webcam
-Envio de Teclado
-Envio de clicks de ratón.
-Keylogger
-Obtener información del sistema
-Administración del sistema (Reiniciar y apagar el equipo)
-Soporte multilenguaje (De momento Español, Inglés y Portugués)
-El servidor puede unirse a un ejecutable cualquiera y ejecutarse en segundo plano(JOINER)
-Se puede especificar que ejecute un programa o comando al iniciarse (Una vez o siempre que se inicie)
-Desinfectar el troyano de forma remota.
-Otras opciones diversas.

Link:
http://albertopajuelo.blogspot.com/2010/12/demonio-troyano-opensource-en-c-y-qt4.html

He iniciado un nuevo proyecto llamado Demoxy. Se trata de un servidor proxy para Demonio que intercomunica de forma indirecta el servidor con el cliente de modo que, todas las conexiones pasan por un servidor intermedio.
Esto tiene ciertas ventajas con respecto al sistema de conexión inversa:

-No es necesario abrir puertos si te encuentras detrás de un ruter.
-Obtienes cierto anonimato, al conectarse el servidor al proxy en vez de a ti directamente parece que sea él el equipo del que proceden las ordenes.

Así mismo tiene también algunas desventajas:
-Necesitas un servidor intermedio con una dirección conocida.
-La conexión puede ser algo más lenta.

El servidor Demoxy está en una fase muy temprana de su desarrollo pero ya he logrado interconectar cliente y servidor con éxito y transmitir información entre ambos sin problema.
He tenido que hacer algunos cambios al cliente de Demonio para que pueda conectarse por el sistema Demoxy y ahora tiene dos opciones de conexión, la tradicional conexión inversa o a través del nuevo sistema.

Aqui un esquema que ilustra la forma de funcionar de ambas conexiones:



Captura de pantalla del Cliente de Demonio con opción de conexión a través de Demoxy:


EDITO

En estos últimos dias he estado implementando el soporte multiconexión de Demoxy, no es una tarea sencilla pues hay que manejar con mucho cuidado todas las posibilidades, conexiones , desconexiones, etc.
Ya he conseguido con éxito conectar varios servidores al cliente a través de Demoxy pero las desconexiones no están implementadas aún.
Los cambios ya están subidos al repositorio SVN

Para usar correctamente Demoxy, en la máquina donde lo vayamos a ejecutar tiene que tener abiertos estos puertos TCP:

1234 - Puerto de conexión principal del servidor
2345 - Puerto de transferencias de archivos
3456 - Puerto de transferencias de capturas de escritorio
4567 - Puerto de transferencia de capturas de webcam

1111 - Redirección de la conexión principal
2222 - Redirección de las transferencias de archivos
3333 - Redirección de capturas de escritorio
4444 - Redirección de capturas de webcam
5555 - Puerto de mensajes de control y estado.

Buenas, otro problema con el dichoso QProcess, resulta que al ejecutar una aplicación con start(). startDetached(), o execute(), la aplicación se congela hasta que la aplicación que has ejecutado se cierra, y eso que se supone que start() y startDetached() son asincronos.
¿A qué es debido esto?

Hola, mi pregunta es si conocen algún buen servicio de hosting gratuito y sin publicidad donde alojar un proyecto que estoy realizando, necesito que se puedan subir todo tipo de archivos ya que necesito que se puedan realizar descargas.

UN SALUDO

Buenas, tengo un bug en mi troyano que llevo ya 2 dias con él y por muchas vueltas que le doy no consigo que funcione correctamente.
Se trata de la consola remota, tengo este slot:

consola esta definido en el .h como QProcess consola.
El caso es que no me funciona, no me devuelve la salida del comando
pero si pongo cmd.exe aparece esto

Microsoft Windows [Versi¢n 6.1.7600]
Copyright (c) 2009 Microsoft Corporation. Reservados todos los derechos.

C:\Users\alberto\Desktop\DemonioCompartido\Demonio\src\servidor-build-desktop>

Alguien tiene alguna idea? aver si puedo sacar ya la 1.0 final de una vez.

Código fuente de un pequeño programita de broma en Qt4 (es que me aburria)

http://qt-apps.org/content/show.php?content=136693

Hola a todos.
Estoy haciendo un pequeño tutorial de programación con las librerias Qt4 que iré poniendo poco a poco en mi blog.
Actualmente ando un poco liado en mi propio proyecto de un troyano y con las clases de DAI pero intentaré hacer por lo menos un post del tutorial a la semana.
Espero que les sirva y perdonad si alguna semana estoy demasiado ocupado como para publicar la nueva entrega
------------------------------------------------------------------------------
Bueno, voy a ir haciendo poco a poco un pequeño curso de programación con las librerias Qt4 ya que parece que hay poco al respecto en español.
Voy a suponer que ya se poseen conocimientos de programación en C++ en general y de programación orientada a objetos.
Lo primero que voy a enseñar es como crear una aplicación simple que mue
stre una ventana.


#include <QtGui/QApplication>
#include <QMainWindow>
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QMainWindow ventana;
    ventana.show();
    return app.exec();

}


Bueno, como veis el código es bastante simple, primero tenemos que incluir la clase QApplication que es la encargada de todo lo referente a nuestra aplicación y la clase QMainWindow que es la que representa la ventana principal de nuestro programa.
Luego en la típica función main declaramos dos objetos:
app de tipo QApplication que será el que contiene las funcionalidades básicas del programa y una ventana principal llamada ventana.

Con ventana.show() le decimos que queremos mostrar la ventana en pantalla y luego
llamamos a app.exec() que es un bucle donde permanecerá la aplicación recibiendo y respondiendo a los eventos del usuario hasta que se le de la orden de cerrar la aplicación, en cuyo caso devolverá el código de salida 0 si todo ha ido bien y saldrá del programa.

Más adelante en próximos post explicaré como incluir botones y el mecanismo de signals y slots típico de la programación en Qt.
Hasta la próxima.
--------------------------------------------------------------------------------
Bueno ya que estaba un poco aburrido hoy voy a continuar con la segunda entrega de mi tutorial de programación en Qt4.
En esta ocasión voy a explicar como añadir botones y hacer que al pulsarlos hagan cosas.
Para añadir un botón a nuestro anterior programa lo primero es incluir un nuevo archivo de cabecera que contiene la clase que maneja nuestro botón, en este caso la clase QPushButton (Nota que todas las clases en Qt empiezan por Q).
Las cabeceras quedarían así:

#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>


Luego bastará con crear un nuevo objeto de esa clase y para que esté incluido en el formulario le pasaremos una referencia a él.
Esto lo haremos de la siguiente forma:
QPushButton *boton = new QPushButton(&ventana);

Con lo que nuestro código completo que añade un botón a la ventana principal queda asi:
#include <QtGui/QApplication>

#include <QMainWindow>
#include <QPushButton>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QMainWindow ventana;
    QPushButton *boton = new QPushButton(&ventana);
    ventana.show();
    return a.exec();
}

Si te fijas verás que el botón que hemos incluido no tiene ningún texto, para ponerle un texto usaremos el método
QPushButton::setText([texto que le queramos poner]);
Aprovecho para explicar algo sobre los métodos en Qt.
Los métodos que sirven para establecer parámetros de los objetos normalmente son los mismos que los que se usan para leerlos pero empezando por set.
Ejemplo:
QPushButton::text() nos devolvería el texto del boton y QPushButton::setText([algun texto]); pondría el texto del botón.

Concluyendo nuestro programita anterior quedaría algo mejor de la siguiente forma:


#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QMainWindow ventana;
    QPushButton *boton = new QPushButton(&ventana);
    boton->setText("Boton de prueba");
    ventana.show();
    return a.exec();
}
Bueno ahora que tenemos un botón querremos que haga algo al pulsarlo ¿no?

En Qt4 la forma de manejar los eventos como pulsación de un botón, rellenar un formulario, etc. se manejan con el sistema de signals y slots.
Esto consiste en que el objeto que recibe la acción (por ejemplo, un botón al ser pulsado), envia una señal (signal) a otro objeto (por ejemplo, la ventana principal), y este objeto receptor tratará esa señal ejecutando uno de sus métodos (slots).
El método que conecta signals y slots es el método connect de la clase QApplication y se usa de la siguiente manera:

QApplication::connect([objeto emisor],SIGNAL([señal]),[objeto receptor],SLOT([método receptor]));

Veamos como haríamos para que, por ejemplo, al pulsar el botón la aplicación se cerrase.

#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    QMainWindow ventana;
    QPushButton *boton = new QPushButton(&ventana);
    boton->setText("Boton de prueba");
    a.connect(boton,SIGNAL(clicked()),&ventana,SLOT(close()));
    ventana.show();
    return a.exec();
}


Como se puede ver en el ejemplo, conectamos la señal clicked() del botón con el slot close() de la ventana principal, lo que hace que al pulsar el botón la aplicación se cierre.

Bueno esto es todo por ahora, en próximas entregas profundizaremos un poco más en el mecanismo de signals y slots.

HASTA LA PRÓXIMA.
-------------------------------------------------------------------------------------------------Bueno, vamos a continuar con el tutorial.
En esta ocasión voy a hablar de como crear signals y slots personalizados para un determinado widget.
Para eso tendremos que crear una clase que herede de la clase a la que queremos añadir signals y/o slots definidos por nosotros donde los declararemos.
Veamos como se hace modificando nuestro programa anterior para que muestre un mensaje emergente al pulsar el botón.

Primero creamos un archivo de cabecera ventanaPrincipal.h y otro archivo ventanaPrincipal.cpp donde implementaremos sus métodos.
El fichero de cabecera quedaria así:

#include <QMainWindow>

class ventanaPrincipal : public QMainWindow
{
    Q_OBJECT
public:
    explicit ventanaPrincipal(QWidget *parent = 0);
    ~ventanaPrincipal();
public slots:
    void mostrarVentanaEmergente();
private:
};

y el fichero cpp asi:

#include <ventanaPrincipal.h>
#include <QMessageBox>
ventanaPrincipal::ventanaPrincipal(QWidget *parent) : QMainWindow(parent)
{

}
ventanaPrincipal::~ventanaPrincipal()
{

}
void ventanaPrincipal::mostrarVentanaEmergente()
{
    QMessageBox mensaje;
    mensaje.setText("Hola mundo!");
    mensaje.show();
}

Como se puede ver en el ejemplo, declaramos una clase ventanaPrincipal que hereda de QMainWindow y en public slots: definimos el lugar donde pondremos nuestros propios slots personalizados.
Los slots se declaran como cualquier método normal de la clase, en nuestro ejemplo he creado el slot mostrarVentanaEmergente() que mostrará una ventana emergente con el texto "Hola mundo!"
Con todo esto nuestro programa principal quedaria así:
#include <QtGui/QApplication>
#include <QMainWindow>
#include <QPushButton>
#include <ventanaPrincipal.h>
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    ventanaPrincipal ventana;
    QPushButton *boton = new QPushButton(&ventana);
    boton->setText("Boton de prueba");
    a.connect(boton,SIGNAL(clicked()),&ventana,SLOT(mostrarVentanaEmergente()));
    ventana.show();
    return a.exec();
}
Lo único que hemos hecho es cambiar el tipo de ventana de QMainWindow a nuestra clase personalizada ventanaPrincipal y conectar el botón a nuestro recién creado slot.
Bueno hasta aquí por hoy, en próximas entregas enseñare como crear signals personalizados.
¡HASTA LA PRÓXIMA!
fuente original: http:\\albertopajuelo.blogspot.com
SALUDOS!

Hola, tengo este simple código en C++ con las librerias Qt4 donde parametros[1] es un QString con la ruta completa del ejecutable que pretendo ejecutar y no me funciona.
¿Que puede estar pasando?

 if (parametros[0] == "execute")
    {
        QProcess ejecutar;
        ejecutar.start(parametros[1]);
    }

Hola, me he hecho una pequeña libreria en c++ para la captura de webcam desde mi troyano Qt4, la he hecho usando la API de windows y más adelante haré otra para v4l y asi completar el soporte multiplataforma.
Pero tengo un problema que no se como sulucionar, resulta que despúes de encender la cámara está solo me captura el primer frame y no se actualiza y no se porque. os dejo el código fuente a ver si le podeis hechar un vistazo (Licencia GPL).
#include "webcamwin.h"

HWND hwndVideo; // video capture window
void encender()
{
    ::hwndVideo = capCreateCaptureWin dowA("captura",WS_POPUP,160, 120 ,320, 240,NULL,0);
    capDriverConnect(::hwndVideo,0);
    capPreviewRate(::hwndVideo,100);
    capPreviewScale(::hwndVideo,false);
    capPreview(::hwndVideo,true);
}

void apagar()
{
    capPreview(::hwndVideo,FALSE);
    DestroyWindow(::hwndVideo);
    ::hwndVideo = NULL;
}

QPixmap capturar()
{
    QPixmap imagen;
    capFileSaveDIB(::hwndVideo,L"prueba.bmp");
    imagen.load("prueba.bmp");
    return imagen;
}

Edito:
Bueno ya solucioné el problema cambiando algunas cosas en la llamada a capCreateWindowA... interesados en la libreria la pueden descargar junto al fuente de mi troyano.