tiann#3031)

…init and adb_data_file

tiann#3031)

…init and adb_data_file

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

tiann#3031)

…init and adb_data_file

tiann#3031)

…init and adb_data_file

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

tiann#3031)

…init and adb_data_file

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: backslashxx@f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
backslashxx@ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>

This migrates ksud execution decision-making to bprm_check_security.
This requires passing proper argv and envp to a modified _ksud handler
aptly named 'ksu_handle_bprm_ksud'.

Introduces:
int ksu_handle_bprm_ksud(const char *filename, const char *argv1,
	const char *envp, size_t envp_len)

which is adapted from:
int ksu_handle_execveat_ksud(int *fd,
	struct filename **filename_ptr, struct user_arg_ptr *argv,
	struct user_arg_ptr *envp, int *flags)

ksu_handle_bprm_ksud handles all the decision making, it decides when it is
time to apply_kernelsu_rules depending if it sees "second_stage".

For LSM hook, turns out we can pull out argv and envp from mm_struct.
The code in here explains itself on how to do it.

whole blob exists on arg_start to arg_end, so we just pull it out and grab next
array after the first null terminator.

as for envp, we pass the pointer then hunt for it when needed

This now provides a small helper function, ksu_copy_from_user_retry, which explains
itself. First we attempt a _nofault copy, if that fails, we try plain.

With that, It also provides an inlined copy_from_user_nofault for < 5.8.

While using strncpy_from_user_nofault was considered, this wont do, this will
only copy up to the first \0.

EDIT: properly move selinux init rules to this commit, its this thing that actually needs it
- ref: f8244dd
- removed on: tiann#3031

devlog:
ximi-libra-test/android_kernel_xiaomi_libra@16e5dce...16c1f5f
ximi-mojito-test/mojito_krenol@28642e6...728de0c
ac73056 *

Stale: tiann#2653

Signed-off-by: backslashxx <118538522+backslashxx@users.noreply.github.com>