분석 환경 : Galaxy Tab S6 Lite / Kernel 4.14.272 (https://github.com/LineageOS/android_kernel_samsung_gta4xl Lineage OS 18.1 branch)
/drivers/soc/samsung/exynos-el3_mon.c
삼성 단말기에만 존재하는 커널 코드 보호 기능.
defconfig에서 CONFIG_EXYNOS_KERNEL_PROTECTION=n 으로 설정하면 빌드에 포함되지 않는다.
실제로 코드 섹션이 변조 되는지는 확인 안해봤음
#ifdef CONFIG_EXYNOS_KERNEL_PROTECTION
static int __init exynos_protect_kernel_text(void)
{
int ret = 0;
unsigned long ktext_start_va = 0;
unsigned long ktext_start_pa = 0;
unsigned long ktext_end_va = 0;
unsigned long ktext_end_pa = 0;
/* Get virtual addresses of kernel text */
ktext_start_va = (unsigned long)_text;
ktext_end_va = (unsigned long)_etext;
/* Translate VA to PA */
ktext_start_pa = (unsigned long)__pa_symbol(_text);
ktext_end_pa = (unsigned long)__pa_symbol(_etext);
/* Request to protect kernel text area */
ret = exynos_smc(SMC_CMD_PROTECT_KERNEL_TEXT,
ktext_start_pa,
ktext_end_pa,
0);
return ret;
pr_info("%s: Success to set Kernel code as read-only\n", __func__);
return 0;
}
core_initcall(exynos_protect_kernel_text);
#endif
/init/main.c
커널 init 시 실행되며, rodata 메모리 영역 보호 기능인 mark_rodata_ro()를 호출한다.
rodata_enabled 변수는 mmu.c / module.c에서 사용하고 있으므로 false로 수정하면 변조하는데 있어서 좀 더 편해진다.
#if defined(CONFIG_STRICT_KERNEL_RWX) || defined(CONFIG_STRICT_MODULE_RWX)
bool rodata_enabled __ro_after_init = true;
static int __init set_debug_rodata(char *str)
{
return strtobool(str, &rodata_enabled);
}
__setup("rodata=", set_debug_rodata);
#endif
#ifdef CONFIG_STRICT_KERNEL_RWX
static void mark_readonly(void)
{
if (rodata_enabled) {
/*
* load_module() results in W+X mappings, which are cleaned up
* with call_rcu_sched(). Let's make sure that queued work is
* flushed so that we don't hit false positives looking for
* insecure pages which are W+X.
*/
rcu_barrier_sched();
mark_rodata_ro();
rodata_test();
} else
pr_info("Kernel memory protection disabled.\n");
}
#else
static inline void mark_readonly(void)
{
pr_warn("This architecture does not have kernel memory protection.\n");
}
#endif
/arch/arm64/mm/mmu.c
__start_rodata ~ __init_begin 메모리 구간을 read-only(PAGE_KENRL_RO) 속성으로 변경한다.
PAGE_KERNEL 로 변경하면 쓰기가 가능해진다.
void mark_rodata_ro(void)
{
unsigned long section_size;
/*
* mark .rodata as read only. Use __init_begin rather than __end_rodata
* to cover NOTES and EXCEPTION_TABLE.
*/
section_size = (unsigned long)__init_begin - (unsigned long)__start_rodata;
update_mapping_prot(__pa_symbol(__start_rodata), (unsigned long)__start_rodata,
section_size, PAGE_KERNEL_RO);
debug_checkwx();
}
더보기
아래는 /arch/arm64/kernel/smp.c에서 호출하는 함수
linear alias _text ~ __init_begin 메모리 구간을 read-only 속성으로 변경한다.
linear alias는 read-only이어도 rodata 변조에는 영향이 없다.
void __init mark_linear_text_alias_ro(void)
{
/*
* Remove the write permissions from the linear alias of .text/.rodata
*/
update_mapping_prot(__pa_symbol(_text), (unsigned long)lm_alias(_text),
(unsigned long)__init_begin - (unsigned long)_text,
PAGE_KERNEL_RO);
}
rodata 영역 기본 속성은 RW이므로, mark_rodata_ro() 의 update_mapping_prot()을 제거하면 lkm(Loadable kernel module)에서 rodata 영역의 변조가 가능해진다.
unsigned long *start_addr = (unsigned long*)kallsyms_lookup_name("__start_rodata");
*start_addr = 0x1;
unsigned long *sys_call_table = (unsigned long*)kallsyms_lookup_name("sys_call_table");
sys_call_table[__NR_openat] = hook_open;
main.c에서 호출하는 rcu_barrier_sched() 가 어떤 역할을 하는지 확인하지 않았으므로, rodata_enabled 변수를 false 로 변경하는게 깔끔해보인다.
참고 : 많은 인터넷 예제 소스들에서 rodata의 속성 변경을 위해 사용하는 update_mapping_prod() 는 mmu.c의 static 함수이므로 호출이 불가능하다. (로그를 넣고 확인해 본 결과 호출되지 않았음)
void (*update_mapping_prot)(phys_addr_t phys, unsigned long virt, phys_addr_t size, pgprot_t prot);
// 주소는 정상적으로 얻어옴
update_mapping_prot = (void *)kallsyms_lookup_name("update_mapping_prot");
unsigned long *start_addr = (unsigned long*)kallsyms_lookup_name("__start_rodata");
// 아래 코드는 실행되지 않으므로, 메모리 속성 변경이 안되어 fault 발생
update_mapping_prot(__pa_symbol(start_addr) , (unsigned long)start_addr, 0x1000, PAGE_KERNEL);
*start_addr = 0x1;
위와 같이 커널을 수정하지 않아도, 메모리 속성 변조 함수인 set_memory_rw()를 직접 구현하면 우회가 가능하다.
우선, 커널 소스의 set_memory_rw 구현 부분을 보자.
/arch/arm64/mm/pageattr.c
struct page_change_data {
pgprot_t set_mask;
pgprot_t clear_mask;
};
static int change_page_range(pte_t *ptep, pgtable_t token, unsigned long addr,
void *data)
{
struct page_change_data *cdata = data;
pte_t pte = *ptep;
pte = clear_pte_bit(pte, cdata->clear_mask);
pte = set_pte_bit(pte, cdata->set_mask);
set_pte(ptep, pte);
return 0;
}
/*
* This function assumes that the range is mapped with PAGE_SIZE pages.
*/
static int __change_memory_common(unsigned long start, unsigned long size,
pgprot_t set_mask, pgprot_t clear_mask)
{
struct page_change_data data;
int ret;
data.set_mask = set_mask;
data.clear_mask = clear_mask;
ret = apply_to_page_range(&init_mm, start, size, change_page_range,
&data);
flush_tlb_kernel_range(start, start + size);
return ret;
}
static int change_memory_common(unsigned long addr, int numpages,
pgprot_t set_mask, pgprot_t clear_mask)
{
unsigned long start = addr;
unsigned long size = PAGE_SIZE*numpages;
unsigned long end = start + size;
struct vm_struct *area;
if (!PAGE_ALIGNED(addr)) {
start &= PAGE_MASK;
end = start + size;
WARN_ON_ONCE(1);
}
/*
* Kernel VA mappings are always live, and splitting live section
* mappings into page mappings may cause TLB conflicts. This means
* we have to ensure that changing the permission bits of the range
* we are operating on does not result in such splitting.
*
* Let's restrict ourselves to mappings created by vmalloc (or vmap).
* Those are guaranteed to consist entirely of page mappings, and
* splitting is never needed.
*
* So check whether the [addr, addr + size) interval is entirely
* covered by precisely one VM area that has the VM_ALLOC flag set.
*/
area = find_vm_area((void *)addr);
if (!area ||
end > (unsigned long)area->addr + area->size ||
!(area->flags & VM_ALLOC))
return -EINVAL;
if (!numpages)
return 0;
return __change_memory_common(start, size, set_mask, clear_mask);
}
int set_memory_ro(unsigned long addr, int numpages)
{
return change_memory_common(addr, numpages,
__pgprot(PTE_RDONLY),
__pgprot(PTE_WRITE));
}
int set_memory_rw(unsigned long addr, int numpages)
{
return change_memory_common(addr, numpages,
__pgprot(PTE_WRITE),
__pgprot(PTE_RDONLY));
}
change_memory_common 함수를 보면 find_vm_area를 체크하는 루틴이 보이는데, syscall 테이블의 경우 vm영역이 아니므로 에러가 리턴된다.
체크 루틴을 제거하고 빌드하면 lkm에서 직접 set_memory_rw을 호출할 수 있지만, 위의 코드는 lkm에서도 구현 가능하므로 find_vm_area 체크 루틴만 제거하고 아래와 같이 코드를 간결하게 작성할 수 있다.
struct mm_struct *init_mm_ptr;
struct page_change_data {
pgprot_t set_mask;
pgprot_t clear_mask;
};
static int change_page_range(pte_t *ptep, pgtable_t token, unsigned long addr, void *data)
{
struct page_change_data *cdata = data;
pte_t pte = READ_ONCE(*ptep);
pte = clear_pte_bit(pte, cdata->clear_mask);
pte = set_pte_bit(pte, cdata->set_mask);
set_pte(ptep, pte);
return 0;
}
void set_memory_rw(unsigned long addr, int size)
{
struct page_change_data data;
unsigned long start_addr_align = addr & PAGE_MASK;
unsigned long end_addr_align = PAGE_ALIGN(addr + size);
int page_size = end_addr_align - start_addr_align;
data.set_mask = __pgprot(PTE_WRITE);
data.clear_mask = __pgprot(PTE_RDONLY);
apply_to_page_range(init_mm_ptr, start_addr_align, page_size, change_page_range, &data);
flush_tlb_kernel_range(start_addr_align, start_addr_align + page_size);
}
void do_it(void)
{
init_mm_ptr = (struct mm_struct *)kallsyms_lookup_name("init_mm");
set_memory_rw((unsigned long)sys_call_table, 0x4000);
}
