test: add basic tests for ctypes' types

Author: MrIndeciso

test/binaries/ctypes_test

@@ -11,6 +11,7 @@
 from scripts.array_test import ArrayTest
 from scripts.basic_test import BasicTest
 from scripts.basic_struct_test import BasicStructTest
+from scripts.ctypes_test import CtypesTest
 from scripts.string_test import StringTest
 
 def test_suite():
@@ -19,6 +20,7 @@ def test_suite():
     suite.addTest(TestLoader().loadTestsFromTestCase(ArrayTest))
     suite.addTest(TestLoader().loadTestsFromTestCase(BasicTest))
     suite.addTest(TestLoader().loadTestsFromTestCase(BasicStructTest))
+    suite.addTest(TestLoader().loadTestsFromTestCase(CtypesTest))
     suite.addTest(TestLoader().loadTestsFromTestCase(StringTest))
 
     return suite

test/run_suite.py

@@ -0,0 +1,82 @@
+#
+# This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+# Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+# Licensed under the MIT license. See LICENSE file in the project root for details.
+#
+
+import unittest
+
+from ctypes import *
+from libdebug import debugger
+from libdestruct import inflater, struct
+
+class CtypesTest(unittest.TestCase):
+    def test_all_types(self):
+        d = debugger("binaries/ctypes_test")
+
+        d.run()
+
+        bp = d.breakpoint("leak")
+
+        class provola(struct):
+            a: c_bool
+            b: c_ushort
+            c: c_char
+            d: c_char_p
+            e: c_double
+            f: c_float
+            g: c_int
+            h: c_int16
+            i: c_int32
+            j: c_int64
+            k: c_int8
+            l: c_long
+            m: c_longdouble
+            n: c_longlong
+            o: c_short
+            p: c_size_t
+            r: c_time_t
+            s: c_void_p
+            t: c_uint
+            u: c_uint16
+            v: c_uint32
+            w: c_uint64
+            x: c_uint8
+            y: c_ulong
+            z: c_ulonglong
+
+        libdestruct = inflater(d.memory)
+
+        d.cont()
+
+        self.assertTrue(bp.hit_on(d))
+
+        obj = libdestruct.inflate(provola, d.regs.rdi)
+
+        self.assertEqual(obj.a.value, True)
+        self.assertEqual(obj.b.value, 1337)
+        self.assertEqual(obj.c.value, b'\x17')
+        self.assertAlmostEqual(obj.e.value, 1337.1337)
+        self.assertAlmostEqual(obj.f.value, 123.456, places=5)
+        self.assertEqual(obj.g.value, 12345)
+        self.assertEqual(obj.h.value, 23456)
+        self.assertEqual(obj.i.value, 0x0eadbeef)
+        self.assertEqual(obj.j.value, 0x0eadbeefdeadbeef)
+        self.assertEqual(obj.k.value, 123)
+        self.assertEqual(obj.l.value, 0xeefd00dbeefd00d)
+        self.assertAlmostEqual(obj.m.value, 123456.789)
+        self.assertEqual(obj.n.value, 0xeefdeadbeefdead)
+        self.assertEqual(obj.o.value, 9876)
+        self.assertEqual(obj.p.value, 0xdeadbeefdeadbeef)
+        self.assertEqual(obj.r.value, 0x123456)
+        self.assertEqual(obj.s.value, 0x1234)
+        self.assertEqual(obj.t.value, 0xdeadbeef)
+        self.assertEqual(obj.u.value, 0x1234)
+        self.assertEqual(obj.v.value, 0xd00dbeef)
+        self.assertEqual(obj.w.value, 0xd00ddeadbeefbeef)
+        self.assertEqual(obj.x.value, 0x46)
+        self.assertEqual(obj.y.value, 0xbeefbeefbeef)
+        self.assertEqual(obj.z.value, 0xd00dd00dd00dd00d)
+
+        d.kill()
+        d.terminate()

test/scripts/ctypes_test.py

@@ -0,0 +1,83 @@
+//
+// This file is part of libdestruct (https://github.com/mrindeciso/libdestruct).
+// Copyright (c) 2024 Roberto Alessandro Bertolini. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for details.
+//
+
+// gcc -o binaries/ctypes_test srcs/ctypes_test.c
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <time.h>
+
+#pragma pack(push, 1)
+struct provola {
+    _Bool a;
+    unsigned short b;
+    char c;
+    char *d;
+    double e;
+    float f;
+    int g;
+    int16_t h;
+    int32_t i;
+    int64_t j;
+    int8_t k;
+    long l;
+    long double m;
+    long long n;
+    short o;
+    size_t p;
+    time_t r;
+    void *s;
+    unsigned int t;
+    uint16_t u;
+    uint32_t v;
+    uint64_t w;
+    uint8_t x;
+    unsigned long y;
+    unsigned long long z;
+};
+#pragma pack(pop)
+
+char NAME[] = "LIBDESTRUCT\0";
+
+void leak(struct provola *ptr)
+{
+
+}
+
+int main()
+{
+    struct provola object;
+    object.a = 1;
+    object.b = 1337;
+    object.c = 23;
+    object.d = NAME;
+    object.e = 1337.1337;
+    object.f = 123.456;
+    object.g = 12345;
+    object.h = 23456;
+    object.i = 0x0eadbeef;
+    object.j = 0x0eadbeefdeadbeef;
+    object.k = 123;
+    object.l = 0xeefd00dbeefd00d;
+    object.m = 123456.789;
+    object.n = 0xeefdeadbeefdead;
+    object.o = 9876;
+    object.p = 0xdeadbeefdeadbeef;
+    object.r = 0x123456;
+    object.s = (void *) 0x1234;
+    object.t = 0xdeadbeef;
+    object.u = 0x1234;
+    object.v = 0xd00dbeef;
+    object.w = 0xd00ddeadbeefbeef;
+    object.x = 0x46;
+    object.y = 0xbeefbeefbeef;
+    object.z = 0xd00dd00dd00dd00d;
+
+    leak(&object);
+
+    return 0;
+}