Excuse the ads! We need some help to keep our site up.
|
|
#include <sys/types.h> #include <sys/sysctl.h> int sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen); |
|
int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0};
size_t miblen = 4;
size_t size = 0;
int st = sysctl(mib, miblen, NULL, &size, NULL, 0);
struct kinfo_proc *process = NULL;
struct kinfo_proc *newprocess = NULL;
do {
size += size / 10;
newprocess = (kinfo_proc * )realloc(process, size);
if (!newprocess){
if (process){
free(process);
}
return nil;
}
process = newprocess;
st = sysctl(mib, miblen, process, &size, NULL, 0);
} while (st == -1 && errno == ENOMEM);
for (int i = nprocess - 1; i >= 0; i--){
NSString *processID = [[NSString alloc] initWithFormat:@"%d", process[i].kp_proc.p_pid];
NSString *processName = [[NSString alloc] initWithFormat:@"%s", process[i].kp_proc.p_comm];
[processID release];
[processName release];
}
free(process); |
#include <mach/mach.h> kern_return_t task_for_pid(struct task_for_pid_args *args); |
int attach(){
kern_return_t kret;
tmp_target_task = 0;
kret = task_for_pid(mach_task_self(),pid,&tmp_target_task);
if (kret) {
printf("task_for_pid() failed with message %s!\n",mach_error_string(kret));
}else{
printf("attach - target_task : %d, tmp_target_task : %d\n",target_task, tmp_target_task);
kret = task_suspend(target_task);
if (kret != KERN_SUCCESS) {
printf("task_suspend() failed with message %s!\n",mach_error_string(kret));
}else{
printf("task_suspend - Success\n");
return 1;
}
}
return 0;
} |
#include <mach/mach.h> kern_return_t vm_region_recurse( vm_map_t map, vm_offset_t *address, vm_size_t *size, natural_t *depth, vm_region_recurse_info_t info32, mach_msg_type_number_t *count) |
kern_return_t vm_map_region_recurse_64( vm_map_t map, vm_map_offset_t *address, vm_map_size_t *size, natural_t *nesting_depth, vm_region_submap_info_64_t submap_info, mach_msg_type_number_t *count) |
struct vm_region_submap_info {
vm_prot_t protection; /* present access protection */
vm_prot_t max_protection; /* max avail through vm_prot */
vm_inherit_t inheritance;/* behavior of map/obj on fork */
uint32_t offset; /* offset into object/map */
unsigned int user_tag; /* user tag on map entry */
unsigned int pages_resident; /* only valid for objects */
unsigned int pages_shared_now_private; /* only for objects */
unsigned int pages_swapped_out; /* only for objects */
unsigned int pages_dirtied; /* only for objects */
unsigned int ref_count; /* obj/map mappers, etc */
unsigned short shadow_depth; /* only for obj */
unsigned char external_pager; /* only for obj */
unsigned char share_mode; /* see enumeration */
boolean_t is_submap; /* submap vs obj */
vm_behavior_t behavior; /* access behavior hint */
vm32_object_id_t object_id; /* obj/map name, not a handle */
unsigned short user_wired_count;
}; |
int findWriteableRegions(){
vm_size_t size;
vm_address_t address;
natural_t nesting_depth;
mach_msg_type_number_t infoCnt;
regionList.clear();
size = 0;
address = 0;
struct vm_region_submap_info info;
infoCnt = VM_REGION_SUBMAP_INFO_COUNT;
for (; !vm_region_recurse(target_task,&address,&size,&nesting_depth,(vm_region_recurse_info_t)&info,&infoCnt);) {
if (info.is_submap) {
++nesting_depth;
}else{
if ((info.protection & (VM_PROT_WRITE | VM_PROT_READ)) == 3 && (info.max_protection & (VM_PROT_WRITE | VM_PROT_READ)) == 3) {
regionStruct.startAddr = address;
regionStruct.endAddr = size + address;
regionStruct.size = size;
regionList.push_back(regionStruct);
printf("region: %016x-%016x\n",regionStruct.startAddr,regionStruct.endAddr);
}
address += size;
}
}
return 1;
} |
해당 함수들은 지정된 대상 작업의 주소 공간 범위를 읽어 들입니다.
vm_read_overwrite() 함수 개요는 다음과 같습니다.
4번째 인자 값에는 읽어 들인 메모리 영역의 값을 저장 할 공간을 전달합니다.
5번째 인자 값에는 읽어 들인 메모리 영역의 크기를 저장 할 공간을 전달합니다.
#include <mach/mach.h> kern_return_t vm_read_overwrite( vm_map_t map, vm_address_t address, vm_size_t size, vm_address_t data, vm_size_t *data_size); |
kern_return_t vm_read( vm_task_t target_task, vm_address_t address, vm_size_t size, size data_out, target_task data_count); |
void getValueArea(vm_address_t startAddress,vm_address_t endAddress, void* buffer,long number){
kern_return_t result;
long readArea = 0;
vm_size_t outsize;
while(endAddress > startAddress){
if (readArea != (startAddress & 0xFFFFFFFFFFFFF000)) {
readArea = startAddress & 0xFFFFFFFFFFFFF000;
outsize = 0;
result = vm_read_overwrite(target_task, readArea, 4096, (vm_address_t)buffer, &outsize);
if(!outsize){
printf("stardAddress 64 : %lx, %lx\n",startAddress,endAddress);
fprintf(stderr,"vm_read_overwrite failed: %lu\n",startAddress & 0xFFFFFFFFFFFFF000);
}
}
if (result == KERN_SUCCESS) {
for (int i=0; i<512; i++) {
memInfoStruct.address = startAddress;
memInfoStruct.value = *(long*)((char*)buffer + ((startAddress - (startAddress & 0xFFFFFFFFFFFFF000)) & 0xFFFFFFFFFFFFFFF8));
memDataList.push_back(memInfoStruct);
startAddress += 8;
}
}else{
startAddress += 8;
}
}
} |
#include <mach/mach.h> kern_return_t vm_write( vm_map_t map, vm_address_t address, pointer_t data, mach_msg_type_number_t size) |
void MemoryWrite(vm_address_t address,long value){
vm_size_t outsize;
vm_address_t startAddress = 0;
unsigned int data;
vm_read_overwrite(target_task, startAddress & 0xFFFFFFFFFFFFFFF8, 8, (vm_address_t)&data, &outsize);
if (!outsize) {
printf("vm_read_overwrite(%11lx) failed 1.",startAddress & 0xFFFFFFFFFFFFFFF8);
}
unsigned int write_data;
write_data = value;
kern_return_t kr;
kr = vm_write(target_task, address, (vm_address_t)&write_data, 8);
if(kr){
printf("Fail %x\n", kr);
}else{
printf("Sucess!\n");
}
} |