[pull] main from vykt:main

Makefile

@@ -1,63 +1,93 @@
 .RECIPEPREFIX:=>
 
-#TODO [set as required] TODO
+
+#[set as required]
+INSTALL_DIR=/usr/local/lib
+INCLUDE_INSTALL_DIR=/usr/local/include
+LD_DIR=/etc/ld.so.conf.d
+
 CC=gcc
-CFLAGS=-ggdb -Wall -fPIC
-INCLUDE=-lcmore
+CFLAGS=
+CFLAGS_TEST=-ggdb3 -O0
+WARN_OPTS=-Wall -Wextra
+LDFLAGS=-lcmore
 
-LIB_DIR="./src/lib"
-TEST_DIR="./src/test"
-TGT_DIR="./src/tgt"
 
-SRC_DIR=$(shell pwd)/src
-BUILD_DIR=$(shell pwd)/build
-DOC_DIR=$(shell pwd)/doc
+#[build constants]
+LIB_DIR=./src/lib
+TEST_DIR=./src/test
+BUILD_DIR=${shell pwd}/build
+PACKAGE_DIR=./package
 
-INSTALL_DIR=/usr/local
-LD_DIR=/etc/ld.so.conf.d
+
+#[installation constants]
+SHARED=libmcry.so
+STATIC=libmcry.a
+HEADER=memcry.h
 
 
 #[set build options]
 ifeq ($(build),debug)
-	CFLAGS += -O0
+	CFLAGS      += -O0 -ggdb3 -fsanitize=address -DDEBUG
+	CFLAGS_TEST += -DDEBUG
+	LDFLAGS     += -static-libasan
 else
-	CFLAGS += -O2
+	CFLAGS += -O3 -flto
 endif
 
 
-#[process targets]
-all: lib test tgt
+#[set static analysis options]
+ifeq ($(fanalyzer),true)
+	CFLAGS += -fanalyzer
+endif
 
-install:
-> cp ${BUILD_DIR}/lib/liblain.so ${INSTALL_DIR}/lib
-> mkdir -pv ${INSTALL_DIR}/include
-> cp ${SRC_DIR}/lib/liblain.h ${INSTALL_DIR}/include
-> mkdir -pv ${INSTALL_DIR}/share/man
-> cp -R ${DOC_DIR}/roff/* ${INSTALL_DIR}/share/man
-> echo "${INSTALL_DIR}/lib" > ${LD_DIR}/90lain.conf
-> ldconfig
 
-install_doc:
-> mkdir -pv ${INSTALL_DIR}/share/doc/liblain
-> cp ${DOC_DIR}/md/* ${INSTALL_DIR}/share/doc/liblain
+#[process targets]
+.PHONY prepare:
+> mkdir -p ${BUILD_DIR}/test ${BUILD_DIR}/lib ${PACKAGE_DIR}
 
-uninstall:
-> rm -vf ${INSTALL_DIR}/lib/liblain.so ${INSTALL_DIR}/include/liblain.h \
-	${INSTALL_DIR}/share/man/man3/liblain_* ${INSTALL_DIR}/share/doc/liblain/*
-> rmdir ${INSTALL_DIR}/share/doc/liblain
-> rm ${LD_DIR}/90lain.conf
-> ldconfig
+test: shared
+> $(MAKE) -C ${TEST_DIR} tests CC='${CC}' _CFLAGS='${CFLAGS_TEST}' \
+		                       _WARN_OPTS='${WARN_OPTS}' \
+                               BUILD_DIR='${BUILD_DIR}/test' \
+                               LIB_BIN_DIR='${BUILD_DIR}/lib'
 
-tgt:
-> $(MAKE) -C ${TGT_DIR} tgt CC='${CC}' BUILD_DIR='${BUILD_DIR}'
+all: shared static
 
-test: lib
-> $(MAKE) -C ${TEST_DIR} test CC='${CC}' BUILD_DIR='${BUILD_DIR}'
+shared:
+> $(MAKE) -C ${LIB_DIR} shared CC='${CC}' _CFLAGS='${CFLAGS} -fPIC' \
+	                           _WARN_OPTS='${WARN_OPTS}' \
+							   _LDFLAGS='${LDFLAGS}' \
+	                           BUILD_DIR='${BUILD_DIR}/lib'
 
-lib:
-> $(MAKE) -C ${LIB_DIR} lib CC='${CC}' CFLAGS='${CFLAGS}' INCLUDE='${INCLUDE}' BUILD_DIR='${BUILD_DIR}'
+static:
+> $(MAKE) -C ${LIB_DIR} static CC='${CC}' _CFLAGS='${CFLAGS}' \
+	                           _WARN_OPTS='${WARN_OPTS}' \
+	                           _LDFLAGS='${LDFLAGS}' \
+	                           BUILD_DIR='${BUILD_DIR}/lib'
 
 clean:
-> $(MAKE) -C ${TEST_DIR} clean_all CC='${CC}' BUILD_DIR='${BUILD_DIR}'
-> $(MAKE) -C ${LIB_DIR} clean_all CC='${CC}' CFLAGS='${CFLAGS}' BUILD_DIR='${BUILD_DIR}'
-> ${MAKE} -C ${TGT_DIR} clean_all CC='${CC}' BUILD_DIR='${BUILD_DIR}'
+> $(MAKE) -C ${TEST_DIR} clean BUILD_DIR='${BUILD_DIR}/test'
+> $(MAKE) -C ${LIB_DIR} clean BUILD_DIR='${BUILD_DIR}/lib'
+> -rm ${PACKAGE_DIR}/*
+
+install:
+> mkdir -pv ${INSTALL_DIR}
+> cp -v ${BUILD_DIR}/lib/${SHARED} ${INSTALL_DIR}
+> cp -v ${BUILD_DIR}/lib/${STATIC} ${INSTALL_DIR}
+> mkdir -pv ${INCLUDE_INSTALL_DIR}
+> cp -v ${LIB_DIR}/${HEADER} ${INCLUDE_INSTALL_DIR}
+> echo "${INSTALL_DIR}" > ${LD_DIR}/90memcry.conf
+> ldconfig
+
+uninstall:
+> -rm -v ${INSTALL_DIR}/{${SHARED},${STATIC}}
+> -rm -v ${INCLUDE_INSTALL_DIR}/${HEADER}
+> -rm ${LD_DIR}/90memcry.conf
+> ldconfig
+
+package: all
+> -cp ${BUILD_DIR}/lib/${SHARED} ${PACKAGE_DIR}
+> -cp ${BUILD_DIR}/lib/${STATIC} ${PACKAGE_DIR}
+> -cp ${LIB_DIR}/memcry.h ${PACKAGE_DIR}
+> -tar cvjf ${PACKAGE_DIR}/memcry.tar.bz2 ${PACKAGE_DIR}/*

README.md

@@ -1,88 +1,165 @@
-# liblain
+# MemCry
 
 <p align="center">
-    <img src="liblain.png" width="150" height="150">
+    <img src="media/memcry.png" width="150" height="150">
 </p>
 
+
 ### ABOUT:
 
-The Lain library (<b>liblain</b>) provides a programmatic interface to the memory and memory maps of processes on Linux. Liblain can be used for:
+**The MemCry Library provides**:
 
-- Code injection
-- Memory analysis
-- Anti-cheat bypass (see [lain.ko](https://github.com/vykt/lain.ko))
+- Graph-like data structure (*map*) for representing the memory map of a target process.
+- The ability to update the *map* as the target's memory mappings change without invalidating pointers to said map.
+- Tracking of (assumed) ownership of unnamed *vm_area*s.
+- Support for **multiple interfaces** for acquiring the memory maps, reading and writing memory.
+- Multiple convenient utilities.
 
-<b>liblain</b> offers both a procfs and a [lain.ko](https://github.com/vykt/lain.ko) LKM backend. Both interfaces provide identical functionality and are interchangable.
+**Planned**:
 
-<b>liblain</b> stores both virtual memory areas and backing objects in nodes traversable as lists or trees. The use of nodes for storage means the internal memory map can be updated without invalidating any pointers. This makes development of complex tools much easier.
+- An interface for operating on coredumps instead of live processes.
 
-In addition to a memory interface <b>liblain</b> also provides several utilities including:
+<p align="center">
+    <img src="media/overview.png">
+</p>
 
-- Same method for resolving PID as ps/top.
-- Fast address -> VM area search.
+See the example below. Feel free to contact me on discord: *@vykt* or email: *vykt[at]disroot[dot]org*
 
----
 
 ### DEPENDENCIES:
 
-<b>liblain</b> requires [libcmore](https://github.com/vykt/libcmore).
+If you're not using a packaged release, you'll need to install:
 
+- [CMore](https://github.com/vykt/cmore) - Data structures for C.
 
-### INSTALLATION:
 
-Fetch the repo:
-```
-$ git clone https://github.com/vykt/liblain
-```
+### EXAMPLE:
 
-Build:
-```
-$ make lib
-```
+```c
+#include <stdio.h>
+#include <stdint.h>
+#include <unistd.h>
 
-Install:
-```
-# make install
-```
+#include <memcry.h>
+#include <cmore.h>
 
-Install additional markdown documentation:
-```
-# make install_doc
-```
 
-To uninstall:
-```
-# make uninstall
-```
+int main() {
 
----
+  int ret;
+
 
-### LINKING:
+  /*
+   *  First, find the PID of the target based on the target's name. You can
+   *  optionally pass a pointer to an uninitialised CMore vector if you want
+   *  to find PIDs of multiple processes with the same name.
+   */
+  pid_t pid;
+  pid = mc_pid_by_name("target_name", NULL);
 
-Ensure your linker searches for liblain in the install directory (adjust as required):
-```
-# echo "/usr/local/lib" > /etc/ld.so.conf.d/liblain.conf
-```
 
-Include `<liblain.h\>` in your sources:
-```
-#include <liblain.h>
-```
+  /*
+   *  Open a session on your target. For the procfs interface, this will
+   *  open file descriptors on /proc/pid/{mem,maps}
+   */
+  mc_session s;
+  ret = mc_open(&s, PROCFS, pid);
+  if (ret != 0) {
+    /* on error, a perror() function is provided */
+    mc_perror("[error]");
+  }
 
-Ask your compiler to link liblain:
-```
-$ gcc -o test test.c -llain
-```
 
----
+  /*
+   *  Read the target's memory map for the first time.
+   */
+  mc_vm_map m;
+  ret = mc_update_map(&s, &m);
+
+
+  /*
+   *  Find the "libfoo.so" object in the target.
+   */
+  cm_lst_node * libfoo_node = NULL;
+  libfoo_node = mc_get_obj_node_by_basename(&m, "libfoo.so");
+  if (libfoo_node == NULL) {/*...*/}
+
+
+  /*
+   *  Print libfoo.so's starting address.
+   */
+  mc_vm_obj * libfoo_obj = MC_GET_NODE_OBJ(libfoo_node);
+  printf("libfoo.so start addr: 0x%lx, end addr: 0x%lx\n", 
+         libfoo_obj->start_addr, libfoo_obj->end_addr);
+
 
-### DOCUMENTATION:
+  /*
+   *  Print the full path of the object after libfoo.so.
+   */
+  cm_lst_node * next_node = libfoo_node->next;
+  mc_vm_obj * next_obj = MC_GET_NODE_OBJ(next_node);
+  printf("after libfoo.so: %s\n", next_obj->pathname);
 
-See `./doc/md` for markdown documentation. After installing <b>liblain</b> the following manpages are available:
 
-| Manpage         | Description                 |
-| --------------- | --------------------------- |
-| `liblain_error` | Error handling              |
-| `liblain_map`   | Memory map data structure   |
-| `liblain_iface` | Using interfaces            |
-| `liblain_util`  | Utilities                   |
+  /*
+   *  Get the first area of libfoo.so. The object of libfoo (libfoo_obj)
+   *  stores pointers to area nodes. 
+   */
+  cm_lst_node * area_node_p = libfoo_obj->vm_area_node_ps.head;
+  cm_lst_node * area_node = MC_GET_NODE_PTR(area_node_p);
+  mc_vm_area * area = MC_GET_NODE_AREA(area_node);
+  printf("is first area writable?: %d\n, area->access & MC_ACCESS_WRITE);
+
+
+  /*
+   *  Get the next area and print its address range.
+   */
+  mc_vm_area * next_area = MC_GET_NODE_AREA(area_node->next);
+  printf("next area start addr: 0x%lx, end addr: 0x%lx\n",
+         next_area->start_addr, next_area->end_addr);
+
+
+  /*
+   *  The target's (OS-wide) memory map may have been updated; we should update
+   *  our local map.
+   */
+  ret = mc_update_map(&s, &m);
+  if (ret != 0) {/*...*/}
+
+
+  /*
+   *  Check if libfoo.so is still mapped. If not, fetch the next mapped 
+   *  object. Even if libfoo.so and its constituent areas have been unmapped, 
+   *  their nodes and object pointers will remain valid.
+   */
+  cm_lst_node * iter_node;
+  mc_vm_obj * iter_obj;
+  if (libfoo_obj->mapped == false) {
+    iter_node = libfoo_node->next;
+    while (iter_node != m.vm_objs.head) {
+      iter_obj = MC_GET_NODE_OBJ(iter_node);
+      if (iter_obj->mapped == true) break;
+    }
+  }
+
+
+  /*
+   *  Clean up unmapped objects & areas. This will cause `libfoo_node` and
+   *  `libfoo_obj` pointers to become invalid.
+   */
+  ret = mc_map_clean_unmapped(&m);
+  if (ret != 0) {/*...*/}
+
+
+  /*
+   *  Clean up and exit.
+   */
+  ret = mc_close(&s);
+  if (ret != 0) {/*...*/}
+
+  ret = mc_del_vm_map(&m);
+  if (ret != 0) {/*...*/}
+
+  return 0;
+}
+```