Linux内核分析的作业不会做……急求大神啊

破解出test这个Linux可执行文件的运行密码

已知：
1、基于Android平台编译
2、运行命令为 ./test pwd
其中pwd为需要破解出的密码，密码正确将输出Welcome

文件在附件里。

找出mydriver.c文件中隐含的所有漏洞，越多分数越高……

这是文件内容：

/*


以下是ARM 32位平台上的某驱动(mydriver)的部分代码，分为用户层与内核层。

用户层代码示例了如何操作内核层的mydriver；
内核层代码示例了一个存在各种漏洞的mydriver；


要求：

以C代码或文字描述的形式列举内核层函数mydriver_ioctl中所有可被利用的漏洞


*/


//////////////////////////////////////////////////////////////////////////
//用户层

struct mydriver_param
{
char __user *buffer;
int offset;
int length;
};

#define MYDRIVER_GET_VERSION _IOW('m', 0, char *)
#define MYDRIVER_READ_BUFFER _IORW('m', 1, struct mydriver_param)
#define MYDRIVER_RESET_INFO _IOR('m', 2, int)
#define MYDRIVER_ADDREF_INFO _IOR('m', 3, int)
#define MYDRIVER_ADD_USER _IOR('m', 4, int *)

int main(void)
{
//拿到设备句柄
int fd = open("/dev/mydriver", O_RDWR);
if (fd!=-1) {
//ioctl将触发内核驱动的mydriver_ioctl函数
char drv_ver[32] = {0};
if (!ioctl(fd, MYDRIVER_GET_VERSION, (void *)&drv_ver)) {
//执行无误，成功！
printf("current version:%s\n", drv_ver);
}
close(fd);
fd = -1;
}
return 0;
}

//////////////////////////////////////////////////////////////////////////
//内核层

#define MYDRIVER_BUFFER_MAX_LENGTH (1024)
#define MYDRIVER_INFO_MAX_COUNT (4)

struct node {
int value;
struct node *next;
struct node *prev;
};

struct list {
struct node *head;
struct node *tail;
};

struct mydriver_info
{
int ref_cnt;
};

struct mydriver
{
struct list user_lst;
const char *version;
char buffer[MYDRIVER_BUFFER_MAX_LENGTH];
struct mydriver_info info[MYDRIVER_INFO_MAX_COUNT];
};

static void list_add(struct list *lst, struct node *newnode)
{
if (lst->head==NULL) {
lst->head = newnode;
lst->tail = newnode;
} else {
newnode->prev = lst->tail;
lst->tail->next = newnode;
lst->tail = newnode;
}
}

static struct node * list_remove_last(struct list *lst)
{
struct node *result;
result = lst->tail;

if (lst->head==lst->tail) {
lst->head = lst->tail = NULL;
} else {
lst->tail = lst->tail->prev;
lst->tail->next = NULL;
}
return result;
}

static int mydriver_open(struct inode *inode, struct file *file)
{
if (file->f_mode & FMODE_READ) {
int i;
struct mydriver *drv;
drv = kmalloc(sizeof(struct mydriver), GFP_KERNEL);
if (!drv)
return -ENOMEM;

drv->version = "1.0.0";
drv->user_lst.head = drv->user_lst.tail = NULL;
drv->buffer[0] = NULL;
for (i=0; i drv->info[i].ref_cnt = 0;
}

file->private_data = drv;
} else {
file->private_data = 0;
}

return 0;
}

static long mydriver_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct mydriver *drv = (struct mydriver *)file->private_data;
long ret = -EINVAL;
void __user *argp = (void __user *) arg;
struct mydriver_param param;
struct node user_node;

if (!drv) {
return ret;
}

switch (cmd) {
case MYDRIVER_GET_VERSION:
if (!access_ok(VERIFY_WRITE, argp, strlen(drv->version)+sizeof(char))) {
ret = -EFAULT;
break;
}
if (__copy_to_user(argp, drv->version, strlen(drv->version))) {
ret = -EFAULT;
break;
}
((char*)argp)[strlen(drv->version)] = '\0';
ret = 0;
break;
case MYDRIVER_READ_BUFFER:
if (copy_from_user(¶m, argp, sizeof(struct mydriver_param))) {
ret = -EFAULT;
break;
}
if (param.offset >= MYDRIVER_BUFFER_MAX_LENGTH) {
break;
}
if (param.offset+param.length >= MYDRIVER_BUFFER_MAX_LENGTH) {
break;
}
memcpy(param.buffer, drv->buffer+param.offset, param.length);
ret = 0;
break;
case MYDRIVER_RESET_INFO:
if ((int)argp < MYDRIVER_INFO_MAX_COUNT) {
drv->info[(int)argp].ref_cnt = 0;
ret = 0;
}
break;
case MYDRIVER_ADDREF_INFO:
if (arg < MYDRIVER_INFO_MAX_COUNT) {
drv->info[(int)argp].ref_cnt = 1;
ret = 0;
}
break;
case MYDRIVER_ADD_USER:
if (access_ok(VERIFY_READ, argp, sizeof(int))) {
int user_val;
memcpy(&user_val, argp, sizeof(int));
user_node.value = user_val;
list_add(&drv->user_lst, &user_node);
if (!user_val)
{
ret = -EFAULT;
break;
}
list_remove_last(&drv->user_lst);
}
break;
}

return ret;
}
//////////////////////////////////////////////////////////////////////////