PyArchiveFile 0.25.2__py3-none-any.whl → 0.27.0__py3-none-any.whl

pyarchivefile.py

@@ -14,7 +14,7 @@
     Copyright 2018-2024 Game Maker 2k - http://intdb.sourceforge.net/
     Copyright 2018-2024 Kazuki Przyborowski - https://github.com/KazukiPrzyborowski
 
-    $FileInfo: pyarchivefile.py - Last Update: 11/6/2025 Ver. 0.25.2 RC 1 - Author: cooldude2k $
+    $FileInfo: pyarchivefile.py - Last Update: 11/14/2025 Ver. 0.27.0 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -24,7 +24,6 @@ import re
 import sys
 import time
 import stat
-import zlib
 import mmap
 import hmac
 import base64
@@ -38,8 +37,8 @@ import zipfile
 import binascii
 import datetime
 import platform
+import collections
 from io import StringIO, BytesIO
-from collections import namedtuple
 import posixpath  # POSIX-safe joins/normpaths
 try:
     from backports import tempfile
@@ -50,12 +49,16 @@ try:
     from http.server import BaseHTTPRequestHandler, HTTPServer
     from socketserver import TCPServer
     from urllib.parse import urlparse, parse_qs
-    import base64
 except ImportError:
     from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
     from SocketServer import TCPServer
     from urlparse import urlparse, parse_qs
-    import base64
+
+try:
+    # Python 3.8+ only
+    from multiprocessing import shared_memory
+except ImportError:
+    shared_memory = None
 
 # FTP Support
 ftpssl = True
@@ -146,6 +149,15 @@ try:
 except Exception:
     PATH_TYPES = (basestring,)
 
+def running_interactively():
+    main = sys.modules.get("__main__")
+    no_main_file = not hasattr(main, "__file__")
+    interactive_flag = bool(getattr(sys.flags, "interactive", 0))
+    return no_main_file or interactive_flag
+
+if running_interactively():
+    logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
+
 def _ensure_text(s, encoding="utf-8", errors="replace", allow_none=False):
     """
     Normalize any input to text_type (unicode on Py2, str on Py3).
@@ -166,7 +178,6 @@ def _ensure_text(s, encoding="utf-8", errors="replace", allow_none=False):
 
     # Handle pathlib.Path & other path-like objects
     try:
-        import os
         if hasattr(os, "fspath"):
             fs = os.fspath(s)
             if isinstance(fs, text_type):
@@ -207,7 +218,6 @@ except ImportError:
 
 # Windows-specific setup
 if os.name == "nt":
-    import io
     def _wrap(stream):
         buf = getattr(stream, "buffer", None)
         is_tty = getattr(stream, "isatty", lambda: False)()
@@ -416,9 +426,13 @@ def is_only_nonprintable(var):
 __file_format_multi_dict__ = {}
 __file_format_default__ = "ArchiveFile"
 __include_defaults__ = True
-__use_inmemfile__ = True
+__use_inmem__ = True
+__use_memfd__ = True
 __use_spoolfile__ = False
 __use_spooldir__ = tempfile.gettempdir()
+__use_new_style__ = True
+__use_advanced_list__ = True
+__use_alt_inode__ = False
 BYTES_PER_KiB = 1024
 BYTES_PER_MiB = 1024 * BYTES_PER_KiB
 # Spool: not tiny, but won’t blow up RAM if many are in use
@@ -440,7 +454,13 @@ if('PYARCHIVEFILE_CONFIG_FILE' in os.environ and os.path.exists(os.environ['PYAR
 else:
     prescriptpath = get_importing_script_path()
     if(prescriptpath is not None):
-        scriptconf = os.path.join(os.path.dirname(prescriptpath), __use_ini_name__)
+        if(__use_ini_file__ and not __use_json_file__):
+            scriptconf = os.path.join(os.path.dirname(prescriptpath), __use_ini_name__)
+        elif(__use_json_file__ and not __use_ini_file__):
+            scriptconf = os.path.join(os.path.dirname(prescriptpath), __use_json_name__)
+        else:
+            scriptconf = ""
+            prescriptpath = None
     else:
         scriptconf = ""
 if os.path.exists(scriptconf):
@@ -462,9 +482,13 @@ if __use_ini_file__ and os.path.exists(__config_file__):
     __file_format_default__ = decode_unicode_escape(config.get('config', 'default'))
     __program_name__ = decode_unicode_escape(config.get('config', 'proname'))
     __include_defaults__ = config.getboolean('config', 'includedef')
-    __use_inmemfile__ = config.getboolean('config', 'inmemfile')
+    __use_inmem__ = config.getboolean('config', 'useinmem')
+    __use_memfd__ = config.getboolean('config', 'usememfd')
     __use_spoolfile__ = config.getboolean('config', 'usespoolfile')
     __spoolfile_size__ = config.getint('config', 'spoolfilesize')
+    __use_new_style__ = config.getboolean('config', 'newstyle')
+    __use_advanced_list__ = config.getboolean('config', 'advancedlist')
+    __use_alt_inode__ = config.getboolean('config', 'altinode')
     # Loop through all sections
     for section in config.sections():
         if section == "config":
@@ -472,8 +496,7 @@ if __use_ini_file__ and os.path.exists(__config_file__):
 
         required_keys = [
             "len", "hex", "ver", "name",
-            "magic", "delimiter", "extension",
-            "newstyle", "advancedlist", "altinode"
+            "magic", "delimiter", "extension"
         ]
 
         # Py2+Py3 compatible key presence check
@@ -493,9 +516,6 @@ if __use_ini_file__ and os.path.exists(__config_file__):
                 'format_hex':         config.get(section, 'hex'),
                 'format_delimiter':   delim,
                 'format_ver':         config.get(section, 'ver'),
-                'new_style':          config.getboolean(section, 'newstyle'),
-                'use_advanced_list':  config.getboolean(section, 'advancedlist'),
-                'use_alt_inode':      config.getboolean(section, 'altinode'),
                 'format_extension':   decode_unicode_escape(config.get(section, 'extension')),
             }
         })
@@ -556,16 +576,19 @@ elif __use_json_file__ and os.path.exists(__config_file__):
     cfg_config = cfg.get('config', {}) or {}
     __file_format_default__ = decode_unicode_escape(_get(cfg_config, 'default', ''))
     __program_name__        = decode_unicode_escape(_get(cfg_config, 'proname', ''))
-    __include_defaults__    = _to_bool(_get(cfg_config, 'includedef', False))
-    __use_inmemfile__       = _to_bool(_get(cfg_config, 'inmemfile', False))
+    __include_defaults__    = _to_bool(_get(cfg_config, 'includedef', True))
+    __use_inmem__       = _to_bool(_get(cfg_config, 'useinmem', True))
+    __use_memfd__       = _to_bool(_get(cfg_config, 'usememfd', True))
     __use_spoolfile__       = _to_bool(_get(cfg_config, 'usespoolfile', False))
     __spoolfile_size__       = _to_int(_get(cfg_config, 'spoolfilesize', DEFAULT_SPOOL_MAX))
+    __use_new_style__       = _to_bool(_get(cfg_config, 'usespoolfile', True))
+    __use_advanced_list__       = _to_bool(_get(cfg_config, 'usespoolfile', True))
+    __use_alt_inode__       = _to_bool(_get(cfg_config, 'usespoolfile', False))
 
     # --- iterate format sections (everything except "config") ---
     required_keys = [
         "len", "hex", "ver", "name",
-        "magic", "delimiter", "extension",
-        "newstyle", "advancedlist", "altinode"
+        "magic", "delimiter", "extension"
     ]
 
     for section_name, section in cfg.items():
@@ -583,9 +606,6 @@ elif __use_json_file__ and os.path.exists(__config_file__):
         fmt_hex    = decode_unicode_escape(_get(section, 'hex', ''))
         fmt_ver    = decode_unicode_escape(_get(section, 'ver', ''))
         delim      = decode_unicode_escape(_get(section, 'delimiter', ''))
-        new_style  = _to_bool(_get(section, 'newstyle', False))
-        adv_list   = _to_bool(_get(section, 'advancedlist', False))
-        alt_inode  = _to_bool(_get(section, 'altinode', False))
         extension  = decode_unicode_escape(_get(section, 'extension', ''))
 
         # keep your delimiter validation semantics
@@ -600,9 +620,6 @@ elif __use_json_file__ and os.path.exists(__config_file__):
                 'format_hex':         fmt_hex,
                 'format_delimiter':   delim,
                 'format_ver':         fmt_ver,
-                'new_style':          new_style,
-                'use_advanced_list':  adv_list,
-                'use_alt_inode':      alt_inode,
                 'format_extension':   extension,
             }
         })
@@ -621,6 +638,7 @@ elif __use_json_file__ and not os.path.exists(__config_file__):
 if not __use_ini_file__ and not __include_defaults__:
     __include_defaults__ = True
 if __include_defaults__:
+    # Arc / Neo
     add_format(__file_format_multi_dict__, "ArchiveFile", "ArchiveFile", ".arc", "ArchiveFile")
     add_format(__file_format_multi_dict__, "NeoFile",     "NeoFile",     ".neo", "NeoFile")
 
@@ -633,21 +651,18 @@ __file_format_len__ = __file_format_multi_dict__[__file_format_default__]['forma
 __file_format_hex__ = __file_format_multi_dict__[__file_format_default__]['format_hex']
 __file_format_delimiter__ = __file_format_multi_dict__[__file_format_default__]['format_delimiter']
 __file_format_ver__ = __file_format_multi_dict__[__file_format_default__]['format_ver']
-__use_new_style__ = __file_format_multi_dict__[__file_format_default__]['new_style']
-__use_advanced_list__ = __file_format_multi_dict__[__file_format_default__]['use_advanced_list']
-__use_alt_inode__ = __file_format_multi_dict__[__file_format_default__]['use_alt_inode']
 __file_format_extension__ = __file_format_multi_dict__[__file_format_default__]['format_extension']
 __file_format_dict__ = __file_format_multi_dict__[__file_format_default__]
 __project__ = __program_name__
 __program_alt_name__ = __program_name__
 __project_url__ = "https://github.com/GameMaker2k/PyArchiveFile"
 __project_release_url__ = __project_url__+"/releases/latest"
-__version_info__ = (0, 25, 2, "RC 1", 1)
-__version_date_info__ = (2025, 11, 6, "RC 1", 1)
+__version_info__ = (0, 27, 0, "RC 1", 1)
+__version_date_info__ = (2025, 11, 14, "RC 1", 1)
 __version_date__ = str(__version_date_info__[0]) + "." + str(
     __version_date_info__[1]).zfill(2) + "." + str(__version_date_info__[2]).zfill(2)
 __revision__ = __version_info__[3]
-__revision_id__ = "$Id: ac98f2d8fa689bbcf7939f892030aad675a7d5fe $"
+__revision_id__ = "$Id: 1cfe8ace647fdc1e6f8536a80322ea8257584b78 $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -659,6 +674,9 @@ if(__version_info__[3] is not None):
 if(__version_info__[3] is None):
     __version__ = str(__version_info__[0]) + "." + str(__version_info__[1]) + "." + str(__version_info__[2])
 
+_logger = logging.getLogger(__project__)      # library-style logger
+_logger.addHandler(logging.NullHandler())     # don't emit logs unless app configures logging
+
 # From: https://stackoverflow.com/a/28568003
 # By Phaxmohdem
 
@@ -796,9 +814,9 @@ except Exception:
 geturls_ua_pyfile_python = "Mozilla/5.0 (compatible; {proname}/{prover}; +{prourl})".format(
     proname=__project__, prover=__version__, prourl=__project_url__)
 if(platform.python_implementation() != ""):
-    py_implementation = platform.python_implementation()
+    py_implementation = platform.python_implementation()+str(platform.python_version_tuple()[0])
 if(platform.python_implementation() == ""):
-    py_implementation = "CPython"
+    py_implementation = "CPython"+str(platform.python_version_tuple()[0])
 geturls_ua_pyfile_python_alt = "Mozilla/5.0 ({osver}; {archtype}; +{prourl}) {pyimp}/{pyver} (KHTML, like Gecko) {proname}/{prover}".format(osver=platform.system(
 )+" "+platform.release(), archtype=platform.machine(), prourl=__project_url__, pyimp=py_implementation, pyver=platform.python_version(), proname=__project__, prover=__version__)
 geturls_ua_googlebot_google = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)"
@@ -814,13 +832,19 @@ geturls_headers_googlebot_google_old = {'Referer': "http://google.com/", 'User-A
 
 compressionsupport = []
 try:
-    import gzip
+    try:
+        import compression.gzip as gzip
+    except ImportError:
+        import gzip
     compressionsupport.append("gz")
     compressionsupport.append("gzip")
 except ImportError:
     pass
 try:
-    import bz2
+    try:
+        import compression.bz2 as bz2
+    except ImportError:
+        import bz2
     compressionsupport.append("bz2")
     compressionsupport.append("bzip2")
 except ImportError:
@@ -841,20 +865,20 @@ except ImportError:
     pass
 '''
 try:
-    import zstandard
+    try:
+        import compression.zstd as zstd
+    except ImportError:
+        import pyzstd.zstdfile as zstd
     compressionsupport.append("zst")
     compressionsupport.append("zstd")
     compressionsupport.append("zstandard")
 except ImportError:
+    pass
+try:
     try:
-        import pyzstd.zstdfile
-        compressionsupport.append("zst")
-        compressionsupport.append("zstd")
-        compressionsupport.append("zstandard")
+        import compression.lzma as lzma
     except ImportError:
-        pass
-try:
-    import lzma
+        import lzma
     compressionsupport.append("lzma")
     compressionsupport.append("xz")
 except ImportError:
@@ -864,12 +888,18 @@ except ImportError:
         compressionsupport.append("xz")
     except ImportError:
         pass
-compressionsupport.append("zlib")
-compressionsupport.append("zl")
-compressionsupport.append("zz")
-compressionsupport.append("Z")
-compressionsupport.append("z")
-
+try:
+    try:
+        import compression.zlib as zlib
+    except ImportError:
+        import zlib
+    compressionsupport.append("zlib")
+    compressionsupport.append("zl")
+    compressionsupport.append("zz")
+    compressionsupport.append("Z")
+    compressionsupport.append("z")
+except ImportError:
+    pass
 compressionlist = ['auto']
 compressionlistalt = []
 outextlist = []
@@ -1028,6 +1058,28 @@ def VerbosePrintOutReturn(dbgtxt, outtype="log", dbgenable=True, dgblevel=20, **
     VerbosePrintOut(dbgtxt, outtype, dbgenable, dgblevel, **kwargs)
     return dbgtxt
 
+def to_ns(timestamp):
+    """
+    Convert a second-resolution timestamp (int or float)
+    into a nanosecond timestamp (int) by zero-padding.
+    Works in Python 2 and Python 3.
+    """
+    try:
+        # Convert incoming timestamp to float so it works for int or float
+        seconds = float(timestamp)
+    except (TypeError, ValueError):
+        raise ValueError("Timestamp must be int or float")
+
+    # Multiply by 1e9 to get nanoseconds, then cast to int
+    return int(seconds * 1000000000)
+
+def format_ns_utc(ts_ns, fmt='%Y-%m-%d %H:%M:%S'):
+    ts_ns = int(ts_ns)
+    sec, ns = divmod(ts_ns, 10**9)
+    dt = datetime.datetime.utcfromtimestamp(sec).replace(microsecond=ns // 1000)
+    base = dt.strftime(fmt)
+    ns_str = "%09d" % ns
+    return base + "." + ns_str
 
 def _split_posix(name):
     """
@@ -2051,34 +2103,53 @@ def _normalize_initial_data(data, isbytes, encoding, errors=None):
 
 
 def MkTempFile(data=None,
-               inmem=__use_inmemfile__,
+               inmem=__use_inmem__, usememfd=__use_memfd__,
                isbytes=True,
-               prefix="",
+               prefix=__program_name__,
                delete=True,
                encoding="utf-8",
-               newline=None,      # text mode only; in-memory objects ignore newline semantics
+               newline=None,
+               text_errors="strict",
                dir=None,
                suffix="",
                use_spool=__use_spoolfile__,
+               autoswitch_spool=False,
                spool_max=__spoolfile_size__,
-               spool_dir=__use_spooldir__):
+               spool_dir=__use_spooldir__,
+               reset_to_start=True,
+               memfd_name=__program_name__,
+               memfd_allow_sealing=False,
+               memfd_flags_extra=0,
+               on_create=None):
     """
     Return a file-like handle with consistent behavior on Py2.7 and Py3.x.
 
     Storage:
-      - inmem=True                       -> BytesIO (bytes) or StringIO (text)
-      - inmem=False, use_spool=True      -> SpooledTemporaryFile (binary), optionally TextIOWrapper for text
-      - inmem=False, use_spool=False     -> NamedTemporaryFile (binary), optionally TextIOWrapper for text
+      - inmem=True, usememfd=True, isbytes=True and memfd available
+            -> memfd-backed anonymous file (binary)
+      - inmem=True, otherwise
+            -> BytesIO (bytes) or StringIO (text)
+      - inmem=False, use_spool=True
+            -> SpooledTemporaryFile (binary), optionally TextIOWrapper for text
+      - inmem=False, use_spool=False
+            -> NamedTemporaryFile (binary), optionally TextIOWrapper for text
 
     Text vs bytes:
       - isbytes=True  -> file expects bytes; 'data' must be bytes-like
-      - isbytes=False -> file expects text; 'data' must be text (unicode/str). Newline translation and encoding
-                         apply only for spooled/named files (not BytesIO/StringIO).
+      - isbytes=False -> file expects text; 'data' must be text (unicode/str). Newline translation and
+                         encoding apply only for spooled/named files (not BytesIO/StringIO).
 
     Notes:
-      - On Windows, NamedTemporaryFile(delete=True) keeps the file open and cannot be reopened by other processes.
-        Use delete=False if you need to pass the path elsewhere.
-      - For text: in-memory StringIO ignores 'newline' (as usual).
+      - On Windows, NamedTemporaryFile(delete=True) keeps the file open and cannot be reopened by
+        other processes. Use delete=False if you need to pass the path elsewhere.
+      - For text: in-memory StringIO ignores 'newline' and 'text_errors' (as usual).
+      - When available, and if usememfd=True, memfd is used only for inmem=True and isbytes=True,
+        providing an anonymous in-memory file descriptor (Linux-only). Text in-memory still uses
+        StringIO to preserve newline semantics.
+      - If autoswitch_spool=True and initial data size exceeds spool_max, in-memory storage is
+        skipped and a spooled file is used instead (if use_spool=True).
+      - If on_create is not None, it is called as on_create(fp, kind) where kind is one of:
+        "memfd", "bytesio", "stringio", "spool", "disk".
     """
 
     # -- sanitize simple params (avoid None surprises) --
@@ -2110,23 +2181,65 @@ def MkTempFile(data=None,
     else:
         init = None
 
+    # Size of init for autoswitch; only meaningful for bytes
+    init_len = len(init) if (init is not None and isbytes) else None
+
     # -------- In-memory --------
     if inmem:
-        if isbytes:
-            f = io.BytesIO(init if init is not None else b"")
-        else:
-            # newline not enforced for StringIO; matches stdlib semantics
-            f = io.StringIO(init if init is not None else "")
-        # already positioned at 0 with provided init; ensure rewind for symmetry
-        f.seek(0)
-        return f
+        # If autoswitch is enabled and data is larger than spool_max, and
+        # spooling is allowed, skip the in-memory branch and fall through
+        # to the spool/disk logic below.
+        if autoswitch_spool and use_spool and init_len is not None and init_len > spool_max:
+            pass  # fall through to spool/disk sections
+        else:
+            # Use memfd only for bytes, and only where available (Linux, Python 3.8+)
+            if usememfd and isbytes and hasattr(os, "memfd_create"):
+                name = memfd_name or prefix or "MkTempFile"
+                flags = 0
+                # Close-on-exec is almost always what you want for temps
+                if hasattr(os, "MFD_CLOEXEC"):
+                    flags |= os.MFD_CLOEXEC
+                # Optional sealing support if requested and available
+                if memfd_allow_sealing and hasattr(os, "MFD_ALLOW_SEALING"):
+                    flags |= os.MFD_ALLOW_SEALING
+                # Extra custom flags (e.g. hugepage flags) if caller wants them
+                if memfd_flags_extra:
+                    flags |= memfd_flags_extra
+
+                fd = os.memfd_create(name, flags)
+                # Binary read/write file-like object backed by RAM
+                f = os.fdopen(fd, "w+b")
+
+                if init is not None:
+                    f.write(init)
+                if reset_to_start:
+                    f.seek(0)
+
+                if on_create is not None:
+                    on_create(f, "memfd")
+                return f
+
+            # Fallback: pure Python in-memory objects
+            if isbytes:
+                f = io.BytesIO(init if init is not None else b"")
+                kind = "bytesio"
+            else:
+                # newline/text_errors not enforced for StringIO; matches stdlib semantics
+                f = io.StringIO(init if init is not None else "")
+                kind = "stringio"
+
+            if reset_to_start:
+                f.seek(0)
+
+            if on_create is not None:
+                on_create(f, kind)
+            return f
 
     # Helper: wrap a binary file into a text file with encoding/newline
     def _wrap_text(handle):
         # For both Py2 & Py3, TextIOWrapper gives consistent newline/encoding behavior
-        tw = io.TextIOWrapper(handle, encoding=encoding, newline=newline)
-        # Position at start; if we wrote initial data below, we will rewind after writing
-        return tw
+        return io.TextIOWrapper(handle, encoding=encoding,
+                                newline=newline, errors=text_errors)
 
     # -------- Spooled (RAM then disk) --------
     if use_spool:
@@ -2134,19 +2247,33 @@ def MkTempFile(data=None,
         bin_mode = "w+b"  # read/write, binary
         b = tempfile.SpooledTemporaryFile(max_size=spool_max, mode=bin_mode, dir=spool_dir)
         f = b if isbytes else _wrap_text(b)
+
         if init is not None:
             f.write(init)
+            if reset_to_start:
+                f.seek(0)
+        elif reset_to_start:
             f.seek(0)
+
+        if on_create is not None:
+            on_create(f, "spool")
         return f
 
     # -------- On-disk temp (NamedTemporaryFile) --------
     # Always create binary file; wrap for text if needed for uniform Py2/3 behavior
-    b = tempfile.NamedTemporaryFile(mode="w+b", prefix=prefix, suffix=suffix, dir=dir, delete=delete)
+    b = tempfile.NamedTemporaryFile(mode="w+b", prefix=prefix, suffix=suffix,
+                                    dir=dir, delete=delete)
     f = b if isbytes else _wrap_text(b)
 
     if init is not None:
         f.write(init)
+        if reset_to_start:
+            f.seek(0)
+    elif reset_to_start:
         f.seek(0)
+
+    if on_create is not None:
+        on_create(f, "disk")
     return f
 
 
@@ -2482,6 +2609,384 @@ def _is_valid_zlib_header(cmf, flg):
         return False
     return True
 
+class SharedMemoryFile(object):
+    """
+    File-like wrapper around multiprocessing.shared_memory.SharedMemory.
+
+    Binary-only API, intended to behave similarly to a regular file opened in
+    'rb', 'wb', or 'r+b' modes (but backed by a fixed-size shared memory block).
+
+    Notes:
+      - Requires Python 3.8+ at runtime to actually use SharedMemory.
+      - On Python 2, importing is fine but constructing will raise RuntimeError.
+      - There is no automatic resizing; buffer size is fixed by SharedMemory.
+      - No real fileno(); this does not represent an OS-level file descriptor.
+      - For text mode, wrap this with io.TextIOWrapper on Python 3:
+            f = SharedMemoryFile(...)
+            tf = io.TextIOWrapper(f, encoding="utf-8")
+    """
+
+    def __init__(self, shm=None, name=None, create=False, size=0,
+                 mode='r+b', offset=0, unlink_on_close=False):
+        """
+        Parameters:
+          shm   : existing SharedMemory object (preferred).
+          name  : name of shared memory block (for attach or create).
+          create: if True, create new SharedMemory; else attach existing.
+          size  : size in bytes (required when create=True).
+          mode  : like 'rb', 'wb', 'r+b', 'ab' (binary only; 't' not supported).
+          offset: starting offset within the shared memory buffer.
+          unlink_on_close: if True, call shm.unlink() when close() is called.
+
+        Usage examples:
+
+            # Create new block and file-like wrapper
+            f = SharedMemoryFile(name=None, create=True, size=4096, mode='r+b')
+
+            # Attach to existing shared memory by name
+            f = SharedMemoryFile(name="xyz", create=False, mode='r+b')
+
+            # Wrap an existing SharedMemory object
+            shm = shared_memory.SharedMemory(create=True, size=1024)
+            f = SharedMemoryFile(shm=shm, mode='r+b')
+        """
+        if shared_memory is None:
+            # No SharedMemory available on this interpreter
+            raise RuntimeError("multiprocessing.shared_memory.SharedMemory "
+                               "is not available on this Python version")
+
+        if 't' in mode:
+            raise ValueError("SharedMemoryFile is binary-only; "
+                             "wrap it with io.TextIOWrapper for text")
+
+        self.mode = mode
+        self._closed = False
+        self._unlinked = False
+        self._unlink_on_close = bool(unlink_on_close)
+
+        if shm is not None:
+            self._shm = shm
+        else:
+            # name may be None when create=True
+            self._shm = shared_memory.SharedMemory(name=name, create=create, size=size)
+
+        self._buf = self._shm.buf
+        self._base_offset = int(offset)
+        if self._base_offset < 0 or self._base_offset > len(self._buf):
+            raise ValueError("offset out of range")
+
+        # We treat the accessible region as [base_offset, len(buf))
+        self._size = len(self._buf) - self._base_offset
+        self._pos = 0  # logical file position within that region
+
+    # ---------- basic properties ----------
+
+    @property
+    def name(self):
+        # SharedMemory name (may be None for anonymous)
+        return getattr(self._shm, "name", None)
+
+    @property
+    def closed(self):
+        return self._closed
+
+    def readable(self):
+        return ('r' in self.mode) or ('+' in self.mode)
+
+    def writable(self):
+        return any(ch in self.mode for ch in ('w', 'a', '+'))
+
+    def seekable(self):
+        return True
+
+    # ---------- core helpers ----------
+
+    def _check_closed(self):
+        if self._closed:
+            raise ValueError("I/O operation on closed SharedMemoryFile")
+
+    def _clamp_pos(self, pos):
+        if pos < 0:
+            return 0
+        if pos > self._size:
+            return self._size
+        return pos
+
+    def _region_bounds(self):
+        """Return (start, end) absolute indices into the SharedMemory buffer."""
+        start = self._base_offset + self._pos
+        end = self._base_offset + self._size
+        return start, end
+
+    # ---------- positioning ----------
+
+    def seek(self, offset, whence=0):
+        """
+        Seek to a new file position.
+
+        whence: 0 = from start, 1 = from current, 2 = from end.
+        """
+        self._check_closed()
+        offset = int(offset)
+        whence = int(whence)
+
+        if whence == 0:   # from start
+            new_pos = offset
+        elif whence == 1: # from current
+            new_pos = self._pos + offset
+        elif whence == 2: # from end
+            new_pos = self._size + offset
+        else:
+            raise ValueError("invalid whence (expected 0, 1, or 2)")
+
+        self._pos = self._clamp_pos(new_pos)
+        return self._pos
+
+    def tell(self):
+        return self._pos
+
+    # ---------- reading ----------
+
+    def read(self, size=-1):
+        """
+        Read up to 'size' bytes (or to EOF if size<0 or None).
+        Returns bytes (py3) or str (py2).
+        """
+        self._check_closed()
+        if not self.readable():
+            raise IOError("SharedMemoryFile not opened for reading")
+
+        if size is None or size < 0:
+            size = self._size - self._pos
+        else:
+            size = int(size)
+            if size < 0:
+                size = 0
+
+        if size == 0:
+            return b'' if not PY2 else ''
+
+        start, end_abs = self._region_bounds()
+        available = end_abs - (self._base_offset + self._pos)
+        if available <= 0:
+            return b'' if not PY2 else ''
+
+        size = min(size, available)
+
+        abs_start = self._base_offset + self._pos
+        abs_end = abs_start + size
+
+        chunk = self._buf[abs_start:abs_end]
+        if PY2:
+            data = bytes(chunk)  # bytes() -> str in py2
+        else:
+            data = bytes(chunk)
+
+        self._pos += len(data)
+        return data
+
+    def readline(self, size=-1):
+        """
+        Read a single line (ending with '\\n' or EOF).
+        If size >= 0, at most that many bytes are returned.
+        """
+        self._check_closed()
+        if not self.readable():
+            raise IOError("SharedMemoryFile not opened for reading")
+
+        # Determine maximum bytes we can scan
+        start, end_abs = self._region_bounds()
+        remaining = end_abs - (self._base_offset + self._pos)
+        if remaining <= 0:
+            return b'' if not PY2 else ''
+
+        if size is not None and size >= 0:
+            size = int(size)
+            max_len = min(size, remaining)
+        else:
+            max_len = remaining
+
+        abs_start = self._base_offset + self._pos
+        abs_max = abs_start + max_len
+
+        # Work on a local bytes slice for easy .find()
+        if PY2:
+            buf_bytes = bytes(self._buf[abs_start:abs_max])
+        else:
+            buf_bytes = bytes(self._buf[abs_start:abs_max])
+
+        idx = buf_bytes.find(b'\n')
+        if idx == -1:
+            # No newline; read entire chunk
+            line_bytes = buf_bytes
+        else:
+            line_bytes = buf_bytes[:idx + 1]
+
+        self._pos += len(line_bytes)
+
+        if PY2:
+            return line_bytes  # already str
+        return line_bytes
+
+    def readinto(self, b):
+        """
+        Read bytes into a pre-allocated writable buffer (bytearray/memoryview).
+        Returns number of bytes read.
+        """
+        self._check_closed()
+        if not self.readable():
+            raise IOError("SharedMemoryFile not opened for reading")
+
+        # Normalize target buffer
+        if isinstance(b, memoryview):
+            mv = b
+        else:
+            mv = memoryview(b)
+
+        size = len(mv)
+        if size <= 0:
+            return 0
+
+        start, end_abs = self._region_bounds()
+        remaining = end_abs - (self._base_offset + self._pos)
+        if remaining <= 0:
+            return 0
+
+        size = min(size, remaining)
+
+        abs_start = self._base_offset + self._pos
+        abs_end = abs_start + size
+
+        mv[:size] = self._buf[abs_start:abs_end]
+        self._pos += size
+        return size
+
+    # ---------- writing ----------
+
+    def write(self, data):
+        """
+        Write bytes-like object to the shared memory region.
+
+        Returns number of bytes written. Will raise if not opened writable
+        or if writing would overflow the fixed-size region.
+        """
+        self._check_closed()
+        if not self.writable():
+            raise IOError("SharedMemoryFile not opened for writing")
+
+        if isinstance(data, memoryview):
+            data = bytes(data)
+        elif isinstance(data, bytearray):
+            data = bytes(data)
+
+        if not isinstance(data, binary_types):
+            raise TypeError("write() expects a bytes-like object")
+
+        data_len = len(data)
+        if data_len == 0:
+            return 0
+
+        # Handle "append" semantics roughly: start from end on first write
+        if 'a' in self.mode and self._pos == 0:
+            # Move to logical end of region
+            self._pos = self._size
+
+        start, end_abs = self._region_bounds()
+        remaining = end_abs - (self._base_offset + self._pos)
+        if data_len > remaining:
+            raise IOError("write would overflow SharedMemory region (need %d, have %d)"
+                          % (data_len, remaining))
+
+        abs_start = self._base_offset + self._pos
+        abs_end = abs_start + data_len
+
+        self._buf[abs_start:abs_end] = data
+        self._pos += data_len
+        return data_len
+
+    def flush(self):
+        """
+        No-op for shared memory; provided for file-like compatibility.
+        """
+        self._check_closed()
+        # nothing to flush
+
+    # ---------- unlink / close / context manager ----------
+
+    def unlink(self):
+        """
+        Unlink (destroy) the underlying shared memory block.
+
+        After unlink(), new processes cannot attach via name.
+        Existing attachments (including this one) can continue to use
+        the memory until they close() it.
+
+        This is idempotent: calling it more than once is safe.
+        """
+        if self._unlinked:
+            return
+
+        try:
+            self._shm.unlink()
+        except AttributeError:
+            # Should not happen on normal Python 3.8+,
+            # but keep a clear error if it does.
+            raise RuntimeError("Underlying SharedMemory object "
+                               "does not support unlink()")
+
+        self._unlinked = True
+
+    def close(self):
+        if self._closed:
+            return
+        self._closed = True
+
+        # Optionally unlink on close if requested
+        if self._unlink_on_close and not self._unlinked:
+            try:
+                self.unlink()
+            except Exception:
+                # best-effort; close anyway
+                pass
+
+        try:
+            self._shm.close()
+        except Exception:
+            pass
+
+    def __enter__(self):
+        self._check_closed()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    # ---------- iteration ----------
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        line = self.readline()
+        if (not line) or len(line) == 0:
+            raise StopIteration
+        return line
+
+    if PY2:
+        next = __next__
+
+    # ---------- misc helpers ----------
+
+    def fileno(self):
+        """
+        There is no real OS-level file descriptor; raise OSError for APIs
+        that require a fileno().
+        """
+        raise OSError("SharedMemoryFile does not have a real fileno()")
+
+    def isatty(self):
+        return False
+
 # ---------- Main class ----------
 class ZlibFile(object):
     """
@@ -3666,7 +4171,7 @@ def _bytes_to_int(b):
 # =========================
 #     Public checksum API
 # =========================
-def GetHeaderChecksum(inlist=None, checksumtype="md5", encodedata=True, formatspecs=__file_format_dict__):
+def GetHeaderChecksum(inlist=None, checksumtype="md5", encodedata=True, formatspecs=__file_format_dict__, saltkey=None):
     """
     Serialize header fields (list/tuple => joined with delimiter + trailing delimiter;
     or a single field) and compute the requested checksum. Returns lowercase hex.
@@ -3678,15 +4183,30 @@ def GetHeaderChecksum(inlist=None, checksumtype="md5", encodedata=True, formatsp
     if encodedata and not isinstance(hdr_bytes, (bytes, bytearray, memoryview)):
         hdr_bytes = _to_bytes(hdr_bytes)
     hdr_bytes = bytes(hdr_bytes)
-
+    saltkeyval = None
+    if(hasattr(saltkey, "read")):
+        saltkeyval = skfp.read()
+        if(not isinstance(saltkeyval, bytes) and sys.version_info[0] >= 3):
+            saltkeyval = saltkeyval.encode("UTF-8")
+    elif(isinstance(saltkey, bytes) and sys.version_info[0] >= 3):
+        saltkeyval = saltkey
+    elif(saltkey is not None and os.path.exists(saltkey)):
+        with open(saltkey, "rb") as skfp:
+            saltkeyval = skfp.read()
+    else:
+        saltkey = None
+    if(saltkeyval is None):
+        saltkey = None
     if CheckSumSupport(algo_key, hashlib_guaranteed):
-         h = hashlib.new(algo_key)
-         h.update(hdr_bytes)
-         return h.hexdigest().lower()
+        if(saltkey is None or saltkeyval is None):
+            h = hashlib.new(algo_key, hdr_bytes)
+        else:
+            h = hmac.new(saltkeyval, hdr_bytes, digestmod=algo_key)
+        return h.hexdigest().lower()
 
     return "0"
 
-def GetFileChecksum(inbytes, checksumtype="md5", encodedata=True, formatspecs=__file_format_dict__):
+def GetFileChecksum(inbytes, checksumtype="md5", encodedata=True, formatspecs=__file_format_dict__, saltkey=None):
     """
     Accepts bytes/str/file-like.
       - Hashlib algos: streamed in 1 MiB chunks.
@@ -3694,13 +4214,29 @@ def GetFileChecksum(inbytes, checksumtype="md5", encodedata=True, formatspecs=__
       - Falls back to one-shot for non-file-like inputs.
     """
     algo_key = (checksumtype or "md5").lower()
-
+    saltkeyval = None
+    if(hasattr(saltkey, "read")):
+        saltkeyval = skfp.read()
+        if(not isinstance(saltkeyval, bytes) and sys.version_info[0] >= 3):
+            saltkeyval = saltkeyval.encode("UTF-8")
+    elif(isinstance(saltkey, bytes) and sys.version_info[0] >= 3):
+        saltkeyval = saltkey
+    elif(saltkey is not None and os.path.exists(saltkey)):
+        with open(saltkey, "rb") as skfp:
+            saltkeyval = skfp.read()
+    else:
+        saltkey = None
+    if(saltkeyval is None):
+        saltkey = None
     # file-like streaming
     if hasattr(inbytes, "read"):
         # hashlib
 
         if CheckSumSupport(algo_key, hashlib_guaranteed):
-            h = hashlib.new(algo_key)
+            if(saltkey is None or saltkeyval is None):
+                h = hashlib.new(algo_key)
+            else:
+                h = hmac.new(saltkeyval, digestmod=algo_key)
             while True:
                 chunk = inbytes.read(__filebuff_size__)
                 if not chunk:
@@ -3721,26 +4257,41 @@ def GetFileChecksum(inbytes, checksumtype="md5", encodedata=True, formatspecs=__
     # one-shot
 
     if CheckSumSupport(algo_key, hashlib_guaranteed):
-        h = hashlib.new(algo_key)
-        h.update(data)
+        if(saltkey is None or saltkeyval is None):
+            h = hashlib.new(algo_key, data)
+        else:
+            h = hmac.new(saltkeyval, data, digestmod=algo_key)
         return h.hexdigest().lower()
 
     return "0"
 
-def ValidateHeaderChecksum(inlist=None, checksumtype="md5", inchecksum="0", formatspecs=__file_format_dict__):
-    calc = GetHeaderChecksum(inlist, checksumtype, True, formatspecs)
+def ValidateHeaderChecksum(inlist=None, checksumtype="md5", inchecksum="0", formatspecs=__file_format_dict__, saltkey=None):
+    calc = GetHeaderChecksum(inlist, checksumtype, True, formatspecs, saltkey)
     want = (inchecksum or "0").strip().lower()
     if want.startswith("0x"):
         want = want[2:]
-    return hmac.compare_digest(want, calc)
+    return CheckChecksums(want, calc)
 
-def ValidateFileChecksum(infile, checksumtype="md5", inchecksum="0", formatspecs=__file_format_dict__):
-    calc = GetFileChecksum(infile, checksumtype, True, formatspecs)
+def ValidateFileChecksum(infile, checksumtype="md5", inchecksum="0", formatspecs=__file_format_dict__, saltkey=None):
+    calc = GetFileChecksum(infile, checksumtype, True, formatspecs, saltkey)
     want = (inchecksum or "0").strip().lower()
     if want.startswith("0x"):
         want = want[2:]
-    return hmac.compare_digest(want, calc)
+    return CheckChecksums(want, calc)
+
+def CheckChecksums(inchecksum, outchecksum):
+    # Normalize as text first
+    calc = (inchecksum or "0").strip().lower()
+    want = (outchecksum or "0").strip().lower()
 
+    if want.startswith("0x"):
+        want = want[2:]
+
+    # Now force both to bytes
+    calc_b = _to_bytes(calc)   # defaults to utf-8, strict
+    want_b = _to_bytes(want)
+
+    return hmac.compare_digest(want_b, calc_b)
 
 def MajorMinorToDev(major, minor):
     """
@@ -4109,11 +4660,11 @@ def ReadFileHeaderDataWoSize(fp, delimiter=_default_delim(None)):
     return first_two + headerdata
 
 
-def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
+def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, saltkey=None):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
-    if(formatspecs['new_style']):
+    if(__use_new_style__):
         HeaderOut = ReadFileHeaderDataBySize(fp, delimiter)
     else:
         HeaderOut = ReadFileHeaderDataWoSize(fp, delimiter)
@@ -4201,15 +4752,14 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
                 except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                     pass
     fp.seek(len(delimiter), 1)
-    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs)
-    if(not hmac.compare_digest(fjsonchecksum, jsonfcs) and not skipchecksum):
+    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs, saltkey)
+    if(not CheckChecksums(fjsonchecksum, jsonfcs) and not skipchecksum):
         VerbosePrintOut("File JSON Data Checksum Error with file " +
                         fname + " at offset " + str(fheaderstart))
         VerbosePrintOut("'" + fjsonchecksum + "' != " + "'" + jsonfcs + "'")
         return False
     fp.seek(len(delimiter), 1)
-    newfcs = GetHeaderChecksum(
-        HeaderOut[:-2], HeaderOut[-4].lower(), True, formatspecs)
+    newfcs = GetHeaderChecksum(HeaderOut[:-2], HeaderOut[-4].lower(), True, formatspecs, saltkey)
     HeaderOut.append(fjsoncontent)
     if(fcs != newfcs and not skipchecksum):
         VerbosePrintOut("File Header Checksum Error with file " +
@@ -4228,10 +4778,9 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
         else:
             fp.seek(fcsize, 1)
     fcontents.seek(0, 0)
-    newfccs = GetFileChecksum(
-        fcontents, HeaderOut[-3].lower(), False, formatspecs)
+    newfccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs, saltkey)
     fcontents.seek(0, 0)
-    if(not hmac.compare_digest(fccs, newfccs) and not skipchecksum and not listonly):
+    if(not CheckChecksums(fccs, newfccs) and not skipchecksum and not listonly):
         VerbosePrintOut("File Content Checksum Error with file " +
                         fname + " at offset " + str(fcontentstart))
         VerbosePrintOut("'" + fccs + "' != " + "'" + newfccs + "'")
@@ -4268,12 +4817,12 @@ def ReadFileHeaderDataWithContent(fp, listonly=False, uncompress=True, skipcheck
     return HeaderOut
 
 
-def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
+def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, saltkey=None):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
     fheaderstart = fp.tell()
-    if(formatspecs['new_style']):
+    if(__use_new_style__):
         HeaderOut = ReadFileHeaderDataBySize(fp, delimiter)
     else:
         HeaderOut = ReadFileHeaderDataWoSize(fp, delimiter)
@@ -4291,40 +4840,51 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
     fbasedir = os.path.dirname(fname)
     flinkname = HeaderOut[6]
     fsize = int(HeaderOut[7], 16)
-    fatime = int(HeaderOut[8], 16)
-    fmtime = int(HeaderOut[9], 16)
-    fctime = int(HeaderOut[10], 16)
-    fbtime = int(HeaderOut[11], 16)
-    fmode = int(HeaderOut[12], 16)
+    fblksize = int(HeaderOut[8], 16)
+    fblocks = int(HeaderOut[9], 16)
+    fflags = int(HeaderOut[10], 16)
+    fatime = int(HeaderOut[11], 16)
+    fmtime = int(HeaderOut[12], 16)
+    fctime = int(HeaderOut[13], 16)
+    fbtime = int(HeaderOut[14], 16)
+    fmode = int(HeaderOut[15], 16)
     fchmode = stat.S_IMODE(fmode)
     ftypemod = stat.S_IFMT(fmode)
-    fwinattributes = int(HeaderOut[13], 16)
-    fcompression = HeaderOut[14]
-    fcsize = int(HeaderOut[15], 16)
-    fuid = int(HeaderOut[16], 16)
-    funame = HeaderOut[17]
-    fgid = int(HeaderOut[18], 16)
-    fgname = HeaderOut[19]
-    fid = int(HeaderOut[20], 16)
-    finode = int(HeaderOut[21], 16)
-    flinkcount = int(HeaderOut[22], 16)
-    fdev = int(HeaderOut[23], 16)
-    fdev_minor = int(HeaderOut[24], 16)
-    fdev_major = int(HeaderOut[25], 16)
-    fseeknextfile = HeaderOut[26]
-    fjsontype = HeaderOut[27]
-    fjsonlen = int(HeaderOut[28], 16)
-    fjsonsize = int(HeaderOut[29], 16)
-    fjsonchecksumtype = HeaderOut[30]
-    fjsonchecksum = HeaderOut[31]
-    fextrasize = int(HeaderOut[32], 16)
-    fextrafields = int(HeaderOut[33], 16)
+    fwinattributes = int(HeaderOut[16], 16)
+    fcompression = HeaderOut[17]
+    fcsize = int(HeaderOut[18], 16)
+    fuid = int(HeaderOut[19], 16)
+    funame = HeaderOut[20]
+    fgid = int(HeaderOut[21], 16)
+    fgname = HeaderOut[22]
+    fid = int(HeaderOut[23], 16)
+    finode = int(HeaderOut[24], 16)
+    flinkcount = int(HeaderOut[25], 16)
+    fdev = int(HeaderOut[26], 16)
+    frdev = int(HeaderOut[27], 16)
+    fseeknextfile = HeaderOut[28]
+    fjsontype = HeaderOut[29]
+    fjsonlen = int(HeaderOut[30], 16)
+    fjsonsize = int(HeaderOut[31], 16)
+    fjsonchecksumtype = HeaderOut[32]
+    fjsonchecksum = HeaderOut[33]
+    fextrasize = int(HeaderOut[34], 16)
+    fextrafields = int(HeaderOut[35], 16)
     fextrafieldslist = []
-    extrastart = 34
+    extrastart = 36
     extraend = extrastart + fextrafields
     while(extrastart < extraend):
         fextrafieldslist.append(HeaderOut[extrastart])
         extrastart = extrastart + 1
+    fvendorfieldslist = []
+    fvendorfields = 0;
+    if((len(HeaderOut) - 4)>extraend):
+        extrastart = extraend
+        extraend = len(HeaderOut) - 4
+        while(extrastart < extraend):
+            fvendorfieldslist.append(HeaderOut[extrastart])
+            extrastart = extrastart + 1
+            fvendorfields = fvendorfields + 1
     if(fextrafields==1):
         try:
             fextrafieldslist = json.loads(base64.b64decode(fextrafieldslist[0]).decode("UTF-8"))
@@ -4402,16 +4962,15 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
                     pass
     fp.seek(len(delimiter), 1)
     fjend = fp.tell() - 1
-    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs)
-    if(not hmac.compare_digest(fjsonchecksum, jsonfcs) and not skipchecksum):
+    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs, saltkey)
+    if(not CheckChecksums(fjsonchecksum, jsonfcs) and not skipchecksum):
         VerbosePrintOut("File JSON Data Checksum Error with file " +
                         fname + " at offset " + str(fheaderstart))
         VerbosePrintOut("'" + fjsonchecksum + "' != " + "'" + jsonfcs + "'")
         return False
     fcs = HeaderOut[-2].lower()
     fccs = HeaderOut[-1].lower()
-    newfcs = GetHeaderChecksum(
-        HeaderOut[:-2], HeaderOut[-4].lower(), True, formatspecs)
+    newfcs = GetHeaderChecksum(HeaderOut[:-2], HeaderOut[-4].lower(), True, formatspecs, saltkey)
     if(fcs != newfcs and not skipchecksum):
         VerbosePrintOut("File Header Checksum Error with file " +
                         fname + " at offset " + str(fheaderstart))
@@ -4434,10 +4993,9 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
             fp.seek(fcsize, 1)
         pyhascontents = False
     fcontents.seek(0, 0)
-    newfccs = GetFileChecksum(
-        fcontents, HeaderOut[-3].lower(), False, formatspecs)
+    newfccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs, saltkey)
     fcontents.seek(0, 0)
-    if(not hmac.compare_digest(fccs, newfccs) and not skipchecksum and not listonly):
+    if(not CheckChecksums(fccs, newfccs) and not skipchecksum and not listonly):
         VerbosePrintOut("File Content Checksum Error with file " +
                         fname + " at offset " + str(fcontentstart))
         VerbosePrintOut("'" + fccs + "' != " + "'" + newfccs + "'")
@@ -4454,8 +5012,7 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
             shutil.copyfileobj(cfcontents, fcontents, length=__filebuff_size__)
             cfcontents.close()
             fcontents.seek(0, 0)
-            fccs = GetFileChecksum(
-                fcontents, HeaderOut[-3].lower(), False, formatspecs)
+            fccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs, saltkey)
     fcontentend = fp.tell()
     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
         fseeknextasnum = int(fseeknextfile.replace("+", ""))
@@ -4477,17 +5034,17 @@ def ReadFileHeaderDataWithContentToArray(fp, listonly=False, contentasfile=True,
     fcontents.seek(0, 0)
     if(not contentasfile):
         fcontents = fcontents.read()
-    outlist = {'fheadersize': fheadsize, 'fhstart': fheaderstart, 'fhend': fhend, 'ftype': ftype, 'fencoding': fencoding, 'fcencoding': fcencoding, 'fname': fname, 'fbasedir': fbasedir, 'flinkname': flinkname, 'fsize': fsize, 'fatime': fatime, 'fmtime': fmtime, 'fctime': fctime, 'fbtime': fbtime, 'fmode': fmode, 'fchmode': fchmode, 'ftypemod': ftypemod, 'fwinattributes': fwinattributes, 'fcompression': fcompression, 'fcsize': fcsize, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount,
-               'fdev': fdev, 'fminor': fdev_minor, 'fmajor': fdev_major, 'fseeknextfile': fseeknextfile, 'fheaderchecksumtype': HeaderOut[-4], 'fjsonchecksumtype': fjsonchecksumtype, 'fcontentchecksumtype': HeaderOut[-3], 'fnumfields': fnumfields + 2, 'frawheader': HeaderOut, 'fextrafields': fextrafields, 'fextrafieldsize': fextrasize, 'fextradata': fextrafieldslist, 'fjsontype': fjsontype, 'fjsonlen': fjsonlen, 'fjsonsize': fjsonsize, 'fjsonrawdata': fjsonrawcontent, 'fjsondata': fjsoncontent, 'fjstart': fjstart, 'fjend': fjend, 'fheaderchecksum': fcs, 'fjsonchecksum': fjsonchecksum, 'fcontentchecksum': fccs, 'fhascontents': pyhascontents, 'fcontentstart': fcontentstart, 'fcontentend': fcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents}
+    outlist = {'fheadersize': fheadsize, 'fhstart': fheaderstart, 'fhend': fhend, 'ftype': ftype, 'fencoding': fencoding, 'fcencoding': fcencoding, 'fname': fname, 'fbasedir': fbasedir, 'flinkname': flinkname, 'fsize': fsize, 'fblksize': fblksize, 'fblocks': fblocks, 'fflags': fflags, 'fatime': fatime, 'fmtime': fmtime, 'fctime': fctime, 'fbtime': fbtime, 'fmode': fmode, 'fchmode': fchmode, 'ftypemod': ftypemod, 'fwinattributes': fwinattributes, 'fcompression': fcompression, 'fcsize': fcsize, 'fuid': fuid, 'funame': funame, 'fgid': fgid, 'fgname': fgname, 'finode': finode, 'flinkcount': flinkcount,
+               'fdev': fdev, 'frdev': frdev, 'fseeknextfile': fseeknextfile, 'fheaderchecksumtype': HeaderOut[-4], 'fjsonchecksumtype': fjsonchecksumtype, 'fcontentchecksumtype': HeaderOut[-3], 'fnumfields': fnumfields + 2, 'frawheader': HeaderOut, 'fvendorfields': fvendorfields, 'fvendordata': fvendorfieldslist, 'fextrafields': fextrafields, 'fextrafieldsize': fextrasize, 'fextradata': fextrafieldslist, 'fjsontype': fjsontype, 'fjsonlen': fjsonlen, 'fjsonsize': fjsonsize, 'fjsonrawdata': fjsonrawcontent, 'fjsondata': fjsoncontent, 'fjstart': fjstart, 'fjend': fjend, 'fheaderchecksum': fcs, 'fjsonchecksum': fjsonchecksum, 'fcontentchecksum': fccs, 'fhascontents': pyhascontents, 'fcontentstart': fcontentstart, 'fcontentend': fcontentend, 'fcontentasfile': contentasfile, 'fcontents': fcontents}
     return outlist
 
 
-def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
+def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, saltkey=None):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
     fheaderstart = fp.tell()
-    if(formatspecs['new_style']):
+    if(__use_new_style__):
         HeaderOut = ReadFileHeaderDataBySize(fp, delimiter)
     else:
         HeaderOut = ReadFileHeaderDataWoSize(fp, delimiter)
@@ -4505,40 +5062,51 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
     fbasedir = os.path.dirname(fname)
     flinkname = HeaderOut[6]
     fsize = int(HeaderOut[7], 16)
-    fatime = int(HeaderOut[8], 16)
-    fmtime = int(HeaderOut[9], 16)
-    fctime = int(HeaderOut[10], 16)
-    fbtime = int(HeaderOut[11], 16)
-    fmode = int(HeaderOut[12], 16)
+    fblksize = int(HeaderOut[8], 16)
+    fblocks = int(HeaderOut[9], 16)
+    fflags = int(HeaderOut[10], 16)
+    fatime = int(HeaderOut[11], 16)
+    fmtime = int(HeaderOut[12], 16)
+    fctime = int(HeaderOut[13], 16)
+    fbtime = int(HeaderOut[14], 16)
+    fmode = int(HeaderOut[15], 16)
     fchmode = stat.S_IMODE(fmode)
     ftypemod = stat.S_IFMT(fmode)
-    fwinattributes = int(HeaderOut[13], 16)
-    fcompression = HeaderOut[14]
-    fcsize = int(HeaderOut[15], 16)
-    fuid = int(HeaderOut[16], 16)
-    funame = HeaderOut[17]
-    fgid = int(HeaderOut[18], 16)
-    fgname = HeaderOut[19]
-    fid = int(HeaderOut[20], 16)
-    finode = int(HeaderOut[21], 16)
-    flinkcount = int(HeaderOut[22], 16)
-    fdev = int(HeaderOut[23], 16)
-    fdev_minor = int(HeaderOut[24], 16)
-    fdev_major = int(HeaderOut[25], 16)
-    fseeknextfile = HeaderOut[26]
-    fjsontype = HeaderOut[27]
-    fjsonlen = int(HeaderOut[28], 16)
-    fjsonsize = int(HeaderOut[29], 16)
-    fjsonchecksumtype = HeaderOut[30]
-    fjsonchecksum = HeaderOut[31]
-    fextrasize = int(HeaderOut[32], 16)
-    fextrafields = int(HeaderOut[33], 16)
+    fwinattributes = int(HeaderOut[16], 16)
+    fcompression = HeaderOut[17]
+    fcsize = int(HeaderOut[18], 16)
+    fuid = int(HeaderOut[19], 16)
+    funame = HeaderOut[20]
+    fgid = int(HeaderOut[21], 16)
+    fgname = HeaderOut[22]
+    fid = int(HeaderOut[23], 16)
+    finode = int(HeaderOut[24], 16)
+    flinkcount = int(HeaderOut[25], 16)
+    fdev = int(HeaderOut[26], 16)
+    frdev = int(HeaderOut[27], 16)
+    fseeknextfile = HeaderOut[28]
+    fjsontype = HeaderOut[29]
+    fjsonlen = int(HeaderOut[30], 16)
+    fjsonsize = int(HeaderOut[31], 16)
+    fjsonchecksumtype = HeaderOut[32]
+    fjsonchecksum = HeaderOut[33]
+    fextrasize = int(HeaderOut[34], 16)
+    fextrafields = int(HeaderOut[35], 16)
     fextrafieldslist = []
-    extrastart = 34
+    extrastart = 36
     extraend = extrastart + fextrafields
     while(extrastart < extraend):
         fextrafieldslist.append(HeaderOut[extrastart])
         extrastart = extrastart + 1
+    fvendorfieldslist = []
+    fvendorfields = 0;
+    if((len(HeaderOut) - 4)>extraend):
+        extrastart = extraend
+        extraend = len(HeaderOut) - 4
+        while(extrastart < extraend):
+            fvendorfieldslist.append(HeaderOut[extrastart])
+            extrastart = extrastart + 1
+            fvendorfields = fvendorfields + 1
     if(fextrafields==1):
         try:
             fextrafieldslist = json.loads(base64.b64decode(fextrafieldslist[0]).decode("UTF-8"))
@@ -4548,6 +5116,7 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
+    fjstart = fp.tell()
     if(fjsontype=="json"):
         fjsoncontent = {}
         fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
@@ -4614,16 +5183,16 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
                 except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                     pass
     fp.seek(len(delimiter), 1)
-    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs)
-    if(not hmac.compare_digest(fjsonchecksum, jsonfcs) and not skipchecksum):
+    fjend = fp.tell() - 1
+    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs, saltkey)
+    if(not CheckChecksums(fjsonchecksum, jsonfcs) and not skipchecksum):
         VerbosePrintOut("File JSON Data Checksum Error with file " +
                         fname + " at offset " + str(fheaderstart))
         VerbosePrintOut("'" + fjsonchecksum + "' != " + "'" + jsonfcs + "'")
         return False
     fcs = HeaderOut[-2].lower()
     fccs = HeaderOut[-1].lower()
-    newfcs = GetHeaderChecksum(
-        HeaderOut[:-2], HeaderOut[-4].lower(), True, formatspecs)
+    newfcs = GetHeaderChecksum(HeaderOut[:-2], HeaderOut[-4].lower(), True, formatspecs, saltkey)
     if(fcs != newfcs and not skipchecksum):
         VerbosePrintOut("File Header Checksum Error with file " +
                         fname + " at offset " + str(fheaderstart))
@@ -4646,9 +5215,9 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
             fp.seek(fcsize, 1)
         pyhascontents = False
     fcontents.seek(0, 0)
-    newfccs = GetFileChecksum(
-        fcontents, HeaderOut[-3].lower(), False, formatspecs)
-    if(not hmac.compare_digest(fccs, newfccs) and not skipchecksum and not listonly):
+    newfccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs, saltkey)
+    fcontents.seek(0, 0)
+    if(not CheckChecksums(fccs, newfccs) and not skipchecksum and not listonly):
         VerbosePrintOut("File Content Checksum Error with file " +
                         fname + " at offset " + str(fcontentstart))
         VerbosePrintOut("'" + fccs + "' != " + "'" + newfccs + "'")
@@ -4665,8 +5234,7 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
             shutil.copyfileobj(cfcontents, fcontents, length=__filebuff_size__)
             cfcontents.close()
             fcontents.seek(0, 0)
-            fccs = GetFileChecksum(
-                fcontents, HeaderOut[-3].lower(), False, formatspecs)
+            fccs = GetFileChecksum(fcontents, HeaderOut[-3].lower(), False, formatspecs, saltkey)
     fcontentend = fp.tell()
     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
         fseeknextasnum = int(fseeknextfile.replace("+", ""))
@@ -4688,12 +5256,12 @@ def ReadFileHeaderDataWithContentToList(fp, listonly=False, contentasfile=False,
     fcontents.seek(0, 0)
     if(not contentasfile):
         fcontents = fcontents.read()
-    outlist = [ftype, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression, fcsize, fuid, funame, fgid, fgname, fid,
-               finode, flinkcount, fdev, fdev_minor, fdev_major, fseeknextfile, fjsoncontent, fextrafieldslist, HeaderOut[-4], HeaderOut[-3], fcontents]
+    outlist = {'fheaders': [ftype, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+               fcsize, fuid, funame, fgid, fgname, fid, finode, flinkcount, fdev, frdev, fseeknextfile], 'fextradata': fextrafieldslist, 'fjsoncontent': fjsoncontent, 'fcontents': fcontents, 'fjsonchecksumtype': fjsonchecksumtype, 'fheaderchecksumtype': HeaderOut[-4].lower(), 'fcontentchecksumtype': HeaderOut[-3].lower()}
     return outlist
 
 
-def ReadFileDataWithContent(fp, filestart=0, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__):
+def ReadFileDataWithContent(fp, filestart=0, listonly=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, saltkey=None):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
@@ -4706,6 +5274,7 @@ def ReadFileDataWithContent(fp, filestart=0, listonly=False, uncompress=True, sk
     CatSizeEnd = CatSize
     fp.seek(curloc, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
+    headeroffset = fp.tell()
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
     formdel = fp.read(formdelszie).decode("UTF-8")
@@ -4713,7 +5282,7 @@ def ReadFileDataWithContent(fp, filestart=0, listonly=False, uncompress=True, sk
         return False
     if(formdel != formatspecs['format_delimiter']):
         return False
-    if(formatspecs['new_style']):
+    if(__use_new_style__):
         inheader = ReadFileHeaderDataBySize(
             fp, formatspecs['format_delimiter'])
     else:
@@ -4721,19 +5290,19 @@ def ReadFileDataWithContent(fp, filestart=0, listonly=False, uncompress=True, sk
             fp, formatspecs['format_delimiter'])
     fprechecksumtype = inheader[-2]
     fprechecksum = inheader[-1]
-    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
-    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs)
+    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs, saltkey)
+    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs, saltkey)
     if(not headercheck and not skipchecksum):
         VerbosePrintOut(
-            "File Header Checksum Error with file at offset " + str(0))
+            "File Header Checksum Error with file at offset " + str(headeroffset))
         VerbosePrintOut("'" + fprechecksum + "' != " +
                         "'" + newfcs + "'")
         return False
-    fnumfiles = int(inheader[6], 16)
-    outfseeknextfile = inheaderdata[7]
-    fjsonsize = int(inheaderdata[10], 16)
-    fjsonchecksumtype = inheader[11]
-    fjsonchecksum = inheader[12]
+    fnumfiles = int(inheader[8], 16)
+    outfseeknextfile = inheaderdata[9]
+    fjsonsize = int(inheaderdata[12], 16)
+    fjsonchecksumtype = inheader[13]
+    fjsonchecksum = inheader[14]
     fp.read(fjsonsize)
     # Next seek directive
     if(re.findall(r"^\+([0-9]+)", outfseeknextfile)):
@@ -4756,8 +5325,7 @@ def ReadFileDataWithContent(fp, filestart=0, listonly=False, uncompress=True, sk
     countnum = 0
     flist = []
     while(countnum < fnumfiles):
-        HeaderOut = ReadFileHeaderDataWithContent(
-            fp, listonly, uncompress, skipchecksum, formatspecs)
+        HeaderOut = ReadFileHeaderDataWithContent(fp, listonly, uncompress, skipchecksum, formatspecs, saltkey)
         if(len(HeaderOut) == 0):
             break
         flist.append(HeaderOut)
@@ -4765,7 +5333,7 @@ def ReadFileDataWithContent(fp, filestart=0, listonly=False, uncompress=True, sk
     return flist
 
 
-def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False):
+def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, saltkey=None, seektoend=False):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
@@ -4778,6 +5346,7 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
     CatSizeEnd = CatSize
     fp.seek(curloc, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
+    headeroffset = fp.tell()
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
     formdel = fp.read(formdelszie).decode("UTF-8")
@@ -4785,16 +5354,16 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
         return False
     if(formdel != formatspecs['format_delimiter']):
         return False
-    if(formatspecs['new_style']):
+    if(__use_new_style__):
         inheader = ReadFileHeaderDataBySize(
             fp, formatspecs['format_delimiter'])
     else:
         inheader = ReadFileHeaderDataWoSize(
             fp, formatspecs['format_delimiter'])
-    fnumextrafieldsize = int(inheader[13], 16)
-    fnumextrafields = int(inheader[14], 16)
+    fnumextrafieldsize = int(inheader[15], 16)
+    fnumextrafields = int(inheader[16], 16)
     fextrafieldslist = []
-    extrastart = 15
+    extrastart = 17
     extraend = extrastart + fnumextrafields
     while(extrastart < extraend):
         fextrafieldslist.append(inheader[extrastart])
@@ -4808,20 +5377,31 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
+    fvendorfieldslist = []
+    fvendorfields = 0;
+    if((len(inheader) - 2)>extraend):
+        extrastart = extraend
+        extraend = len(inheader) - 2
+        while(extrastart < extraend):
+            fvendorfieldslist.append(HeaderOut[extrastart])
+            extrastart = extrastart + 1
+            fvendorfields = fvendorfields + 1
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
-    fhencoding = inheader[2]
-    fostype = inheader[3]
-    fpythontype = inheader[4]
-    fprojectname = inheader[4]
-    fnumfiles = int(inheader[6], 16)
-    fseeknextfile = inheader[7]
-    fjsontype = inheader[8]
-    fjsonlen = int(inheader[9], 16)
-    fjsonsize = int(inheader[10], 16)
-    fjsonchecksumtype = inheader[11]
-    fjsonchecksum = inheader[12]
+    fheadctime = int(inheader[2], 16)
+    fheadmtime = int(inheader[3], 16)
+    fhencoding = inheader[4]
+    fostype = inheader[5]
+    fpythontype = inheader[6]
+    fprojectname = inheader[7]
+    fnumfiles = int(inheader[8], 16)
+    fseeknextfile = inheader[9]
+    fjsontype = inheader[10]
+    fjsonlen = int(inheader[11], 16)
+    fjsonsize = int(inheader[12], 16)
+    fjsonchecksumtype = inheader[13]
+    fjsonchecksum = inheader[14]
     fjsoncontent = {}
     fjstart = fp.tell()
     if(fjsontype=="json"):
@@ -4907,25 +5487,25 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
         fp.seek(fseeknextasnum, 0)
     else:
         return False
-    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs)
-    if(not hmac.compare_digest(fjsonchecksum, jsonfcs) and not skipchecksum):
+    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs, saltkey)
+    if(not CheckChecksums(fjsonchecksum, jsonfcs) and not skipchecksum):
         VerbosePrintOut("File JSON Data Checksum Error with file " +
                         fname + " at offset " + str(fheaderstart))
         VerbosePrintOut("'" + fjsonchecksum + "' != " + "'" + jsonfcs + "'")
         return False
     fprechecksumtype = inheader[-2]
     fprechecksum = inheader[-1]
-    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
-    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs)
+    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs, saltkey)
+    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs, saltkey)
     if(not headercheck and not skipchecksum):
         VerbosePrintOut(
-            "File Header Checksum Error with file at offset " + str(0))
+            "File Header Checksum Error with file at offset " + str(headeroffset))
         VerbosePrintOut("'" + fprechecksum + "' != " +
                         "'" + newfcs + "'")
         return False
     formversions = re.search('(.*?)(\\d+)', formstring).groups()
     fcompresstype = ""
-    outlist = {'fnumfiles': fnumfiles, 'ffilestart': filestart, 'fformat': formversions[0], 'fcompression': fcompresstype, 'fencoding': fhencoding, 'fversion': formversions[1], 'fostype': fostype, 'fprojectname': fprojectname, 'fimptype': fpythontype, 'fheadersize': fheadsize, 'fsize': CatSizeEnd, 'fnumfields': fnumfields + 2, 'fformatspecs': formatspecs, 'fseeknextfile': fseeknextfile, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'fjsonchecksumtype': fjsonchecksumtype, 'fjsontype': fjsontype, 'fjsonlen': fjsonlen, 'fjsonsize': fjsonsize, 'fjsonrawdata': fjsonrawcontent, 'fjsondata': fjsoncontent, 'fjstart': fjstart, 'fjend': fjend, 'fjsonchecksum': fjsonchecksum, 'frawheader': [formstring] + inheader, 'fextrafields': fnumextrafields, 'fextrafieldsize': fnumextrafieldsize, 'fextradata': fextrafieldslist, 'ffilelist': []}
+    outlist = {'fnumfiles': fnumfiles, 'ffilestart': filestart, 'fformat': formversions[0], 'fcompression': fcompresstype, 'fencoding': fhencoding, 'fmtime': fheadmtime, 'fctime': fheadctime, 'fversion': formversions[1], 'fostype': fostype, 'fprojectname': fprojectname, 'fimptype': fpythontype, 'fheadersize': fheadsize, 'fsize': CatSizeEnd, 'fnumfields': fnumfields + 2, 'fformatspecs': formatspecs, 'fseeknextfile': fseeknextfile, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, 'fjsonchecksumtype': fjsonchecksumtype, 'fjsontype': fjsontype, 'fjsonlen': fjsonlen, 'fjsonsize': fjsonsize, 'fjsonrawdata': fjsonrawcontent, 'fjsondata': fjsoncontent, 'fjstart': fjstart, 'fjend': fjend, 'fjsonchecksum': fjsonchecksum, 'frawheader': [formstring] + inheader, 'fextrafields': fnumextrafields, 'fextrafieldsize': fnumextrafieldsize, 'fextradata': fextrafieldslist, 'fvendorfields': fvendorfields, 'fvendordata': fvendorfieldslist, 'ffilelist': []}
     if (seekstart < 0) or (seekstart > fnumfiles):
         seekstart = 0
     if (seekend == 0) or (seekend > fnumfiles) or (seekend < seekstart):
@@ -4952,16 +5532,15 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
             prefjsonchecksum = preheaderdata[31]
             prejsoncontent = fp.read(prefjsonsize).decode("UTF-8")
             fp.seek(len(delimiter), 1)
-            prejsonfcs = GetFileChecksum(prejsoncontent, prefjsonchecksumtype, True, formatspecs)
-            if(not hmac.compare_digest(prefjsonchecksum, prejsonfcs) and not skipchecksum):
+            prejsonfcs = GetFileChecksum(prejsoncontent, prefjsonchecksumtype, True, formatspecs, saltkey)
+            if(not CheckChecksums(prefjsonchecksum, prejsonfcs) and not skipchecksum):
                 VerbosePrintOut("File JSON Data Checksum Error with file " +
                                 prefname + " at offset " + str(prefhstart))
                 VerbosePrintOut("'" + prefjsonchecksum + "' != " + "'" + prejsonfcs + "'")
                 return False
-            prenewfcs = GetHeaderChecksum(
-                preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
+            prenewfcs = GetHeaderChecksum(preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs, saltkey)
             prefcs = preheaderdata[-2]
-            if(not hmac.compare_digest(prefcs, prenewfcs) and not skipchecksum):
+            if(not CheckChecksums(prefcs, prenewfcs) and not skipchecksum):
                 VerbosePrintOut("File Header Checksum Error with file " +
                                  prefname + " at offset " + str(prefhstart))
                 VerbosePrintOut("'" + prefcs + "' != " +
@@ -4976,11 +5555,10 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
             if(prefsize > 0):
                 prefcontents.write(fp.read(prefsize))
                 prefcontents.seek(0, 0)
-                prenewfccs = GetFileChecksum(
-                    prefcontents, preheaderdata[-3].lower(), False, formatspecs)
+                prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs, saltkey)
                 prefccs = preheaderdata[-1]
                 pyhascontents = True
-                if(not hmac.compare_digest(prefccs, prenewfccs) and not skipchecksum):
+                if(not CheckChecksums(prefccs, prenewfccs) and not skipchecksum):
                     VerbosePrintOut("File Content Checksum Error with file " +
                                     prefname + " at offset " + str(prefcontentstart))
                     VerbosePrintOut("'" + prefccs +
@@ -5007,8 +5585,7 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
     realidnum = 0
     countnum = seekstart
     while (fp.tell() < CatSizeEnd) if seektoend else (countnum < seekend):
-        HeaderOut = ReadFileHeaderDataWithContentToArray(
-            fp, listonly, contentasfile, uncompress, skipchecksum, formatspecs)
+        HeaderOut = ReadFileHeaderDataWithContentToArray(fp, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey)
         if(len(HeaderOut) == 0):
             break
         HeaderOut.update({'fid': realidnum, 'fidalt': realidnum})
@@ -5019,7 +5596,7 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
     return outlist
 
 
-def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, seektoend=False):
+def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=False, uncompress=True, skipchecksum=False, formatspecs=__file_format_dict__, saltkey=None, seektoend=False):
     if(not hasattr(fp, "read")):
         return False
     delimiter = formatspecs['format_delimiter']
@@ -5032,6 +5609,7 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
     CatSizeEnd = CatSize
     fp.seek(curloc, 0)
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
+    headeroffset = fp.tell()
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelszie = len(formatspecs['format_delimiter'])
     formdel = fp.read(formdelszie).decode("UTF-8")
@@ -5039,16 +5617,16 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
         return False
     if(formdel != formatspecs['format_delimiter']):
         return False
-    if(formatspecs['new_style']):
+    if(__use_new_style__):
         inheader = ReadFileHeaderDataBySize(
             fp, formatspecs['format_delimiter'])
     else:
         inheader = ReadFileHeaderDataWoSize(
             fp, formatspecs['format_delimiter'])
-    fnumextrafieldsize = int(inheader[13], 16)
-    fnumextrafields = int(inheader[14], 16)
+    fnumextrafieldsize = int(inheader[15], 16)
+    fnumextrafields = int(inheader[16], 16)
     fextrafieldslist = []
-    extrastart = 15
+    extrastart = 17
     extraend = extrastart + fnumextrafields
     while(extrastart < extraend):
         fextrafieldslist.append(inheader[extrastart])
@@ -5062,19 +5640,98 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
                 fextrafieldslist = json.loads(fextrafieldslist[0])
             except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
                 pass
+    fvendorfieldslist = []
+    fvendorfields = 0;
+    if((len(inheader) - 2)>extraend):
+        extrastart = extraend
+        extraend = len(inheader) - 2
+        while(extrastart < extraend):
+            fvendorfieldslist.append(HeaderOut[extrastart])
+            extrastart = extrastart + 1
+            fvendorfields = fvendorfields + 1
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
-    fnumfiles = int(inheader[6], 16)
-    fseeknextfile = inheaderdata[7]
-    fjsontype = int(inheader[8], 16)
-    fjsonlen = int(inheader[9], 16)
-    fjsonsize = int(inheader[10], 16)
-    fjsonchecksumtype = inheader[11]
-    fjsonchecksum = inheader[12]
+    fheadctime = int(inheader[2], 16)
+    fheadmtime = int(inheader[3], 16)
+    fhencoding = inheader[4]
+    fostype = inheader[5]
+    fpythontype = inheader[6]
+    fprojectname = inheader[7]
+    fnumfiles = int(inheader[8], 16)
+    fseeknextfile = inheader[9]
+    fjsontype = inheader[10]
+    fjsonlen = int(inheader[11], 16)
+    fjsonsize = int(inheader[12], 16)
+    fjsonchecksumtype = inheader[13]
+    fjsonchecksum = inheader[14]
     fjsoncontent = {}
     fjstart = fp.tell()
-    fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+    if(fjsontype=="json"):
+        fjsoncontent = {}
+        fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+        if(fjsonsize > 0):
+            try:
+                fjsonrawcontent = base64.b64decode(fprejsoncontent.encode("UTF-8")).decode("UTF-8")
+                fjsoncontent = json.loads(base64.b64decode(fprejsoncontent.encode("UTF-8")).decode("UTF-8"))
+            except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
+                try:
+                    fjsonrawcontent = fprejsoncontent
+                    fjsoncontent = json.loads(fprejsoncontent)
+                except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
+                    fprejsoncontent = ""
+                    fjsonrawcontent = fprejsoncontent 
+                    fjsoncontent = {}
+        else:
+            fprejsoncontent = ""
+            fjsonrawcontent = fprejsoncontent 
+            fjsoncontent = {}
+    elif(testyaml and fjsontype == "yaml"):
+        fjsoncontent = {}
+        fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+        if (fjsonsize > 0):
+            try:
+                # try base64 → utf-8 → YAML
+                fjsonrawcontent = base64.b64decode(fprejsoncontent.encode("UTF-8")).decode("UTF-8")
+                fjsoncontent = yaml.safe_load(fjsonrawcontent) or {}
+            except (binascii.Error, UnicodeDecodeError, yaml.YAMLError):
+                try:
+                    # fall back to treating the bytes as plain text YAML
+                    fjsonrawcontent = fprejsoncontent
+                    fjsoncontent = yaml.safe_load(fjsonrawcontent) or {}
+                except (UnicodeDecodeError, yaml.YAMLError):
+                    # final fallback: empty
+                    fprejsoncontent = ""
+                    fjsonrawcontent = fprejsoncontent
+                    fjsoncontent = {}
+        else:
+            fprejsoncontent = ""
+            fjsonrawcontent = fprejsoncontent
+            fjsoncontent = {}
+    elif(not testyaml and fjsontype == "yaml"):
+        fjsoncontent = {}
+        fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+        fprejsoncontent = ""
+        fjsonrawcontent = fprejsoncontent
+    elif(fjsontype=="list"):
+        fprejsoncontent = fp.read(fjsonsize).decode("UTF-8")
+        flisttmp = MkTempFile()
+        flisttmp.write(fprejsoncontent.encode())
+        flisttmp.seek(0)
+        fjsoncontent = ReadFileHeaderData(flisttmp, fjsonlen, delimiter)
+        flisttmp.close()
+        fjsonrawcontent = fjsoncontent
+        if(fjsonlen==1):
+            try:
+                fjsonrawcontent = base64.b64decode(fjsoncontent[0]).decode("UTF-8")
+                fjsoncontent = json.loads(base64.b64decode(fjsoncontent[0]).decode("UTF-8"))
+                fjsonlen = len(fjsoncontent)
+            except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
+                try:
+                    fjsonrawcontent = fjsoncontent[0]
+                    fjsoncontent = json.loads(fjsoncontent[0])
+                except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
+                    pass
     fjend = fp.tell()
     if(re.findall("^\\+([0-9]+)", fseeknextfile)):
         fseeknextasnum = int(fseeknextfile.replace("+", ""))
@@ -5093,19 +5750,19 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
         fp.seek(fseeknextasnum, 0)
     else:
         return False
-    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs)
-    if(not hmac.compare_digest(fjsonchecksum, jsonfcs) and not skipchecksum):
+    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs, saltkey)
+    if(not CheckChecksums(fjsonchecksum, jsonfcs) and not skipchecksum):
         VerbosePrintOut("File JSON Data Checksum Error with file " +
                         fname + " at offset " + str(fheaderstart))
         VerbosePrintOut("'" + fjsonchecksum + "' != " + "'" + jsonfcs + "'")
         return False
     fprechecksumtype = inheader[-2]
     fprechecksum = inheader[-1]
-    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
-    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs)
+    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs, saltkey)
+    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs, saltkey)
     if(not headercheck and not skipchecksum):
         VerbosePrintOut(
-            "File Header Checksum Error with file at offset " + str(0))
+            "File Header Checksum Error with file at offset " + str(headeroffset))
         VerbosePrintOut("'" + fprechecksum + "' != " +
                         "'" + newfcs + "'")
         return False
@@ -5121,7 +5778,7 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
         il = 0
         while(il < seekstart):
             prefhstart = fp.tell()
-            if(formatspecs['new_style']):
+            if(__use_new_style__):
                 preheaderdata = ReadFileHeaderDataBySize(
                     fp, formatspecs['format_delimiter'])
             else:
@@ -5143,16 +5800,15 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
             prefjsonchecksum = preheaderdata[31]
             prefprejsoncontent = fp.read(prefjsonsize).decode("UTF-8")
             fp.seek(len(delimiter), 1)
-            prejsonfcs = GetFileChecksum(prefprejsoncontent, prefjsonchecksumtype, True, formatspecs)
-            if(not hmac.compare_digest(prefjsonchecksum, prejsonfcs) and not skipchecksum):
+            prejsonfcs = GetFileChecksum(prefprejsoncontent, prefjsonchecksumtype, True, formatspecs, saltkey)
+            if(not CheckChecksums(prefjsonchecksum, prejsonfcs) and not skipchecksum):
                 VerbosePrintOut("File JSON Data Checksum Error with file " +
                                 prefname + " at offset " + str(prefhstart))
                 VerbosePrintOut("'" + prefjsonchecksum + "' != " + "'" + prejsonfcs + "'")
                 return False
-            prenewfcs = GetHeaderChecksum(
-                preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs)
+            prenewfcs = GetHeaderChecksum(preheaderdata[:-2], preheaderdata[-4].lower(), True, formatspecs, saltkey)
             prefcs = preheaderdata[-2]
-            if(not hmac.compare_digest(prefcs, prenewfcs) and not skipchecksum):
+            if(not CheckChecksums(prefcs, prenewfcs) and not skipchecksum):
                 VerbosePrintOut("File Header Checksum Error with file " +
                                 prefname + " at offset " + str(prefhstart))
                 VerbosePrintOut("'" + prefcs + "' != " +
@@ -5169,11 +5825,10 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
                     prefcontents = fp.read(prefsize)
                 else:
                     prefcontents = fp.read(prefcsize)
-                prenewfccs = GetFileChecksum(
-                    prefcontents, preheaderdata[-3].lower(), False, formatspecs)
+                prenewfccs = GetFileChecksum(prefcontents, preheaderdata[-3].lower(), False, formatspecs, saltkey)
                 prefccs = preheaderdata[-1]
                 pyhascontents = True
-                if(not hmac.compare_digest(prefccs, prenewfccs) and not skipchecksum):
+                if(not CheckChecksums(prefccs, prenewfccs) and not skipchecksum):
                     VerbosePrintOut("File Content Checksum Error with file " +
                                     prefname + " at offset " + str(prefcontentstart))
                     VerbosePrintOut("'" + prefccs +
@@ -5200,8 +5855,7 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
     realidnum = 0
     countnum = seekstart
     while (fp.tell() < CatSizeEnd) if seektoend else (countnum < seekend):
-        HeaderOut = ReadFileHeaderDataWithContentToList(
-            fp, listonly, contentasfile, uncompress, skipchecksum, formatspecs)
+        HeaderOut = ReadFileHeaderDataWithContentToList(fp, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey)
         if(len(HeaderOut) == 0):
             break
         outlist.append(HeaderOut)
@@ -5209,7 +5863,7 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
         realidnum = realidnum + 1
     return outlist
 
-def ReadInFileWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+def ReadInFileWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False):
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
         try:
@@ -5304,7 +5958,7 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=
             else:
                 break
             readfp.seek(oldfppos, 0)
-            ArchiveList.append(ReadFileDataWithContentToArray(readfp, currentfilepos, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, informatspecs, seektoend))
+            ArchiveList.append(ReadFileDataWithContentToArray(readfp, currentfilepos, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, informatspecs, saltkey, seektoend))
             currentfilepos = readfp.tell()
         else:
             infp = UncompressFileAlt(readfp, formatspecs, currentfilepos)
@@ -5326,27 +5980,27 @@ def ReadInFileWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=
                 else:
                     break
                 infp.seek(oldinfppos, 0)
-                ArchiveList.append(ReadFileDataWithContentToArray(infp, currentinfilepos, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, informatspecs, seektoend))
+                ArchiveList.append(ReadFileDataWithContentToArray(infp, currentinfilepos, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, informatspecs, saltkey, seektoend))
                 currentinfilepos = infp.tell()
             currentfilepos = readfp.tell()
     return ArchiveList
 
 
-def ReadInMultipleFileWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+def ReadInMultipleFileWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False):
     if(isinstance(infile, (list, tuple, ))):
         pass
     else:
         infile = [infile]
     outretval = []
     for curfname in infile:
-        outretval.append(ReadInFileWithContentToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend))
+        outretval.append(ReadInFileWithContentToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey, seektoend))
     return outretval
 
-def ReadInMultipleFilesWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
-    return ReadInMultipleFileWithContentToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+def ReadInMultipleFilesWithContentToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False):
+    return ReadInMultipleFileWithContentToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey, seektoend)
 
 
-def ReadInFileWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+def ReadInFileWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False):
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         fp = infile
         try:
@@ -5441,7 +6095,7 @@ def ReadInFileWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0
             else:
                 break
             readfp.seek(oldfppos, 0)
-            ArchiveList.append(ReadFileDataWithContentToList(readfp, currentfilepos, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, informatspecs, seektoend))
+            ArchiveList.append(ReadFileDataWithContentToList(readfp, currentfilepos, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, informatspecs, saltkey, seektoend))
             currentfilepos = readfp.tell()
         else:
             infp = UncompressFileAlt(readfp, formatspecs, currentfilepos)
@@ -5463,24 +6117,24 @@ def ReadInFileWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0
                 else:
                     break
                 infp.seek(oldinfppos, 0)
-                ArchiveList.append(ReadFileDataWithContentToList(infp, currentinfilepos, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, informatspecs, seektoend))
+                ArchiveList.append(ReadFileDataWithContentToList(infp, currentinfilepos, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, informatspecs, saltkey, seektoend))
                 currentinfilepos = infp.tell()
             currentfilepos = readfp.tell()
     return ArchiveList
 
 
-def ReadInMultipleFileWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
+def ReadInMultipleFileWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False):
     if(isinstance(infile, (list, tuple, ))):
         pass
     else:
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        outretval.append(ReadInFileWithContentToList(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend))
+        outretval.append(ReadInFileWithContentToList(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey, seektoend))
     return outretval
 
-def ReadInMultipleFilesWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False):
-    return ReadInMultipleFileWithContentToList(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+def ReadInMultipleFilesWithContentToList(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False):
+    return ReadInMultipleFileWithContentToList(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey, seektoend)
 
 
 def _field_to_bytes(x):
@@ -5534,7 +6188,7 @@ def AppendNullBytes(indata=None, delimiter=__file_format_dict__['format_delimite
 def _hex_lower(n):
     return format(int(n), 'x').lower()
 
-def AppendFileHeader(fp, numfiles, fencoding, extradata=[], jsondata={}, checksumtype=["md5", "md5"], formatspecs=__file_format_dict__):
+def AppendFileHeader(fp, numfiles, fencoding, extradata=[], jsondata={}, checksumtype=["md5", "md5"], formatspecs=__file_format_dict__, saltkey=None):
     """
     Build and write the archive file header.
     Returns the same file-like 'fp' on success, or False on failure.
@@ -5598,18 +6252,21 @@ def AppendFileHeader(fp, numfiles, fencoding, extradata=[], jsondata={}, checksu
     tmpoutlist.append(fjsonsize)
     if(len(jsondata) > 0):
         tmpoutlist.append(checksumtype[1])
-        tmpoutlist.append(GetFileChecksum(fjsoncontent, checksumtype[1], True, formatspecs))
+        tmpoutlist.append(GetFileChecksum(fjsoncontent, checksumtype[1], True, formatspecs, saltkey))
     else:
         tmpoutlist.append("none")
-        tmpoutlist.append(GetFileChecksum(fjsoncontent, "none", True, formatspecs))
+        tmpoutlist.append(GetFileChecksum(fjsoncontent, "none", True, formatspecs, saltkey))
     # Preserve your original "tmpoutlen" computation exactly
     tmpoutlist.append(extrasizelen)
     tmpoutlist.append(extrafields)
-    tmpoutlen = 8 + len(tmpoutlist) + len(xlist)
+    tmpoutlen = 10 + len(tmpoutlist) + len(xlist)
     tmpoutlenhex = _hex_lower(tmpoutlen)
-
+    if(hasattr(time, "time_ns")):
+        fctime = format(int(time.time_ns()), 'x').lower()
+    else:
+        fctime = format(int(to_ns(time.time())), 'x').lower()
     # Serialize the first group
-    fnumfilesa = AppendNullBytes([tmpoutlenhex, fencoding, platform.system(), py_implementation, __program_name__, fnumfiles_hex, "+"+str(len(formatspecs['format_delimiter']))], delimiter)
+    fnumfilesa = AppendNullBytes([tmpoutlenhex, fctime, fctime, fencoding, platform.system(), py_implementation, __program_name__+str(__version_info__[0]), fnumfiles_hex, "+"+str(len(formatspecs['format_delimiter']))], delimiter)
     # Append tmpoutlist
     fnumfilesa += AppendNullBytes(tmpoutlist, delimiter)
     # Append extradata items if any
@@ -5619,7 +6276,7 @@ def AppendFileHeader(fp, numfiles, fencoding, extradata=[], jsondata={}, checksu
     fnumfilesa += AppendNullByte(checksumtype[0], delimiter)
 
     # 5) inner checksum over fnumfilesa
-    outfileheadercshex = GetFileChecksum(fnumfilesa, checksumtype[0], True, formatspecs)
+    outfileheadercshex = GetFileChecksum(fnumfilesa, checksumtype[0], True, formatspecs, saltkey)
     tmpfileoutstr = fnumfilesa + AppendNullByte(outfileheadercshex, delimiter)
 
     # 6) size of (tmpfileoutstr) excluding one delimiter, per your original math
@@ -5632,7 +6289,7 @@ def AppendFileHeader(fp, numfiles, fencoding, extradata=[], jsondata={}, checksu
         + fnumfilesa
     )
 
-    outfileheadercshex = GetFileChecksum(fnumfilesa, checksumtype[0], True, formatspecs)
+    outfileheadercshex = GetFileChecksum(fnumfilesa, checksumtype[0], True, formatspecs, saltkey)
     fnumfilesa += AppendNullByte(outfileheadercshex, delimiter)
 
     # 8) final total size field (again per your original logic)
@@ -5665,21 +6322,21 @@ def AppendFileHeader(fp, numfiles, fencoding, extradata=[], jsondata={}, checksu
     return fp
 
 
-def MakeEmptyFilePointer(fp, fmttype=__file_format_default__, checksumtype=["md5", "md5"], formatspecs=__file_format_multi_dict__):
+def MakeEmptyFilePointer(fp, fmttype=__file_format_default__, checksumtype=["md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None):
     if(IsNestedDict(formatspecs) and fmttype in formatspecs):
         formatspecs = formatspecs[fmttype]
     elif(IsNestedDict(formatspecs) and fmttype not in formatspecs):
         fmttype = __file_format_default__
         formatspecs = formatspecs[fmttype]
-    AppendFileHeader(fp, 0, "UTF-8", [], {}, checksumtype, formatspecs)
+    AppendFileHeader(fp, 0, "UTF-8", [], {}, checksumtype, formatspecs, saltkey)
     return fp
 
 
-def MakeEmptyArchiveFilePointer(fp, fmttype=__file_format_default__, checksumtype=["md5", "md5"], formatspecs=__file_format_multi_dict__):
-    return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs)
+def MakeEmptyArchiveFilePointer(fp, fmttype=__file_format_default__, checksumtype=["md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None):
+    return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs, saltkey)
 
 
-def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5"], formatspecs=__file_format_multi_dict__, returnfp=False):
+def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, returnfp=False):
     if(IsNestedDict(formatspecs) and fmttype=="auto" and 
         (outfile != "-" and outfile is not None and not hasattr(outfile, "read") and not hasattr(outfile, "write"))):
         get_in_ext = os.path.splitext(outfile)
@@ -5709,6 +6366,7 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         fp = MkTempFile()
     elif(hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = outfile
+        return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs, saltkey)
     elif(re.findall(__upload_proto_support__, outfile)):
         fp = MkTempFile()
     else:
@@ -5720,7 +6378,7 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
             fp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
         except PermissionError:
             return False
-    AppendFileHeader(fp, 0, "UTF-8", [], {}, checksumtype, formatspecs)
+    AppendFileHeader(fp, 0, "UTF-8", ['hello', 'goodbye'], {}, checksumtype, formatspecs, saltkey)
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -5751,11 +6409,11 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         return True
 
 
-def MakeEmptyArchiveFile(outfile, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5"], formatspecs=__file_format_dict__, returnfp=False):
-    return MakeEmptyFile(outfile, "auto", compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, returnfp)
+def MakeEmptyArchiveFile(outfile, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, returnfp=False):
+    return MakeEmptyFile(outfile, "auto", compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, saltkey, returnfp)
 
 
-def AppendFileHeaderWithContent(fp, filevalues=[], extradata=[], jsondata={}, filecontent="", checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__):
+def AppendFileHeaderWithContent(fp, filevalues=[], extradata=[], jsondata={}, filecontent="", checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None):
     if(not hasattr(fp, "write")):
         return False
     if (isinstance(extradata, dict) or IsNestedDictAlt(extradata)) and len(extradata) > 0:
@@ -5787,10 +6445,10 @@ def AppendFileHeaderWithContent(fp, filevalues=[], extradata=[], jsondata={}, fi
     tmpoutlist.append(fjsonsize)
     if(len(jsondata) > 0):
         tmpoutlist.append(checksumtype[2])
-        tmpoutlist.append(GetFileChecksum(fjsoncontent, checksumtype[2], True, formatspecs))
+        tmpoutlist.append(GetFileChecksum(fjsoncontent, checksumtype[2], True, formatspecs, saltkey))
     else:
         tmpoutlist.append("none")
-        tmpoutlist.append(GetFileChecksum(fjsoncontent, "none", True, formatspecs))
+        tmpoutlist.append(GetFileChecksum(fjsoncontent, "none", True, formatspecs, saltkey))
     tmpoutlist.append(extrasizelen)
     tmpoutlist.append(extrafields)
     outfileoutstr = AppendNullBytes(
@@ -5805,22 +6463,18 @@ def AppendFileHeaderWithContent(fp, filevalues=[], extradata=[], jsondata={}, fi
     outfileoutstr = outfileoutstr + \
         AppendNullBytes(checksumlist, formatspecs['format_delimiter'])
     nullstrecd = formatspecs['format_delimiter'].encode('UTF-8')
-    outfileheadercshex = GetFileChecksum(
-        outfileoutstr, checksumtype[0], True, formatspecs)
+    outfileheadercshex = GetFileChecksum(outfileoutstr, checksumtype[0], True, formatspecs, saltkey)
     if(len(filecontent) == 0):
-        outfilecontentcshex = GetFileChecksum(
-            filecontent, "none", False, formatspecs)
+        outfilecontentcshex = GetFileChecksum(filecontent, "none", False, formatspecs, saltkey)
     else:
-        outfilecontentcshex = GetFileChecksum(
-            filecontent, checksumtype[1], False, formatspecs)
+        outfilecontentcshex = GetFileChecksum(filecontent, checksumtype[1], False, formatspecs, saltkey)
     tmpfileoutstr = outfileoutstr + \
         AppendNullBytes([outfileheadercshex, outfilecontentcshex],
                         formatspecs['format_delimiter'])
     formheaersize = format(int(len(tmpfileoutstr) - len(formatspecs['format_delimiter'])), 'x').lower()
     outfileoutstr = AppendNullByte(
         formheaersize, formatspecs['format_delimiter']) + outfileoutstr
-    outfileheadercshex = GetFileChecksum(
-        outfileoutstr, checksumtype[0], True, formatspecs)
+    outfileheadercshex = GetFileChecksum(outfileoutstr, checksumtype[0], True, formatspecs, saltkey)
     outfileoutstr = outfileoutstr + \
         AppendNullBytes([outfileheadercshex, outfilecontentcshex],
                         formatspecs['format_delimiter'])
@@ -5838,14 +6492,9 @@ def AppendFileHeaderWithContent(fp, filevalues=[], extradata=[], jsondata={}, fi
         pass
     return fp
 
-def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False):
-    if(not hasattr(fp, "write")):
-        return False
-    advancedlist = formatspecs['use_advanced_list']
-    altinode = formatspecs['use_alt_inode']
-    if(verbose):
-        logging.basicConfig(format="%(message)s",
-                            stream=PY_STDOUT_TEXT, level=logging.DEBUG)
+def AppendFilesWithContentToList(infiles, dirlistfromtxt=False, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+    advancedlist = __use_advanced_list__
+    altinode = __use_alt_inode__
     infilelist = []
     if(infiles == "-"):
         for line in PY_STDIN_TEXT:
@@ -5885,16 +6534,8 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
     inodetofile = {}
     filetoinode = {}
     inodetoforminode = {}
-    numfiles = int(len(GetDirList))
-    fnumfiles = format(numfiles, 'x').lower()
-    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs)
-    try:
-        fp.flush()
-        if(hasattr(os, "sync")):
-            os.fsync(fp.fileno())
-    except (io.UnsupportedOperation, AttributeError, OSError):
-        pass
     FullSizeFilesAlt = 0
+    tmpoutlist = []
     for curfname in GetDirList:
         fencoding = "UTF-8"
         if(re.findall("^[.|/]", curfname)):
@@ -5916,14 +6557,24 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
             FullSizeFilesAlt += fstatinfo.st_rsize
         except AttributeError:
             FullSizeFilesAlt += fstatinfo.st_size
+        fblksize = 0
+        if(hasattr(fstatinfo, "st_blksize")):
+            fblksize = format(int(fstatinfo.st_blksize), 'x').lower()
+        fblocks = 0
+        if(hasattr(fstatinfo, "st_blocks")):
+            fblocks = format(int(fstatinfo.st_blocks), 'x').lower()
+        fflags = 0
+        if(hasattr(fstatinfo, "st_flags")):
+            fflags = format(int(fstatinfo.st_flags), 'x').lower()
         ftype = 0
-        if(hasattr(os.path, "isjunction") and os.path.isjunction(fname)):
+        if(not followlink and hasattr(os.path, "isjunction") and os.path.isjunction(fname)):
             ftype = 13
-        elif(hasattr(fstatinfo, "st_blocks") and fstatinfo.st_blocks * 512 < fstatinfo.st_size):
-            ftype = 12
         elif(stat.S_ISREG(fpremode)):
-            ftype = 0
-        elif(stat.S_ISLNK(fpremode)):
+            if(hasattr(fstatinfo, "st_blocks") and fstatinfo.st_size > 0 and fstatinfo.st_blocks * 512 < fstatinfo.st_size):
+                ftype = 12
+            else:
+                ftype = 0
+        elif(not followlink and stat.S_ISLNK(fpremode)):
             ftype = 2
         elif(stat.S_ISCHR(fpremode)):
             ftype = 3
@@ -5945,43 +6596,42 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
             ftype = 0
         flinkname = ""
         fcurfid = format(int(curfid), 'x').lower()
-        if not followlink and finode != 0:
+        if(not followlink and finode != 0):
             unique_id = (fstatinfo.st_dev, finode)
-            if ftype != 1:
-                if unique_id in inodelist:
+            if(ftype != 1):
+                if(unique_id in inodetofile):
                     # Hard link detected
                     ftype = 1
                     flinkname = inodetofile[unique_id]
-                    if altinode:
-                        fcurinode = format(int(unique_id[1]), 'x').lower()
-                    else:
-                        fcurinode = format(int(inodetoforminode[unique_id]), 'x').lower()
                 else:
-                    # New inode
-                    inodelist.append(unique_id)
+                    # First time seeing this inode
                     inodetofile[unique_id] = fname
+                if(unique_id not in inodetoforminode):
                     inodetoforminode[unique_id] = curinode
-                    if altinode:
-                        fcurinode = format(int(unique_id[1]), 'x').lower()
-                    else:
-                        fcurinode = format(int(curinode), 'x').lower()
-                    curinode += 1
+                    curinode = curinode + 1
+                if(altinode):
+                    # altinode == True → use real inode number
+                    fcurinode = format(int(unique_id[1]), 'x').lower()
+                else:
+                    # altinode == False → use synthetic inode id
+                    fcurinode = format(int(inodetoforminode[unique_id]), 'x').lower()
         else:
             # Handle cases where inodes are not supported or symlinks are followed
             fcurinode = format(int(curinode), 'x').lower()
-            curinode += 1
+            curinode = curinode + 1
         curfid = curfid + 1
         if(ftype == 2):
             flinkname = os.readlink(fname)
-            if(not os.path.exists(flinkname)):
+            if(not os.path.exists(fname)):
                 return False
         try:
             fdev = fstatinfo.st_rdev
         except AttributeError:
             fdev = 0
-        getfdev = GetDevMajorMinor(fdev)
-        fdev_minor = getfdev[0]
-        fdev_major = getfdev[1]
+        try:
+            frdev = fstatinfo.st_rdev
+        except AttributeError:
+            frdev = 0
         # Types that should be considered zero-length in the archive context:
         zero_length_types = {1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 13}
         # Types that have actual data to read:
@@ -5992,13 +6642,28 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
             fsize = format(int(fstatinfo.st_size), 'x').lower()
         else:
             fsize = format(int(fstatinfo.st_size), 'x').lower()
-        fatime = format(int(fstatinfo.st_atime), 'x').lower()
-        fmtime = format(int(fstatinfo.st_mtime), 'x').lower()
-        fctime = format(int(fstatinfo.st_ctime), 'x').lower()
+        if(hasattr(fstatinfo, "st_atime_ns")):
+            fatime = format(int(fstatinfo.st_atime_ns), 'x').lower()
+        else:
+            fatime = format(int(to_ns(fstatinfo.st_atime)), 'x').lower()
+        if(hasattr(fstatinfo, "st_mtime_ns")):
+            fmtime = format(int(fstatinfo.st_mtime_ns), 'x').lower()
+        else:
+            fmtime = format(int(to_ns(fstatinfo.st_mtime)), 'x').lower()
+        if(hasattr(fstatinfo, "st_ctime_ns")):
+            fctime = format(int(fstatinfo.st_ctime_ns), 'x').lower()
+        else:
+            fctime = format(int(to_ns(fstatinfo.st_ctime)), 'x').lower()
         if(hasattr(fstatinfo, "st_birthtime")):
-            fbtime = format(int(fstatinfo.st_birthtime), 'x').lower()
+            if(hasattr(fstatinfo, "st_birthtime_ns")):
+                fbtime = format(int(fstatinfo.st_birthtime_ns), 'x').lower()
+            else:
+                fbtime = format(int(to_ns(fstatinfo.st_birthtime)), 'x').lower()
         else:
-            fbtime = format(int(fstatinfo.st_ctime), 'x').lower()
+            if(hasattr(fstatinfo, "st_ctime_ns")):
+                fbtime = format(int(fstatinfo.st_ctime_ns), 'x').lower()
+            else:
+                fbtime = format(int(to_ns(fstatinfo.st_ctime)), 'x').lower()
         fmode = format(int(fstatinfo.st_mode), 'x').lower()
         fchmode = format(int(stat.S_IMODE(fstatinfo.st_mode)), 'x').lower()
         ftypemod = format(int(stat.S_IFMT(fstatinfo.st_mode)), 'x').lower()
@@ -6025,8 +6690,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
         except ImportError:
             fgname = ""
         fdev = format(int(fdev), 'x').lower()
-        fdev_minor = format(int(fdev_minor), 'x').lower()
-        fdev_major = format(int(fdev_major), 'x').lower()
+        frdev = format(int(frdev), 'x').lower()
         finode = format(int(finode), 'x').lower()
         flinkcount = format(int(flinkcount), 'x').lower()
         if(hasattr(fstatinfo, "st_file_attributes")):
@@ -6046,7 +6710,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
                 typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
                 if(typechecktest is not False):
-                    typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=True)
+                    typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=False)
                     fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, 0, False)[0]
                 if(typechecktest is False and not compresswholefile):
@@ -6087,16 +6751,15 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
                         fcompression = curcompression
                         fcontents.close()
                         fcontents = cfcontents
-        elif followlink and (ftype == 1 or ftype == 2):
-            if(not os.path.exists(flinkname)):
+        elif followlink and (ftype == 2 or ftype in data_types):
+            if(not os.path.exists(fname)):
                 return False
-            flstatinfo = os.stat(flinkname)
             with open(flinkname, "rb") as fpc:
                 shutil.copyfileobj(fpc, fcontents, length=__filebuff_size__)
                 typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
                 if(typechecktest is not False):
-                    typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=True)
+                    typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=False)
                     fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, 0, False)[0]
                 if(typechecktest is False and not compresswholefile):
@@ -6140,11 +6803,29 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
         if(fcompression == "none"):
             fcompression = ""
         fcontents.seek(0, 0)
+        if(not contentasfile):
+            fcontents = fcontents.read()
         ftypehex = format(ftype, 'x').lower()
-        tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
-                      fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, fdev_minor, fdev_major, "+"+str(len(formatspecs['format_delimiter']))]
-        AppendFileHeaderWithContent(
-            fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs)
+        tmpoutlist.append({'fheaders': [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+                           fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))], 'fextradata': extradata, 'fjsoncontent': jsondata, 'fcontents': fcontents, 'fjsonchecksumtype': checksumtype[2], 'fheaderchecksumtype': checksumtype[0], 'fcontentchecksumtype': checksumtype[1]})
+    return tmpoutlist
+
+def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+    GetDirList = AppendFilesWithContentToList(infiles, dirlistfromtxt, extradata, jsondata, False, compression, compresswholefile, compressionlevel, compressionuselist, followlink, [checksumtype[2], checksumtype[3], checksumtype[3]], formatspecs, saltkey, verbose)
+    if(not hasattr(fp, "write")):
+        return False
+    numfiles = int(len(GetDirList))
+    fnumfiles = format(numfiles, 'x').lower()
+    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
+    try:
+        fp.flush()
+        if(hasattr(os, "sync")):
+            os.fsync(fp.fileno())
+    except (io.UnsupportedOperation, AttributeError, OSError):
+        pass
+    for curfname in GetDirList:
+        tmpoutlist = curfname['fheaders']
+        AppendFileHeaderWithContent(fp, tmpoutlist, curfname['fextradata'], curfname['fjsoncontent'], curfname['fcontents'], [curfname['fheaderchecksumtype'], curfname['fcontentchecksumtype'], curfname['fjsonchecksumtype']], formatspecs, saltkey)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -6153,12 +6834,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
             pass
     return fp
 
-def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False):
-    if(not hasattr(fp, "write")):
-        return False
-    if(verbose):
-        logging.basicConfig(format="%(message)s",
-                            stream=PY_STDOUT_TEXT, level=logging.DEBUG)
+def AppendFilesWithContentFromTarFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
     curinode = 0
     curfid = 0
     inodelist = []
@@ -6200,10 +6876,8 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
-                if 'zstandard' in sys.modules:
-                    infile = ZstdFile(fileobj=infile, mode="rb")
-                elif 'pyzstd' in sys.modules:
-                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                if 'zstd' in compressionsupport:
+                    infile = zstd.ZstdFile(infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
@@ -6212,23 +6886,14 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
-                if 'zstandard' in sys.modules:
-                    infile = ZstdFile(fileobj=infile, mode="rb")
-                elif 'pyzstd' in sys.modules:
-                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                if 'zstd' in compressionsupport:
+                    infile = zstd.ZstdFile(infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(infile, "r")
     except FileNotFoundError:
         return False
-    numfiles = int(len(tarfp.getmembers()))
-    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs)
-    try:
-        fp.flush()
-        if(hasattr(os, "sync")):
-            os.fsync(fp.fileno())
-    except (io.UnsupportedOperation, AttributeError, OSError):
-        pass
+    tmpoutlist = []
     for member in sorted(tarfp.getmembers(), key=lambda x: x.name):
         fencoding = "UTF-8"
         if(re.findall("^[.|/]", member.name)):
@@ -6240,6 +6905,9 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
         fpremode = member.mode
         ffullmode = member.mode
         flinkcount = 0
+        fblksize = 0
+        fblocks = 0
+        fflags = 0
         ftype = 0
         if(member.isreg()):
             ffullmode = member.mode + stat.S_IFREG
@@ -6277,12 +6945,11 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
         curfid = curfid + 1
         if(ftype == 2):
             flinkname = member.linkname
+        fdev = format(int("0"), 'x').lower()
         try:
-            fdev = format(int(os.makedev(member.devmajor, member.devminor)), 'x').lower()
+            frdev = format(int(os.makedev(member.devmajor, member.devminor)), 'x').lower()
         except AttributeError:
-            fdev = format(int(MakeDevAlt(member.devmajor, member.devminor)), 'x').lower()
-        fdev_minor = format(int(member.devminor), 'x').lower()
-        fdev_major = format(int(member.devmajor), 'x').lower()
+            frdev = format(int(MakeDevAlt(member.devmajor, member.devminor)), 'x').lower()
         # Types that should be considered zero-length in the archive context:
         zero_length_types = {1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 13}
         # Types that have actual data to read:
@@ -6293,10 +6960,10 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
             fsize = format(int(member.size), 'x').lower()
         else:
             fsize = format(int(member.size), 'x').lower()
-        fatime = format(int(member.mtime), 'x').lower()
-        fmtime = format(int(member.mtime), 'x').lower()
-        fctime = format(int(member.mtime), 'x').lower()
-        fbtime = format(int(member.mtime), 'x').lower()
+        fatime = format(int(to_ns(member.mtime)), 'x').lower()
+        fmtime = format(int(to_ns(member.mtime)), 'x').lower()
+        fctime = format(int(to_ns(member.mtime)), 'x').lower()
+        fbtime = format(int(to_ns(member.mtime)), 'x').lower()
         fmode = format(int(ffullmode), 'x').lower()
         fchmode = format(int(stat.S_IMODE(ffullmode)), 'x').lower()
         ftypemod = format(int(stat.S_IFMT(ffullmode)), 'x').lower()
@@ -6318,7 +6985,7 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
             typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
             fcontents.seek(0, 0)
             if(typechecktest is not False):
-                typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=True)
+                typechecktest = GetBinaryFileType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
             fcencoding = GetFileEncoding(fcontents, 0, False)[0]
             if(typechecktest is False and not compresswholefile):
@@ -6362,26 +7029,38 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
         if(fcompression == "none"):
             fcompression = ""
         fcontents.seek(0, 0)
+        if(not contentasfile):
+            fcontents = fcontents.read()
         ftypehex = format(ftype, 'x').lower()
-        tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
-                      fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, fdev_minor, fdev_major, "+"+str(len(formatspecs['format_delimiter']))]
-        AppendFileHeaderWithContent(
-            fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs)
+        tmpoutlist.append({'fheaders': [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+                           fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))], 'fextradata': extradata, 'fjsoncontent': jsondata, 'fcontents': fcontents, 'fjsonchecksumtype': checksumtype[2], 'fheaderchecksumtype': checksumtype[0], 'fcontentchecksumtype': checksumtype[1]})
+    return tmpoutlist
+
+def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+    if(not hasattr(fp, "write")):
+        return False
+    GetDirList = AppendFilesWithContentFromTarFileToList(infile, extradata, jsondata, False, compression, compresswholefile, compressionlevel, compressionuselist, [checksumtype[2], checksumtype[3], checksumtype[3]], formatspecs, saltkey, verbose)
+    numfiles = int(len(GetDirList))
+    fnumfiles = format(numfiles, 'x').lower()
+    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
+    try:
+        fp.flush()
+        if(hasattr(os, "sync")):
+            os.fsync(fp.fileno())
+    except (io.UnsupportedOperation, AttributeError, OSError):
+        pass
+    for curfname in GetDirList:
+        tmpoutlist = curfname['fheaders']
+        AppendFileHeaderWithContent(fp, tmpoutlist, curfname['fextradata'], curfname['fjsoncontent'], curfname['fcontents'], [curfname['fheaderchecksumtype'], curfname['fcontentchecksumtype'], curfname['fjsonchecksumtype']], formatspecs, saltkey)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
                 os.fsync(fp.fileno())
         except (io.UnsupportedOperation, AttributeError, OSError):
             pass
-        fcontents.close()
     return fp
 
-def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False):
-    if(not hasattr(fp, "write")):
-        return False
-    if(verbose):
-        logging.basicConfig(format="%(message)s",
-                            stream=PY_STDOUT_TEXT, level=logging.DEBUG)
+def AppendFilesWithContentFromZipFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
     curinode = 0
     curfid = 0
     inodelist = []
@@ -6414,14 +7093,7 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
     ziptest = zipfp.testzip()
     if(ziptest):
         VerbosePrintOut("Bad file found!")
-    numfiles = int(len(zipfp.infolist()))
-    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs)
-    try:
-        fp.flush()
-        if(hasattr(os, "sync")):
-            os.fsync(fp.fileno())
-    except (io.UnsupportedOperation, AttributeError, OSError):
-        pass
+    tmpoutlist = []
     for member in sorted(zipfp.infolist(), key=lambda x: x.filename):
         fencoding = "UTF-8"
         if(re.findall("^[.|/]", member.filename)):
@@ -6436,6 +7108,9 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
         else:
             fpremode = int(stat.S_IFREG | 0x1b6)
         flinkcount = 0
+        fblksize = 0
+        fblocks = 0
+        fflags = 0
         ftype = 0
         if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
             ftype = 5
@@ -6446,8 +7121,7 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
         fcurinode = format(int(curfid), 'x').lower()
         curfid = curfid + 1
         fdev = format(int(0), 'x').lower()
-        fdev_minor = format(int(0), 'x').lower()
-        fdev_major = format(int(0), 'x').lower()
+        frdev = format(int(0), 'x').lower()
         if(ftype == 5):
             fsize = format(int("0"), 'x').lower()
         elif(ftype == 0):
@@ -6455,13 +7129,13 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
         else:
             fsize = format(int(member.file_size), 'x').lower()
         fatime = format(
-            int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower()
+            int(to_ns(time.mktime(member.date_time + (0, 0, -1)))), 'x').lower()
         fmtime = format(
-            int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower()
+            int(to_ns(time.mktime(member.date_time + (0, 0, -1)))), 'x').lower()
         fctime = format(
-            int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower()
+            int(to_ns(time.mktime(member.date_time + (0, 0, -1)))), 'x').lower()
         fbtime = format(
-            int(time.mktime(member.date_time + (0, 0, -1))), 'x').lower()
+            int(to_ns(time.mktime(member.date_time + (0, 0, -1)))), 'x').lower()
         if(zipinfo.create_system == 0 or zipinfo.create_system == 10):
             fwinattributes = format(int(zipinfo.external_attr & 0xFFFF), 'x').lower()
             if ((hasattr(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
@@ -6576,30 +7250,44 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
         if(fcompression == "none"):
             fcompression = ""
         fcontents.seek(0, 0)
+        if(not contentasfile):
+            fcontents = fcontents.read()
         ftypehex = format(ftype, 'x').lower()
-        tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
-                      fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, fdev_minor, fdev_major, "+"+str(len(formatspecs['format_delimiter']))]
-        AppendFileHeaderWithContent(
-            fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs)
+        tmpoutlist.append({'fheaders': [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+                           fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))], 'fextradata': extradata, 'fjsoncontent': jsondata, 'fcontents': fcontents, 'fjsonchecksumtype': checksumtype[2], 'fheaderchecksumtype': checksumtype[0], 'fcontentchecksumtype': checksumtype[1]})
+    return tmpoutlist
+
+def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+    if(not hasattr(fp, "write")):
+        return False
+    GetDirList = AppendFilesWithContentFromZipFileToList(infile, extradata, jsondata, False, compression, compresswholefile, compressionlevel, compressionuselist, [checksumtype[2], checksumtype[3], checksumtype[3]], formatspecs, saltkey, verbose)
+    numfiles = int(len(GetDirList))
+    fnumfiles = format(numfiles, 'x').lower()
+    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
+    try:
+        fp.flush()
+        if(hasattr(os, "sync")):
+            os.fsync(fp.fileno())
+    except (io.UnsupportedOperation, AttributeError, OSError):
+        pass
+    for curfname in GetDirList:
+        tmpoutlist = curfname['fheaders']
+        AppendFileHeaderWithContent(fp, tmpoutlist, curfname['fextradata'], curfname['fjsoncontent'], curfname['fcontents'], [curfname['fheaderchecksumtype'], curfname['fcontentchecksumtype'], curfname['fjsonchecksumtype']], formatspecs, saltkey)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
                 os.fsync(fp.fileno())
         except (io.UnsupportedOperation, AttributeError, OSError):
             pass
-        fcontents.close()
     return fp
 
 if(not rarfile_support):
-    def AppendFilesWithContentFromRarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False):
+    def AppendFilesWithContentFromRarFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
         return False
-else:       
-    def AppendFilesWithContentFromRarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False):
-        if(not hasattr(fp, "write")):
-            return False
-        if(verbose):
-            logging.basicConfig(format="%(message)s",
-                                stream=PY_STDOUT_TEXT, level=logging.DEBUG)
+    def AppendFilesWithContentFromRarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+        return False
+else:
+    def AppendFilesWithContentFromRarFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
         curinode = 0
         curfid = 0
         inodelist = []
@@ -6614,20 +7302,7 @@ else:
         rartest = rarfp.testrar()
         if(rartest):
             VerbosePrintOut("Bad file found!")
-        numfiles = int(len(rarfp.infolist()))
-        AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs)
-        try:
-            fp.flush()
-            if(hasattr(os, "sync")):
-                os.fsync(fp.fileno())
-        except (io.UnsupportedOperation, AttributeError, OSError):
-            pass
-        try:
-            fp.flush()
-            if(hasattr(os, "sync")):
-                os.fsync(fp.fileno())
-        except (io.UnsupportedOperation, AttributeError, OSError):
-            pass
+        tmpoutlist = []
         for member in sorted(rarfp.infolist(), key=lambda x: x.filename):
             is_unix = False
             is_windows = False
@@ -6671,6 +7346,9 @@ else:
             fcompression = ""
             fcsize = format(int(0), 'x').lower()
             flinkcount = 0
+            fblksize = 0
+            fblocks = 0
+            fflags = 0
             ftype = 0
             if(member.is_file()):
                 ftype = 0
@@ -6685,8 +7363,7 @@ else:
             fcurinode = format(int(curfid), 'x').lower()
             curfid = curfid + 1
             fdev = format(int(0), 'x').lower()
-            fdev_minor = format(int(0), 'x').lower()
-            fdev_major = format(int(0), 'x').lower()
+            frdev = format(int(0), 'x').lower()
             if(ftype == 5):
                 fsize = format(int("0"), 'x').lower()
             elif(ftype == 0):
@@ -6695,20 +7372,20 @@ else:
                 fsize = format(int(member.file_size), 'x').lower()
             try:
                 if(member.atime):
-                    fatime = format(int(member.atime.timestamp()), 'x').lower()
+                    fatime = format(int(to_ns(member.atime.timestamp())), 'x').lower()
                 else:
-                    fatime = format(int(member.mtime.timestamp()), 'x').lower()
+                    fatime = format(int(to_ns(member.mtime.timestamp())), 'x').lower()
             except AttributeError:
-                fatime = format(int(member.mtime.timestamp()), 'x').lower()
-            fmtime = format(int(member.mtime.timestamp()), 'x').lower()
+                fatime = format(int(to_ns(member.mtime.timestamp())), 'x').lower()
+            fmtime = format(int(to_ns(member.mtime.timestamp())), 'x').lower()
             try:
                 if(member.ctime):
-                    fctime = format(int(member.ctime.timestamp()), 'x').lower()
+                    fctime = format(int(to_ns(member.ctime.timestamp())), 'x').lower()
                 else:
-                    fctime = format(int(member.mtime.timestamp()), 'x').lower()
+                    fctime = format(int(to_ns(member.mtime.timestamp())), 'x').lower()
             except AttributeError:
-                fctime = format(int(member.mtime.timestamp()), 'x').lower()
-            fbtime = format(int(member.mtime.timestamp()), 'x').lower()
+                fctime = format(int(to_ns(member.mtime.timestamp())), 'x').lower()
+            fbtime = format(int(to_ns(member.mtime.timestamp())), 'x').lower()
             if(is_unix and member.external_attr != 0):
                 fmode = format(int(member.external_attr), 'x').lower()
                 fchmode = format(
@@ -6809,30 +7486,84 @@ else:
             if(fcompression == "none"):
                 fcompression = ""
             fcontents.seek(0, 0)
+            if(not contentasfile):
+                fcontents = fcontents.read()
             ftypehex = format(ftype, 'x').lower()
-            tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
-                          fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, fdev_minor, fdev_major, "+"+str(len(formatspecs['format_delimiter']))]
-            AppendFileHeaderWithContent(
-                fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs)
+            tmpoutlist.append({'fheaders': [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+                               fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))], 'fextradata': extradata, 'fjsoncontent': jsondata, 'fcontents': fcontents, 'fjsonchecksumtype': checksumtype[2], 'fheaderchecksumtype': checksumtype[0], 'fcontentchecksumtype': checksumtype[1]})
+        return tmpoutlist
+    def AppendFilesWithContentFromRarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+        if(not hasattr(fp, "write")):
+            return False
+        GetDirList = AppendFilesWithContentFromRarFileToList(infile, extradata, jsondata, False, compression, compresswholefile, compressionlevel, compressionuselist, [checksumtype[2], checksumtype[3], checksumtype[3]], formatspecs, saltkey, verbose)
+        numfiles = int(len(GetDirList))
+        fnumfiles = format(numfiles, 'x').lower()
+        AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
+        try:
+            fp.flush()
+            if(hasattr(os, "sync")):
+                os.fsync(fp.fileno())
+        except (io.UnsupportedOperation, AttributeError, OSError):
+            pass
+        for curfname in GetDirList:
+            tmpoutlist = curfname['fheaders']
+            AppendFileHeaderWithContent(fp, tmpoutlist, curfname['fextradata'], curfname['fjsoncontent'], curfname['fcontents'], [curfname['fheaderchecksumtype'], curfname['fcontentchecksumtype'], curfname['fjsonchecksumtype']], formatspecs, saltkey)
             try:
                 fp.flush()
                 if(hasattr(os, "sync")):
                     os.fsync(fp.fileno())
             except (io.UnsupportedOperation, AttributeError, OSError):
                 pass
-            fcontents.close()
         return fp
 
 if(not py7zr_support):
-    def AppendFilesWithContentFromSevenZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False):
+    def sevenzip_readall(infile, **kwargs):
         return False
 else:
-    def AppendFilesWithContentFromSevenZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False):
-        if(not hasattr(fp, "write")):
-            return False
-        if(verbose):
-            logging.basicConfig(format="%(message)s",
-                                stream=PY_STDOUT_TEXT, level=logging.DEBUG)
+    class _MemoryIO(py7zr.Py7zIO):
+        """In-memory file object used by py7zr's factory API."""
+        def __init__(self):
+            self._buf = bytearray()
+        def write(self, data):
+            # py7zr will call this repeatedly with chunks
+            self._buf.extend(data)
+        def read(self, size=None):
+            if size is None:
+                return bytes(self._buf)
+            return bytes(self._buf[:size])
+        def seek(self, offset, whence=0):
+            # we don't really need seeking for your use case
+            return 0
+        def flush(self):
+            pass
+        def size(self):
+            return len(self._buf)
+    class _MemoryFactory(py7zr.WriterFactory):
+        """Factory that creates _MemoryIO objects and keeps them by filename."""
+        def __init__(self):
+            self.files = {}
+        def create(self, filename: str) -> py7zr.Py7zIO:
+            io_obj = _MemoryIO()
+            self.files[filename] = io_obj
+            return io_obj
+    def sevenzip_readall(infile, **kwargs):
+        """
+        Replacement for SevenZipFile.readall() using the new py7zr API.
+
+        Returns: dict[filename -> _MemoryIO]
+        """
+        factory = _MemoryFactory()
+        with py7zr.SevenZipFile(infile, mode="r", **kwargs) as archive:
+            archive.extractall(factory=factory)
+        return factory.files
+
+if(not py7zr_support):
+    def AppendFilesWithContentFromSevenZipFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+        return False
+    def AppendFilesWithContentFromSevenZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+        return False
+else:
+    def AppendFilesWithContentFromSevenZipFileToList(infile, extradata=[], jsondata={}, contentasfile=False, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
         formver = formatspecs['format_ver']
         fileheaderver = str(int(formver.replace(".", "")))
         curinode = 0
@@ -6844,19 +7575,15 @@ else:
         if(not os.path.exists(infile) or not os.path.isfile(infile)):
             return False
         szpfp = py7zr.SevenZipFile(infile, mode="r")
-        file_content = szpfp.readall()
+        try:
+            file_content = szpfp.readall()
+        except AttributeError:
+            file_content = sevenzip_readall(infile)
         #sztest = szpfp.testzip()
         sztestalt = szpfp.test()
         if(sztestalt):
             VerbosePrintOut("Bad file found!")
-        numfiles = int(len(szpfp.list()))
-        AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs)
-        try:
-            fp.flush()
-            if(hasattr(os, "sync")):
-                os.fsync(fp.fileno())
-        except (io.UnsupportedOperation, AttributeError, OSError):
-            pass
+        tmpoutlist = []
         for member in sorted(szpfp.list(), key=lambda x: x.filename):
             fencoding = "UTF-8"
             if(re.findall("^[.|/]", member.filename)):
@@ -6873,6 +7600,9 @@ else:
             fcompression = ""
             fcsize = format(int(0), 'x').lower()
             flinkcount = 0
+            fblksize = 0
+            fblocks = 0
+            fflags = 0
             ftype = 0
             if(member.is_directory):
                 ftype = 5
@@ -6883,14 +7613,13 @@ else:
             fcurinode = format(int(curfid), 'x').lower()
             curfid = curfid + 1
             fdev = format(int(0), 'x').lower()
-            fdev_minor = format(int(0), 'x').lower()
-            fdev_major = format(int(0), 'x').lower()
+            frdev = format(int(0), 'x').lower()
             if(ftype == 5):
                 fsize = format(int("0"), 'x').lower()
-            fatime = format(int(member.creationtime.timestamp()), 'x').lower()
-            fmtime = format(int(member.creationtime.timestamp()), 'x').lower()
-            fctime = format(int(member.creationtime.timestamp()), 'x').lower()
-            fbtime = format(int(member.creationtime.timestamp()), 'x').lower()
+            fatime = format(int(to_ns(member.creationtime.timestamp())), 'x').lower()
+            fmtime = format(int(to_ns(member.creationtime.timestamp())), 'x').lower()
+            fctime = format(int(to_ns(member.creationtime.timestamp())), 'x').lower()
+            fbtime = format(int(to_ns(member.creationtime.timestamp())), 'x').lower()
             if(member.is_directory):
                 fmode = format(int(stat.S_IFDIR | 0x1ff), 'x').lower()
                 fchmode = format(
@@ -6940,7 +7669,10 @@ else:
                 typechecktest = CheckCompressionType(fcontents, filestart=0, closefp=False)
                 fcontents.seek(0, 0)
                 fcencoding = GetFileEncoding(fcontents, 0, False)[0]
-                file_content[member.filename].close()
+                try:
+                    file_content[member.filename].close()
+                except AttributeError:
+                    pass
                 if(typechecktest is False and not compresswholefile):
                     fcontents.seek(0, 2)
                     ucfsize = fcontents.tell()
@@ -6982,25 +7714,39 @@ else:
             if(fcompression == "none"):
                 fcompression = ""
             fcontents.seek(0, 0)
+            if(not contentasfile):
+                fcontents = fcontents.read()
             ftypehex = format(ftype, 'x').lower()
-            tmpoutlist = [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
-                          fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, fdev_minor, fdev_major, "+"+str(len(formatspecs['format_delimiter']))]
-            AppendFileHeaderWithContent(
-                fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs)
+            tmpoutlist.append({'fheaders': [ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression,
+                               fcsize, fuid, funame, fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, "+"+str(len(formatspecs['format_delimiter']))], 'fextradata': extradata, 'fjsoncontent': jsondata, 'fcontents': fcontents, 'fjsonchecksumtype': checksumtype[2], 'fheaderchecksumtype': checksumtype[0], 'fcontentchecksumtype': checksumtype[1]})
+        return tmpoutlist
+    def AppendFilesWithContentFromSevenZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+        if(not hasattr(fp, "write")):
+            return False
+        GetDirList = AppendFilesWithContentFromSevenZipFileToList(infile, extradata, jsondata, False, compression, compresswholefile, compressionlevel, compressionuselist, [checksumtype[2], checksumtype[3], checksumtype[3]], formatspecs, saltkey, verbose)
+        numfiles = int(len(GetDirList))
+        fnumfiles = format(numfiles, 'x').lower()
+        AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
+        try:
+            fp.flush()
+            if(hasattr(os, "sync")):
+                os.fsync(fp.fileno())
+        except (io.UnsupportedOperation, AttributeError, OSError):
+            pass
+        for curfname in GetDirList:
+            tmpoutlist = curfname['fheaders']
+            AppendFileHeaderWithContent(fp, tmpoutlist, curfname['fextradata'], curfname['fjsoncontent'], curfname['fcontents'], [curfname['fheaderchecksumtype'], curfname['fcontentchecksumtype'], curfname['fjsonchecksumtype']], formatspecs, saltkey)
             try:
                 fp.flush()
                 if(hasattr(os, "sync")):
                     os.fsync(fp.fileno())
             except (io.UnsupportedOperation, AttributeError, OSError):
                 pass
-            fcontents.close()
         return fp
 
-def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False):
+def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
     if(not hasattr(fp, "write")):
         return False
-    if(verbose):
-        logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
     GetDirList = inlist
     if(not GetDirList):
         return False
@@ -7012,7 +7758,7 @@ def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, extradata=[], jsond
     inodetoforminode = {}
     numfiles = int(len(GetDirList))
     fnumfiles = format(numfiles, 'x').lower()
-    AppendFileHeader(fp, numfiles, "UTF-8", [], [checksumtype[0], checksumtype[1]], formatspecs)
+    AppendFileHeader(fp, numfiles, "UTF-8", [], [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
     for curfname in GetDirList:
         ftype = format(curfname[0], 'x').lower()
         fencoding = curfname[1]
@@ -7026,44 +7772,45 @@ def AppendListsWithContent(inlist, fp, dirlistfromtxt=False, extradata=[], jsond
         fbasedir = os.path.dirname(fname)
         flinkname = curfname[4]
         fsize = format(curfname[5], 'x').lower()
-        fatime = format(curfname[6], 'x').lower()
-        fmtime = format(curfname[7], 'x').lower()
-        fctime = format(curfname[8], 'x').lower()
-        fbtime = format(curfname[9], 'x').lower()
-        fmode = format(curfname[10], 'x').lower()
-        fwinattributes = format(curfname[11], 'x').lower()
-        fcompression = curfname[12]
-        fcsize = format(curfname[13], 'x').lower()
-        fuid = format(curfname[14], 'x').lower()
-        funame = curfname[15]
-        fgid = format(curfname[16], 'x').lower()
-        fgname = curfname[17]
-        fid = format(curfname[18], 'x').lower()
-        finode = format(curfname[19], 'x').lower()
-        flinkcount = format(curfname[20], 'x').lower()
-        fdev = format(curfname[21], 'x').lower()
-        fdev_minor = format(curfname[22], 'x').lower()
-        fdev_major = format(curfname[23], 'x').lower()
-        fseeknextfile = curfname[24]
-        extradata = curfname[25]
-        fheaderchecksumtype = curfname[26]
-        fcontentchecksumtype = curfname[27]
-        fcontents = curfname[28]
+        fblksize = format(curfname[6], 'x').lower()
+        fblocks = format(curfname[7], 'x').lower()
+        fflags = format(curfname[8], 'x').lower()
+        fatime = format(curfname[9], 'x').lower()
+        fmtime = format(curfname[10], 'x').lower()
+        fctime = format(curfname[11], 'x').lower()
+        fbtime = format(curfname[12], 'x').lower()
+        fmode = format(curfname[13], 'x').lower()
+        fwinattributes = format(curfname[14], 'x').lower()
+        fcompression = curfname[15]
+        fcsize = format(curfname[16], 'x').lower()
+        fuid = format(curfname[17], 'x').lower()
+        funame = curfname[18]
+        fgid = format(curfname[19], 'x').lower()
+        fgname = curfname[20]
+        fid = format(curfname[21], 'x').lower()
+        finode = format(curfname[22], 'x').lower()
+        flinkcount = format(curfname[23], 'x').lower()
+        fdev = format(curfname[24], 'x').lower()
+        frdev = format(curfname[25], 'x').lower()
+        fseeknextfile = curfname[26]
+        extradata = curfname[27]
+        fheaderchecksumtype = curfname[28]
+        fcontentchecksumtype = curfname[29]
+        fcontents = curfname[30]
         fencoding = GetFileEncoding(fcontents, 0, False)[0]
-        tmpoutlist = [ftype, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression, fcsize,
-                      fuid, funame, fgid, fgname, fid, finode, flinkcount, fdev, fdev_minor, fdev_major, fseeknextfile]
+        tmpoutlist = [ftype, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime, fctime, fbtime, fmode, fwinattributes, fcompression, fcsize,
+                      fuid, funame, fgid, fgname, fid, finode, flinkcount, fdev, frdev, fseeknextfile]
         fcontents.seek(0, 0)
-        AppendFileHeaderWithContent(
-            fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs)
+        AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, saltkey)
     return fp
 
 
-def AppendInFileWithContent(infile, fp, dirlistfromtxt=False, extradata=[], jsondata={}, followlink=False, checksumtype=["md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False):
-    inlist = ReadInFileWithContentToList(infile, "auto", 0, 0, False, False, True, False, formatspecs)
-    return AppendListsWithContent(inlist, fp, dirlistfromtxt, extradata, jsondata, followlink, checksumtype, formatspecs, verbose)
+def AppendInFileWithContent(infile, fp, dirlistfromtxt=False, extradata=[], jsondata={}, followlink=False, checksumtype=["md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False):
+    inlist = ReadInFileWithContentToList(infile, "auto", 0, 0, False, False, True, False, formatspecs, saltkey, False)
+    return AppendListsWithContent(inlist, fp, dirlistfromtxt, extradata, jsondata, followlink, checksumtype, formatspecs, saltkey, verbose)
 
 
-def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
     if(IsNestedDict(formatspecs) and fmttype=="auto" and 
         (outfile != "-" and outfile is not None and not hasattr(outfile, "read") and not hasattr(outfile, "write"))):
         get_in_ext = os.path.splitext(outfile)
@@ -7107,8 +7854,7 @@ def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmtt
             fp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
         except PermissionError:
             return False
-    AppendFilesWithContent(infiles, fp, dirlistfromtxt, extradata, jsondata, compression,
-                                   compresswholefile, compressionlevel, compressionuselist, followlink, checksumtype, formatspecs, verbose)
+    AppendFilesWithContent(infiles, fp, dirlistfromtxt, extradata, jsondata, compression, compresswholefile, compressionlevel, compressionuselist, followlink, checksumtype, formatspecs, saltkey, verbose)
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -7137,12 +7883,12 @@ def AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt=False, fmtt
         fp.close()
         return True
 
-def AppendFilesWithContentToStackedOutFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+def AppendFilesWithContentToStackedOutFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
     if not isinstance(infiles, list):
         infiles = [infiles]
     returnout = False
     for infileslist in infiles:
-        returnout = AppendFilesWithContentToOutFile(infileslist, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, followlink, checksumtype, formatspecs, verbose, True)
+        returnout = AppendFilesWithContentToOutFile(infileslist, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, followlink, checksumtype, formatspecs, saltkey, verbose, True)
         if(not returnout):
             break
         else:
@@ -7152,7 +7898,7 @@ def AppendFilesWithContentToStackedOutFile(infiles, outfile, dirlistfromtxt=Fals
         return True
     return returnout
 
-def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, extradata=[], jsondata={}, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
+def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, extradata=[], jsondata={}, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False, saltkey=None, returnfp=False):
     if(IsNestedDict(formatspecs) and fmttype=="auto" and 
         (outfile != "-" and outfile is not None and not hasattr(outfile, "read") and not hasattr(outfile, "write"))):
         get_in_ext = os.path.splitext(outfile)
@@ -7193,8 +7939,7 @@ def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmtty
             fp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
         except PermissionError:
             return False
-    AppendListsWithContent(inlist, fp, dirlistfromtxt, extradata, jsondata, compression,
-                                   compresswholefile, compressionlevel, followlink, checksumtype, formatspecs, verbose)
+    AppendListsWithContent(inlist, fp, dirlistfromtxt, extradata, jsondata, compression, compresswholefile, compressionlevel, followlink, checksumtype, formatspecs, saltkey, verbose)
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -7224,7 +7969,7 @@ def AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt=False, fmtty
         fp.close()
         return True
 
-def AppendFilesWithContentFromTarFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+def AppendFilesWithContentFromTarFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
     if(IsNestedDict(formatspecs) and fmttype=="auto" and 
         (outfile != "-" and outfile is not None and not hasattr(outfile, "read") and not hasattr(outfile, "write"))):
         get_in_ext = os.path.splitext(outfile)
@@ -7266,8 +8011,7 @@ def AppendFilesWithContentFromTarFileToOutFile(infiles, outfile, fmttype="auto",
             fp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
         except PermissionError:
             return False
-    AppendFilesWithContentFromTarFile(infiles, fp, extradata, jsondata, compression,
-                                   compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, verbose)
+    AppendFilesWithContentFromTarFile(infiles, fp, extradata, jsondata, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, saltkey, verbose)
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -7297,12 +8041,12 @@ def AppendFilesWithContentFromTarFileToOutFile(infiles, outfile, fmttype="auto",
         fp.close()
         return True
 
-def AppendFilesWithContentFromTarFileToStackedOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+def AppendFilesWithContentFromTarFileToStackedOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
     if not isinstance(infiles, list):
         infiles = [infiles]
     returnout = False
     for infileslist in infiles:
-        returnout = AppendFilesWithContentFromTarFileToOutFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, True)
+        returnout = AppendFilesWithContentFromTarFileToOutFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, saltkey, verbose, True)
         if(not returnout):
             break
         else:
@@ -7312,7 +8056,7 @@ def AppendFilesWithContentFromTarFileToStackedOutFile(infiles, outfile, fmttype=
         return True
     return returnout
 
-def AppendFilesWithContentFromZipFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+def AppendFilesWithContentFromZipFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
     if(IsNestedDict(formatspecs) and fmttype=="auto" and 
         (outfile != "-" and outfile is not None and not hasattr(outfile, "read") and not hasattr(outfile, "write"))):
         get_in_ext = os.path.splitext(outfile)
@@ -7354,8 +8098,7 @@ def AppendFilesWithContentFromZipFileToOutFile(infiles, outfile, fmttype="auto",
             fp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
         except PermissionError:
             return False
-    AppendFilesWithContentFromZipFile(infiles, fp, extradata, jsondata, compression,
-                                   compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, verbose)
+    AppendFilesWithContentFromZipFile(infiles, fp, extradata, jsondata, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, saltkey, verbose)
     if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
         fp = CompressOpenFileAlt(
             fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -7385,12 +8128,12 @@ def AppendFilesWithContentFromZipFileToOutFile(infiles, outfile, fmttype="auto",
         fp.close()
         return True
 
-def AppendFilesWithContentFromZipFileToStackedOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+def AppendFilesWithContentFromZipFileToStackedOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
     if not isinstance(infiles, list):
         infiles = [infiles]
     returnout = False
     for infileslist in infiles:
-        returnout = AppendFilesWithContentFromZipFileToOutFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, True)
+        returnout = AppendFilesWithContentFromZipFileToOutFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, saltkey, verbose, True)
         if(not returnout):
             break
         else:
@@ -7401,10 +8144,10 @@ def AppendFilesWithContentFromZipFileToStackedOutFile(infiles, outfile, fmttype=
     return returnout
 
 if(not rarfile_support):
-    def AppendFilesWithContentFromRarFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+    def AppendFilesWithContentFromRarFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
         return False
 else:
-    def AppendFilesWithContentFromRarFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+    def AppendFilesWithContentFromRarFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
         if(IsNestedDict(formatspecs) and fmttype=="auto" and 
             (outfile != "-" and outfile is not None and not hasattr(outfile, "read") and not hasattr(outfile, "write"))):
             get_in_ext = os.path.splitext(outfile)
@@ -7446,8 +8189,7 @@ else:
                 fp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
             except PermissionError:
                 return False
-        AppendFilesWithContentFromRarFile(infiles, fp, extradata, jsondata, compression,
-                                       compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, verbose)
+        AppendFilesWithContentFromRarFile(infiles, fp, extradata, jsondata, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, saltkey, verbose)
         if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = CompressOpenFileAlt(
                 fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -7477,12 +8219,12 @@ else:
             fp.close()
             return True
 
-def AppendFilesWithContentFromRarFileToStackedOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+def AppendFilesWithContentFromRarFileToStackedOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
     if not isinstance(infiles, list):
         infiles = [infiles]
     returnout = False
     for infileslist in infiles:
-        returnout = AppendFilesWithContentFromRarFileToOutFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, True)
+        returnout = AppendFilesWithContentFromRarFileToOutFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, saltkey, verbose, True)
         if(not returnout):
             break
         else:
@@ -7493,10 +8235,10 @@ def AppendFilesWithContentFromRarFileToStackedOutFile(infiles, outfile, fmttype=
     return returnout
 
 if(not py7zr_support):
-    def AppendFilesWithContentFromSevenZipFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+    def AppendFilesWithContentFromSevenZipFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
         return False
 else:
-    def AppendFilesWithContentFromSevenZipFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+    def AppendFilesWithContentFromSevenZipFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
         if(IsNestedDict(formatspecs) and fmttype=="auto" and 
             (outfile != "-" and outfile is not None and not hasattr(outfile, "read") and not hasattr(outfile, "write"))):
             get_in_ext = os.path.splitext(outfile)
@@ -7538,8 +8280,7 @@ else:
                 fp = CompressOpenFile(outfile, compresswholefile, compressionlevel)
             except PermissionError:
                 return False
-        AppendFilesWithContentFromSevenZipFile(infiles, fp, extradata, jsondata, compression,
-                                       compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, verbose)
+        AppendFilesWithContentFromSevenZipFile(infiles, fp, extradata, jsondata, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, saltkey, verbose)
         if(outfile == "-" or outfile is None or hasattr(outfile, "read") or hasattr(outfile, "write")):
             fp = CompressOpenFileAlt(
                 fp, compression, compressionlevel, compressionuselist, formatspecs)
@@ -7569,12 +8310,12 @@ else:
             fp.close()
             return True
 
-def AppendFilesWithContentFromSevenZipFileToStackedOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
+def AppendFilesWithContentFromSevenZipFileToStackedOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
     if not isinstance(infiles, list):
         infiles = [infiles]
     returnout = False
     for infileslist in infiles:
-        returnout = AppendFilesWithContentFromSevenZipFileToOutFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, True)
+        returnout = AppendFilesWithContentFromSevenZipFileToOutFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, saltkey, verbose, True)
         if(not returnout):
             break
         else:
@@ -7584,9 +8325,9 @@ def AppendFilesWithContentFromSevenZipFileToStackedOutFile(infiles, outfile, fmt
         return True
     return returnout
 
-def AppendInFileWithContentToOutFile(infile, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, extradata=[], jsondata={}, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-    inlist = ReadInFileWithContentToList(infile, "auto", 0, 0, False, False, True, False, formatspecs)
-    return AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, extradata, jsondata, followlink, checksumtype, formatspecs, verbose, returnfp)
+def AppendInFileWithContentToOutFile(infile, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, extradata=[], jsondata={}, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, saltkey=None, verbose=False, returnfp=False):
+    inlist = ReadInFileWithContentToList(infile, "auto", 0, 0, False, False, True, False, formatspecs, saltkey, False)
+    return AppendListsWithContentToOutFile(inlist, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, extradata, jsondata, followlink, checksumtype, formatspecs, saltkey, verbose, returnfp)
 
 
 def PrintPermissionString(fchmode, ftype):
@@ -8270,10 +9011,8 @@ def CheckCompressionSubType(infile, formatspecs=__file_format_multi_dict__, file
             elif(compresscheck == "lz4" and compresscheck in compressionsupport):
                 fp = lz4.frame.open(infile, "rb")
             elif(compresscheck == "zstd" and compresscheck in compressionsupport):
-                if 'zstandard' in sys.modules:
-                    fp = ZstdFile(infile, mode="rb")
-                elif 'pyzstd' in sys.modules:
-                    fp = pyzstd.zstdfile.ZstdFile(infile, mode="rb")
+                if 'zstd' in compressionsupport:
+                    fp = zstd.ZstdFile(infile, mode="rb")
                 else:
                     return Flase
             elif((compresscheck == "lzma" or compresscheck == "xz") and compresscheck in compressionsupport):
@@ -8390,10 +9129,8 @@ def UncompressFileAlt(fp, formatspecs=__file_format_multi_dict__, filestart=0,
     elif kind in ("lzma","xz") and (("lzma" in compressionsupport) or ("xz" in compressionsupport)):
         wrapped = lzma.LZMAFile(src)
     elif kind == "zstd"   and ("zstd" in compressionsupport or "zstandard" in compressionsupport):
-        if 'zstandard' in sys.modules:
-            wrapped = ZstdFile(fileobj=src, mode="rb")
-        elif 'pyzstd' in sys.modules:
-            wrapped = pyzstd.zstdfile.ZstdFile(fileobj=src, mode="rb")
+        if 'zstd' in compressionsupport:
+            wrapped = zstd.ZstdFile(src, mode="rb")
         else:
             return False
     elif kind == "lz4"    and "lz4"    in compressionsupport:
@@ -8461,10 +9198,8 @@ def UncompressFile(infile, formatspecs=__file_format_multi_dict__, mode="rb",
         elif (compresscheck == "bzip2" and "bzip2" in compressionsupport):
             fp = bz2.open(infile, mode)
         elif (compresscheck == "zstd" and "zstandard" in compressionsupport):
-            if 'zstandard' in sys.modules:
-                fp = ZstdFile(infile, mode=mode)
-            elif 'pyzstd' in sys.modules:
-                fp = pyzstd.zstdfile.ZstdFile(infile, mode=mode)
+            if 'zstd' in compressionsupport:
+                fp = zstd.ZstdFile(infile, mode=mode)
             else:
                 return False
         elif (compresscheck == "lz4" and "lz4" in compressionsupport):
@@ -9233,10 +9968,8 @@ def CompressOpenFile(outfile, compressionenable=True, compressionlevel=None,
             outfp = FileLikeAdapter(bz2.open(outfile, mode, compressionlevel), mode="wb")
 
         elif (fextname == ".zst" and "zstandard" in compressionsupport):
-            if 'zstandard' in sys.modules:
-                outfp = FileLikeAdapter(ZstdFile(outfile, mode=mode, level=compressionlevel), mode="wb")
-            elif 'pyzstd' in sys.modules:
-                outfp = FileLikeAdapter(pyzstd.zstdfile.ZstdFile(outfile, mode=mode, level=compressionlevel), mode="wb")
+            if 'zstd' in compressionsupport:
+                outfp = FileLikeAdapter(zstd.ZstdFile(outfile, mode=mode, level=compressionlevel), mode="wb")
             else:
                 return False  # fix: 'Flase' -> False
 
@@ -9327,56 +10060,54 @@ def CheckSumSupport(checkfor, guaranteed=True):
         return False
 
 
-def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
-        return AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, followlink, checksumtype, formatspecs, verbose, returnfp)
+def PackArchiveFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
+        return AppendFilesWithContentToOutFile(infiles, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, followlink, checksumtype, formatspecs, saltkey, verbose, returnfp)
 
-def PackStackedArchiveFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_multi_dict__, verbose=False, returnfp=False):
-        return AppendFilesWithContentToStackedOutFile(infiles, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, followlink, checksumtype, formatspecs, verbose, returnfp)
+def PackStackedArchiveFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_multi_dict__, saltkey=None, verbose=False, returnfp=False):
+        return AppendFilesWithContentToStackedOutFile(infiles, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, followlink, checksumtype, formatspecs, saltkey, verbose, returnfp)
 
-def PackArchiveFileFromDirList(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-    return PackArchiveFile(infiles, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, checksumtype, extradata, formatspecs, verbose, returnfp)
+def PackArchiveFileFromDirList(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], formatspecs=__file_format_dict__, saltkey=None, verbose=False, returnfp=False):
+    return PackArchiveFile(infiles, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, checksumtype, extradata, formatspecs, saltkey, verbose, returnfp)
 
 
-def PackArchiveFileFromTarFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-    return AppendFilesWithContentFromTarFileToOutFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, returnfp)
+def PackArchiveFileFromTarFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, saltkey=None, verbose=False, returnfp=False):
+    return AppendFilesWithContentFromTarFileToOutFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, saltkey, verbose, returnfp)
 
 
-def PackArchiveFileFromZipFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-    return AppendFilesWithContentFromZipFileToOutFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, returnfp)
+def PackArchiveFileFromZipFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, saltkey=None, verbose=False, returnfp=False):
+    return AppendFilesWithContentFromZipFileToOutFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, saltkey, verbose, returnfp)
 
 
 if(not rarfile_support):
-    def PackArchiveFileFromRarFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
+    def PackArchiveFileFromRarFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, saltkey=None, verbose=False, returnfp=False):
         return False
 else:
-    def PackArchiveFileFromRarFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-        return AppendFilesWithContentFromRarFileToOutFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, returnfp)
+    def PackArchiveFileFromRarFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, saltkey=None, verbose=False, returnfp=False):
+        return AppendFilesWithContentFromRarFileToOutFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, saltkey, verbose, returnfp)
 
 
 if(not py7zr_support):
-    def PackArchiveFileFromSevenZipFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
+    def PackArchiveFileFromSevenZipFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], formatspecs=__file_format_dict__, saltkey=None, verbose=False, returnfp=False):
         return False
 else:
-    def PackArchiveFileFromSevenZipFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-        return AppendFilesWithContentFromSevenZipFileToOutFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, verbose, returnfp)
+    def PackArchiveFileFromSevenZipFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, saltkey=None, verbose=False, returnfp=False):
+        return AppendFilesWithContentFromSevenZipFileToOutFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, extradata, jsondata, checksumtype, formatspecs, saltkey, verbose, returnfp)
 
 
-def PackArchiveFileFromInFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
+def PackArchiveFileFromInFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, saltkey=None, verbose=False, returnfp=False):
     checkcompressfile = CheckCompressionSubType(infile, formatspecs, 0, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
-    if(verbose):
-        logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
     if(checkcompressfile == "tarfile" and TarFileCheck(infile)):
-        return PackArchiveFileFromTarFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, verbose, returnfp)
+        return PackArchiveFileFromTarFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, saltkey, verbose, returnfp)
     elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-        return PackArchiveFileFromZipFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, verbose, returnfp)
+        return PackArchiveFileFromZipFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, saltkey, verbose, returnfp)
     elif(rarfile_support and checkcompressfile == "rarfile" and (rarfile.is_rarfile(infile) or rarfile.is_rarfile_sfx(infile))):
-        return PackArchiveFileFromRarFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, verbose, returnfp)
+        return PackArchiveFileFromRarFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, saltkey, verbose, returnfp)
     elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
-        return PackArchiveFileFromSevenZipFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, verbose, returnfp)
+        return PackArchiveFileFromSevenZipFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, saltkey, verbose, returnfp)
     elif(IsSingleDict(formatspecs) and checkcompressfile == formatspecs['format_magic']):
-        return RePackArchiveFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, False, 0, 0, checksumtype, False, extradata, jsondata, formatspecs, verbose, returnfp)
+        return RePackArchiveFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, False, 0, 0, checksumtype, False, extradata, jsondata, formatspecs, saltkey, verbose, returnfp)
     else:
         return False
     return False
@@ -9445,19 +10176,12 @@ def ArchiveFileArrayValidate(listarrayfiles, verbose=False):
             ok = False
     return ok
 
-def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
-                        formatspecs=__file_format_multi_dict__,  # keep default like original
-                        seektoend=False, verbose=False, returnfp=False):
-    if(verbose):
-        logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
-
+def ArchiveFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
     if(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype in formatspecs):
         formatspecs = formatspecs[fmttype]
     elif(IsNestedDict(formatspecs) and fmttype!="auto" and fmttype not in formatspecs):
         fmttype = "auto"
-
     curloc = filestart
-
     if(hasattr(infile, "read") or hasattr(infile, "write")):
         curloc = infile.tell()
         fp = infile
@@ -9473,7 +10197,6 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
         if(not fp):
             return False
         fp.seek(filestart, 0)
-
     elif(infile == "-"):
         fp = MkTempFile()
         shutil.copyfileobj(PY_STDIN_BUF, fp, length=__filebuff_size__)
@@ -9485,7 +10208,6 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
         if(not fp):
             return False
         fp.seek(filestart, 0)
-
     elif(isinstance(infile, bytes) and sys.version_info[0] >= 3):
         fp = MkTempFile()
         fp.write(infile)
@@ -9497,7 +10219,6 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
         if(not fp):
             return False
         fp.seek(filestart, 0)
-
     elif(re.findall(__download_proto_support__, infile)):
         fp = download_file_from_internet_file(infile)
         fp = UncompressFileAlt(fp, formatspecs, filestart)
@@ -9508,7 +10229,6 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
         if(not fp):
             return False
         fp.seek(filestart, 0)
-
     else:
         infile = RemoveWindowsPath(infile)
         checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
@@ -9555,11 +10275,9 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
         fp.seek(0, 2)
     except (OSError, ValueError):
         SeekToEndOfFile(fp)
-
     CatSize = fp.tell()
     CatSizeEnd = CatSize
     fp.seek(curloc, 0)
-
     if(IsNestedDict(formatspecs)):
         compresschecking = CheckCompressionType(fp, formatspecs, filestart, False)
         if(compresschecking not in formatspecs):
@@ -9567,54 +10285,36 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
         else:
             formatspecs = formatspecs[compresschecking]
             fp.seek(filestart, 0)
-
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
+    headeroffset = fp.tell()
     formstring = fp.read(formatspecs['format_len'] + len(inheaderver)).decode("UTF-8")
     formdelsize = len(formatspecs['format_delimiter'])
     formdel = fp.read(formdelsize).decode("UTF-8")
-
     if(formstring != formatspecs['format_magic'] + inheaderver):
         return False
     if(formdel != formatspecs['format_delimiter']):
         return False
-
-    if(formatspecs['new_style']):
+    if(__use_new_style__):
         inheader = ReadFileHeaderDataBySize(fp, formatspecs['format_delimiter'])
     else:
         inheader = ReadFileHeaderDataWoSize(fp, formatspecs['format_delimiter'])
-
-    fnumextrafieldsize = int(inheader[13], 16)
-    fnumextrafields = int(inheader[14], 16)
-    extrastart = 15
+    fnumextrafieldsize = int(inheader[15], 16)
+    fnumextrafields = int(inheader[16], 16)
+    extrastart = 17
     extraend = extrastart + fnumextrafields
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
-    fnumfiles = int(inheader[6], 16)
+    fnumfiles = int(inheader[8], 16)
     fprechecksumtype = inheader[-2]
     fprechecksum = inheader[-1]
-    outfseeknextfile = inheader[7]
-    fjsonsize = int(inheader[10], 16)
-    fjsonchecksumtype = inheader[11]
-    fjsonchecksum = inheader[12]
+    outfseeknextfile = inheader[9]
+    fjsonsize = int(inheader[12], 16)
+    fjsonchecksumtype = inheader[13]
+    fjsonchecksum = inheader[14]
+    headerjsonoffset = fp.tell()
     fprejsoncontent = fp.read(fjsonsize)
-    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs)
-    if(fjsonsize > 0):
-        if(hmac.compare_digest(jsonfcs, fjsonchecksum)):
-            if(verbose):
-                VerbosePrintOut("File JSON Data Checksum Passed at offset " + str(outfjstart))
-                VerbosePrintOut("'" + outfjsonchecksum + "' == " + "'" + injsonfcs + "'")
-        else:
-            valid_archive = False
-            invalid_archive = True
-            if(verbose):
-                VerbosePrintOut("File JSON Data Checksum Error at offset " + str(outfjstart))
-                VerbosePrintOut("'" + outfjsonchecksum + "' != " + "'" + injsonfcs + "'")
-    if(not hmac.compare_digest(fjsonchecksum, jsonfcs) and not skipchecksum):
-        VerbosePrintOut("File JSON Data Checksum Error with file " +
-                        fname + " at offset " + str(fheaderstart))
-        VerbosePrintOut("'" + fjsonchecksum + "' != " + "'" + jsonfcs + "'")
-        return False
+    jsonfcs = GetFileChecksum(fprejsoncontent, fjsonchecksumtype, True, formatspecs, saltkey)
     # Next seek directive
     if(re.findall(r"^\+([0-9]+)", outfseeknextfile)):
         fseeknextasnum = int(outfseeknextfile.replace("+", ""))
@@ -9633,14 +10333,11 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
         fp.seek(fseeknextasnum, 0)
     else:
         return False
-
     il = 0
-    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs)
-    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs)
-
+    headercheck = ValidateHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, fprechecksum, formatspecs, saltkey)
+    newfcs = GetHeaderChecksum([formstring] + inheader[:-1], fprechecksumtype, True, formatspecs, saltkey)
     valid_archive = True
     invalid_archive = False
-
     if(verbose):
         if(hasattr(infile, "read") or hasattr(infile, "write")):
             try:
@@ -9652,78 +10349,56 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
         else:
             VerbosePrintOut(infile)
         VerbosePrintOut("Number of Records " + str(fnumfiles))
-
     if(headercheck):
         if(verbose):
-            VerbosePrintOut("File Header Checksum Passed at offset " + str(0))
+            VerbosePrintOut("File Header Checksum Passed at offset " + str(headeroffset))
             VerbosePrintOut("'" + fprechecksum + "' == " + "'" + newfcs + "'")
     else:
         # always flip flags, even when not verbose
         valid_archive = False
         invalid_archive = True
         if(verbose):
-            VerbosePrintOut("File Header Checksum Failed at offset " + str(0))
+            VerbosePrintOut("File Header Checksum Failed at offset " + str(headeroffset))
             VerbosePrintOut("'" + fprechecksum + "' != " + "'" + newfcs + "'")
-
+    if(fjsonsize > 0):
+        if(CheckChecksums(jsonfcs, fjsonchecksum)):
+            if(verbose):
+                VerbosePrintOut("File JSON Data Checksum Passed at offset " + str(headerjsonoffset))
+                VerbosePrintOut("'" + outfjsonchecksum + "' == " + "'" + injsonfcs + "'")
+        else:
+            valid_archive = False
+            invalid_archive = True
+            if(verbose):
+                VerbosePrintOut("File JSON Data Checksum Error at offset " + str(headerjsonoffset))
+                VerbosePrintOut("'" + outfjsonchecksum + "' != " + "'" + injsonfcs + "'")
     if(verbose):
         VerbosePrintOut("")
-
     # Iterate either until EOF (seektoend) or fixed count
     while (fp.tell() < CatSizeEnd) if seektoend else (il < fnumfiles):
         outfhstart = fp.tell()
-        if(formatspecs['new_style']):
+        if(__use_new_style__):
             inheaderdata = ReadFileHeaderDataBySize(fp, formatspecs['format_delimiter'])
         else:
             inheaderdata = ReadFileHeaderDataWoSize(fp, formatspecs['format_delimiter'])
 
         if(len(inheaderdata) == 0):
             break
-
-        outfheadsize = int(inheaderdata[0], 16)
-        outfnumfields = int(inheaderdata[1], 16)
-        outftype = int(inheaderdata[2], 16)
-        # FIX: these must come from inheaderdata, not inheader
-        outfostype = inheaderdata[3]
-        outfencoding = inheaderdata[4]
-
         if(re.findall("^[.|/]", inheaderdata[5])):
             outfname = inheaderdata[5]
         else:
             outfname = "./" + inheaderdata[5]
         outfbasedir = os.path.dirname(outfname)
-
-        outflinkname = inheaderdata[6]
         outfsize = int(inheaderdata[7], 16)
-        outfatime = int(inheaderdata[8], 16)
-        outfmtime = int(inheaderdata[9], 16)
-        outfctime = int(inheaderdata[10], 16)
-        outfbtime = int(inheaderdata[11], 16)
-        outfmode = int(inheaderdata[12], 16)
-        outfchmode = stat.S_IMODE(outfmode)
-        outftypemod = stat.S_IFMT(outfmode)
-        outfwinattributes = int(inheaderdata[13], 16)
-        outfcompression = inheaderdata[14]
-        outfcsize = int(inheaderdata[15], 16)
-        outfuid = int(inheaderdata[16], 16)
-        outfuname = inheaderdata[17]
-        outfgid = int(inheaderdata[18], 16)
-        outfgname = inheaderdata[19]
-        fid = int(inheaderdata[20], 16)
-        finode = int(inheaderdata[21], 16)
-        flinkcount = int(inheaderdata[22], 16)
-        outfdev = int(inheaderdata[23], 16)
-        outfdev_minor = int(inheaderdata[24], 16)
-        outfdev_major = int(inheaderdata[25], 16)
-        outfseeknextfile = inheaderdata[26]
-        outfjsontype = inheaderdata[27]
-        outfjsonlen = int(inheaderdata[28], 16)
-        outfjsonsize = int(inheaderdata[29], 16)
-        outfjsonchecksumtype = inheaderdata[30]
-        outfjsonchecksum = inheaderdata[31]
-
+        outfcompression = inheaderdata[17]
+        outfcsize = int(inheaderdata[18], 16)
+        fid = int(inheaderdata[23], 16)
+        finode = int(inheaderdata[24], 16)
+        outfseeknextfile = inheaderdata[28]
+        outfjsonsize = int(inheaderdata[31], 16)
+        outfjsonchecksumtype = inheaderdata[32]
+        outfjsonchecksum = inheaderdata[33]
         outfhend = fp.tell() - 1  # (kept for parity; not used)
         outfjstart = fp.tell()
-
         # Read JSON bytes; compute checksum on bytes for robustness
         outfprejsoncontent_bytes = fp.read(outfjsonsize)
         # Decode for any downstream text needs (not used further here)
@@ -9731,27 +10406,21 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
             outfprejsoncontent = outfprejsoncontent_bytes.decode("UTF-8")
         except Exception:
             outfprejsoncontent = None
-
         outfjend = fp.tell()
         fp.seek(len(formatspecs['format_delimiter']), 1)
-
-        injsonfcs = GetFileChecksum(outfprejsoncontent_bytes, outfjsonchecksumtype, True, formatspecs)
-
-        outfextrasize = int(inheaderdata[32], 16)
-        outfextrafields = int(inheaderdata[33], 16)
+        injsonfcs = GetFileChecksum(outfprejsoncontent_bytes, outfjsonchecksumtype, True, formatspecs, saltkey)
+        outfextrafields = int(inheaderdata[35], 16)
         extrafieldslist = []
-        extrastart = 34
+        extrastart = 36
         extraend = extrastart + outfextrafields
-
         outfcs = inheaderdata[-2].lower()
         outfccs = inheaderdata[-1].lower()
-        infcs = GetHeaderChecksum(inheaderdata[:-2], inheaderdata[-4].lower(), True, formatspecs)
-
+        infcs = GetHeaderChecksum(inheaderdata[:-2], inheaderdata[-4].lower(), True, formatspecs, saltkey)
         if(verbose):
             VerbosePrintOut(outfname)
             VerbosePrintOut("Record Number " + str(il) + "; File ID " + str(fid) + "; iNode Number " + str(finode))
 
-        if(hmac.compare_digest(outfcs, infcs)):
+        if(CheckChecksums(outfcs, infcs)):
             if(verbose):
                 VerbosePrintOut("File Header Checksum Passed at offset " + str(outfhstart))
                 VerbosePrintOut("'" + outfcs + "' == " + "'" + infcs + "'")
@@ -9761,9 +10430,8 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
             if(verbose):
                 VerbosePrintOut("File Header Checksum Failed at offset " + str(outfhstart))
                 VerbosePrintOut("'" + outfcs + "' != " + "'" + infcs + "'")
-
         if(outfjsonsize > 0):
-            if(hmac.compare_digest(injsonfcs, outfjsonchecksum)):
+            if(CheckChecksums(injsonfcs, outfjsonchecksum)):
                 if(verbose):
                     VerbosePrintOut("File JSON Data Checksum Passed at offset " + str(outfjstart))
                     VerbosePrintOut("'" + outfjsonchecksum + "' == " + "'" + injsonfcs + "'")
@@ -9773,21 +10441,19 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
                 if(verbose):
                     VerbosePrintOut("File JSON Data Checksum Error at offset " + str(outfjstart))
                     VerbosePrintOut("'" + outfjsonchecksum + "' != " + "'" + injsonfcs + "'")
-
         outfcontentstart = fp.tell()
         outfcontents = b""   # FIX: bytes for Py2/3 consistency
         pyhascontents = False
-
         if(outfsize > 0):
             if(outfcompression == "none" or outfcompression == "" or outfcompression == "auto"):
                 outfcontents = fp.read(outfsize)
             else:
                 outfcontents = fp.read(outfcsize)
 
-            infccs = GetFileChecksum(outfcontents, inheaderdata[-3].lower(), False, formatspecs)
+            infccs = GetFileChecksum(outfcontents, inheaderdata[-3].lower(), False, formatspecs, saltkey)
             pyhascontents = True
 
-            if(hmac.compare_digest(outfccs, infccs)):
+            if(CheckChecksums(outfccs, infccs)):
                 if(verbose):
                     VerbosePrintOut("File Content Checksum Passed at offset " + str(outfcontentstart))
                     VerbosePrintOut("'" + outfccs + "' == " + "'" + infccs + "'")
@@ -9797,10 +10463,8 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
                 if(verbose):
                     VerbosePrintOut("File Content Checksum Failed at offset " + str(outfcontentstart))
                     VerbosePrintOut("'" + outfccs + "' != " + "'" + infccs + "'")
-
         if(verbose):
             VerbosePrintOut("")
-
         # Next seek directive
         if(re.findall(r"^\+([0-9]+)", outfseeknextfile)):
             fseeknextasnum = int(outfseeknextfile.replace("+", ""))
@@ -9819,9 +10483,7 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
             fp.seek(fseeknextasnum, 0)
         else:
             return False
-
         il = il + 1
-
     if(valid_archive):
         if(returnfp):
             return fp
@@ -9833,34 +10495,34 @@ def ArchiveFileValidate(infile, fmttype="auto", filestart=0,
         return False
 
 
-def ArchiveFileValidateFile(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    return ArchiveFileValidate(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+def ArchiveFileValidateFile(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
+    return ArchiveFileValidate(infile, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
 
 
-def ArchiveFileValidateMultiple(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+def ArchiveFileValidateMultiple(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
     if(isinstance(infile, (list, tuple, ))):
         pass
     else:
         infile = [infile]
     outretval = True
     for curfname in infile:
-        curretfile = ArchiveFileValidate(curfname, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+        curretfile = ArchiveFileValidate(curfname, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
         if(not curretfile):
             outretval = False
     return outretval
 
-def ArchiveFileValidateMultipleFiles(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    return ArchiveFileValidateMultiple(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+def ArchiveFileValidateMultipleFiles(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
+    return ArchiveFileValidateMultiple(infile, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
 
 
-def StackedArchiveFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+def StackedArchiveFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
     outretval = []
     outstartfile = filestart
     outfsize = float('inf')
     while True:
         if outstartfile >= outfsize:   # stop when function signals False
             break
-        is_valid_file = ArchiveFileValidate(infile, fmttype, outstartfile, formatspecs, seektoend, verbose, True)
+        is_valid_file = ArchiveFileValidate(infile, fmttype, outstartfile, formatspecs, saltkey, seektoend, verbose, True)
         if is_valid_file is False:   # stop when function signals False
             outretval.append(is_valid_file)
             break
@@ -9877,33 +10539,36 @@ def StackedArchiveFileValidate(infile, fmttype="auto", filestart=0, formatspecs=
     if(returnfp):
         return infile
     else:
-        infile.close()
+        try:
+            infile.close()
+        except AttributeError:
+            return False
         return outretval
     
 
 
-def StackedArchiveFileValidateFile(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    return StackedArchiveFileValidate(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+def StackedArchiveFileValidateFile(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
+    return StackedArchiveFileValidate(infile, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
 
 
-def StackedArchiveFileValidateMultiple(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+def StackedArchiveFileValidateMultiple(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
     if(isinstance(infile, (list, tuple, ))):
         pass
     else:
         infile = [infile]
     outretval = True
     for curfname in infile:
-        curretfile = StackedArchiveFileValidate(curfname, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+        curretfile = StackedArchiveFileValidate(curfname, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
         if(not curretfile):
             outretval = False
     return outretval
 
-def StackedArchiveFileValidateMultipleFiles(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    return StackedArchiveFileValidateMultiple(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+def StackedArchiveFileValidateMultipleFiles(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
+    return StackedArchiveFileValidateMultiple(infile, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
 
 
-def ArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
-    outfp = ReadInFileWithContentToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend)
+def ArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, returnfp=False):
+    outfp = ReadInFileWithContentToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey, seektoend)
     if not returnfp:
         for item in outfp:
             fp = item.get('fp')
@@ -9917,26 +10582,26 @@ def ArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend
     return outfp
 
 
-def MultipleArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def MultipleArchiveFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, returnfp=False):
     if(isinstance(infile, (list, tuple, ))):
         pass
     else:
         infile = [infile]
     outretval = []
     for curfname in infile:
-        outretval.append(ArchiveFileToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp))
+        outretval.append(ArchiveFileToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey, seektoend, returnfp))
     return outretval
 
-def MultipleArchiveFilesToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
-    return MultipleArchiveFileToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+def MultipleArchiveFilesToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, returnfp=False):
+    return MultipleArchiveFileToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
 
 
-def ArchiveFileStringToArray(instr, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def ArchiveFileStringToArray(instr, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, returnfp=False):
     checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     fp = MkTempFile(instr)
-    listarrayfiles = ArchiveFileToArray(fp, "auto", filestart, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    listarrayfiles = ArchiveFileToArray(fp, "auto", filestart, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
     return listarrayfiles
 
 
@@ -9945,9 +10610,8 @@ def TarFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     fp = MkTempFile()
-    fp = PackArchiveFileFromTarFile(
-        infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, False, True)
-    listarrayfiles = ArchiveFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    fp = PackArchiveFileFromTarFile(infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, None, False, True)
+    listarrayfiles = ArchiveFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, None, seektoend, returnfp)
     return listarrayfiles
 
 
@@ -9956,9 +10620,8 @@ def ZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     fp = MkTempFile()
-    fp = PackArchiveFileFromZipFile(
-        infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, False, True)
-    listarrayfiles = ArchiveFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    fp = PackArchiveFileFromZipFile(infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, None, False, True)
+    listarrayfiles = ArchiveFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, None, seektoend, returnfp)
     return listarrayfiles
 
 
@@ -9972,9 +10635,8 @@ if(rarfile_support):
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         fp = MkTempFile()
-        fp = PackArchiveFileFromRarFile(
-            infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, False, True)
-        listarrayfiles = ArchiveFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        fp = PackArchiveFileFromRarFile(infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, None, False, True)
+        listarrayfiles = ArchiveFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, None, seektoend, returnfp)
         return listarrayfiles
 
 if(not py7zr_support):
@@ -9987,13 +10649,12 @@ if(py7zr_support):
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         fp = MkTempFile()
-        fp = PackArchiveFileFromSevenZipFile(
-            infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, False, True)
-        listarrayfiles = ArchiveFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        fp = PackArchiveFileFromSevenZipFile(infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, None, False, True)
+        listarrayfiles = ArchiveFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, None, seektoend, returnfp)
         return listarrayfiles
 
 
-def InFileToArray(infile, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def InFileToArray(infile, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, returnfp=False):
     checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
@@ -10006,17 +10667,16 @@ def InFileToArray(infile, filestart=0, seekstart=0, seekend=0, listonly=False, c
     elif(py7zr_support and checkcompressfile == "7zipfile" and py7zr.is_7zfile(infile)):
         return SevenZipFileToArray(infile, seekstart, seekend, listonly, contentasfile, skipchecksum, formatspecs, seektoend, returnfp)
     elif(checkcompressfile == formatspecs['format_magic']):
-        return ArchiveFileToArray(infile, "auto", filestart, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        return ArchiveFileToArray(infile, "auto", filestart, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
     else:
         return False
     return False
 
 
-def ListDirToArray(infiles, dirlistfromtxt=False, fmttype=__file_format_default__, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, filestart=0, seekstart=0, seekend=0, listonly=False, skipchecksum=False, checksumtype=["md5", "md5", "md5"], extradata=[], formatspecs=__file_format_dict__, verbose=False, seektoend=False, returnfp=False):
+def ListDirToArray(infiles, dirlistfromtxt=False, fmttype=__file_format_default__, compression="auto", compresswholefile=True, compressionlevel=None, followlink=False, filestart=0, seekstart=0, seekend=0, listonly=False, saltkey=None, skipchecksum=False, checksumtype=["md5", "md5", "md5"], extradata=[], formatspecs=__file_format_dict__, verbose=False, seektoend=False, returnfp=False):
     outarray = MkTempFile()
-    packform = PackArchiveFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile,
-                              compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True)
-    listarrayfiles = ArchiveFileToArray(outarray, "auto", filestart, seekstart, seekend, listonly, True, True, skipchecksum, formatspecs, seektoend, returnfp)
+    packform = PackArchiveFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, followlink, checksumtype, extradata, formatspecs, saltkey, verbose, True)
+    listarrayfiles = ArchiveFileToArray(outarray, "auto", filestart, seekstart, seekend, listonly, True, True, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
     return listarrayfiles
 
 
@@ -10138,12 +10798,12 @@ def ArchiveFileArrayToArrayIndex(inarray, returnfp=False):
     return out
 
 
-def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=None,  followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=None, skipchecksum=False, extradata=None, jsondata=None, formatspecs=None, seektoend=False, verbose=False, returnfp=False):
+def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt,  followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["md5", "md5", "md5", "md5", "md5"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_multi_dict__, insaltkey=None, outsaltkey=None, seektoend=False, verbose=False, returnfp=False):
     # ---------- Safe defaults ----------
     if compressionuselist is None:
         compressionuselist = compressionlistalt
     if checksumtype is None:
-        checksumtype = ["md5", "md5", "md5", "md5"]
+        checksumtype = ["md5", "md5", "md5", "md5", "md5"]
     if extradata is None:
         extradata = []
     if jsondata is None:
@@ -10162,7 +10822,7 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
             infile = RemoveWindowsPath(infile)
         listarrayfileslist = ArchiveFileToArray(
             infile, "auto", filestart, seekstart, seekend,
-            False, True, True, skipchecksum, formatspecs, seektoend, False
+            False, True, True, skipchecksum, formatspecs, insaltkey, seektoend, False
         )
 
     # ---------- Format specs selection ----------
@@ -10229,9 +10889,6 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
         if (compression is None) or (compressionuselist and compression not in compressionuselist):
             compression = "auto"
 
-        if verbose:
-            logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
-
         # No files?
         if not listarrayfiles.get('ffilelist'):
             return False
@@ -10244,7 +10901,7 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
         if lenlist != fnumfiles:
             fnumfiles = lenlist
 
-        AppendFileHeader(fp, fnumfiles, listarrayfiles.get('fencoding', 'utf-8'), [], checksumtype[0], formatspecs)
+        AppendFileHeader(fp, fnumfiles, listarrayfiles.get('fencoding', 'utf-8'), listarrayfiles['fextradata'], listarrayfiles['fjsondata'], [checksumtype[0], checksumtype[1]], formatspecs, outsaltkey)
 
         # loop counters
         lcfi = 0
@@ -10274,6 +10931,9 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
             # fields (hex-encoded where expected)
             fheadersize = format(int(cur_entry['fheadersize']), 'x').lower()
             fsize       = format(int(cur_entry['fsize']), 'x').lower()
+            fblksize       = format(int(cur_entry['fblksize']), 'x').lower()
+            fblocks       = format(int(cur_entry['fblocks']), 'x').lower()
+            fflags       = format(int(cur_entry['fflags']), 'x').lower()
             flinkname   = cur_entry['flinkname']
             fatime      = format(int(cur_entry['fatime']), 'x').lower()
             fmtime      = format(int(cur_entry['fmtime']), 'x').lower()
@@ -10292,8 +10952,7 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
             fcompression   = cur_entry['fcompression']
             fcsize         = format(int(cur_entry['fcsize']), 'x').lower()
             fdev           = format(int(cur_entry['fdev']), 'x').lower()
-            fdev_minor     = format(int(cur_entry['fminor']), 'x').lower()
-            fdev_major     = format(int(cur_entry['fmajor']), 'x').lower()
+            frdev           = format(int(cur_entry['frdev']), 'x').lower()
             fseeknextfile  = cur_entry['fseeknextfile']
 
             # extra fields sizing
@@ -10304,6 +10963,12 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
             # extradata/jsondata defaults per file
             if not followlink and len(extradata) <= 0:
                 extradata = cur_entry['fextradata']
+
+            fvendorfields = cur_entry['fvendorfields']
+            ffvendorfieldslist = []
+            if(fvendorfields>0):
+                ffvendorfieldslist = cur_entry['fvendorfieldslist']
+
             if not followlink and len(jsondata) <= 0:
                 jsondata = cur_entry['fjsondata']
 
@@ -10339,7 +11004,11 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
                         fcontents.seek(0, 0)
                         cfcontents.seek(0, 0)
                         cfcontents = CompressOpenFileAlt(
-                            cfcontents, compressionuselist[ilmin], compressionlevel, compressionuselist, formatspecs
+                            cfcontents,
+                            compressionuselist[ilmin],
+                            compressionlevel,
+                            compressionuselist,
+                            formatspecs
                         )
                         if cfcontents:
                             cfcontents.seek(0, 2)
@@ -10347,7 +11016,7 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
                             cfcontents.close()
                         else:
                             ilcsize.append(float("inf"))
-                        ilmin += 1
+                        ilmin = ilmin + 1
                     ilcmin = ilcsize.index(min(ilcsize))
                     curcompression = compressionuselist[ilcmin]
 
@@ -10356,16 +11025,24 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
                 shutil.copyfileobj(fcontents, cfcontents, length=__filebuff_size__)
                 cfcontents.seek(0, 0)
                 cfcontents = CompressOpenFileAlt(
-                    cfcontents, curcompression, compressionlevel, compressionuselist, formatspecs
+                    cfcontents,
+                    curcompression,
+                    compressionlevel,
+                    compressionuselist,
+                    formatspecs
                 )
                 cfcontents.seek(0, 2)
-                cfsize_val = cfcontents.tell()
-                if ucfsize > cfsize_val:
-                    fcsize = format(int(cfsize_val), 'x').lower()
+                cfsize = cfcontents.tell()
+                if ucfsize > cfsize:
+                    fcsize = format(int(cfsize), 'x').lower()
                     fcompression = curcompression
                     fcontents.close()
                     fcontents = cfcontents
 
+            if fcompression == "none":
+                fcompression = ""
+            fcontents.seek(0, 0)
+
             # link following (fixed: use listarrayfiles, not prelistarrayfiles)
             if followlink:
                 if (cur_entry['ftype'] == 1 or cur_entry['ftype'] == 2):
@@ -10374,6 +11051,9 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
                     flinkinfo = listarrayfiles['ffilelist'][flinkid]
                     fheadersize = format(int(flinkinfo['fheadersize']), 'x').lower()
                     fsize       = format(int(flinkinfo['fsize']), 'x').lower()
+                    fblksize       = format(int(flinkinfo['fblksize']), 'x').lower()
+                    fblocks       = format(int(flinkinfo['fblocks']), 'x').lower()
+                    fflags       = format(int(flinkinfo['fflags']), 'x').lower()
                     flinkname   = flinkinfo['flinkname']
                     fatime      = format(int(flinkinfo['fatime']), 'x').lower()
                     fmtime      = format(int(flinkinfo['fmtime']), 'x').lower()
@@ -10392,14 +11072,19 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
                     fcompression   = flinkinfo['fcompression']
                     fcsize         = format(int(flinkinfo['fcsize']), 'x').lower()
                     fdev           = format(int(flinkinfo['fdev']), 'x').lower()
-                    fdev_minor     = format(int(flinkinfo['fminor']), 'x').lower()
-                    fdev_major     = format(int(flinkinfo['fmajor']), 'x').lower()
+                    frdev           = format(int(flinkinfo['frdev']), 'x').lower()
                     fseeknextfile  = flinkinfo['fseeknextfile']
                     if (len(flinkinfo['fextradata']) > flinkinfo['fextrafields']
                         and len(flinkinfo['fextradata']) > 0):
                         flinkinfo['fextrafields'] = len(flinkinfo['fextradata'])
                     if len(extradata) < 0:
                         extradata = flinkinfo['fextradata']
+
+                    fvendorfields = flinkinfo['fvendorfields']
+                    ffvendorfieldslist = []
+                    if(fvendorfields>0):
+                        ffvendorfieldslist = flinkinfo['fvendorfieldslist']
+
                     if len(jsondata) < 0:
                         jsondata = flinkinfo['fjsondata']
                     fcontents = flinkinfo['fcontents']
@@ -10428,15 +11113,15 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
                 fcompression = ""
 
             tmpoutlist = [
-                ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fatime, fmtime,
+                ftypehex, fencoding, fcencoding, fname, flinkname, fsize, fblksize, fblocks, fflags, fatime, fmtime,
                 fctime, fbtime, fmode, fwinattributes, fcompression, fcsize, fuid, funame,
-                fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, fdev_minor, fdev_major, fseeknextfile
+                fgid, fgname, fcurfid, fcurinode, flinkcount, fdev, frdev, fseeknextfile
             ]
 
-            AppendFileHeaderWithContent(
-                fp, tmpoutlist, extradata, jsondata, fcontents.read(),
-                [checksumtype[1], checksumtype[2], checksumtype[3]], formatspecs
-            )
+            if(fvendorfields>0 and len(ffvendorfieldslist)>0):
+                extradata.extend(fvendorfields)
+            
+            AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(),[checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, outsaltkey)
             try:
                 fcontents.close()
             except Exception:
@@ -10481,12 +11166,12 @@ def RePackArchiveFile(infile, outfile, fmttype="auto", compression="auto", compr
             pass
         return True
 
-def RePackMultipleArchiveFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=None,  followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=None, skipchecksum=False, extradata=None, jsondata=None, formatspecs=None, seektoend=False, verbose=False, returnfp=False):
+def RePackMultipleArchiveFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt,  followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["md5", "md5", "md5", "md5", "md5"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_multi_dict__, insaltkey=None, outsaltkey=None, seektoend=False, verbose=False, returnfp=False):
     if not isinstance(infiles, list):
         infiles = [infiles]
     returnout = False
     for infileslist in infiles:
-        returnout = RePackArchiveFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend, checksumtype, skipchecksum, extradata, jsondata, formatspecs, seektoend, verbose, True)
+        returnout = RePackArchiveFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend, checksumtype, skipchecksum, extradata, jsondata, formatspecs, insaltkey, outsaltkey, seektoend, verbose, True)
         if(not returnout):
             break
         else:
@@ -10496,33 +11181,28 @@ def RePackMultipleArchiveFile(infiles, outfile, fmttype="auto", compression="aut
         return True
     return returnout
 
-def RePackArchiveFileFromString(instr, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["md5", "md5", "md5"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
+def RePackArchiveFileFromString(instr, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["md5", "md5", "md5", "md5", "md5"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_multi_dict__, insaltkey=None, outsaltkey=None, seektoend=False, verbose=False, returnfp=False):
     fp = MkTempFile(instr)
-    listarrayfiles = RePackArchiveFile(fp, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend,
-                                     checksumtype, skipchecksum, extradata, jsondata, formatspecs, seektoend, verbose, returnfp)
+    listarrayfiles = RePackArchiveFile(fp, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend, checksumtype, skipchecksum, extradata, jsondata, formatspecs, insaltkey, outsaltkey, seektoend, verbose, returnfp)
     return listarrayfiles
 
 
-def PackArchiveFileFromListDir(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["md5", "md5", "md5"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_dict__, seektoend=False, verbose=False, returnfp=False):
+def PackArchiveFileFromListDir(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, filestart=0, seekstart=0, seekend=0, checksumtype=["md5", "md5", "md5", "md5", "md5"], skipchecksum=False, extradata=[], jsondata={}, formatspecs=__file_format_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
     outarray = MkTempFile()
-    packform = PackArchiveFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile,
-                              compressionlevel, compressionuselist, followlink, checksumtype, extradata, formatspecs, verbose, True)
-    listarrayfiles = RePackArchiveFile(outarray, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend,
-                                     checksumtype, skipchecksum, extradata, jsondata, formatspecs, seektoend, verbose, returnfp)
+    packform = PackArchiveFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, checksumtype, extradata, formatspecs, saltkey, verbose, True)
+    listarrayfiles = RePackArchiveFile(outarray, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend, checksumtype, skipchecksum, extradata, jsondata, formatspecs, saltkey, seektoend, verbose, returnfp)
     return listarrayfiles
 
 
-def UnPackArchiveFile(infile, outdir=None, followlink=False, filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, preservepermissions=True, preservetime=True, seektoend=False, verbose=False, returnfp=False):
+def UnPackArchiveFile(infile, outdir=None, followlink=False, filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, preservepermissions=True, preservetime=True, seektoend=False, verbose=False, returnfp=False):
     if(outdir is not None):
         outdir = RemoveWindowsPath(outdir)
-    if(verbose):
-        logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
     if(isinstance(infile, dict)):
         listarrayfiles = infile
     else:
         if(infile != "-" and not hasattr(infile, "read") and not hasattr(infile, "write") and not (sys.version_info[0] >= 3 and isinstance(infile, bytes))):
             infile = RemoveWindowsPath(infile)
-        listarrayfiles = ArchiveFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, True, skipchecksum, formatspecs, seektoend, returnfp)
+        listarrayfiles = ArchiveFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, True, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
     if(not listarrayfiles):
         return False
     lenlist = len(listarrayfiles['ffilelist'])
@@ -10758,9 +11438,9 @@ def UnPackArchiveFile(infile, outdir=None, followlink=False, filestart=0, seekst
         return True
 
 
-def UnPackArchiveFileString(instr, outdir=None, followlink=False, filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+def UnPackArchiveFileString(instr, outdir=None, followlink=False, filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
     fp = MkTempFile(instr)
-    listarrayfiles = UnPackArchiveFile(fp, outdir, followlink, filestart, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
+    listarrayfiles = UnPackArchiveFile(fp, outdir, followlink, filestart, seekstart, seekend, skipchecksum, formatspecs, saltkey, seektoend, verbose, returnfp)
     return listarrayfiles
 
 def ftype_to_str(ftype):
@@ -10778,9 +11458,7 @@ def ftype_to_str(ftype):
     # Default to "file" if unknown
     return mapping.get(ftype, "file")
 
-def ArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
-    if(verbose):
-        logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
+def ArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, newstyle=False, returnfp=False):
     if(isinstance(infile, dict)):
         listarrayfileslist = [infile]
     if(isinstance(infile, list)):
@@ -10788,7 +11466,7 @@ def ArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seeke
     else:
         if(infile != "-" and not hasattr(infile, "read") and not hasattr(infile, "write") and not (sys.version_info[0] >= 3 and isinstance(infile, bytes))):
             infile = RemoveWindowsPath(infile)
-        listarrayfileslist = ArchiveFileToArray(infile, fmttype, filestart, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
+        listarrayfileslist = ArchiveFileToArray(infile, fmttype, filestart, seekstart, seekend, True, False, False, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
     if(not listarrayfileslist):
         return False
     for listarrayfiles in listarrayfileslist:
@@ -10825,8 +11503,11 @@ def ArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seeke
                     VerbosePrintOut(ftype_to_str(listarrayfiles['ffilelist'][lcfi]['ftype']) + "\t" + listarrayfiles['ffilelist'][lcfi]['fcompression'] + "\t" + str(
                     listarrayfiles['ffilelist'][lcfi]['fsize']).rjust(15) + "\t" + printfname)
                 else:
+                    ts_ns = listarrayfiles['ffilelist'][lcfi]['fmtime']
+                    sec, ns = divmod(int(ts_ns), 10**9)
+                    dt = datetime.datetime.utcfromtimestamp(sec).replace(microsecond=ns // 1000)
                     VerbosePrintOut(PrintPermissionString(listarrayfiles['ffilelist'][lcfi]['fmode'], listarrayfiles['ffilelist'][lcfi]['ftype']) + " " + str(fuprint) + "/" + str(fgprint) + " " + str(
-                    listarrayfiles['ffilelist'][lcfi]['fsize']).rjust(15) + " " + datetime.datetime.utcfromtimestamp(listarrayfiles['ffilelist'][lcfi]['fmtime']).strftime('%Y-%m-%d %H:%M') + " " + printfname)
+                    listarrayfiles['ffilelist'][lcfi]['fsize']).rjust(15) + " " + dt.strftime('%Y-%m-%d %H:%M') + " " + printfname)
             lcfi = lcfi + 1
     if(returnfp):
         return listarrayfiles['fp']
@@ -10834,25 +11515,25 @@ def ArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seeke
         return True
 
 
-def MultipleArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def MultipleArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, returnfp=False):
     if(isinstance(infile, (list, tuple, ))):
         pass
     else:
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        outretval[curfname] = ArchiveFileListFiles(infile, fmttype, filestart, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, returnfp)
+        outretval[curfname] = ArchiveFileListFiles(infile, fmttype, filestart, seekstart, seekend, skipchecksum, formatspecs, saltkey, seektoend, verbose, newstyle, returnfp)
     return outretval
 
 
-def StackedArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
+def StackedArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, newstyle=False, returnfp=False):
     outretval = []
     outstartfile = filestart
     outfsize = float('inf')
     while True:
         if outstartfile >= outfsize:   # stop when function signals False
             break
-        list_file_retu = ArchiveFileListFiles(infile, fmttype, outstartfile, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, True)
+        list_file_retu = ArchiveFileListFiles(infile, fmttype, outstartfile, seekstart, seekend, skipchecksum, formatspecs, saltkey, seektoend, verbose, newstyle, True)
         if list_file_retu is False:   # stop when function signals False
             outretval.append(list_file_retu)
         else:
@@ -10868,30 +11549,31 @@ def StackedArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0
     if(returnfp):
         return infile
     else:
-        infile.close()
+        try:
+            infile.close()
+        except AttributeError:
+            return False
         return outretval
 
 
-def MultipleStackedArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def MultipleStackedArchiveFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, uncompress=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, returnfp=False):
     if(isinstance(infile, (list, tuple, ))):
         pass
     else:
         infile = [infile]
     outretval = {}
     for curfname in infile:
-        outretval[curfname] = StackedArchiveFileListFiles(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+        outretval[curfname] = StackedArchiveFileListFiles(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
     return outretval
 
 
-def ArchiveFileStringListFiles(instr, filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
+def ArchiveFileStringListFiles(instr, filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, newstyle=False, returnfp=False):
     fp = MkTempFile(instr)
-    listarrayfiles = ArchiveFileListFiles(instr, "auto", filestart, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, returnfp)
+    listarrayfiles = ArchiveFileListFiles(instr, "auto", filestart, seekstart, seekend, skipchecksum, formatspecs, saltkey, seektoend, verbose, newstyle, returnfp)
     return listarrayfiles
 
 
 def TarFileListFiles(infile, verbose=False, returnfp=False):
-    if(verbose):
-        logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
     if(infile == "-"):
         infile = MkTempFile()
         shutil.copyfileobj(PY_STDIN_BUF, infile, length=__filebuff_size__)
@@ -10927,10 +11609,8 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
-                if 'zstandard' in sys.modules:
-                    infile = ZstdFile(fileobj=infile, mode="rb")
-                elif 'pyzstd' in sys.modules:
-                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                if 'zstd' in compressionsupport:
+                    infile = zstd.ZstdFile(infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(fileobj=infile, mode="r")
@@ -10939,10 +11619,8 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
             if(IsNestedDict(formatspecs) and compresscheck in formatspecs):
                 formatspecs = formatspecs[compresscheck]
             if(compresscheck=="zstd"):
-                if 'zstandard' in sys.modules:
-                    infile = ZstdFile(fileobj=infile, mode="rb")
-                elif 'pyzstd' in sys.modules:
-                    infile = pyzstd.zstdfile.ZstdFile(fileobj=infile, mode="rb")
+                if 'zstd' in compressionsupport:
+                    infile = zstd.ZstdFile(infile, mode="rb")
                 tarfp = tarfile.open(fileobj=infile, mode="r")
             else:
                 tarfp = tarfile.open(infile, "r")
@@ -11012,8 +11690,6 @@ def TarFileListFiles(infile, verbose=False, returnfp=False):
 
 
 def ZipFileListFiles(infile, verbose=False, returnfp=False):
-    if(verbose):
-        logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
     if(infile == "-"):
         infile = MkTempFile()
         shutil.copyfileobj(PY_STDIN_BUF, infile, length=__filebuff_size__)
@@ -11139,8 +11815,6 @@ if(not rarfile_support):
 
 if(rarfile_support):
     def RarFileListFiles(infile, verbose=False, returnfp=False):
-        if(verbose):
-            logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
         if(not os.path.exists(infile) or not os.path.isfile(infile)):
             return False
         if(not rarfile.is_rarfile(infile) and not rarfile.is_rarfile_sfx(infile)):
@@ -11268,14 +11942,15 @@ if(not py7zr_support):
 
 if(py7zr_support):
     def SevenZipFileListFiles(infile, verbose=False, returnfp=False):
-        if(verbose):
-            logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
         if(not os.path.exists(infile) or not os.path.isfile(infile)):
             return False
         lcfi = 0
         returnval = {}
         szpfp = py7zr.SevenZipFile(infile, mode="r")
-        file_content = szpfp.readall()
+        try:
+            file_content = szpfp.readall()
+        except AttributeError:
+            file_content = sevenzip_readall(infile)
         #sztest = szpfp.testzip()
         sztestalt = szpfp.test()
         if(sztestalt):
@@ -11319,7 +11994,10 @@ if(py7zr_support):
                     printfname = member.filename
                 if(ftype == 0):
                     fsize = len(file_content[member.filename].read())
-                    file_content[member.filename].close()
+                    try:
+                        file_content[member.filename].close()
+                    except AttributeError:
+                        pass
                 try:
                     fuid = int(os.getuid())
                 except (KeyError, AttributeError):
@@ -11363,8 +12041,6 @@ if(py7zr_support):
 
 
 def InFileListFiles(infile, verbose=False, formatspecs=__file_format_multi_dict__, seektoend=False, newstyle=False, returnfp=False):
-    if(verbose):
-        logging.basicConfig(format="%(message)s", stream=PY_STDOUT_TEXT, level=logging.DEBUG)
     checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
@@ -11391,44 +12067,6 @@ def ListDirListFiles(infiles, dirlistfromtxt=False, compression="auto", compress
         outarray, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
     return listarrayfiles
 
-"""
-PyNeoFile compatibility layer
-"""
-
-def make_empty_file_pointer_neo(fp, fmttype=None, checksumtype='md5', formatspecs=__file_format_multi_dict__, encoding='UTF-8'):
-    return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs)
-
-def make_empty_archive_file_pointer_neo(fp, fmttype=None, checksumtype='md5', formatspecs=__file_format_multi_dict__, encoding='UTF-8'):
-    return make_empty_file_pointer_neo(fp, fmttype, checksumtype, formatspecs, encoding)
-
-def make_empty_file_neo(outfile=None, fmttype=None, checksumtype='md5', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
-    return MakeEmptyFile(outfile, fmttype, "auto", False, None, compressionlistalt, checksumtype, formatspecs, returnfp)
-
-def make_empty_archive_file_neo(outfile=None, fmttype=None, checksumtype='md5', formatspecs=__file_format_multi_dict__, encoding='UTF-8', returnfp=False):
-    return make_empty_file_neo(outfile, fmttype, checksumtype, formatspecs, encoding, returnfp)
-
-def pack_neo(infiles, outfile=None, formatspecs=__file_format_multi_dict__, checksumtypes=["md5", "md5", "md5", "md5"], encoding="UTF-8", compression="auto", compression_level=None, returnfp=False):
-    return PackArchiveFile(infiles, outfile, False, "auto", compression, False, compression_level, compressionlistalt, False, checksumtypes, [], {}, formatspecs, False, returnfp)
-
-def archive_to_array_neo(infile, formatspecs=__file_format_multi_dict__, listonly=False, skipchecksum=False, uncompress=True, returnfp=False):
-    return ArchiveFileToArray(infile, "auto", 0, 0, 0, listonly, True, uncompress, skipchecksum, formatspecs, False, returnfp)
-
-def unpack_neo(infile, outdir='.', formatspecs=__file_format_multi_dict__, skipchecksum=False, uncompress=True, returnfp=False):
-    return UnPackArchiveFile(infile, outdir, False, 0, 0, skipchecksum, formatspecs, True, True, False, False, returnfp)
-
-def repack_neo(infile, outfile=None, formatspecs=__file_format_dict__, checksumtypes=["md5", "md5", "md5", "md5"], compression="auto", compression_level=None, returnfp=False):
-    return RePackArchiveFile(infile, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
-
-def validate_neo(infile, formatspecs=__file_format_multi_dict__, verbose=False, return_details=False, returnfp=False):
-    return ArchiveFileValidate(infile, "auto", formatspecs, False, verbose, returnfp)
-
-def listfiles_neo(infile, formatspecs=__file_format_multi_dict__, advanced=False, include_dirs=True, returnfp=False):
-    return ArchiveFileListFiles(infile, "auto", 0, 0, False, formatspecs, False, True, advanced, returnfp)
-
-def convert_foreign_to_neo(infile, outfile=None, formatspecs=__file_format_multi_dict__, checksumtypes=["md5", "md5", "md5", "md5"], compression="auto", compression_level=None, returnfp=False):
-    intmp = InFileToArray(infile, 0, 0, 0, False, True, False, formatspecs, False, False)
-    return RePackArchiveFile(intmp, outfile, "auto", compression, False, compression_level, compressionlistalt, False, 0, 0, checksumtypes, False, [], {}, formatspecs, False, False, returnfp)
-
 def detect_cwd(ftp, file_dir):
     """
     Test whether cwd into file_dir works. Returns True if it does,
@@ -13494,7 +14132,6 @@ def run_http_file_server(fileobj, url, on_progress=None, backlog=5):
             if not ah or not ah.strip().lower().startswith("basic "):
                 return False
             try:
-                import base64
                 b64 = ah.strip().split(" ", 1)[1]
                 raw = base64.b64decode(_to_bytes(b64))
                 try: raw_txt = raw.decode("utf-8")