lisezmoi.developpeurs

Cctt, "Covert Channel Tunneling Tool" - 顾名思义

  service.

      B5A) Shell serveur

        La fonction executee positionne des parametres dans le  contexte  client
      et cree un nouveau processus (le manager).

        Quand des donnees se presenteront sur la socket, la boucle principale de
      do_server() verifiera le contexte client et ne touchera pas aux donnees de
      la socket tandis que le manager pourra, lui, les traiter.

        Le manager se charge de creer un troisieme processus qui sera  le  shell
      demande par le client et possede un acces immediat en lecture/ecriture  au
      trafic circulant sur  la  socket.  Il  n'est  donc  plus  fait  appel  aux
      fonctions de stockage  temporaire  utilisees  dans  la  boucle  principale
      do_server().

      B5B) Demande de la liste Proxy

        La fonction executee envoie (avec le codage approprie) la liste de proxy
      configuree et ferme la connexion.

      B5C) ReverseShell

        La demande de service est enregistree pour la premiere serie de donnees.
        Quand de  nouvelles  donnnes  se  presentent  (a  partir  de  la  boucle
      principale do_server()),   le  serveur  verifie  si  le  client  est  deja
      identifie     et     le     cas     echeant     execute     la    fonction
      srv_manage_connection_type() (.c du meme  nom)  qui  verifie  le  type  de
      service et appelle la fonction client_told chargee d'afficher les  donnees
      emises.

        L'envoi de donnees au client s'effectue par  l'entree  de  commandes  au
      niveau du mode interactif serveur (voir B6).

      B5D) Demande de proxy.

        La demande de service est enregistree pour la premiere serie de donnees.
        Quand de n ouvelles  donnnes  se  presentent  (a  partir  de  la  boucle
      principale do_server()),   le  serveur  verifie  si  le  client  est  deja
      identifie     et     le     cas     echeant     execute     la    fonction
      srv_manage_connection_type() (.c du meme  nom)  qui  verifie  le  type  de
      service et appelle l'une des deux fonctions :
          * client_wants_proxing_to() (.c du meme nom).
          * client_spoke_to_proxy() (client_told.c).

        La premiere fonction est chargee d'analyser la demande du client  et  si
      celle-ci est valide (par rapport  a  la  liste  d'autorisation  de  proxy)
      d'ouvrir la connexion vers l'application demandee.
        La seconde fonction est chargee d'envoyer les donnees recues du client a
      l'application demandee, une fois que le canal precedent a ete ouvert.

        Quand une application envoie des donnees pour un client, celles-ci  sont
      emises sur la bonne socket par la fonction check_proxy_connections() de la
      boucle principale do_server() (voir B).

  B6) Mode interactif 

    La boucle principale do_server positionne egalement l'entree  standard  dans
  le poll du select et sa gestion est realisee par  le  biaias  de  la  fonction
  parse_cmd (parse_cmd.c).
    => Cette fonction est encore un tableau de pointeurs sur fonction permettant
  d'aller chercher la bonne action a realiser.

================================================================================

C) Description du code client

  Apres initialisation, la fonction do_channel() lance a partir d'un tableau  de
pointeur sur fonction la fonction de gestion de canal requise. C'est  l'une  des
fonctions channel_do_xxx (channel_do_xxx.c).
  Ces fonctions ont pour but de :
    * identifier le client et envoyer la demande de service au serveur.
    * gerer le type de service demande.

  C1) Etablissement de la connexion reseau

    Si le client ne fonctionne pas en mode proxy local, il commence par  etablir
la socket de connexion au serveur avec le protocole (TCP  ou  UDP)  approprie  :
client_socket() (channels_functions.c).

    Dans le cas contraire, le client commence par se configurer en  proxy  local
  client_binds_local_proxy() (.c du meme  nom)  et  n'etablira  les  sockets  de
  connexion au serveur que si des clients applicatifs se connectent. 
    Quand ces connexions sont etablies, le client retransmet les  donnees  entre
  le(s) client(s) applicatif(s) et le serveur en prenant en compte  le  type  de
  canal demande.

  C2) Identification du client

    La fonction d'identification cl_identification()  (cl_identification.c)  est
  relative au type de canal  utilise  (voir  B3)  et  se  charge  d'executer  la
  fonction convenable qui peut etre :
      * cl_identification_clear  : La requete d'identification est en clair.
      * cl_identification_basic  : La requete d'identification est  codee  selon
        le principe du canal socket_encode.

    Si le client ne fonctionne pas en proxy  local  et  que  l'idenfication  est
  incorrecte, le client quitte.
    Si  le  client  fonctionne  en  proxy  local  et  que  l'identification  est
  incorrecte, le client  ferme  la  connexion  avec  l'applicatif  qui  lui  est
  connecte.

    Notez que la demande de service est contenue dans la identification.

  C3) Shell demande au serveur ou demande de liste d'autorisation Proxy

    C'est la fonction channel_do_socket_go() (.c du meme nom) qui est executee.

  C4) Envoi d'un ReverseShell au serveur

    C'est la fonction  channel_do_socket_rshell()  (.c  du  meme  nom)  qui  est
  executee.

================================================================================

I) Activation du mode DEBUG

  Le mode DEBUG (parametre -D de la ligne de commande) donne des informations de
debugage lors de l'execution du client ou du serveur. 
  Ces informations  sont  fournies  par  la  fonction  cctt_debug()  disposee  a
certains endroits du code.

  2 types  de  debug  sont  disponibles  et  doivent  etre  specifies  avant  la
compilation dans main.c en positionnant la variable GLOBAL_DEBUG a 1 ou a 2.
  Positionne a 1, le debug est normal => Appel a 'cctt_debug()'.
  Positionne a 2, le debug est plus verbeux.  =>  Les  appels  a  'cctt_debug()'
precedes de 'if (OPT_DEBUG2())' sont egalement pris en compte.
  
================================================================================
  
II) Comment ajouter un type de canal ?

  Pour ajouter un type de canal, suivez les etapes :

    1) Fonction synopsis (functions.c), ajouter le commentaire sur  le  type  de
       canal.
    2) Dans le tableau channel_types_array[] (channels.c),  ajouter  le  {label}
       correspondant au type de canal ainsi que les fonctions a executer en mode
       client et en mode serveur.
    3) Creer  un  fichier  channel_do_{label}.c  dans  src/  qui  contiendra  la
       fonction channel_do_{label}
       => Consultez les autres fonctions pour connaitre le type et parametres de
       cette nouvelle fonction.
    4) Ajouter   le    prototypage    de    cette    nouvelle    fonction   dans
       includes/channels.h
    5) Creer un fichier server_do_{label}.c dans src/ qui contiendra la fonction
       server_do_{label}
       => Consultez les autres fonctions pour connaitre le type et parametres de
       cette nouvelle fonction.
    6) Ajouter    le    prototypage    de    cette   nouvelle   fonction    dans
       includes/channels.h
    7) Ajouter les deux fichiers .c dans src/Makefile
    8) Recompiler CCTT

================================================================================

III) Comment ajouter un type d'identification ?

  Note: Les types d'identification client/serveur doivent etre complementaires.

  Pour ajouter une methode d'identification dans les fichiers de configuration :

    1) Ajouter le label dans les fichiers de  configuration  pour  la  directive
       IDENT.
    2) Dans le tableau ident_type_array (conf_file_IDENT.c),  ajouter  le  label
       desire, puis les fonctions a appeler en mode client et en mode serveur.
    3) Dans   le  fichier  cl_identification.c,  ajouter  la  nouvelle  fonction
       effectuant l'identification du client.
    4) Dans includes/cl_identification.h, ajouter le prototypage de la  nouvelle
       fonction.
    5) Dans   le   fichier  srv_ident_client.c,  ajouter  la  nouvelle  fonction
       effectuant l'identification du cote serveur.
    6) Dans includes/srv_ident_client.h, ajouter le prototypage de  la  nouvelle
       fonction.
    7) Recompiler CCTT

================================================================================

IV) Comment ajouter un parametre dans un fichier de configuration ?

  Pour ajouter un parametre dans un fichier de configuration, suivez les etapes:
    1) Ajouter le nom de la directive dans le  tableau  ConfigFileFunctionsArray
       (conf_file_functions.c).
    2) Ajouter  le  nom  de  la  fonction  dans  le  tableau  ConfigFileArrayPtr
       (conf_file_functions.c).
    3) Creer un fichier {nom_de_la_fonction}.c dans lequel est codee la nouvelle
       fonction.
    4) Ajouter le prototypage de la fonction dans includes/conf_file_functions.h
    5) Ajouter le nom du fichier .c dans le Makefile.
    6) Recompiler