pytsk3 20231007__tar.gz → 20250729__tar.gz

{pytsk3-20231007 → pytsk3-20250729}/MANIFEST.in

@@ -7,7 +7,7 @@ exclude .git .gitignore .gitmodules
 exclude .travis.yml
 exclude API-CHANGES.txt config.log ruleset.xml setupDevRepos.py travis_build.sh
 recursive-include dpkg *
-recursive-include patches *.patch
+recursive-include patches *
 recursive-include sleuthkit *
 recursive-exclude sleuthkit/autom4te.cache *
 recursive-exclude sleuthkit/bindings *

{pytsk3-20231007 → pytsk3-20250729}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pytsk3
-Version: 20231007
+Version: 20250729
 Summary: Python bindings for the SleuthKit
 Home-page: https://github.com/py4n6/pytsk
 Author: Michael Cohen
@@ -10,6 +10,6 @@ Maintainer-email: joachim.metz@gmail.com
 License: Apache License, Version 2.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 
 Python bindings for the SleuthKit

{pytsk3-20231007 → pytsk3-20250729}/class_parser.py

@@ -235,7 +235,7 @@ import lexer
 DEBUG = 0
 
 # The pytsk3 version.
-VERSION = "20231007"
+VERSION = "20250729"
 
 # These functions are used to manage library memory.
 FREE = "aff4_free"
@@ -2315,8 +2315,8 @@ class ResultException(object):
 
 
 class Method(object):
-    default_re = re.compile("DEFAULT\(([A-Z_a-z0-9]+)\) =(.+);")
-    exception_re = re.compile("RAISES\(([^,]+),\s*([^\)]+)\) =(.+);")
+    default_re = re.compile(r"DEFAULT\(([A-Z_a-z0-9]+)\) =(.+);")
+    exception_re = re.compile(r"RAISES\(([^,]+),\s*([^\)]+)\) =(.+);")
     typedefed_re = re.compile(r"struct (.+)_t \*")
 
     def __init__(
@@ -4117,11 +4117,11 @@ class HeaderParser(lexer.SelfFeederMixIn):
         ["CCLASS", "END_CCLASS", "END_CCLASS,POP_STATE", None],
 
         # Recognize struct definitions (With name)
-        ["INITIAL", "([A-Z_a-z0-9 ]+)?struct\s+([A-Z_a-z0-9]+)\s+{",
+        ["INITIAL", r"([A-Z_a-z0-9 ]+)?struct\s+([A-Z_a-z0-9]+)\s+{",
          "PUSH_STATE,STRUCT_START", "STRUCT"],
 
         # Without name (using typedef)
-        ["INITIAL", "typedef\s+struct\s+{",
+        ["INITIAL", r"typedef\s+struct\s+{",
          "PUSH_STATE,TYPEDEF_STRUCT_START", "STRUCT"],
 
         ["STRUCT", r"^\s*([0-9A-Z_a-z ]+\s+\*?)\s*([A-Z_a-z0-9]+)(?:\[([A-Z_a-z0-9]+)\])?\s*;",
@@ -4131,13 +4131,13 @@ class HeaderParser(lexer.SelfFeederMixIn):
          "STRUCT_ATTRIBUTE_PTR", None],
 
         # Struct ended with typedef
-        ["STRUCT", "}\s+([0-9A-Za-z_]+);", "POP_STATE,TYPEDEF_STRUCT_END", None],
+        ["STRUCT", r"}\s+([0-9A-Za-z_]+);", "POP_STATE,TYPEDEF_STRUCT_END", None],
         ["STRUCT", "}", "POP_STATE,STRUCT_END", None],
 
         # Handle recursive struct or union definition (At the moment
         # we cant handle them at all)
-        ["(RECURSIVE_)?STRUCT", "(struct|union)\s+([_A-Za-z0-9]+)?\s*{", "PUSH_STATE", "RECURSIVE_STRUCT"],
-        ["RECURSIVE_STRUCT", "}\s+[0-9A-Za-z]+", "POP_STATE", None],
+        ["(RECURSIVE_)?STRUCT", r"(struct|union)\s+([_A-Za-z0-9]+)?\s*{", "PUSH_STATE", "RECURSIVE_STRUCT"],
+        ["RECURSIVE_STRUCT", r"}\s+[0-9A-Za-z]+", "POP_STATE", None],
         ["RECURSIVE_STRUCT", "};", "POP_STATE", None],
 
         # Process enums (2 forms - named and typedefed)

pytsk3-20250729/dpkg/changelog

@@ -0,0 +1,5 @@
+pytsk3 (20250729-1) unstable; urgency=low
+
+  * Auto-generated
+
+ -- Joachim Metz <joachim.metz@gmail.com>  Tue, 29 Jul 2025 07:05:03 -0100

pytsk3-20231007/patches/sleuthkit-4.12.1-configure.ac → pytsk3-20250729/patches/sleuthkit-4.14.0-configure.ac

@@ -1,15 +1,12 @@
 diff --git a/configure.ac b/configure.ac
-index 94c0c3b7..354e666e 100644
+index 447c0a5bb..d25b5b5e2 100644
 --- a/configure.ac
 +++ b/configure.ac
-@@ -407,31 +407,8 @@ AC_CONFIG_FILES([
-     tsk/img/Makefile
-     tsk/vs/Makefile
-     tsk/fs/Makefile
--    tsk/hashdb/Makefile
--    tsk/auto/Makefile
+@@ -333,28 +333,7 @@ AC_CONFIG_FILES([
+     tsk/auto/Makefile
      tsk/pool/Makefile
--    tsk/util/Makefile
+     tsk/util/Makefile
+-    tsk/util/Bitlocker/Makefile
 -    tools/Makefile
 -    tools/imgtools/Makefile
 -    tools/vstools/Makefile
@@ -31,7 +28,7 @@ index 94c0c3b7..354e666e 100644
 -    case-uco/java/Makefile
 -    unit_tests/Makefile
 -    unit_tests/base/Makefile])
-+    tsk/util/Makefile])
++    tsk/util/Bitlocker/Makefile])
  
  AC_OUTPUT
  

{pytsk3-20231007 → pytsk3-20250729}/pytsk3.cpp

@@ -296,6 +296,10 @@ Struct TSK_FS_DIR:
     TSK_FS_DIR_WALK_FLAG_RECURSE
     TSK_FS_DIR_WALK_FLAG_NOORPHAN
 
+    Enum TSK_FS_ENCRYPTION_TYPE_ENUM:
+    TSK_FS_ENCRYPTION_TYPE_NONE
+    TSK_FS_ENCRYPTION_TYPE_BITLOCKER
+
     Enum TSK_FS_FFIND_FLAG_ENUM:
     TSK_FS_FFIND_ALL
 
@@ -376,6 +380,8 @@ Struct TSK_FS_INFO:
     uint8_t : fs_id
     uint64_t : fs_id_used
     TSK_ENDIAN_ENUM : endian
+    TSK_FS_ENCRYPTION_TYPE_ENUM : encryption_type
+    
     TSK_FS_DIR * : orphan_dir
     
 
@@ -641,6 +647,7 @@ Constants:
  TSK_ERR_FS
  TSK_ERR_FS_ARG
  TSK_ERR_FS_ATTR_NOTFOUND
+ TSK_ERR_FS_BITLOCKER_ERROR
  TSK_ERR_FS_BLK_NUM
  TSK_ERR_FS_CORRUPT
  TSK_ERR_FS_ENCRYPTED
@@ -791,6 +798,8 @@ Constants:
  TSK_FS_DIR_WALK_FLAG_NOORPHAN
  TSK_FS_DIR_WALK_FLAG_RECURSE
  TSK_FS_DIR_WALK_FLAG_UNALLOC
+ TSK_FS_ENCRYPTION_TYPE_BITLOCKER
+ TSK_FS_ENCRYPTION_TYPE_NONE
  TSK_FS_FFIND_ALL
  TSK_FS_FILE_READ_FLAG_NOID
  TSK_FS_FILE_READ_FLAG_NONE
@@ -1045,7 +1054,7 @@ static struct python_wrapper_map_t {
     Object class_ref;
     PyTypeObject *python_type;
     void (*initialize_proxies)(Gen_wrapper self, void *item);
-} python_wrappers[67];
+} python_wrappers[68];
 
 /* Create the relevant wrapper from the item based on the lookup table.
  */
@@ -2849,6 +2858,36 @@ int TSK_FS_ISTAT_FLAG_ENUM_init_type(
 static int pyTSK_FS_ISTAT_FLAG_ENUM_init(pyTSK_FS_ISTAT_FLAG_ENUM *self, PyObject *args, PyObject *kwds)
 ;
 static void TSK_FS_ISTAT_FLAG_ENUM_dealloc(pyTSK_FS_ISTAT_FLAG_ENUM *self);
+/******************** TSK_FS_ENCRYPTION_TYPE_ENUM ***********************/
+typedef struct {
+    PyObject_HEAD
+    PyObject *value;
+} pyTSK_FS_ENCRYPTION_TYPE_ENUM;
+
+int TSK_FS_ENCRYPTION_TYPE_ENUM_init_type(
+    PyTypeObject *type_object )
+{
+    type_object->tp_dict = PyDict_New();
+    PyObject *integer_object = NULL;
+    integer_object = PyLong_FromLong(TSK_FS_ENCRYPTION_TYPE_NONE);
+
+    PyDict_SetItemString(type_object->tp_dict, "TSK_FS_ENCRYPTION_TYPE_NONE", integer_object);
+
+    Py_DecRef(integer_object);
+
+    integer_object = PyLong_FromLong(TSK_FS_ENCRYPTION_TYPE_BITLOCKER);
+
+    PyDict_SetItemString(type_object->tp_dict, "TSK_FS_ENCRYPTION_TYPE_BITLOCKER", integer_object);
+
+    Py_DecRef(integer_object);
+
+    return( 1 );
+}
+
+/* static PyTypeObject TSK_FS_ENCRYPTION_TYPE_ENUM_Type; */
+static int pyTSK_FS_ENCRYPTION_TYPE_ENUM_init(pyTSK_FS_ENCRYPTION_TYPE_ENUM *self, PyObject *args, PyObject *kwds)
+;
+static void TSK_FS_ENCRYPTION_TYPE_ENUM_dealloc(pyTSK_FS_ENCRYPTION_TYPE_ENUM *self);
 /******************** TSK_FS_INFO ***********************/
 typedef struct {
     PyObject_HEAD
@@ -2884,6 +2923,8 @@ PyObject *pyTSK_FS_INFO_flags_getter(pyTSK_FS_INFO *self, PyObject *arguments);
 PyObject *pyTSK_FS_INFO_fs_id_getter(pyTSK_FS_INFO *self, PyObject *arguments);
 PyObject *pyTSK_FS_INFO_fs_id_used_getter(pyTSK_FS_INFO *self, PyObject *arguments);
 PyObject *pyTSK_FS_INFO_endian_getter(pyTSK_FS_INFO *self, PyObject *arguments);
+PyObject *pyTSK_FS_INFO_encryption_type_getter(pyTSK_FS_INFO *self, PyObject *arguments);
+PyObject *pyTSK_FS_INFO_encryption_data_getter(pyTSK_FS_INFO *self, PyObject *arguments);
 PyObject *pyTSK_FS_INFO_orphan_dir_getter(pyTSK_FS_INFO *self, PyObject *arguments);
 PyObject *pyTSK_FS_INFO_impl_getter(pyTSK_FS_INFO *self, PyObject *arguments);
 /******************** TSK_FS_BLKCALC_FLAG_ENUM ***********************/
@@ -8969,6 +9010,183 @@ static PyTypeObject TSK_FS_ISTAT_FLAG_ENUM_Type = {
     0,
 };
 
+static PyMethodDef TSK_FS_ENCRYPTION_TYPE_ENUM_methods[] = {
+    {NULL, NULL, 0, NULL}  /* Sentinel */
+};
+
+static PyGetSetDef TSK_FS_ENCRYPTION_TYPE_ENUM_get_set_definitions[] = {
+    {NULL, NULL, NULL, NULL, NULL}  /* Sentinel */
+};
+
+static PyObject *TSK_FS_ENCRYPTION_TYPE_ENUM_int(pyTSK_FS_ENCRYPTION_TYPE_ENUM *self) {
+    Py_IncRef(self->value);
+    return self->value;
+}
+#if PY_MAJOR_VERSION >= 3
+static PyNumberMethods TSK_FS_ENCRYPTION_TYPE_ENUM_as_number = {
+    (binaryfunc)    0,             /* nb_add */
+    (binaryfunc)    0,             /* nb_subtract */
+    (binaryfunc)    0,             /* nb_multiply */
+    (binaryfunc)    0,             /* nb_remainder */
+    (binaryfunc)    0,             /* nb_divmod */
+    (ternaryfunc)   0,             /* nb_power */
+    (unaryfunc)     0,             /* nb_negative */
+    (unaryfunc)     0,             /* nb_positive */
+    (unaryfunc)     0,             /* nb_absolute */
+    (inquiry)       0,   /* nb_bool */
+    (unaryfunc)     0,             /* nb_invert */
+    (binaryfunc)    0,             /* nb_lshift */
+    (binaryfunc)    0,             /* nb_rshift */
+    (binaryfunc)    0,             /* nb_and */
+    (binaryfunc)    0,             /* nb_xor */
+    (binaryfunc)    0,             /* nb_or */
+    (unaryfunc)     TSK_FS_ENCRYPTION_TYPE_ENUM_int,       /* nb_int */
+    (void *)        NULL,          /* nb_reserved */
+    (unaryfunc)     0,             /* nb_float */
+
+    (binaryfunc)    0,             /* nb_inplace_add */
+    (binaryfunc)    0,             /* nb_inplace_subtract */
+    (binaryfunc)    0,             /* nb_inplace_multiply */
+    (binaryfunc)    0,             /* nb_inplace_remainder */
+    (ternaryfunc)   0,             /* nb_inplace_power */
+    (binaryfunc)    0,             /* nb_inplace_lshift */
+    (binaryfunc)    0,             /* nb_inplace_rshift */
+    (binaryfunc)    0,             /* nb_inplace_and */
+    (binaryfunc)    0,             /* nb_inplace_xor */
+    (binaryfunc)    0,             /* nb_inplace_or */
+
+    (binaryfunc)    0,             /* nb_floor_divide */
+    (binaryfunc)    0,             /* nb_true_divide */
+    (binaryfunc)    0,             /* nb_inplace_floor_divide */
+    (binaryfunc)    0,             /* nb_inplace_true_divide */
+
+    (unaryfunc)     0,             /* nb_index */
+};
+#else
+static PyNumberMethods TSK_FS_ENCRYPTION_TYPE_ENUM_as_number = {
+    (binaryfunc)    0,             /* nb_add */
+    (binaryfunc)    0,             /* nb_subtract */
+    (binaryfunc)    0,             /* nb_multiply */
+    (binaryfunc)    0,             /* nb_divide */
+    (binaryfunc)    0,             /* nb_remainder */
+    (binaryfunc)    0,             /* nb_divmod */
+    (ternaryfunc)   0,             /* nb_power */
+    (unaryfunc)     0,             /* nb_negative */
+    (unaryfunc)     0,             /* nb_positive */
+    (unaryfunc)     0,             /* nb_absolute */
+    (inquiry)       0,   /* nb_nonzero */
+    (unaryfunc)     0,             /* nb_invert */
+    (binaryfunc)    0,             /* nb_lshift */
+    (binaryfunc)    0,             /* nb_rshift */
+    (binaryfunc)    0,             /* nb_and */
+    (binaryfunc)    0,             /* nb_xor */
+    (binaryfunc)    0,             /* nb_or */
+    (coercion)      0,             /* nb_coerce */
+    (unaryfunc)     TSK_FS_ENCRYPTION_TYPE_ENUM_int,       /* nb_int */
+    (unaryfunc)     0,             /* nb_long */
+    (unaryfunc)     0,             /* nb_float */
+    (unaryfunc)     0,             /* nb_oct */
+    (unaryfunc)     0,             /* nb_hex */
+
+    (binaryfunc)    0,             /* nb_inplace_add */
+    (binaryfunc)    0,             /* nb_inplace_subtract */
+    (binaryfunc)    0,             /* nb_inplace_multiply */
+    (binaryfunc)    0,             /* nb_inplace_divide */
+    (binaryfunc)    0,             /* nb_inplace_remainder */
+    (ternaryfunc)   0,             /* nb_inplace_power */
+    (binaryfunc)    0,             /* nb_inplace_lshift */
+    (binaryfunc)    0,             /* nb_inplace_rshift */
+    (binaryfunc)    0,             /* nb_inplace_and */
+    (binaryfunc)    0,             /* nb_inplace_xor */
+    (binaryfunc)    0,             /* nb_inplace_or */
+
+    (binaryfunc)    0,             /* nb_floor_divide */
+    (binaryfunc)    0,             /* nb_true_divide */
+    (binaryfunc)    0,             /* nb_inplace_floor_divide */
+    (binaryfunc)    0,             /* nb_inplace_true_divide */
+
+    (unaryfunc)     0,             /* nb_index */
+};
+#endif /* PY_MAJOR_VERSION >= 3 */
+
+static PyTypeObject TSK_FS_ENCRYPTION_TYPE_ENUM_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    /* tp_name */
+    "pytsk3.TSK_FS_ENCRYPTION_TYPE_ENUM",
+    /* tp_basicsize */
+    sizeof(pyTSK_FS_ENCRYPTION_TYPE_ENUM),
+    /* tp_itemsize */
+    0,
+    /* tp_dealloc */
+    (destructor) TSK_FS_ENCRYPTION_TYPE_ENUM_dealloc,
+    /* tp_print */
+    0,
+    /* tp_getattr */
+    0,
+    /* tp_setattr */
+    0,
+    /* tp_compare */
+    0,
+    /* tp_repr */
+    0,
+    /* tp_as_number */
+    &TSK_FS_ENCRYPTION_TYPE_ENUM_as_number,
+    /* tp_as_sequence */
+    0,
+    /* tp_as_mapping */
+    0,
+    /* tp_hash */
+    0,
+    /* tp_call */
+    0,
+    /* tp_str */
+    (reprfunc) 0,
+    /* tp_getattro */
+    (getattrofunc) 0,
+    /* tp_setattro */
+    0,
+    /* tp_as_buffer */
+    0,
+    /* tp_flags */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
+    /* tp_doc */
+    "TSK_FS_ENCRYPTION_TYPE_ENUM: ",
+    /* tp_traverse */
+    0,
+    /* tp_clear */
+    0,
+    /* tp_richcompare */
+    0,
+    /* tp_weaklistoffset */
+    0,
+    /* tp_iter */
+    (getiterfunc) 0,
+    /* tp_iternext */
+    (iternextfunc) 0,
+    /* tp_methods */
+    TSK_FS_ENCRYPTION_TYPE_ENUM_methods,
+    /* tp_members */
+    0,
+    /* tp_getset */
+    TSK_FS_ENCRYPTION_TYPE_ENUM_get_set_definitions,
+    /* tp_base */
+    0,
+    /* tp_dict */
+    0,
+    /* tp_descr_get */
+    0,
+    /* tp_descr_set */
+    0,
+    /* tp_dictoffset */
+    0,
+    /* tp_init */
+    (initproc) pyTSK_FS_ENCRYPTION_TYPE_ENUM_init,
+    /* tp_alloc */
+    0,
+    /* tp_new */
+    0,
+};
+
 static PyMethodDef TSK_FS_INFO_methods[] = {
     {NULL, NULL, 0, NULL}  /* Sentinel */
 };
@@ -9088,6 +9306,18 @@ static PyGetSetDef TSK_FS_INFO_get_set_definitions[] = {
       "endian.",
       NULL },
 
+    { "encryption_type",
+      (getter) pyTSK_FS_INFO_encryption_type_getter,
+      (setter) 0,
+      "encryption_type.",
+      NULL },
+
+    { "encryption_data",
+      (getter) pyTSK_FS_INFO_encryption_data_getter,
+      (setter) 0,
+      "encryption_data.",
+      NULL },
+
     { "orphan_dir",
       (getter) pyTSK_FS_INFO_orphan_dir_getter,
       (setter) 0,
@@ -16244,6 +16474,33 @@ on_error:
     return -1;
 }
 
+static void TSK_FS_ENCRYPTION_TYPE_ENUM_dealloc(pyTSK_FS_ENCRYPTION_TYPE_ENUM *self) {
+    struct _typeobject *ob_type = NULL;
+
+    if(self != NULL) {
+        Py_DecRef(self->value);
+        ob_type = Py_TYPE(self);
+        if(ob_type != NULL && ob_type->tp_free != NULL) {
+            ob_type->tp_free((PyObject*) self);
+        }
+    }
+}
+static int pyTSK_FS_ENCRYPTION_TYPE_ENUM_init(pyTSK_FS_ENCRYPTION_TYPE_ENUM *self, PyObject *args, PyObject *kwds)
+{
+    const char *kwlist[] = {"value", NULL};
+
+    if(!PyArg_ParseTupleAndKeywords(args, kwds, "O", (char **) kwlist, &self->value)) {
+        goto on_error;
+    }
+
+    Py_IncRef(self->value);
+
+    return 0;
+
+on_error:
+    return -1;
+}
+
 static void TSK_FS_INFO_dealloc(pyTSK_FS_INFO *self) {
     struct _typeobject *ob_type = NULL;
 
@@ -16464,6 +16721,22 @@ static PyObject *pyTSK_FS_INFO_getattr(pyTSK_FS_INFO *self, PyObject *pyname) {
         PyList_Append(list_object, string_object);
         Py_DecRef(string_object);
 
+#if PY_MAJOR_VERSION >= 3
+        string_object = PyUnicode_FromString("encryption_type");
+#else
+        string_object = PyString_FromString("encryption_type");
+#endif
+        PyList_Append(list_object, string_object);
+        Py_DecRef(string_object);
+
+#if PY_MAJOR_VERSION >= 3
+        string_object = PyUnicode_FromString("encryption_data");
+#else
+        string_object = PyString_FromString("encryption_data");
+#endif
+        PyList_Append(list_object, string_object);
+        Py_DecRef(string_object);
+
 #if PY_MAJOR_VERSION >= 3
         string_object = PyUnicode_FromString("orphan_dir");
 #else
@@ -16916,6 +17189,43 @@ Py_END_ALLOW_THREADS
 
 }
 
+PyObject *pyTSK_FS_INFO_encryption_type_getter(pyTSK_FS_INFO *self, PyObject *arguments) {
+    PyObject *Py_result = NULL;
+    int UNUSED encryption_type = 0;
+
+
+Py_BEGIN_ALLOW_THREADS
+encryption_type = (self->base->encryption_type);
+Py_END_ALLOW_THREADS
+
+    PyErr_Clear();
+#if PY_MAJOR_VERSION >= 3
+    Py_result = PyLong_FromLong(encryption_type);
+#else
+    Py_result = PyInt_FromLong(encryption_type);
+#endif
+
+
+    return Py_result;
+
+}
+
+PyObject *pyTSK_FS_INFO_encryption_data_getter(pyTSK_FS_INFO *self, PyObject *arguments) {
+    PyObject *Py_result = NULL;
+
+
+    Py_BEGIN_ALLOW_THREADS
+    (void) (self->base->encryption_data);
+    Py_END_ALLOW_THREADS
+
+Py_IncRef(Py_None);
+Py_result = Py_None;
+
+
+    return Py_result;
+
+}
+
 PyObject *pyTSK_FS_INFO_orphan_dir_getter(pyTSK_FS_INFO *self, PyObject *arguments) {
     PyObject *Py_result = NULL;
     Gen_wrapper wrapped_orphan_dir = NULL;
@@ -21977,7 +22287,7 @@ on_error:
  */
 PyObject *pytsk3_get_version(PyObject *self, PyObject *arguments) {
     const char *errors = NULL;
-    return(PyUnicode_DecodeUTF8("20231007", (Py_ssize_t) 8, errors));
+    return(PyUnicode_DecodeUTF8("20250729", (Py_ssize_t) 8, errors));
 }
 
 static PyMethodDef pytsk3_module_methods[] = {
@@ -22345,6 +22655,17 @@ PyMODINIT_FUNC initpytsk3(void) {
     Py_IncRef((PyObject *)&TSK_FS_ISTAT_FLAG_ENUM_Type);
     PyModule_AddObject(module, "TSK_FS_ISTAT_FLAG_ENUM", (PyObject *)&TSK_FS_ISTAT_FLAG_ENUM_Type);
 
+    /* Initialize: TSK_FS_ENCRYPTION_TYPE_ENUM */
+    TSK_FS_ENCRYPTION_TYPE_ENUM_Type.tp_new = PyType_GenericNew;
+    if (TSK_FS_ENCRYPTION_TYPE_ENUM_init_type(&TSK_FS_ENCRYPTION_TYPE_ENUM_Type) != 1) {
+        goto on_error;
+    }
+    if (PyType_Ready(&TSK_FS_ENCRYPTION_TYPE_ENUM_Type) < 0) {
+        goto on_error;
+    }
+    Py_IncRef((PyObject *)&TSK_FS_ENCRYPTION_TYPE_ENUM_Type);
+    PyModule_AddObject(module, "TSK_FS_ENCRYPTION_TYPE_ENUM", (PyObject *)&TSK_FS_ENCRYPTION_TYPE_ENUM_Type);
+
     /* Initialize: TSK_FS_INFO */
     TSK_FS_INFO_Type.tp_new = PyType_GenericNew;
     if (PyType_Ready(&TSK_FS_INFO_Type) < 0) {
@@ -22606,6 +22927,9 @@ PyMODINIT_FUNC initpytsk3(void) {
     tmp = PyLong_FromUnsignedLongLong((uint64_t) TSK_ERR_FS_ATTR_NOTFOUND);
     PyDict_SetItemString(d, "TSK_ERR_FS_ATTR_NOTFOUND", tmp);
     Py_DecRef(tmp);
+    tmp = PyLong_FromUnsignedLongLong((uint64_t) TSK_ERR_FS_BITLOCKER_ERROR);
+    PyDict_SetItemString(d, "TSK_ERR_FS_BITLOCKER_ERROR", tmp);
+    Py_DecRef(tmp);
     tmp = PyLong_FromUnsignedLongLong((uint64_t) TSK_ERR_FS_BLK_NUM);
     PyDict_SetItemString(d, "TSK_ERR_FS_BLK_NUM", tmp);
     Py_DecRef(tmp);
@@ -23056,6 +23380,12 @@ PyMODINIT_FUNC initpytsk3(void) {
     tmp = PyLong_FromUnsignedLongLong((uint64_t) TSK_FS_DIR_WALK_FLAG_UNALLOC);
     PyDict_SetItemString(d, "TSK_FS_DIR_WALK_FLAG_UNALLOC", tmp);
     Py_DecRef(tmp);
+    tmp = PyLong_FromUnsignedLongLong((uint64_t) TSK_FS_ENCRYPTION_TYPE_BITLOCKER);
+    PyDict_SetItemString(d, "TSK_FS_ENCRYPTION_TYPE_BITLOCKER", tmp);
+    Py_DecRef(tmp);
+    tmp = PyLong_FromUnsignedLongLong((uint64_t) TSK_FS_ENCRYPTION_TYPE_NONE);
+    PyDict_SetItemString(d, "TSK_FS_ENCRYPTION_TYPE_NONE", tmp);
+    Py_DecRef(tmp);
     tmp = PyLong_FromUnsignedLongLong((uint64_t) TSK_FS_FFIND_ALL);
     PyDict_SetItemString(d, "TSK_FS_FFIND_ALL", tmp);
     Py_DecRef(tmp);
@@ -23570,6 +23900,7 @@ TOTAL_CCLASSES++;
 
 
 
+
 
 
 python_wrappers[TOTAL_CCLASSES].class_ref = (Object)&__Img_Info;

{pytsk3-20231007 → pytsk3-20250729}/pytsk3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pytsk3
-Version: 20231007
+Version: 20250729
 Summary: Python bindings for the SleuthKit
 Home-page: https://github.com/py4n6/pytsk
 Author: Michael Cohen
@@ -10,6 +10,6 @@ Maintainer-email: joachim.metz@gmail.com
 License: Apache License, Version 2.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 
 Python bindings for the SleuthKit