[Android Linux Kernel] 메모리 보호 코드 분석 및 우회

분석 환경 : 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);
}