No commit message

No commit message

.gitattributes

+* text=auto !eol
+/Makefile.in -text
+/configure -text
+/configure.in -text
+/configure_for_cgc -text
+example/Makefile.in -text
+example/callback.c -text
+inferfn/Makefile.in -text
+inferfn/infer.c -text
+inferfn/infer.h -text
+inferfn/infercallback.c -text
+lib/Makefile.in -text
+lib/crt.s -text
+lib/tiny_linker_script -text
+libc/Makefile.in -text
+libc/include/cgc.h -text
+libc/include/itoa.h -text
+libc/include/itox.h -text
+libc/include/malloc.h -text
+libc/include/null.h -text
+libc/include/read.h -text
+libc/include/stdint.h -text
+libc/include/stdlib.h -text
+libc/include/strlen.h -text
+libc/include/syscall.h -text
+libc/include/write.h -text
+libc/src/Makefile.in -text
+libc/src/cgc.s -text
+libc/src/itoa.c -text
+libc/src/malloc.c -text
+libc/src/read.c -text
+libc/src/strlen.c -text
+libc/src/write.c -text
+p1/Makefile.in -text
+p1/p1callbacks.c -text
+watchsyscall/Makefile.in -text
+watchsyscall/cgc.s -text
+watchsyscall/wa_callbacks.c -text

Makefile.in

+
+
+CC=@CC@
+CFLAGS=@CFLAGS@
+
+dirs=@DIRS@ lib
+
+all:
+	for i in ${dirs};  do cd $$i; make; cd ..; done
+	
+clean:
+	for i in ${dirs};  do cd $$i; make clean; cd ..; done
+

configure.in

+
+AC_INIT(myconfig, version-0.1)
+
+AC_PROG_CC
+
+AC_ARG_ENABLE([debugging],              [  --enable-debugging                enable -g when compiling])
+AC_ARG_ENABLE([cgc],              	[  --enable-cgc                enable -DCGC when compiling for CGC binaries])
+AC_ARG_ENABLE([inferfn],              	[  --enable-inferfn                enable -DCGC when compiling for CGC binaries])
+#AC_ARG_ENABLE([example],              	[  --enable-debugging                enable -g when compiling])
+#AC_ARG_ENABLE([libc],              	[  --enable-libc                enable $1 for building ])
+
+OPTIMIZE="-O3"
+if test "$enable_debugging" = yes; then
+        OPTIMIZE="-g  -DDEBUG"
+fi
+
+AC_SUBST(OPTIMIZE, $OPTIMIZE)
+
+
+enable_dir()
+{
+
+	dir=$1
+	shift 
+	extra_makefiles="$*"
+	eval enabled=\$enable_$dir
+
+	echo "$dir enabled=$enabled"
+	if test "$enabled" = yes; then
+		bad_warnings="$bad_warnings $dir"
+		AC_OUTPUT($dir/Makefile)
+		for i in $extra_makefiles; do
+			AC_OUTPUT($dir/$i/Makefile)
+		done
+		DIRS="$DIRS $dir"
+	fi
+}
+
+LIB=$ZIPR_HOME/callbacks/lib/callbacks.a
+AR=ar
+CC=gcc
+CFLAGS="$OPTIMIZE -nostdinc -fPIE -fPIC -I$ZIPR_HOME/callbacks/libc/include  -fno-stack-protector"
+LD=gcc
+LDFLAGS="-r -nostdlib -fPIC -fPIE"
+AS=nasm
+ASFLAGS="-felf"
+
+
+if test "$enable_cgc" = yes; then
+	echo Enabling CGC build.
+	CFLAGS="$CFLAGS -DCGC"
+	ASFLAGS="$ASFLAGS -DCGC"
+fi
+
+# output lib's makefile, which is always needed.
+AC_OUTPUT(lib/Makefile)
+
+
+enable_dir libc src/
+enable_dir example
+enable_dir watchsyscall
+enable_dir p1
+enable_dir inferfn
+
+AC_OUTPUT(Makefile)
+
+AC_SUBST(DIRS)
+AC_SUBST(CC)
+AC_SUBST(CFLAGS)
+AC_SUBST(LD)
+AC_SUBST(LDFLAGS)
+AC_SUBST(AS)
+AC_SUBST(ASFLAGS)
+AC_SUBST(ARCH)
+AC_SUBST(AR)
+AC_SUBST(OS)
+AC_SUBST(LIB)
+
+echo "------------------------------------------------"
+echo "Ignore configure warnings about unknown --enable options for these items: $bad_warnings"
+echo "------------------------------------------------"

configure_for_cgc

+#!/bin/bash
+
+
+./configure --enable-watchsyscall --enable-cgc $*
+
+
+# enable p1 only if it's needed.
+#./configure --enable-watchsyscall --enable-libc --enable-cgc --enable-p1 $*

example/Makefile.in

+
+
+CC=@CC@
+CFLAGS=@CFLAGS@
+LIB=@LIB@
+AR=@AR@
+AS=@AS@
+ASFLAGS=@ASFLAGS@
+
+OBJS=callback.o
+
+
+.SUFFIXES: .o .s .c
+
+.c.o:
+	$(CC) $(CFLAGS) $(INCLUDE) -D__$(ARCH) -c $<
+
+.s.o:
+	$(AS) $(ASFLAGS) $<
+
+
+all: 	$(OBJS)
+	$(AR) -r $(LIB) $(OBJS)
+
+clean:
+	rm *.o
+	
+

example/callback.c

+/*
+ * Copyright (c) 2014 - Zephyr Software LLC
+ *
+ * This file may be used and modified for non-commercial purposes as long as
+ * all copyright, permission, and nonwarranty notices are preserved.
+ * Redistribution is prohibited without prior written consent from Zephyr
+ * Software.
+ *
+ * Please contact the authors for restrictions applying to commercial use.
+ *
+ * THIS SOURCE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Author: Zephyr Software
+ * e-mail: jwd@zephyr-software.com
+ * URL   : http://www.zephyr-software.com/
+ *
+ */
+
+#include <stdint.h>
+
+__attribute__ ((externally_visible)) __attribute__ ((used)) print_hello()
+{
+	char str[]="Hello";
+//	write(1,str,sizeof(str));
+}
+
+void truncation_detector_signed_32_8(uintptr_t ret)
+{
+	char str[]="truncation_detector_signed_32_8 called\n";
+//	write(1,str,sizeof(str));
+}

inferfn/Makefile.in

+
+
+CC=@CC@
+CFLAGS=@CFLAGS@
+LIB=@LIB@
+AR=@AR@
+AS=@AS@
+ASFLAGS=@ASFLAGS@
+
+OBJS=infercallback.o infer.o
+
+
+.SUFFIXES: .o .s .c
+
+.c.o:
+	$(CC) $(CFLAGS) $(INCLUDE) -D__$(ARCH) -c $<
+
+.s.o:
+	$(AS) $(ASFLAGS) $<
+
+
+all: 	$(OBJS)
+	$(AR) -r $(LIB) $(OBJS)
+
+clean:
+	rm *.o
+	
+

inferfn/infer.c

+#include "infer.h"
+#include <null.h>
+
+static void clear_argument(struct argument *arg)
+{
+	if (!arg) return;
+        arg->type = ARG_NONE;
+}
+
+static void clear_request(struct request *req)
+{
+	if (!req) return;
+        req->command = CMD_NONE;
+        req->num_args = 0;
+        clear_argument(&req->arg1);
+        clear_argument(&req->arg2);
+        clear_argument(&req->arg3);
+        clear_argument(&req->arg4);
+        req->outarg_type = ARG_NONE;
+}
+
+static void clear_response(struct response *res)
+{
+	if (!res) return;
+        res->ok = 0;
+        res->outarg.type = ARG_NONE;
+}
+
+
+static void send_response(const int fd, struct response *res)
+{
+	write(fd, res, sizeof(struct response));
+}
+
+static void send_error_response(const int fd)
+{
+        struct response res;
+        clear_response(&res);
+        send_response(fd, &res);
+}
+
+static void handleAlloc(struct request *req, struct response *res)
+{
+	int i;
+	int size = req->arg1.val.num;
+	int value = req->arg2.val.num;
+	char *newmem = NULL; 
+
+	// allocate memory
+	int retval = cgc_allocate(size, 0, &newmem);
+
+	if (retval == 0)
+	{
+		// initialize to specified value
+		for (i = 0; i < size; ++i)
+			newmem[i] = value;
+
+		res->ok = 1;
+		res->outarg.type = ARG_PTR;
+		res->outarg.val.addr = newmem;
+	}
+	else
+	{
+		res->ok = 0;
+	}
+}
+
+/* <bytes> READ <addr> <numBytes> */
+static void handleRead(struct request *req, struct response *res)
+{
+        uintptr_t ptr = req->arg1.val.addr;
+        int num_bytes = req->arg2.val.num;
+        int i;
+
+        if (num_bytes <= MAX_NUM_BYTES)
+                res->ok = 1;
+        else
+        {
+                num_bytes = MAX_NUM_BYTES;
+                res->ok = 0;
+        }
+
+        res->outarg.type = ARG_BYTES;
+        res->outarg.val.bytes.num_bytes = num_bytes;
+
+        for (i = 0; i < num_bytes; ++i)
+        {
+                char *tmp = ptr;
+                res->outarg.val.bytes.bytes[i] = tmp[i];
+        }
+}
+
+/* WRITE <addr> <bytes> */
+static void handleWrite(struct request *req, struct response *res)
+{
+        uintptr_t ptr = req->arg1.val.addr;
+        int num_bytes = req->arg2.val.bytes.num_bytes;
+        char *bytes = req->arg2.val.bytes.bytes;
+        int i;
+
+//        printf("WRITE %p %d\n", ptr, num_bytes);
+
+        for (i = 0; i < num_bytes; ++i)
+                ((char*)ptr)[i] = bytes[i];
+
+        res->ok = 1;
+}
+
+static uintptr_t get_func_arg(struct argument *arg)
+{
+        if (arg->type == ARG_INT)
+                return (uintptr_t) arg->val.num;
+        else if (arg->type == ARG_PTR)
+                return (uintptr_t) arg->val.addr;
+        else if (arg->type == ARG_BYTES)
+                return (uintptr_t) arg->val.bytes.bytes;
+        else
+                return (uintptr_t) 0x0;
+}
+
+/* outarg CALL <fn*> [arg] [arg] [arg] */
+static void handleCall(struct request *req, struct response *res)
+{
+        struct argument outarg; // void, int, void*
+
+        struct argument *arg1 = &req->arg1;   // int, void*
+        struct argument *arg2 = &req->arg2;   // int, void*
+        struct argument *arg3 = &req->arg3;   // int, void*
+        struct argument *arg4 = &req->arg4;   // int, void*
+
+        uintptr_t retval;
+        uintptr_t (*fn)(uintptr_t, ...);
+        uintptr_t fa1, fa2, fa3;
+
+        fn = arg1->val.addr;
+
+        fa1 = get_func_arg(arg2); // arg2 of request maps to function argument 1
+        fa2 = get_func_arg(arg3); // arg3 of request maps to function argument 2
+        fa3 = get_func_arg(arg4); // arg4 of request maps to function argument 3
+
+//        printf("CALL fn:%p #args: %d ret_type: %d\n", fn, req->num_args, req->outarg_type);
+
+        if (req->num_args >= 1 && req->num_args <= 4)
+        {
+                retval = (*fn)(fa1, fa2, fa3);
+
+                if (req->outarg_type == ARG_INT) {
+//                        printf("return value = %d\n", retval);
+                        res->ok = 1;
+                        res->outarg.type = ARG_INT;
+                        res->outarg.val.num = retval;
+                        return;
+                } else if (req->outarg_type == ARG_PTR) {
+                        res->ok = 1;
+                        res->outarg.type = ARG_PTR;
+                        res->outarg.val.addr = retval;
+ //                       printf("return value(addr) = %p\n", retval);
+                        return;
+                }
+        }
+}
+
+
+static int handleCommand(const int fd, struct request *req, struct response *res)
+{
+	clear_response(res);
+
+	switch(req->command) {
+		case CMD_ALLOC:
+			handleAlloc(req, res);
+			send_response(fd, res);
+			return 0;
+			break;
+		case CMD_CALL:
+			handleCall(req, res);
+			send_response(fd, res);
+			return 0;
+			break;
+		case CMD_READ:
+			handleRead(req, res);
+			send_response(fd, res);
+			return 0;
+			break;
+		case CMD_WRITE:
+			handleWrite(req, res);
+			send_response(fd, res);
+			return 0;
+   			break;
+		case CMD_QUIT:
+		default:
+			return 1;
+			break;
+	}
+
+	return 1;
+}
+
+void commandLoop()
+{
+	int fdin = 0;    // stdin
+	int fdout = 1;   // stdout
+	int done = 0;
+	int bytes_read;
+	char buf[sizeof(struct request) + 1024];
+
+	struct request req;
+	struct response res;
+
+	do {
+		clear_request(&req); 
+		read(fdin, &req, sizeof(struct request));
+		done = handleCommand(fdout, &req, &res);
+	} while (!done);
+}

inferfn/infer.h

+#ifndef _INFER_FN_
+#define _INFER_FN_
+
+#include <stdint.h>
+#include <syscall.h>
+
+#define MAX_NUM_BYTES 512
+
+/*
+ *    void* ALLOC <size> <value>
+ *    outarg CALL <fn*> [arg] [arg] [arg]
+ *    WRITE <addr> <bytes>
+ *    <bytes> READ <addr> <numbytes>
+ *
+ */
+enum command_type { CMD_NONE, CMD_ALLOC, CMD_CALL, CMD_READ, CMD_WRITE, CMD_QUIT };
+enum arg_type { ARG_NONE, ARG_INT, ARG_PTR, ARG_BYTES };
+
+struct bytearray {
+        int num_bytes;
+        char bytes[MAX_NUM_BYTES];
+};
+
+struct argument {
+        enum arg_type type;
+        union {
+                int num;    
+                uintptr_t addr;
+                struct bytearray bytes;
+        } val;
+};
+
+struct request {
+        int command;
+        int num_args;
+
+        struct argument arg1;
+        struct argument arg2;
+        struct argument arg3;
+        struct argument arg4;
+
+        enum arg_type outarg_type;
+};
+
+struct response {
+        int ok; 
+        struct argument outarg; 
+};
+
+#endif

inferfn/infercallback.c

+/*
+ * Copyright (c) 2014 - Zephyr Software LLC
+ *
+ * This file may be used and modified for non-commercial purposes as long as
+ * all copyright, permission, and nonwarranty notices are preserved.
+ * Redistribution is prohibited without prior written consent from Zephyr
+ * Software.
+ *
+ * Please contact the authors for restrictions applying to commercial use.
+ *
+ * THIS SOURCE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Author: Zephyr Software
+ * e-mail: jwd@zephyr-software.com
+ * URL   : http://www.zephyr-software.com/
+ *
+ */
+
+#include "infer.h"
+
+#ifdef DEBUG
+	#define print_str_debug print_str
+	#define print_int_debug print_int
+	#define assert(a) {if(!a) print_str("assert failure!"), cgc_terminate(254);}
+#else
+	#define print_str_debug(a) 
+	#define print_int_debug(a) 
+	#define assert(a)
+#endif
+
+
+#ifdef DEBUG
+#if 0 // figure out a way to link these funcs iff someone needs them?
+#define write_fd 2
+void print_str(char *s)
+{
+	write(write_fd,s,strlen(s));
+}
+void print_int(int x)
+{
+	char buf[100];
+	itox(x,buf);
+	write(write_fd,buf,strlen(buf));
+}
+#endif
+#endif
+
+
+
+typedef struct 
+{
+        int edi;
+        int esi;
+        int ebp;
+        int esp_dummy;
+        int ebx;
+        int edx;
+        int ecx;
+        int eax;
+        int flags;
+} reg_values_t;
+
+
+void inference_handler(volatile int p_retaddress, volatile int p_address, volatile int p_exitPolicy, reg_values_t rv)
+{
+#ifdef DEBUG
+	print_str("infer_handler() invoked\n");
+#endif
+
+	commandLoop();
+
+	cgc_terminate(3);
+}
+

lib/Makefile.in

+
+
+CC=@CC@
+CFLAGS=@CFLAGS@
+LIB=@LIB@
+AR=@AR@
+AS=@AS@
+ASFLAGS=@ASFLAGS@
+LD=@LD@
+LDFLAGS=@LDFLAGS@
+
+OBJS=crt.o
+
+relocatable_obj=callbacks.exe.o
+
+
+.SUFFIXES: .o .s .c
+
+.c.o:
+	$(CC) $(CFLAGS) $(INCLUDE) -D__$(ARCH) -c $<
+
+.s.o:
+	$(AS) $(ASFLAGS) $<
+
+all: $(OBJS) $(relocatable_obj)
+
+$(relocatable_obj): $(OBJS) $(LIB)
+	$(LD) -Wl,--whole-archive $(LDFLAGS) $(OBJS) $(LIB) -o $@
+	objcopy --remove-section .comment callbacks.exe.o
+	objcopy --remove-section .note.GNU-stack callbacks.exe.o
+	$(LD) -Bstatic -static -T tiny_linker_script -Wl,--whole-archive callbacks.exe.o -nostdlib -o callbacks.exe  -pie
+
+clean:
+	rm -f *.o *.a callbacks.exe.o callbacks.exe
+	
+

lib/crt.s

+bits 32
+global _start
+section .text
+_start: 
+	hlt
+	

lib/tiny_linker_script

+
+/*  
+  [ 1] .text             PROGBITS        00000000 000040 000022 00  AX  0   0 16
+  [ 2] .eh_frame         PROGBITS        00000000 000064 000040 00   A  0   0  4
+  [ 4] .data             PROGBITS        00000000 0000a4 000000 00  WA  0   0  4
+  [ 5] .bss              NOBITS          00000000 0000a4 000000 00  WA  0   0  4
+*/
+
+SECTIONS
+{
+ 	. = 0x0;
+	.text	:
+	{ 
+		*(.text) 
+		*(.eh_frame) 
+		*(.data) 
+		*(.bss)  
+	}
+}
+
+

libc/Makefile.in

+
+
+
+all: 	
+	cd src/; make
+
+clean:
+	cd src/; make clean
+	
+

libc/include/cgc.h

+/*
+ * Copyright (c) 2014 - Zephyr Software LLC
+ *
+ * This file may be used and modified for non-commercial purposes as long as
+ * all copyright, permission, and nonwarranty notices are preserved.
+ * Redistribution is prohibited without prior written consent from Zephyr
+ * Software.
+ *
+ * Please contact the authors for restrictions applying to commercial use.
+ *
+ * THIS SOURCE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Author: Zephyr Software
+ * e-mail: jwd@zephyr-software.com
+ * URL   : http://www.zephyr-software.com/
+ *
+ */
+
+#ifndef  cgc_h
+#define  cgc_h
+
+void cgc_terminate(int status_);
+int cgc_transmit(int fd, const void *buf, size_t count, size_t *tx_bytes);
+int cgc_receive(int fd, void *buf, size_t count, size_t *rx_bytes);
+int cgc_fdwait(int nfds, fd_set *readfds, fd_set *writefds, const struct timeval *timeout, int *readyfds);
+int cgc_allocate(size_t length, int is_X, void **addr);
+int cgc_deallocate(void *addr, size_t length);
+int cgc_random(void *buf, size_t count, size_t *rnd_bytes);
+
+#endif

libc/include/itoa.h

+#ifndef itoa_h
+#define itoa_h
+
+char* itoa(int i, char b[]);
+
+#endif
+

libc/include/itox.h

+#ifndef itox_h
+#define itox_h
+
+char* itox(int i, char b[]);
+
+#endif
+

libc/include/malloc.h

+/*
+ * Copyright (c) 2014 - Zephyr Software LLC
+ *
+ * This file may be used and modified for non-commercial purposes as long as
+ * all copyright, permission, and nonwarranty notices are preserved.
+ * Redistribution is prohibited without prior written consent from Zephyr
+ * Software.
+ *
+ * Please contact the authors for restrictions applying to commercial use.
+ *
+ * THIS SOURCE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
+ * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Author: Zephyr Software
+ * e-mail: jwd@zephyr-software.com
+ * URL   : http://www.zephyr-software.com/
+ *
+ */
+
+#ifndef malloc_h
+#define malloc_h
+
+#include <stdint.h>
+
+void* malloc(size_t size);
+void free(void*);
+void* calloc(size_t nmemb, size_t size);
+
+#endif

libc/include/null.h

+#ifndef NULL
+#define NULL ((void*)0L)
+#endif