🚀 go-pugleaf

Addendum:

> Das ist wohl richtig so, aber dennoch ist der Compiler nicht im kernel
> space ausser das OS unterstuetzt processor-task affinities. Der compiler
> task ist dann an eine CPU gebunden und laeuft als task uninterruptable.
> main pgm kann schon umgewandelt werden, wenn man einen temporaeren
> TLB pool generiert, der nicht vom qcc ILE compiler aquiriert wird.

Hey, ich glaube, ich habe einen Weg gefunden, wie man doch einen Compiler
im Kernel haben koennte. Also, im Prinzip funktioniert es, wie beim Viren
schreiben unter Linux (nicht sehr bekannt). Das Prinzip liegt das Problem
darin, dass man einen jump ins cr0 (0xC0000000) machen muss, und das ge-
schieht, indem man eine Trap oder Call GATE benutzt und den IDT im Ring-0
selector veraendert, dass er auf alle memory segmente Schreibberrechtigung
hat. Dies kann man gemaess "Intel Architecture Manual" durch das setzen
des WP bits [ich weiss jedoch nicht, was in einem page fault mit der GOT
passiert, aber wenn's Euch interessiert, schaut unter ../linux/arch/i386/\
kernel/head.S nach] erreichen. So, das ist eigentlich schon die halbe
Anleitung, um einen Virus unter Linux zu schreiben. Leider funktioniert
es _nicht_! Ja, ich kenne den code von allen sogennanten Linux "Viren",
aber das sind alles keine richtigen polymorphen Viren, sondern haeufig
nur lokale Infektoren, nicht per-process resident und die cavity infection
ist beschraenkt auf ELF pointer infection und PLT redirection. Das ist
eigentlich der einzig wahre Unterschied, weshalb Viren unter Linux nur
im process space des callers funktionieren [ok, dies kann verheerende
Folgen haben, wenn man NFS faehrt :) ]. 

Bei dem Microschrot OS (DOS, Win *, including XP) kann man vom user space
aus beliebige jumps via trap gate in den cr0 machen und man hat den 
kompletten virtuellen Addressbereich des OS zum Ueberschreiben zur Ver-
fuegung.

Sorry, ich bin ein wenig mit meinen Erklaerungen vom Weg geraten, aber
im Prinzip koennte ein Compiler im Kernel wie ein Virus funktionieren.
Ich habe mich heute Nacht mal im Plan9 kernel source code rumgeschaut
und dort interessante ideen gefunden. Wenn man diese mit dem kernel monte
projekt mixt, dann wuerde das evt. funktionieren, aber hoechstens fuer
UP.

Beispiel (fuer einen syscall/library call 0.Ordnung):

/* 
 * This could be a part of the gcc kernel module 
 * 
 * stupid non-working preprocessing syscall -> int80 baschtel
 *
 * GPLv2 :) 
 * (c) Roberto Nibali, ratz, 2001 
 *
 */

scan_PGI_table() {
  unsigned long PGI_table;
  __asm("
	movl %cr3, %eax
	movl %eax, (PGI_table)
	movl %cr0, %eax
	movl %eax, (r_cr0)	 # Hello Mr. B. Gates, are you unhappy :)
	movl %cr4, %eax
	movl %eax, (r_cr4)
  ");
}

scall_2_pS() {
asm ("
.text
.align  8
.L__scall:
        scall
        hlt
.align  8
");

#define scall_0(n)                      ({      \
  int ret;                                      \
    asm volatile ("                             \
        pushl   %%ebp                           \n\
        movl    %%esp,%%ebp                     \n\
        call    .L__scall                       \n\
        popl    %%ebp"                          \
        : "=a"(ret)                             \
        : "a"(n)                                \
        : "ecx","edx");                         \
    ((unsigned int)ret<=0xfffff000) ? ret :     \
       (__set_errno(-ret), ret=-1);     })
}

static void cleanup_scall_up (void *info){
   asm volatile ("
        xorl    %%eax,%%eax
        xorl    %%edx,%%edx
        movl    $0x174,%%ecx
        wrmsr
        movl    $0x175,%%ecx
        wrmsr
        movl    $0x176,%%ecx
        wrmsr"
        : : : "eax","ecx","edx"
        );
}

/* [... lots of other functions :)] */

cleanup_module(){
     cleanup_scall_up();
}
init_module(){
     scan_PGI_table();
     preprocessor();
     scall_2_pS();
     compile_LDT_save();
     be_happy();
}

Das laeuft nicht, aber ist so etwas wie eine Denkhilfe. Also, Juerg, Adrian,
so koennte das mit einem Compiler funktionieren. oups, zusaetzlich muesste 
man den kernel_thread noch atomic daemonizen (ich glaube CLONE_VM) und eine
realtime prio queue fuer den kernel_thread geben, sonst ist der scheduler zu
fair und das Programm wird nie fertig mit kompilieren.

Ja, ja, es gibt allerhand, was die Leute so in den Kernel reinbasteln wollen.
Letzthin kam mir einer mit der Idee xml!! also Ausgabeformat fuer das proc-fs
zu machen. Er hat jetzt eine neue email Adresse :)

Sorry fuer das lange posting und dann erst noch aus google heraus, aber ich
kann im Moment meine Mails nicht von tac.ch abrufen, da wir intern mal wieder
die security policy erhoeht haben und am Wochenende arbeite ich selten in
der Firma.

So und nun weg von den Kernel Sourcen und vorbereiten fuer's UG, dort ist
heute naemlich ein alter Kumpel von mir, Richard Dorfmeister und wird
ziemlich geilen ambient, drum'n'bass chillout Sound auflegen. Vielleicht
sieht man sich ja,

Gruss,
Roberto Nibali, ratz