PyFoxFile 0.25.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

pyfoxfile.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: pyfoxfile.py - Last Update: 11/3/2025 Ver. 0.25.0 RC 1 - Author: cooldude2k $
+    $FileInfo: pyfoxfile.py - Last Update: 11/12/2025 Ver. 0.26.0 RC 1 - Author: cooldude2k $
 '''
 
 from __future__ import absolute_import, division, print_function, unicode_literals, generators, with_statement, nested_scopes
@@ -416,9 +416,13 @@ def is_only_nonprintable(var):
 __file_format_multi_dict__ = {}
 __file_format_default__ = "FoxFile"
 __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
@@ -462,9 +466,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 +480,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 +500,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 +560,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 +590,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 +604,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,
             }
         })
@@ -641,21 +642,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/PyFoxFile"
 __project_release_url__ = __project_url__+"/releases/latest"
-__version_info__ = (0, 25, 0, "RC 1", 1)
-__version_date_info__ = (2025, 11, 5, "RC 1", 1)
+__version_info__ = (0, 26, 0, "RC 1", 1)
+__version_date_info__ = (2025, 11, 12, "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: 1e44250af6454c3f042d7212eb751c2c18543954 $"
+__revision_id__ = "$Id: 472d03caa48196f32a369d9ab15f43ee378c9557 $"
 if(__version_info__[4] is not None):
     __version_date_plusrc__ = __version_date__ + \
         "-" + str(__version_date_info__[4])
@@ -667,6 +665,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
 
@@ -1036,6 +1037,20 @@ 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 _split_posix(name):
     """
@@ -2059,34 +2074,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=None,
+               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) --
@@ -2118,23 +2152,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:
@@ -2142,19 +2218,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
 
 
@@ -3674,7 +3764,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.
@@ -3686,15 +3776,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.
@@ -3702,13 +3807,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:
@@ -3729,26 +3850,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):
     """
@@ -4117,11 +4253,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)
@@ -4209,15 +4345,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 " +
@@ -4236,10 +4371,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 + "'")
@@ -4276,12 +4410,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)
@@ -4299,40 +4433,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)>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"))
@@ -4410,16 +4555,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))
@@ -4442,10 +4586,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 + "'")
@@ -4462,8 +4605,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("+", ""))
@@ -4485,17 +4627,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)
@@ -4513,36 +4655,38 @@ 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])
@@ -4622,16 +4766,15 @@ 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):
+    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))
@@ -4654,9 +4797,8 @@ 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)
+    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 + "'")
@@ -4673,8 +4815,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("+", ""))
@@ -4696,12 +4837,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 = [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, fjsoncontent, fextrafieldslist, HeaderOut[-4], HeaderOut[-3], fcontents]
     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']
@@ -4721,7 +4862,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:
@@ -4729,20 +4870,42 @@ 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))
         VerbosePrintOut("'" + fprechecksum + "' != " +
                         "'" + newfcs + "'")
         return False
-    fnumfiles = int(inheader[4], 16)
+    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)):
+        fseeknextasnum = int(outfseeknextfile.replace("+", ""))
+        if(abs(fseeknextasnum) == 0):
+            pass
+        fp.seek(fseeknextasnum, 1)
+    elif(re.findall(r"^\-([0-9]+)", outfseeknextfile)):
+        fseeknextasnum = int(outfseeknextfile)
+        if(abs(fseeknextasnum) == 0):
+            pass
+        fp.seek(fseeknextasnum, 1)
+    elif(re.findall(r"^([0-9]+)", outfseeknextfile)):
+        fseeknextasnum = int(outfseeknextfile)
+        if(abs(fseeknextasnum) == 0):
+            pass
+        fp.seek(fseeknextasnum, 0)
+    else:
+        return False
     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)
@@ -4750,7 +4913,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']
@@ -4770,16 +4933,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[6], 16)
-    fnumextrafields = int(inheader[7], 16)
+    fnumextrafieldsize = int(inheader[15], 16)
+    fnumextrafields = int(inheader[16], 16)
     fextrafieldslist = []
-    extrastart = 8
+    extrastart = 17
     extraend = extrastart + fnumextrafields
     while(extrastart < extraend):
         fextrafieldslist.append(inheader[extrastart])
@@ -4793,17 +4956,126 @@ 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)>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]
-    fnumfiles = int(inheader[5], 16)
+    fheadctime = int(inheader[1], 16)
+    fheadmtime = int(inheader[1], 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"):
+        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("+", ""))
+        if(abs(fseeknextasnum) == 0):
+            pass
+        fp.seek(fseeknextasnum, 1)
+    elif(re.findall("^\\-([0-9]+)", fseeknextfile)):
+        fseeknextasnum = int(fseeknextfile)
+        if(abs(fseeknextasnum) == 0):
+            pass
+        fp.seek(fseeknextasnum, 1)
+    elif(re.findall("^([0-9]+)", fseeknextfile)):
+        fseeknextasnum = int(fseeknextfile)
+        if(abs(fseeknextasnum) == 0):
+            pass
+        fp.seek(fseeknextasnum, 0)
+    else:
+        return False
+    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))
@@ -4812,7 +5084,7 @@ def ReadFileDataWithContentToArray(fp, filestart=0, seekstart=0, seekend=0, list
         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, 'fimptype': fpythontype, 'fheadersize': fheadsize, 'fsize': CatSizeEnd, 'fnumfields': fnumfields + 2, 'fformatspecs': formatspecs, 'fchecksumtype': fprechecksumtype, 'fheaderchecksum': fprechecksum, '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):
@@ -4839,16 +5111,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 + "' != " +
@@ -4863,11 +5134,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 +
@@ -4894,8 +5164,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})
@@ -4906,7 +5175,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']
@@ -4926,16 +5195,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[6], 16)
-    fnumextrafields = int(inheader[7], 16)
+    fnumextrafieldsize = int(inheader[15], 16)
+    fnumextrafields = int(inheader[16], 16)
     fextrafieldslist = []
-    extrastart = 8
+    extrastart = 17
     extraend = extrastart + fnumextrafields
     while(extrastart < extraend):
         fextrafieldslist.append(inheader[extrastart])
@@ -4952,14 +5221,44 @@ def ReadFileDataWithContentToList(fp, filestart=0, seekstart=0, seekend=0, listo
     formversion = re.findall("([\\d]+)", formstring)
     fheadsize = int(inheader[0], 16)
     fnumfields = int(inheader[1], 16)
-    fhencoding = inheader[2]
-    fostype = inheader[3]
-    fpythontype = inheader[4]
-    fnumfiles = int(inheader[5], 16)
+    fnumfiles = int(inheader[8], 16)
+    fseeknextfile = inheaderdata[9]
+    fjsontype = int(inheader[10], 16)
+    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")
+    fjend = fp.tell()
+    if(re.findall("^\\+([0-9]+)", fseeknextfile)):
+        fseeknextasnum = int(fseeknextfile.replace("+", ""))
+        if(abs(fseeknextasnum) == 0):
+            pass
+        fp.seek(fseeknextasnum, 1)
+    elif(re.findall("^\\-([0-9]+)", fseeknextfile)):
+        fseeknextasnum = int(fseeknextfile)
+        if(abs(fseeknextasnum) == 0):
+            pass
+        fp.seek(fseeknextasnum, 1)
+    elif(re.findall("^([0-9]+)", fseeknextfile)):
+        fseeknextasnum = int(fseeknextfile)
+        if(abs(fseeknextasnum) == 0):
+            pass
+        fp.seek(fseeknextasnum, 0)
+    else:
+        return False
+    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))
@@ -4978,7 +5277,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:
@@ -5000,16 +5299,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(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 + "' != " +
@@ -5026,11 +5324,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(prefcs, prenewfcs) 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 +
@@ -5057,8 +5354,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)
@@ -5066,7 +5362,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:
@@ -5161,7 +5457,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)
@@ -5183,27 +5479,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:
@@ -5298,7 +5594,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)
@@ -5320,24 +5616,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):
@@ -5391,12 +5687,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=None,
-                     checksumtype="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.
@@ -5444,24 +5735,47 @@ def AppendFileHeader(fp,
     # 4) core header fields before checksum:
     #    tmpoutlenhex, fencoding, platform.system(), fnumfiles
     fnumfiles_hex = _hex_lower(numfiles)
-
+    fjsontype = "json"
+    if(len(jsondata) > 0):
+        try:
+            fjsoncontent = json.dumps(jsondata, separators=(',', ':')).encode("UTF-8")
+        except (binascii.Error, json.decoder.JSONDecodeError, UnicodeDecodeError):
+            fjsoncontent = "".encode("UTF-8")
+    else:
+        fjsoncontent = "".encode("UTF-8")
+    fjsonsize = format(len(fjsoncontent), 'x').lower()
+    fjsonlen = format(len(jsondata), 'x').lower()
+    tmpoutlist = []
+    tmpoutlist.append(fjsontype)
+    tmpoutlist.append(fjsonlen)
+    tmpoutlist.append(fjsonsize)
+    if(len(jsondata) > 0):
+        tmpoutlist.append(checksumtype[1])
+        tmpoutlist.append(GetFileChecksum(fjsoncontent, checksumtype[1], True, formatspecs, saltkey))
+    else:
+        tmpoutlist.append("none")
+        tmpoutlist.append(GetFileChecksum(fjsoncontent, "none", True, formatspecs, saltkey))
     # Preserve your original "tmpoutlen" computation exactly
-    tmpoutlist = [extrasizelen, extrafields]   # you used this as a separate list
-    tmpoutlen = 4 + len(tmpoutlist) + len(xlist) + 2
+    tmpoutlist.append(extrasizelen)
+    tmpoutlist.append(extrafields)
+    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, fnumfiles_hex], delimiter)
+    fnumfilesa = AppendNullBytes([tmpoutlenhex, fctime, fctime, fencoding, platform.system(), py_implementation, __program_name__, fnumfiles_hex, "+"+str(len(formatspecs['format_delimiter']))], delimiter)
     # Append tmpoutlist
     fnumfilesa += AppendNullBytes(tmpoutlist, delimiter)
     # Append extradata items if any
     if xlist:
         fnumfilesa += AppendNullBytes(xlist, delimiter)
     # Append checksum type
-    fnumfilesa += AppendNullByte(checksumtype, delimiter)
+    fnumfilesa += AppendNullByte(checksumtype[0], delimiter)
 
     # 5) inner checksum over fnumfilesa
-    outfileheadercshex = GetFileChecksum(fnumfilesa, checksumtype, 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
@@ -5474,7 +5788,7 @@ def AppendFileHeader(fp,
         + fnumfilesa
     )
 
-    outfileheadercshex = GetFileChecksum(fnumfilesa, checksumtype, True, formatspecs)
+    outfileheadercshex = GetFileChecksum(fnumfilesa, checksumtype[0], True, formatspecs, saltkey)
     fnumfilesa += AppendNullByte(outfileheadercshex, delimiter)
 
     # 8) final total size field (again per your original logic)
@@ -5482,10 +5796,11 @@ def AppendFileHeader(fp,
     formheaersizestr = AppendNullByte(formheaersize, delimiter)  # computed but not appended in original
     # Note: you computed 'formheaersizestr' but didn’t append it afterward in the original either.
     # Keeping that behavior for compatibility.
-
+    nullstrecd = formatspecs['format_delimiter'].encode('UTF-8')
+    outfileout = fnumfilesa + fjsoncontent + nullstrecd
     # 9) write and try to sync
     try:
-        fp.write(fnumfilesa)
+        fp.write(outfileout)
     except (OSError, io.UnsupportedOperation):
         return False
 
@@ -5506,21 +5821,21 @@ def AppendFileHeader(fp,
     return fp
 
 
-def MakeEmptyFilePointer(fp, fmttype=__file_format_default__, checksumtype="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 MakeEmptyFoxFilePointer(fp, fmttype=__file_format_default__, checksumtype="md5", formatspecs=__file_format_multi_dict__):
-    return MakeEmptyFilePointer(fp, fmttype, checksumtype, formatspecs)
+def MakeEmptyFoxFilePointer(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", 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)
@@ -5550,6 +5865,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:
@@ -5561,7 +5877,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)
@@ -5592,11 +5908,11 @@ def MakeEmptyFile(outfile, fmttype="auto", compression="auto", compresswholefile
         return True
 
 
-def MakeEmptyFoxFile(outfile, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype="md5", formatspecs=__file_format_dict__, returnfp=False):
-    return MakeEmptyFile(outfile, "auto", compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, formatspecs, returnfp)
+def MakeEmptyFoxFile(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:
@@ -5628,10 +5944,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(
@@ -5646,22 +5962,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'])
@@ -5679,14 +5991,11 @@ 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"], formatspecs=__file_format_dict__, verbose=False):
+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):
     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)
+    advancedlist = __use_advanced_list__
+    altinode = __use_alt_inode__
     infilelist = []
     if(infiles == "-"):
         for line in PY_STDIN_TEXT:
@@ -5728,7 +6037,7 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
     inodetoforminode = {}
     numfiles = int(len(GetDirList))
     fnumfiles = format(numfiles, 'x').lower()
-    AppendFileHeader(fp, numfiles, "UTF-8", [], checksumtype[0], formatspecs)
+    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
     try:
         fp.flush()
         if(hasattr(os, "sync")):
@@ -5757,14 +6066,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
@@ -5786,43 +6105,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:
@@ -5833,13 +6151,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()
@@ -5866,8 +6199,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")):
@@ -5928,10 +6260,9 @@ 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)
@@ -5982,10 +6313,9 @@ def AppendFilesWithContent(infiles, fp, dirlistfromtxt=False, extradata=[], json
             fcompression = ""
         fcontents.seek(0, 0)
         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[1], checksumtype[2], checksumtype[3]], formatspecs)
+        tmpoutlist = [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']))]
+        AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, saltkey)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -5994,12 +6324,9 @@ 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"], formatspecs=__file_format_dict__, verbose=False):
+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
-    if(verbose):
-        logging.basicConfig(format="%(message)s",
-                            stream=PY_STDOUT_TEXT, level=logging.DEBUG)
     curinode = 0
     curfid = 0
     inodelist = []
@@ -6063,7 +6390,7 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
     except FileNotFoundError:
         return False
     numfiles = int(len(tarfp.getmembers()))
-    AppendFileHeader(fp, numfiles, "UTF-8", [], checksumtype[0], formatspecs)
+    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
     try:
         fp.flush()
         if(hasattr(os, "sync")):
@@ -6081,6 +6408,15 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
         fpremode = member.mode
         ffullmode = member.mode
         flinkcount = 0
+        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(member.isreg()):
             ffullmode = member.mode + stat.S_IFREG
@@ -6118,12 +6454,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:
@@ -6134,10 +6469,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()
@@ -6204,10 +6539,9 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
             fcompression = ""
         fcontents.seek(0, 0)
         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[1], checksumtype[2], checksumtype[3]], formatspecs)
+        tmpoutlist = [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']))]
+        AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, saltkey)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -6217,12 +6551,9 @@ def AppendFilesWithContentFromTarFile(infile, fp, extradata=[], jsondata={}, com
         fcontents.close()
     return fp
 
-def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=False):
+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
-    if(verbose):
-        logging.basicConfig(format="%(message)s",
-                            stream=PY_STDOUT_TEXT, level=logging.DEBUG)
     curinode = 0
     curfid = 0
     inodelist = []
@@ -6256,7 +6587,7 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
     if(ziptest):
         VerbosePrintOut("Bad file found!")
     numfiles = int(len(zipfp.infolist()))
-    AppendFileHeader(fp, numfiles, "UTF-8", [], checksumtype[0], formatspecs)
+    AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
     try:
         fp.flush()
         if(hasattr(os, "sync")):
@@ -6277,6 +6608,15 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
         else:
             fpremode = int(stat.S_IFREG | 0x1b6)
         flinkcount = 0
+        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(member, "is_dir") and member.is_dir()) or member.filename.endswith('/')):
             ftype = 5
@@ -6287,8 +6627,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):
@@ -6296,13 +6635,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('/')):
@@ -6418,10 +6757,9 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
             fcompression = ""
         fcontents.seek(0, 0)
         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[1], checksumtype[2], checksumtype[3]], formatspecs)
+        tmpoutlist = [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']))]
+        AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, saltkey)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -6432,16 +6770,12 @@ def AppendFilesWithContentFromZipFile(infile, fp, extradata=[], jsondata={}, com
     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"], formatspecs=__file_format_dict__, verbose=False):
+    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
-
-if(rarfile_support):
-    def AppendFilesWithContentFromRarFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=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__, 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)
         curinode = 0
         curfid = 0
         inodelist = []
@@ -6457,7 +6791,7 @@ if(rarfile_support):
         if(rartest):
             VerbosePrintOut("Bad file found!")
         numfiles = int(len(rarfp.infolist()))
-        AppendFileHeader(fp, numfiles, "UTF-8", [], checksumtype[0], formatspecs)
+        AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -6513,6 +6847,15 @@ if(rarfile_support):
             fcompression = ""
             fcsize = format(int(0), 'x').lower()
             flinkcount = 0
+            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(member.is_file()):
                 ftype = 0
@@ -6527,8 +6870,7 @@ if(rarfile_support):
             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):
@@ -6537,20 +6879,20 @@ if(rarfile_support):
                 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(
@@ -6652,10 +6994,9 @@ if(rarfile_support):
                 fcompression = ""
             fcontents.seek(0, 0)
             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[1], checksumtype[2], checksumtype[3]], formatspecs)
+            tmpoutlist = [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']))]
+            AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, saltkey)
             try:
                 fp.flush()
                 if(hasattr(os, "sync")):
@@ -6666,16 +7007,12 @@ if(rarfile_support):
         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"], formatspecs=__file_format_dict__, verbose=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
-
-if(py7zr_support):
-    def AppendFilesWithContentFromSevenZipFile(infile, fp, extradata=[], jsondata={}, compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5", "md5"], formatspecs=__file_format_dict__, verbose=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__, 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)
         formver = formatspecs['format_ver']
         fileheaderver = str(int(formver.replace(".", "")))
         curinode = 0
@@ -6693,7 +7030,7 @@ if(py7zr_support):
         if(sztestalt):
             VerbosePrintOut("Bad file found!")
         numfiles = int(len(szpfp.list()))
-        AppendFileHeader(fp, numfiles, "UTF-8", [], checksumtype[0], formatspecs)
+        AppendFileHeader(fp, numfiles, "UTF-8", [], {}, [checksumtype[0], checksumtype[1]], formatspecs, saltkey)
         try:
             fp.flush()
             if(hasattr(os, "sync")):
@@ -6716,6 +7053,15 @@ if(py7zr_support):
             fcompression = ""
             fcsize = format(int(0), 'x').lower()
             flinkcount = 0
+            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(member.is_directory):
                 ftype = 5
@@ -6726,14 +7072,13 @@ if(py7zr_support):
             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(
@@ -6826,10 +7171,9 @@ if(py7zr_support):
                 fcompression = ""
             fcontents.seek(0, 0)
             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[1], checksumtype[2], checksumtype[3]], formatspecs)
+            tmpoutlist = [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']))]
+            AppendFileHeaderWithContent(fp, tmpoutlist, extradata, jsondata, fcontents.read(), [checksumtype[2], checksumtype[3], checksumtype[4]], formatspecs, saltkey)
             try:
                 fp.flush()
                 if(hasattr(os, "sync")):
@@ -6839,11 +7183,9 @@ if(py7zr_support):
             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"], 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
@@ -6855,7 +7197,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], 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]
@@ -6869,44 +7211,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[1], checksumtype[2], checksumtype[3]], 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"], 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)
@@ -6950,8 +7293,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)
@@ -6980,12 +7322,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"], 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:
@@ -6995,7 +7337,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"], 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)
@@ -7036,8 +7378,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)
@@ -7067,7 +7408,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"], 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)
@@ -7109,8 +7450,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)
@@ -7140,12 +7480,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"], 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:
@@ -7155,7 +7495,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"], 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)
@@ -7197,8 +7537,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)
@@ -7228,12 +7567,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"], 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:
@@ -7244,11 +7583,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"], 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
-
-if(rarfile_support):
-    def AppendFilesWithContentFromRarFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=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__, 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)
@@ -7290,8 +7628,7 @@ if(rarfile_support):
                 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)
@@ -7321,12 +7658,12 @@ if(rarfile_support):
             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"], 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:
@@ -7337,11 +7674,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"], 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
-
-if(py7zr_support):
-    def AppendFilesWithContentFromSevenZipFileToOutFile(infiles, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, extradata=[], jsondata={}, checksumtype=["md5", "md5", "md5", "md5"], formatspecs=__file_format_multi_dict__, verbose=False, returnfp=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__, 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)
@@ -7383,8 +7719,7 @@ if(py7zr_support):
                 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)
@@ -7414,12 +7749,12 @@ if(py7zr_support):
             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"], 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:
@@ -7429,9 +7764,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"], 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):
@@ -9172,58 +9507,54 @@ def CheckSumSupport(checkfor, guaranteed=True):
         return False
 
 
-def PackFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["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 PackFoxFile(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 PackStackedFoxFile(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["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 PackStackedFoxFile(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 PackFoxFileFromDirList(infiles, outfile, dirlistfromtxt=False, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, followlink=False, checksumtype=["md5", "md5", "md5"], extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
-    return PackFoxFile(infiles, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, checksumtype, extradata, formatspecs, verbose, returnfp)
+def PackFoxFileFromDirList(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 PackFoxFile(infiles, outfile, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, checksumtype, extradata, formatspecs, saltkey, verbose, returnfp)
 
 
-def PackFoxFileFromTarFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["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 PackFoxFileFromTarFile(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 PackFoxFileFromZipFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["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 PackFoxFileFromZipFile(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 PackFoxFileFromRarFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
+    def PackFoxFileFromRarFile(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
-
-if(rarfile_support):
-    def PackFoxFileFromRarFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["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)
+else:
+    def PackFoxFileFromRarFile(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 PackFoxFileFromSevenZipFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], extradata=[], formatspecs=__file_format_dict__, verbose=False, returnfp=False):
+    def PackFoxFileFromSevenZipFile(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
-
-if(py7zr_support):
-    def PackFoxFileFromSevenZipFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["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)
+else:
+    def PackFoxFileFromSevenZipFile(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 PackFoxFileFromInFile(infile, outfile, fmttype="auto", compression="auto", compresswholefile=True, compressionlevel=None, compressionuselist=compressionlistalt, checksumtype=["md5", "md5", "md5"], extradata=[], jsondata={}, formatspecs=__file_format_dict__, verbose=False, returnfp=False):
+def PackFoxFileFromInFile(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 PackFoxFileFromTarFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, verbose, returnfp)
+        return PackFoxFileFromTarFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, saltkey, verbose, returnfp)
     elif(checkcompressfile == "zipfile" and zipfile.is_zipfile(infile)):
-        return PackFoxFileFromZipFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, verbose, returnfp)
+        return PackFoxFileFromZipFile(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 PackFoxFileFromRarFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, verbose, returnfp)
+        return PackFoxFileFromRarFile(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 PackFoxFileFromSevenZipFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, verbose, returnfp)
+        return PackFoxFileFromSevenZipFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, checksumtype, extradata, jsondata, formatspecs, saltkey, verbose, returnfp)
     elif(IsSingleDict(formatspecs) and checkcompressfile == formatspecs['format_magic']):
-        return RePackFoxFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, False, 0, 0, checksumtype, False, extradata, jsondata, formatspecs, verbose, returnfp)
+        return RePackFoxFile(infile, outfile, fmttype, compression, compresswholefile, compressionlevel, False, 0, 0, checksumtype, False, extradata, jsondata, formatspecs, saltkey, verbose, returnfp)
     else:
         return False
     return False
@@ -9292,19 +9623,12 @@ def FoxFileArrayValidate(listarrayfiles, verbose=False):
             ok = False
     return ok
 
-def FoxFileValidate(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 FoxFileValidate(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
@@ -9320,7 +9644,6 @@ def FoxFileValidate(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__)
@@ -9332,7 +9655,6 @@ def FoxFileValidate(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)
@@ -9344,7 +9666,6 @@ def FoxFileValidate(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)
@@ -9355,7 +9676,6 @@ def FoxFileValidate(infile, fmttype="auto", filestart=0,
         if(not fp):
             return False
         fp.seek(filestart, 0)
-
     else:
         infile = RemoveWindowsPath(infile)
         checkcompressfile = CheckCompressionSubType(infile, formatspecs, filestart, True)
@@ -9402,11 +9722,9 @@ def FoxFileValidate(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):
@@ -9414,43 +9732,59 @@ def FoxFileValidate(infile, fmttype="auto", filestart=0,
         else:
             formatspecs = formatspecs[compresschecking]
             fp.seek(filestart, 0)
-
     inheaderver = str(int(formatspecs['format_ver'].replace(".", "")))
     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']):
+    headeroffset = fp.tell()
+    if(__use_new_style__):
         inheader = ReadFileHeaderDataBySize(fp, formatspecs['format_delimiter'])
     else:
         inheader = ReadFileHeaderDataWoSize(fp, formatspecs['format_delimiter'])
-
-    fnumextrafieldsize = int(inheader[6], 16)
-    fnumextrafields = int(inheader[7], 16)
-    extrastart = 8
+    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)
-    fhencoding = inheader[2]
-    fostype = inheader[3]
-    fpythontype = inheader[4]
-    fnumfiles = int(inheader[5], 16)
+    fnumfiles = int(inheader[8], 16)
     fprechecksumtype = inheader[-2]
     fprechecksum = inheader[-1]
-
+    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, saltkey)
+    # Next seek directive
+    if(re.findall(r"^\+([0-9]+)", outfseeknextfile)):
+        fseeknextasnum = int(outfseeknextfile.replace("+", ""))
+        if(abs(fseeknextasnum) == 0):
+            pass
+        fp.seek(fseeknextasnum, 1)
+    elif(re.findall(r"^\-([0-9]+)", outfseeknextfile)):
+        fseeknextasnum = int(outfseeknextfile)
+        if(abs(fseeknextasnum) == 0):
+            pass
+        fp.seek(fseeknextasnum, 1)
+    elif(re.findall(r"^([0-9]+)", outfseeknextfile)):
+        fseeknextasnum = int(outfseeknextfile)
+        if(abs(fseeknextasnum) == 0):
+            pass
+        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:
@@ -9462,78 +9796,56 @@ def FoxFileValidate(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)
@@ -9541,27 +9853,21 @@ def FoxFileValidate(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 + "'")
@@ -9571,9 +9877,8 @@ def FoxFileValidate(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 + "'")
@@ -9583,21 +9888,19 @@ def FoxFileValidate(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 + "'")
@@ -9607,10 +9910,8 @@ def FoxFileValidate(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("+", ""))
@@ -9629,9 +9930,7 @@ def FoxFileValidate(infile, fmttype="auto", filestart=0,
             fp.seek(fseeknextasnum, 0)
         else:
             return False
-
         il = il + 1
-
     if(valid_archive):
         if(returnfp):
             return fp
@@ -9643,34 +9942,34 @@ def FoxFileValidate(infile, fmttype="auto", filestart=0,
         return False
 
 
-def FoxFileValidateFile(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    return FoxFileValidate(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+def FoxFileValidateFile(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
+    return FoxFileValidate(infile, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
 
 
-def FoxFileValidateMultiple(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+def FoxFileValidateMultiple(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 = FoxFileValidate(curfname, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+        curretfile = FoxFileValidate(curfname, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
         if(not curretfile):
             outretval = False
     return outretval
 
-def FoxFileValidateMultipleFiles(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    return FoxFileValidateMultiple(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+def FoxFileValidateMultipleFiles(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
+    return FoxFileValidateMultiple(infile, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
 
 
-def StackedFoxFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+def StackedFoxFileValidate(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 = FoxFileValidate(infile, fmttype, outstartfile, formatspecs, seektoend, verbose, True)
+        is_valid_file = FoxFileValidate(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
@@ -9687,33 +9986,36 @@ def StackedFoxFileValidate(infile, fmttype="auto", filestart=0, formatspecs=__fi
     if(returnfp):
         return infile
     else:
-        infile.close()
+        try:
+            infile.close()
+        except AttributeError:
+            return False
         return outretval
     
 
 
-def StackedFoxFileValidateFile(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    return StackedFoxFileValidate(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+def StackedFoxFileValidateFile(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
+    return StackedFoxFileValidate(infile, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
 
 
-def StackedFoxFileValidateMultiple(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
+def StackedFoxFileValidateMultiple(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 = StackedFoxFileValidate(curfname, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+        curretfile = StackedFoxFileValidate(curfname, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
         if(not curretfile):
             outretval = False
     return outretval
 
-def StackedFoxFileValidateMultipleFiles(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, returnfp=False):
-    return StackedFoxFileValidateMultiple(infile, fmttype, filestart, formatspecs, seektoend, verbose, returnfp)
+def StackedFoxFileValidateMultipleFiles(infile, fmttype="auto", filestart=0, formatspecs=__file_format_multi_dict__, saltkey=None, seektoend=False, verbose=False, returnfp=False):
+    return StackedFoxFileValidateMultiple(infile, fmttype, filestart, formatspecs, saltkey, seektoend, verbose, returnfp)
 
 
-def FoxFileToArray(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 FoxFileToArray(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')
@@ -9727,26 +10029,26 @@ def FoxFileToArray(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0,
     return outfp
 
 
-def MultipleFoxFileToArray(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 MultipleFoxFileToArray(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(FoxFileToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp))
+        outretval.append(FoxFileToArray(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey, seektoend, returnfp))
     return outretval
 
-def MultipleFoxFilesToArray(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 MultipleFoxFileToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+def MultipleFoxFilesToArray(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 MultipleFoxFileToArray(infile, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
 
 
-def FoxFileStringToArray(instr, filestart=0, seekstart=0, seekend=0, listonly=False, contentasfile=True, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, returnfp=False):
+def FoxFileStringToArray(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 = FoxFileToArray(fp, "auto", filestart, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    listarrayfiles = FoxFileToArray(fp, "auto", filestart, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
     return listarrayfiles
 
 
@@ -9755,9 +10057,8 @@ def TarFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     fp = MkTempFile()
-    fp = PackFoxFileFromTarFile(
-        infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, False, True)
-    listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    fp = PackFoxFileFromTarFile(infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, None, False, True)
+    listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, None, seektoend, returnfp)
     return listarrayfiles
 
 
@@ -9766,9 +10067,8 @@ def ZipFileToArray(infile, seekstart=0, seekend=0, listonly=False, contentasfile
     if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
         formatspecs = formatspecs[checkcompressfile]
     fp = MkTempFile()
-    fp = PackFoxFileFromZipFile(
-        infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, False, True)
-    listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+    fp = PackFoxFileFromZipFile(infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, None, False, True)
+    listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, None, seektoend, returnfp)
     return listarrayfiles
 
 
@@ -9782,9 +10082,8 @@ if(rarfile_support):
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         fp = MkTempFile()
-        fp = PackFoxFileFromRarFile(
-            infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, False, True)
-        listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        fp = PackFoxFileFromRarFile(infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, None, False, True)
+        listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, None, seektoend, returnfp)
         return listarrayfiles
 
 if(not py7zr_support):
@@ -9797,13 +10096,12 @@ if(py7zr_support):
         if(IsNestedDict(formatspecs) and checkcompressfile in formatspecs):
             formatspecs = formatspecs[checkcompressfile]
         fp = MkTempFile()
-        fp = PackFoxFileFromSevenZipFile(
-            infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, False, True)
-        listarrayfiles = FoxFileToArray(fp, "auto", 0, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        fp = PackFoxFileFromSevenZipFile(infile, fp, "auto", True, None, compressionlistalt, "md5", [], formatspecs, None, False, True)
+        listarrayfiles = FoxFileToArray(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]
@@ -9816,17 +10114,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 FoxFileToArray(infile, "auto", filestart, seekstart, seekend, listonly, contentasfile, True, skipchecksum, formatspecs, seektoend, returnfp)
+        return FoxFileToArray(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 = PackFoxFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile,
-                              compressionlevel, followlink, checksumtype, extradata, formatspecs, verbose, True)
-    listarrayfiles = FoxFileToArray(outarray, "auto", filestart, seekstart, seekend, listonly, True, True, skipchecksum, formatspecs, seektoend, returnfp)
+    packform = PackFoxFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, followlink, checksumtype, extradata, formatspecs, saltkey, verbose, True)
+    listarrayfiles = FoxFileToArray(outarray, "auto", filestart, seekstart, seekend, listonly, True, True, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
     return listarrayfiles
 
 
@@ -9948,12 +10245,12 @@ def FoxFileArrayToArrayIndex(inarray, returnfp=False):
     return out
 
 
-def RePackFoxFile(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 RePackFoxFile(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:
@@ -9972,7 +10269,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
             infile = RemoveWindowsPath(infile)
         listarrayfileslist = FoxFileToArray(
             infile, "auto", filestart, seekstart, seekend,
-            False, True, True, skipchecksum, formatspecs, seektoend, False
+            False, True, True, skipchecksum, formatspecs, insaltkey, seektoend, False
         )
 
     # ---------- Format specs selection ----------
@@ -10039,9 +10336,6 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
         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
@@ -10054,7 +10348,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
         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
@@ -10084,6 +10378,9 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
             # 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()
@@ -10102,8 +10399,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
             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
@@ -10114,6 +10410,12 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
             # 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']
 
@@ -10149,7 +10451,11 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                         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)
@@ -10157,7 +10463,7 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                             cfcontents.close()
                         else:
                             ilcsize.append(float("inf"))
-                        ilmin += 1
+                        ilmin = ilmin + 1
                     ilcmin = ilcsize.index(min(ilcsize))
                     curcompression = compressionuselist[ilcmin]
 
@@ -10166,16 +10472,24 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 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):
@@ -10184,6 +10498,9 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                     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()
@@ -10202,14 +10519,19 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                     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']
@@ -10238,15 +10560,15 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
                 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:
@@ -10291,12 +10613,12 @@ def RePackFoxFile(infile, outfile, fmttype="auto", compression="auto", compressw
             pass
         return True
 
-def RePackMultipleFoxFile(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 RePackMultipleFoxFile(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 = RePackFoxFile(infileslist, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend, checksumtype, skipchecksum, extradata, jsondata, formatspecs, seektoend, verbose, True)
+        returnout = RePackFoxFile(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:
@@ -10306,33 +10628,28 @@ def RePackMultipleFoxFile(infiles, outfile, fmttype="auto", compression="auto",
         return True
     return returnout
 
-def RePackFoxFileFromString(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 RePackFoxFileFromString(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 = RePackFoxFile(fp, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend,
-                                     checksumtype, skipchecksum, extradata, jsondata, formatspecs, seektoend, verbose, returnfp)
+    listarrayfiles = RePackFoxFile(fp, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend, checksumtype, skipchecksum, extradata, jsondata, formatspecs, insaltkey, outsaltkey, seektoend, verbose, returnfp)
     return listarrayfiles
 
 
-def PackFoxFileFromListDir(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 PackFoxFileFromListDir(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 = PackFoxFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile,
-                              compressionlevel, compressionuselist, followlink, checksumtype, extradata, formatspecs, verbose, True)
-    listarrayfiles = RePackFoxFile(outarray, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend,
-                                     checksumtype, skipchecksum, extradata, jsondata, formatspecs, seektoend, verbose, returnfp)
+    packform = PackFoxFile(infiles, outarray, dirlistfromtxt, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, checksumtype, extradata, formatspecs, saltkey, verbose, True)
+    listarrayfiles = RePackFoxFile(outarray, outfile, fmttype, compression, compresswholefile, compressionlevel, compressionuselist, followlink, filestart, seekstart, seekend, checksumtype, skipchecksum, extradata, jsondata, formatspecs, saltkey, seektoend, verbose, returnfp)
     return listarrayfiles
 
 
-def UnPackFoxFile(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 UnPackFoxFile(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 = FoxFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, True, skipchecksum, formatspecs, seektoend, returnfp)
+        listarrayfiles = FoxFileToArray(infile, "auto", filestart, seekstart, seekend, False, True, True, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
     if(not listarrayfiles):
         return False
     lenlist = len(listarrayfiles['ffilelist'])
@@ -10568,9 +10885,9 @@ def UnPackFoxFile(infile, outdir=None, followlink=False, filestart=0, seekstart=
         return True
 
 
-def UnPackFoxFileString(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 UnPackFoxFileString(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 = UnPackFoxFile(fp, outdir, followlink, filestart, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, returnfp)
+    listarrayfiles = UnPackFoxFile(fp, outdir, followlink, filestart, seekstart, seekend, skipchecksum, formatspecs, saltkey, seektoend, verbose, returnfp)
     return listarrayfiles
 
 def ftype_to_str(ftype):
@@ -10588,9 +10905,7 @@ def ftype_to_str(ftype):
     # Default to "file" if unknown
     return mapping.get(ftype, "file")
 
-def FoxFileListFiles(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 FoxFileListFiles(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)):
@@ -10598,7 +10913,7 @@ def FoxFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0
     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 = FoxFileToArray(infile, fmttype, filestart, seekstart, seekend, True, False, False, skipchecksum, formatspecs, seektoend, returnfp)
+        listarrayfileslist = FoxFileToArray(infile, fmttype, filestart, seekstart, seekend, True, False, False, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
     if(not listarrayfileslist):
         return False
     for listarrayfiles in listarrayfileslist:
@@ -10635,8 +10950,11 @@ def FoxFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0
                     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']
@@ -10644,25 +10962,25 @@ def FoxFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, seekend=0
         return True
 
 
-def MultipleFoxFileListFiles(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 MultipleFoxFileListFiles(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] = FoxFileListFiles(infile, fmttype, filestart, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, returnfp)
+        outretval[curfname] = FoxFileListFiles(infile, fmttype, filestart, seekstart, seekend, skipchecksum, formatspecs, saltkey, seektoend, verbose, newstyle, returnfp)
     return outretval
 
 
-def StackedFoxFileListFiles(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 StackedFoxFileListFiles(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 = FoxFileListFiles(infile, fmttype, outstartfile, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, True)
+        list_file_retu = FoxFileListFiles(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:
@@ -10678,30 +10996,31 @@ def StackedFoxFileListFiles(infile, fmttype="auto", filestart=0, seekstart=0, se
     if(returnfp):
         return infile
     else:
-        infile.close()
+        try:
+            infile.close()
+        except AttributeError:
+            return False
         return outretval
 
 
-def MultipleStackedFoxFileListFiles(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 MultipleStackedFoxFileListFiles(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] = StackedFoxFileListFiles(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, seektoend, returnfp)
+        outretval[curfname] = StackedFoxFileListFiles(curfname, fmttype, filestart, seekstart, seekend, listonly, contentasfile, uncompress, skipchecksum, formatspecs, saltkey, seektoend, returnfp)
     return outretval
 
 
-def FoxFileStringListFiles(instr, filestart=0, seekstart=0, seekend=0, skipchecksum=False, formatspecs=__file_format_multi_dict__, seektoend=False, verbose=False, newstyle=False, returnfp=False):
+def FoxFileStringListFiles(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 = FoxFileListFiles(instr, "auto", filestart, seekstart, seekend, skipchecksum, formatspecs, seektoend, verbose, newstyle, returnfp)
+    listarrayfiles = FoxFileListFiles(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__)
@@ -10822,8 +11141,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__)
@@ -10949,8 +11266,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)):
@@ -11078,8 +11393,6 @@ 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
@@ -11173,8 +11486,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]
@@ -11201,44 +11512,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 PackFoxFile(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 FoxFileToArray(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 UnPackFoxFile(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 RePackFoxFile(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 FoxFileValidate(infile, "auto", formatspecs, False, verbose, returnfp)
-
-def listfiles_neo(infile, formatspecs=__file_format_multi_dict__, advanced=False, include_dirs=True, returnfp=False):
-    return FoxFileListFiles(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 RePackFoxFile(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,
@@ -12842,7 +13115,7 @@ def run_tcp_file_server(fileobj, url, on_progress=None):
     Ends after serving exactly one client or wait window elapses.
 
     URL example:
-      tcp://user:pass@0.0.0.0:5000/path/my.fox?
+      tcp://user:pass@0.0.0.0:5000/path/my.arc?
           auth=1&enforce_path=1&rate=200000&timeout=5&wait=30&ssl=0
     """
     parts, o = _parse_net_url(url)  # already returns proto/host/port/timeout/ssl/etc.
@@ -13044,7 +13317,7 @@ def run_udp_file_server(fileobj, url, on_progress=None):
     Ends after serving exactly one client or wait window elapses.
 
     URL example:
-      udp://user:pass@0.0.0.0:5001/path/my.fox?
+      udp://user:pass@0.0.0.0:5001/path/my.arc?
           auth=1&enforce_path=1&rate=250000&timeout=5&wait=30
     """
     parts, o = _parse_net_url(url)
@@ -13468,7 +13741,7 @@ def run_tcp_file_server(fileobj, url, on_progress=None):
     Ends after serving exactly one client or wait window elapses.
 
     URL example:
-      tcp://user:pass@0.0.0.0:5000/path/my.fox?
+      tcp://user:pass@0.0.0.0:5000/path/my.arc?
           auth=1&enforce_path=1&rate=200000&timeout=5&wait=30&ssl=0
     """
     parts, o = _parse_net_url(url)  # already returns proto/host/port/timeout/ssl/etc.
@@ -14020,7 +14293,7 @@ def run_udp_file_server(fileobj, url, on_progress=None):
     Ends after serving exactly one client or wait window elapses.
 
     URL example:
-      udp://user:pass@0.0.0.0:5001/path/my.fox?
+      udp://user:pass@0.0.0.0:5001/path/my.arc?
           auth=1&enforce_path=1&rate=250000&timeout=5&wait=30
     """
     parts, o = _parse_net_url(url)