/*
rndkill kernel module will totally fuck up your kernel.
Copyright (C) 2004 Aaron Lenoir

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

/* Deze code zal enkel werken op kernel 2.2 en later! */

/* KERNEL MODULE FROM HELL: To make matters worse, everything
 * in dutch! >)
 *
 * AUTHOR CLAIMS NO RESPONSIBILITY IN ANY WAY!!!!!!!!!
 *
 * RNDKILL IS EEN EXTREEM GEVAARLIJKE MODULE EN JE MAG ZE
 * NIET IN DE KERNEL LADEN TENZIJ JE PRECIES WEET WAT ZE DOET 
 * EN JE WEET WELKE RISICO'S ERAAN ZIJN VERBONDEN!
 *
 * DE AUTEUR IS IN DE VERSTE VERTE NIET VERANTWOORDELIJK
 * VOOR ENIGE PERMANENTE SCHADE AAN ALLES.
 *
 * VOOR ALLE VEILIGHEID KUN JE BEST "sync" DOEN VOOR JE
 * DE MODULE INSMOD EN "sync" NET VOOR JE ZE RMMOD.
 *
 * ZEG NIET DAT JE NIET GEWAARSCHUWD BENT.
 *
 * Om te compileren:
 *
 * 	make
 * (negeer waarschuwingen)
 *
 * Om de module te laden:
 *
 *	sync; insmod rndkill.o
 *
 * Om de module uit de kernel weg te halen:
 *
 *	sync; rmmod rndkill
 *
 *
 * (_*_) http://users.pandora.be/pittaman/ (_*_)
 *
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <sys/syscall.h>
#include <linux/sched.h>
#include <linux/signal.h> /* voor SIGKILL... */
#include <linux/random.h> /* duh... */
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Aaron Lenoir");


/* COMMENT DIT OM HET ECHT VOLLEDIG NAAR DE KLOTEN TE HELPEN */
#define __POESIEKILL__

/* We zullen alleen random dingen doen wanneer SIGKILL het gegeven
 * signaal is. */
#ifdef __POESIEKILL__
#define TARGET_SIG SIGKILL
#else
#define TARGET_SIG SIGHUP
#endif

#define RAND_BUF 16

/* de AMNESTY constante bepaald vanaf welke PID men kan killen.
 * Dus: Wanneer AMNESTY 20 is zullen de eerste 20 PID'S nooit worden gekilled.
 * ... denk ik. */
#ifdef __POESIEKILL__
#define AMNESTY 20 /* >( NOG STEEDS LEVENSGEVAARLIJK >( */
#else
#define AMNESTY 0 /* Zelfs init kan gekilled worden! TOTAAL VERNEUKTE BOEL */
#endif

extern void * sys_call_table[]; /* Deze array bevat adressen van system calls */ 
extern void get_random_bytes(void *, int);

asmlinkage int(*original_call)(pid_t pid, int sig);

int start_module(void);
void end_module(void);

/* Om de 1 of andere reden asmlinkage ... ik laat het maar staan en zoek
 * wel eens uit wat het wil zeggen :| */
asmlinkage int random_kill(pid_t pid, int sig)
{
	pid_t npid;
	int i, n, b=0;
	struct task_struct * p;
	char rnd_buf[RAND_BUF];
	if(sig == TARGET_SIG) {
		/* TARGET_SIG OPGEROEPEN PREPARE TO VERNEUK! */
		
		/* Om te beginnen moeten we de hoogste actieve PID
		 * afhalen. Dat kunnen we dankzij sched.h */
		 /* denk ik...*/
		
		p = &init_task;
		p = p->prev_task;
		
		get_random_bytes(rnd_buf, RAND_BUF);
		
		for(i=0,n=0;i<RAND_BUF;i++,n += (int)rnd_buf[i]);
		npid = ((pid_t)( (n >> 4) & (((int)p->pid)-AMNESTY))) + AMNESTY;
		
		printk("- Random PID om te doden: %d\n", (int)npid);
		
		while(find_task_by_pid((int)npid) == NULL) {
			if(npid < p->pid)
				npid++;
			else
				npid--;
		}
		/* root of all evil */
		return original_call(npid, sig);
	}

	return original_call(pid, sig);
}

int start_module()
{
	/* Eerst moeten we de originele functie opslaan! */
	original_call = sys_call_table[__NR_kill];
	/* Dan vervangen we het adres met random_kill() */
	sys_call_table[__NR_kill] = random_kill;
	return 0;
}

void end_module()
{
	/* Nu moeten we de backup terug plaatsen! */
	if(sys_call_table[__NR_kill] != random_kill) {
		printk("IEMAND HEEFT AAN DE VERNEUKTE KILL SYSCALL GEPRUTST!!\n");
	}

	sys_call_table[__NR_kill] = original_call;
}


module_init(start_module);
module_exit(end_module);