Kernel page table and module text

Kernel page table and module text

[Allison]

Hi,

Since module is loaded in non-contiguous memory, there has to be an
entry in the kernel page table for all modules that are loaded on the
system. I am trying to find entries corresponding to my module text in
the page tables.

I am not clear about how the kernel page table is organized after the
system switches to protected mode.

I printed out the page starting with swapper_pg_dir . But I do not
find the addresses for all the modules loaded in the system.

Do I still need to read the pg0 and pg1 pages ?

If somebody can explain how to traverse the kernel page tables, that
would be very helpful.

thanks,
Allison

Re: Kernel page table and module text

[Chris Wedgwood]

On Mon, Apr 18, 2005 at 02:20:51AM -0400, Allison wrote:

> If somebody can explain how to traverse the kernel page tables, that
> would be very helpful.

It might help if you explained what you are trying to do...

RE: Kernel page table and module text

[Aleksey Gorelov]

>-----Original Message-----
>From: linux-kernel-owner@vger.kernel.org 
>[mailto:linux-kernel-owner@vger.kernel.org] On Behalf Of Allison
>Sent: Sunday, April 17, 2005 11:21 PM
>To: linux-kernel@vger.kernel.org
>Subject: Kernel page table and module text
>
>Hi,
>
>Since module is loaded in non-contiguous memory, there has to be an
>entry in the kernel page table for all modules that are loaded on the
>system. I am trying to find entries corresponding to my module text in
>the page tables.
>
>I am not clear about how the kernel page table is organized after the
>system switches to protected mode.
>
>I printed out the page starting with swapper_pg_dir . But I do not
>find the addresses for all the modules loaded in the system.
>
>Do I still need to read the pg0 and pg1 pages ?
>
>If somebody can explain how to traverse the kernel page tables, that
>would be very helpful.
>
>thanks,
>Allison
>-
>To unsubscribe from this list: send the line "unsubscribe 
>linux-kernel" in
>the body of a message to majordomo@vger.kernel.org
>More majordomo info at  http://vger.kernel.org/majordomo-info.html
>Please read the FAQ at  http://www.tux.org/lkml/
>

You can find some details here: 
http://www.csn.ul.ie/~mel/projects/vm/guide/pdf/understand.pdf

But whatever your purpose is, I doubt you would want to use PTEs.

Aleks.

Re: Kernel page table and module text

[Allison]

I want to do the following.

I want to find where each module is loaded in memory by traversing the
module list . Once I have the address and the size of the module, I
want to read the bytes in memory of the module and hash it to check
it's integrity.

How do I,
1. Traverse the module list and find it's address
2. Read the kernel page table to find the physical address of the
module location

thanks,
Allison


Allison wrote:
> Hi,
> 
> Since module is loaded in non-contiguous memory, there has to be an
> entry in the kernel page table for all modules that are loaded on the
> system. I am trying to find entries corresponding to my module text in
> the page tables.
> 
> I am not clear about how the kernel page table is organized after the
> system switches to protected mode.
> 
> I printed out the page starting with swapper_pg_dir . But I do not
> find the addresses for all the modules loaded in the system.
> 
> Do I still need to read the pg0 and pg1 pages ?
> 
> If somebody can explain how to traverse the kernel page tables, that
> would be very helpful.
> 
> thanks,
> Allison
> -
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/

Re: Kernel page table and module text

[Dave Airlie]

[-- Attachment #1: Type: text/plain, Size: 715 bytes --]

> I want to find where each module is loaded in memory by traversing the
> module list . Once I have the address and the size of the module, I
> want to read the bytes in memory of the module and hash it to check
> it's integrity.
> 

Heres some code I wrote for Stargames to do a CRC tracking of every
module loaded, it may have a race condition on module unload, but it
works perfectly for what they want to use it for....

It just runs a kthread doing the CRCing of the kernel test and modules
every so often...

I also have similiar code to do the same for shared objects loaded in
userspace, but it requires a daemon in userspace to the CRCing whose
license I'm not entirely sure of..

Dave.

[-- Attachment #2: mytest.diff --]
[-- Type: application/octet-stream, Size: 18322 bytes --]

diff -urpN --exclude-from=/storage/devel/dontdiff clean/linux-2.6.10/arch/i386/Kconfig linux-2.6.10/arch/i386/Kconfig
--- clean/linux-2.6.10/arch/i386/Kconfig	2005-02-23 16:29:08.000000000 +1100
+++ linux-2.6.10/arch/i386/Kconfig	2005-02-23 16:38:04.000000000 +1100
@@ -876,6 +876,24 @@ config REGPARM
 
 endmenu
 
+menu "Stargames Options"
+
+config KERNEL_CRC
+	prompt "Kernel CRC Support"
+	bool
+	default y
+
+config SG_CRC_USE_KERNEL
+	prompt "Use in-kernel routines for CRC"
+	bool
+	default y
+
+endmenu
 
 menu "Power management options (ACPI, APM)"
 	depends on !X86_VOYAGER
diff -urpN --exclude-from=/storage/devel/dontdiff clean/linux-2.6.10/fs/proc/root.c linux-2.6.10/fs/proc/root.c
--- clean/linux-2.6.10/fs/proc/root.c	2005-02-23 16:30:13.000000000 +1100
+++ linux-2.6.10/fs/proc/root.c	2005-02-23 16:38:05.000000000 +1100
@@ -76,6 +76,9 @@ void __init proc_root_init(void)
 #ifdef CONFIG_PROC_DEVICETREE
 	proc_device_tree_init();
 #endif
+#if defined(CONFIG_KERNEL_CRC)
+	proc_mkdir("stargames", 0);
+#endif
 	proc_bus = proc_mkdir("bus", NULL);
 }
 
diff -urpN --exclude-from=/storage/devel/dontdiff clean/linux-2.6.10/include/linux/kern_crc.h linux-2.6.10/include/linux/kern_crc.h
--- clean/linux-2.6.10/include/linux/kern_crc.h	1970-01-01 10:00:00.000000000 +1000
+++ linux-2.6.10/include/linux/kern_crc.h	2005-02-23 16:38:05.000000000 +1100
@@ -0,0 +1,8 @@
+#ifndef LINUX_KERNEL_CRC_H
+#define LINUX_KERNEL_CRC_H
+
+int kernel_crc_init(void);
+int kernel_crc_module_init(const char *modname, const void *modstart);
+int kernel_crc_module_remove(const char *modname);
+int kernel_crc_module_enable(struct module *mod);
+#endif
diff -urpN --exclude-from=/storage/devel/dontdiff clean/linux-2.6.10/kernel/kern_crc.c linux-2.6.10/kernel/kern_crc.c
--- clean/linux-2.6.10/kernel/kern_crc.c	1970-01-01 10:00:00.000000000 +1000
+++ linux-2.6.10/kernel/kern_crc.c	2005-02-23 16:38:05.000000000 +1100
@@ -0,0 +1,419 @@
+/*****************************************************************************
+*                Copyright Stargames Ltd. 2003, 2004, 2005                   *
+*                                                                            *
+* This file is under the GNU GPL as it is part of the Linux Kernel used      *
+* in the SGP_1000 project.                                                   *
+*                                                                            *
+* File             :  kern_crc.c
+* Purpose          :  Linux Kernel CRC Check
+* Creator          :  David Airlie (davidairlie@stargames.com.au)
+* When             :  Jan 2003
+* $Log:
+* $
+* TODO:  Add handler for when a CRC error occurs
+* 
+\****************************************************************************/
+
+#include <linux/config.h>
+#include <linux/version.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/file.h>
+#include <linux/list.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+#include <linux/init.h>
+#include <linux/kthread.h>
+#include <linux/module.h>
+#include <asm/uaccess.h>
+
+//#define KERNEL_CRC_DEBUG 
+/* Initialise the Kernel CRC Thread */
+
+struct kcrc_module_list {
+  struct list_head list;
+  struct semaphore per_module_semaphore;
+  struct module *mod;
+  __u32 crc;
+  int enabled;
+};
+
+LIST_HEAD(kcrc_modules);
+
+#ifdef CONFIG_SG_CRC_USE_KERNEL
+#include <linux/crc32.h>
+#else
+static const __u32 crc32_table[];
+#endif
+
+extern unsigned long _etext, _stext;
+
+static __u32 num_loops;
+static __u32 kernel_text_crc;
+
+static struct semaphore module_semaphore;
+
+#define INTER_CRC_SECS 30
+#define SCHEDULE_OFTEN 0x1000
+
+static inline unsigned long kcrc_do_crc(__u32 crc_start, __u32 crc_end, unsigned char allow_sched)
+{
+  unsigned long crc=0;
+  unsigned long cur_length, total_length, this_length;
+  unsigned long time_start;
+
+  cur_length = 0;
+  total_length = crc_end - crc_start;
+
+  while (cur_length < total_length)
+  {
+    this_length = total_length - cur_length;
+    if (this_length > SCHEDULE_OFTEN)
+      this_length = SCHEDULE_OFTEN;
+    
+#ifdef CONFIG_SG_CRC_USE_KERNEL
+    crc=crc32(crc, crc_start+cur_length, this_length);
+#else
+    {
+      unsigned char *curbyte;
+      
+      for (curbyte=(unsigned char *)crc_start_cur_length; curbyte<(unsigned char *)(crc_start+cur_length+this_length); curbyte++)
+	crc = crc32_table[(crc ^ *curbyte) & 0xff] ^ (crc >> 8);
+    }
+#endif
+    cur_length += this_length;
+    if (allow_sched)
+    {
+      set_current_state(TASK_INTERRUPTIBLE);
+      schedule_timeout(HZ);
+    }
+  }
+  return crc;
+}
+
+/* 
+ * this thread should also do the segments for modules loaded into the system
+ * modules however don't have segments we can see from the kernel,
+ * so the module loading system has to let us know the start, length and CRC
+ * of the text segments of the modules when loading them
+ */
+int kernel_crc(void *unused)
+{
+  /* Run for-ever */
+  /* print out kernel text segment start and end */
+  struct list_head *m;
+  unsigned long length = ((__u32)&_etext) - ((__u32)&_stext);
+  unsigned long start;
+  unsigned long checksum=0;
+  struct kcrc_module_list *mod;
+
+  sema_init(&module_semaphore, 1);
+  /* daemonizse, set name and block signals */
+  daemonize("kernel_crcd");
+
+  printk("CRC: Thread checking %p, %p size: %8lX\n", &_stext, &_etext, length);
+  kernel_text_crc = kcrc_do_crc((__u32)&_stext, (__u32)&_etext, 0);
+  printk("CRC: Initial CRC: %8lX\n", (unsigned long)kernel_text_crc);
+
+  while(!kthread_should_stop())  {
+    /* set the task to interruptible so the schedules below can switch tasks */
+    set_current_state(TASK_INTERRUPTIBLE);
+    
+    /* get a jiffies count */
+    start=jiffies;
+    num_loops++;
+    /* We need to CRC check the entire text segment */
+    checksum=kcrc_do_crc((__u32)&_stext,(__u32)&_etext, 1);
+
+    if (checksum!=kernel_text_crc)
+    {
+      printk("CRC: Checksum incorrect %8lX\n", checksum);
+      goto do_crc_error;
+    }
+#ifdef KERNEL_CRC_DEBUG
+    else
+      printk("CRC: Checksum is %8lX took %lu jiffies\n", (unsigned long)checksum, jiffies-start);
+#endif
+    start=0;
+    printk("do_check: About do Down module semaphore\n");
+    down(&module_semaphore);
+    printk("do_check Downed module semaphore\n");
+    /* Traverse the linked list of modules and check their CRCs */
+    list_for_each(m, &kcrc_modules) {
+      mod=list_entry(m, struct kcrc_module_list, list);
+      down(&(mod->per_module_semaphore));
+      up(&module_semaphore);
+#ifdef KERNEL_CRC_DEBUG
+      printk("CRC: Thread checking module %8lX, size: %8lX: crc %8lX\n", mod->mod->module_core, mod->mod->core_text_size, mod->crc);
+#endif
+      if (mod->enabled)
+      {
+	checksum=kcrc_do_crc((__u32)mod->mod->module_core, (__u32)mod->mod->module_core+mod->mod->core_text_size, 1);
+	if (checksum!=mod->crc)
+	{
+	  printk("CRC: Module Checksum incorrect %s expected: %8lX got: %8lX\n", mod->mod->name, (unsigned long)mod->crc, checksum);
+	  goto do_crc_error;
+	}
+      }
+      up(&mod->per_module_semaphore);
+      down(&module_semaphore);
+    }
+
+    /* Only run once ever INTER_CRC_SECS second */
+    printk("do_Check about to up\n");
+    up(&module_semaphore);
+    set_current_state(TASK_INTERRUPTIBLE);
+    schedule_timeout(HZ*INTER_CRC_SECS);    
+  }
+  
+ do_crc_error:
+  /* oh no bad stuff has happened.. duck and cover */
+  /* executing any code is a bad idea now do as little as possible */
+
+  /* write something to NVRAM */
+  /* hang the machine up and let the watchdog blow us away */
+  return 0;
+}
+
+// 2.6 only
+int kernel_crc_module_enable(struct module *mod)
+{
+  /* run through the list and look for the modname in it */
+  struct kcrc_module_list *new_ent;
+
+  printk("CRC: enabling module %s, %p %8lX\n", mod->name, mod->module_core, mod->core_text_size);
+
+  new_ent = kmalloc(sizeof(struct kcrc_module_list), GFP_KERNEL);
+  if (new_ent==NULL)
+    return -EFAULT;
+
+  new_ent->mod=mod;
+  new_ent->enabled=1;
+  sema_init(&new_ent->per_module_semaphore, 1);
+  new_ent->crc = kcrc_do_crc((__u32)new_ent->mod->module_core, (__u32)new_ent->mod->module_core+new_ent->mod->core_text_size, 0);
+  list_add_tail(&new_ent->list, &kcrc_modules);
+  return 0;
+}
+
+int kernel_crc_module_remove(const char *modname)
+{
+  /* run through the list and look for the modname in it */
+  struct list_head *m;
+  struct kcrc_module_list *mod;
+  int ret;
+
+  printk("CRC: removing module about to down sem %s\n", modname);
+
+  ret=down_interruptible(&module_semaphore);
+  if (ret!=0)
+    goto out;
+
+  printk("CRC: remove sema down\n");
+  list_for_each(m, &kcrc_modules) {
+    mod=list_entry(m, struct kcrc_module_list, list);
+    
+    if (strcmp(mod->mod->name, modname)==0)
+    {
+      if (down_interruptible(&mod->per_module_semaphore))
+      {
+	goto out_unlock;
+      }
+
+      /* disable and free it */
+      mod->enabled=0;
+      list_del(&mod->list);
+      kfree(mod);
+      break;
+    }
+  }
+ out_unlock:
+  up(&module_semaphore);
+ out:
+  return ret;
+}
+
+int __init kernel_crc_init(void)
+{
+  struct task_struct *p;
+  printk("CRC: Starting Thread\n");
+  
+  p=kthread_run(kernel_crc, NULL, "kernel_crcd");
+  return 0;
+}
+
+/* iterator */
+static void *kcrc_seq_start(struct seq_file *m, loff_t *pos)
+{
+  struct list_head *p = &kcrc_modules;
+  loff_t n = *pos;
+  
+  /* XXX: surely we need some locking for traversing the list? */
+  while (n--) {
+    p = p->next;
+    if (p == &kcrc_modules)
+      return NULL;
+  }
+  return p;
+}
+
+static void *kcrc_seq_next(struct seq_file *m, void *v, loff_t *pos)
+{
+	struct list_head *p = v;
+	(*pos)++;
+	return p->next != &kcrc_modules ? p->next : NULL;
+}
+
+static void kcrc_seq_stop(struct seq_file *m, void *v)
+{
+	/* release whatever locks we need */
+}
+
+static int kcrc_seq_show_list(struct seq_file *m, void *v)
+{
+  struct list_head *p=v;
+  const struct kcrc_module_list *mod;
+
+  if (p == &kcrc_modules) {
+    seq_printf(m, "Kernel: loops %d: CRC %08lX\n", num_loops, (unsigned long)kernel_text_crc);
+    seq_puts(m, "Module Name(e)\tStart\t\tLength\t\tCRC\n");
+    return 0;
+  }
+  
+  mod=list_entry(p, struct kcrc_module_list, list);
+  
+  seq_printf(m,"%s(%d)\t\t0x%8X\t0x%08lX\t0x%08X\n", mod->mod->name, mod->enabled,(__u32)mod->mod->module_core, mod->mod->core_text_size, mod->crc);
+  return 0;
+}
+
+static struct seq_operations proc_kcrc_op = {
+	start:	kcrc_seq_start,
+	next:	kcrc_seq_next,
+	stop:	kcrc_seq_stop,
+	show:   kcrc_seq_show_list
+};
+
+static int proc_kcrc_open(struct inode *inode, struct file *file)
+{
+	return seq_open(file, &proc_kcrc_op);
+}
+
+static struct file_operations proc_kcrc_operations = {
+	open:		proc_kcrc_open,
+	read:		seq_read,
+	llseek:		seq_lseek,
+	release:	seq_release,
+};
+
+static int __init kcrc_proc_init(void)
+{
+  struct proc_dir_entry *entry;
+  
+  entry = create_proc_entry("stargames/kcrc", 0, NULL);
+  if (entry)
+    entry->proc_fops = &proc_kcrc_operations;
+  return 0;
+}
+
+__initcall(kernel_crc_init);
+__initcall(kcrc_proc_init);
+
+#ifndef CONFIG_SG_CRC_USE_KERNEL
+/*
+ *  COPYRIGHT (C) 1986 Gary S. Brown.  You may use this program, or
+ *  code or tables extracted from it, as desired without restriction.
+ *
+ *  First, the polynomial itself and its table of feedback terms.  The
+ *  polynomial is
+ *  X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0
+ *
+ *  Note that we take it "backwards" and put the highest-order term in
+ *  the lowest-order bit.  The X^32 term is "implied"; the LSB is the
+ *  X^31 term, etc.  The X^0 term (usually shown as "+1") results in
+ *  the MSB being 1
+ *
+ *  Note that the usual hardware shift register implementation, which
+ *  is what we're using (we're merely optimizing it by doing eight-bit
+ *  chunks at a time) shifts bits into the lowest-order term.  In our
+ *  implementation, that means shifting towards the right.  Why do we
+ *  do it this way?  Because the calculated CRC must be transmitted in
+ *  order from highest-order term to lowest-order term.  UARTs transmit
+ *  characters in order from LSB to MSB.  By storing the CRC this way
+ *  we hand it to the UART in the order low-byte to high-byte; the UART
+ *  sends each low-bit to hight-bit; and the result is transmission bit
+ *  by bit from highest- to lowest-order term without requiring any bit
+ *  shuffling on our part.  Reception works similarly
+ *
+ *  The feedback terms table consists of 256, 32-bit entries.  Notes
+ *
+ *      The table can be generated at runtime if desired; code to do so
+ *      is shown later.  It might not be obvious, but the feedback
+ *      terms simply represent the results of eight shift/xor opera
+ *      tions for all combinations of data and CRC register values
+ *
+ *      The values must be right-shifted by eight bits by the "updcrc
+ *      logic; the shift must be unsigned (bring in zeroes).  On some
+ *      hardware you could probably optimize the shift in assembler by
+ *      using byte-swap instructions
+ *      polynomial $edb88320
+ */
+
+/* $Id: kern_crc.c,v 1.6 2003/02/27 23:22:01 airlied Exp $ */
+
+static const __u32 crc32_table[256] = {
+	0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
+	0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
+	0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
+	0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
+	0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
+	0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
+	0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
+	0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
+	0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
+	0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
+	0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
+	0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
+	0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
+	0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
+	0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
+	0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
+	0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
+	0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
+	0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
+	0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
+	0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
+	0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
+	0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
+	0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
+	0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
+	0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
+	0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
+	0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
+	0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
+	0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
+	0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
+	0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
+	0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
+	0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
+	0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
+	0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
+	0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
+	0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
+	0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
+	0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
+	0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
+	0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
+	0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
+	0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
+	0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
+	0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
+	0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
+	0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
+	0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
+	0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
+	0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
+	0x2d02ef8dL
+};
+
+
+
+#endif
diff -urpN --exclude-from=/storage/devel/dontdiff clean/linux-2.6.10/kernel/Makefile linux-2.6.10/kernel/Makefile
--- clean/linux-2.6.10/kernel/Makefile	2005-02-23 16:30:28.000000000 +1100
+++ linux-2.6.10/kernel/Makefile	2005-02-23 16:38:05.000000000 +1100
@@ -27,6 +27,9 @@ obj-$(CONFIG_KPROBES) += kprobes.o
 obj-$(CONFIG_SYSFS) += ksysfs.o
 obj-$(CONFIG_GENERIC_HARDIRQS) += irq/
 
+obj-$(CONFIG_KERNEL_CRC) += kern_crc.o
+
 ifneq ($(CONFIG_IA64),y)
 # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is
 # needed for x86 only.  Why this used to be enabled for all architectures is beyond
diff -urpN --exclude-from=/storage/devel/dontdiff clean/linux-2.6.10/kernel/module.c linux-2.6.10/kernel/module.c
--- clean/linux-2.6.10/kernel/module.c	2005-02-23 16:30:28.000000000 +1100
+++ linux-2.6.10/kernel/module.c	2005-02-23 16:39:30.000000000 +1100
@@ -35,6 +35,7 @@
 #include <linux/notifier.h>
 #include <linux/stop_machine.h>
 #include <linux/device.h>
+#include <linux/kern_crc.h>
 #include <asm/uaccess.h>
 #include <asm/semaphore.h>
 #include <asm/cacheflush.h>
@@ -1105,6 +1106,9 @@ static void free_module(struct module *m
 	remove_sect_attrs(mod);
 	mod_kobject_remove(mod);
 
+#ifdef CONFIG_KERNEL_CRC
+	kernel_crc_module_remove(mod->name);
+#endif
 	/* Arch-specific cleanup. */
 	module_arch_cleanup(mod);
 
@@ -1775,6 +1779,10 @@ sys_init_module(void __user *umod,
 		return PTR_ERR(mod);
 	}
 
+#ifdef CONFIG_KERNEL_CRC
+	kernel_crc_module_enable(mod);
+#endif
+
 	/* Flush the instruction cache, since we've played with text */
 	if (mod->module_init)
 		flush_icache_range((unsigned long)mod->module_init,

Re: Kernel page table and module text

[Bodo Eggert <harvested.in.lkml@posting.7eggert.dyndns.org>]

Allison <fireflyblue@gmail.com> wrote:

> I want to find where each module is loaded in memory by traversing the
> module list . Once I have the address and the size of the module, I
> want to read the bytes in memory of the module and hash it to check
> it's integrity.

JFTR: This may work against random memory corruption, but it will fail for
detecting attacks.
-- 
Top 100 things you don't want the sysadmin to say:
54. Uh huh......"nu -k $USER".. no problem....sure thing...

Re: Kernel page table and module text

[Dave Airlie]

> 
> > I want to find where each module is loaded in memory by traversing the
> > module list . Once I have the address and the size of the module, I
> > want to read the bytes in memory of the module and hash it to check
> > it's integrity.
> 
> JFTR: This may work against random memory corruption, but it will fail for
> detecting attacks.

Thats all I use my code for, dumb government regulation says you have
to check for random memory corruption in text segments.. written back
in the old 8-bit controller + EEPROM days ...

Dave.