
#
# Copyright 2018,2020 NXP
# SPDX-License-Identifier: Apache-2.0
#
#


# Begin preamble

import ctypes, os, sys
from ctypes import *

_int_types = (c_int16, c_int32)
if hasattr(ctypes, 'c_int64'):
    # Some builds of ctypes apparently do not have c_int64
    # defined; it's a pretty good bet that these builds do not
    # have 64-bit pointers.
    _int_types += (c_int64,)
for t in _int_types:
    if sizeof(t) == sizeof(c_size_t):
        c_ptrdiff_t = t
del t
del _int_types

class c_void(Structure):
    # c_void_p is a buggy return type, converting to int, so
    # POINTER(None) == c_void_p is actually written as
    # POINTER(c_void), so it can be treated as a real pointer.
    _fields_ = [('dummy', c_int)]

def POINTER(obj):
    p = ctypes.POINTER(obj)

    # Convert None to a real NULL pointer to work around bugs
    # in how ctypes handles None on 64-bit platforms
    if not isinstance(p.from_param, classmethod):
        def from_param(cls, x):
            if x is None:
                return cls()
            else:
                return x
        p.from_param = classmethod(from_param)

    return p

class UserString:
    def __init__(self, seq):
        if isinstance(seq, str):
            self.data = seq
        elif isinstance(seq, UserString):
            self.data = seq.data[:]
        else:
            self.data = str(seq)
    def __str__(self): return str(self.data)
    def __repr__(self): return repr(self.data)
    def __int__(self): return int(self.data)
    def __long__(self): return int(self.data)
    def __float__(self): return float(self.data)
    def __complex__(self): return complex(self.data)
    def __hash__(self): return hash(self.data)

    def __cmp__(self, string):
        if isinstance(string, UserString):
            return cmp(self.data, string.data)
        else:
            return cmp(self.data, string)
    def __contains__(self, char):
        return char in self.data

    def __len__(self): return len(self.data)
    def __getitem__(self, index): return self.__class__(self.data[index])
    def __getslice__(self, start, end):
        start = max(start, 0); end = max(end, 0)
        return self.__class__(self.data[start:end])

    def __add__(self, other):
        if isinstance(other, UserString):
            return self.__class__(self.data + other.data)
        elif isinstance(other, str):
            return self.__class__(self.data + other)
        else:
            return self.__class__(self.data + str(other))
    def __radd__(self, other):
        if isinstance(other, str):
            return self.__class__(other + self.data)
        else:
            return self.__class__(str(other) + self.data)
    def __mul__(self, n):
        return self.__class__(self.data*n)
    __rmul__ = __mul__
    def __mod__(self, args):
        return self.__class__(self.data % args)

    # the following methods are defined in alphabetical order:
    def capitalize(self): return self.__class__(self.data.capitalize())
    def center(self, width, *args):
        return self.__class__(self.data.center(width, *args))
    def count(self, sub, start=0, end=sys.maxsize):
        return self.data.count(sub, start, end)
    def decode(self, encoding=None, errors=None): # XXX improve this?
        if encoding:
            if errors:
                return self.__class__(self.data.decode(encoding, errors))
            else:
                return self.__class__(self.data.decode(encoding))
        else:
            return self.__class__(self.data.decode())
    def encode(self, encoding=None, errors=None): # XXX improve this?
        if encoding:
            if errors:
                return self.__class__(self.data.encode(encoding, errors))
            else:
                return self.__class__(self.data.encode(encoding))
        else:
            return self.__class__(self.data.encode())
    def endswith(self, suffix, start=0, end=sys.maxsize):
        return self.data.endswith(suffix, start, end)
    def expandtabs(self, tabsize=8):
        return self.__class__(self.data.expandtabs(tabsize))
    def find(self, sub, start=0, end=sys.maxsize):
        return self.data.find(sub, start, end)
    def index(self, sub, start=0, end=sys.maxsize):
        return self.data.index(sub, start, end)
    def isalpha(self): return self.data.isalpha()
    def isalnum(self): return self.data.isalnum()
    def isdecimal(self): return self.data.isdecimal()
    def isdigit(self): return self.data.isdigit()
    def islower(self): return self.data.islower()
    def isnumeric(self): return self.data.isnumeric()
    def isspace(self): return self.data.isspace()
    def istitle(self): return self.data.istitle()
    def isupper(self): return self.data.isupper()
    def join(self, seq): return self.data.join(seq)
    def ljust(self, width, *args):
        return self.__class__(self.data.ljust(width, *args))
    def lower(self): return self.__class__(self.data.lower())
    def lstrip(self, chars=None): return self.__class__(self.data.lstrip(chars))
    def partition(self, sep):
        return self.data.partition(sep)
    def replace(self, old, new, maxsplit=-1):
        return self.__class__(self.data.replace(old, new, maxsplit))
    def rfind(self, sub, start=0, end=sys.maxsize):
        return self.data.rfind(sub, start, end)
    def rindex(self, sub, start=0, end=sys.maxsize):
        return self.data.rindex(sub, start, end)
    def rjust(self, width, *args):
        return self.__class__(self.data.rjust(width, *args))
    def rpartition(self, sep):
        return self.data.rpartition(sep)
    def rstrip(self, chars=None): return self.__class__(self.data.rstrip(chars))
    def split(self, sep=None, maxsplit=-1):
        return self.data.split(sep, maxsplit)
    def rsplit(self, sep=None, maxsplit=-1):
        return self.data.rsplit(sep, maxsplit)
    def splitlines(self, keepends=0): return self.data.splitlines(keepends)
    def startswith(self, prefix, start=0, end=sys.maxsize):
        return self.data.startswith(prefix, start, end)
    def strip(self, chars=None): return self.__class__(self.data.strip(chars))
    def swapcase(self): return self.__class__(self.data.swapcase())
    def title(self): return self.__class__(self.data.title())
    def translate(self, *args):
        return self.__class__(self.data.translate(*args))
    def upper(self): return self.__class__(self.data.upper())
    def zfill(self, width): return self.__class__(self.data.zfill(width))

class MutableString(UserString):
    """mutable string objects

    Python strings are immutable objects.  This has the advantage, that
    strings may be used as dictionary keys.  If this property isn't needed
    and you insist on changing string values in place instead, you may cheat
    and use MutableString.

    But the purpose of this class is an educational one: to prevent
    people from inventing their own mutable string class derived
    from UserString and than forget thereby to remove (override) the
    __hash__ method inherited from UserString.  This would lead to
    errors that would be very hard to track down.

    A faster and better solution is to rewrite your program using lists."""
    def __init__(self, string=""):
        self.data = string
    def __hash__(self):
        raise TypeError("unhashable type (it is mutable)")
    def __setitem__(self, index, sub):
        if index < 0:
            index += len(self.data)
        if index < 0 or index >= len(self.data): raise IndexError
        self.data = self.data[:index] + sub + self.data[index+1:]
    def __delitem__(self, index):
        if index < 0:
            index += len(self.data)
        if index < 0 or index >= len(self.data): raise IndexError
        self.data = self.data[:index] + self.data[index+1:]
    def __setslice__(self, start, end, sub):
        start = max(start, 0); end = max(end, 0)
        if isinstance(sub, UserString):
            self.data = self.data[:start]+sub.data+self.data[end:]
        elif isinstance(sub, str):
            self.data = self.data[:start]+sub+self.data[end:]
        else:
            self.data =  self.data[:start]+str(sub)+self.data[end:]
    def __delslice__(self, start, end):
        start = max(start, 0); end = max(end, 0)
        self.data = self.data[:start] + self.data[end:]
    def immutable(self):
        return UserString(self.data)
    def __iadd__(self, other):
        if isinstance(other, UserString):
            self.data += other.data
        elif isinstance(other, str):
            self.data += other
        else:
            self.data += str(other)
        return self
    def __imul__(self, n):
        self.data *= n
        return self

class String(MutableString, Union):

    _fields_ = [('raw', POINTER(c_char)),
                ('data', c_char_p)]

    def __init__(self, obj=""):
        if isinstance(obj, (str, UserString)):
            self.data = str(obj)
        else:
            self.raw = obj

    def __len__(self):
        return self.data and len(self.data) or 0

    def from_param(cls, obj):
        # Convert None or 0
        if obj is None or obj == 0:
            return cls(POINTER(c_char)())

        # Convert from String
        elif isinstance(obj, String):
            return obj

        # Convert from str
        elif isinstance(obj, str):
            return cls(obj)

        # Convert from c_char_p
        elif isinstance(obj, c_char_p):
            return obj

        # Convert from POINTER(c_char)
        elif isinstance(obj, POINTER(c_char)):
            return obj

        # Convert from raw pointer
        elif isinstance(obj, int):
            return cls(cast(obj, POINTER(c_char)))

        # Convert from object
        else:
            return String.from_param(obj._as_parameter_)
    from_param = classmethod(from_param)

def ReturnString(obj, func=None, arguments=None):
    return String.from_param(obj)

# As of ctypes 1.0, ctypes does not support custom error-checking
# functions on callbacks, nor does it support custom datatypes on
# callbacks, so we must ensure that all callbacks return
# primitive datatypes.
#
# Non-primitive return values wrapped with UNCHECKED won't be
# typechecked, and will be converted to c_void_p.
def UNCHECKED(type):
    if (hasattr(type, "_type_") and isinstance(type._type_, str)
        and type._type_ != "P"):
        return type
    else:
        return c_void_p

# ctypes doesn't have direct support for variadic functions, so we have to write
# our own wrapper class
class _variadic_function(object):
    def __init__(self,func,restype,argtypes):
        self.func=func
        self.func.restype=restype
        self.argtypes=argtypes
    def _as_parameter_(self):
        # So we can pass this variadic function as a function pointer
        return self.func
    def __call__(self,*args):
        fixed_args=[]
        i=0
        for argtype in self.argtypes:
            # Typecheck what we can
            fixed_args.append(argtype.from_param(args[i]))
            i+=1
        return self.func(*fixed_args+list(args[i:]))

# End preamble

_libs = {}
_libdirs = ['/usr/local/lib']

# Begin loader

# ----------------------------------------------------------------------------
# Copyright (c) 2008 David James
# Copyright (c) 2006-2008 Alex Holkner
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
#  * Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#  * Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in
#    the documentation and/or other materials provided with the
#    distribution.
#  * Neither the name of pyglet nor the names of its
#    contributors may be used to endorse or promote products
#    derived from this software without specific prior written
#    permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
# ----------------------------------------------------------------------------

import os.path, re, sys, glob
import platform
import ctypes
import logging
import ctypes.util
log = logging.getLogger(__name__)

def _environ_path(name):
    if name in os.environ:
        return os.environ[name].split(":")
    else:
        return []

class LibraryLoader(object):
    def __init__(self):
        self.other_dirs=[]

    def load_library(self,libname):
        """Given the name of a library, load it."""
        paths = self.getpaths(libname)

        for path in paths:
            if os.path.exists(path):
                log.debug("loading library from path: %s" % path)
                return self.load(path)

        raise ImportError("%s not found." % libname)

    def load(self,path):
        """Given a path to a library, load it."""
        try:
            # Darwin requires dlopen to be called with mode RTLD_GLOBAL instead
            # of the default RTLD_LOCAL.  Without this, you end up with
            # libraries not being loadable, resulting in "Symbol not found"
            # errors
            if sys.platform == 'darwin':
                return ctypes.CDLL(path, ctypes.RTLD_GLOBAL)
            else:
                return ctypes.cdll.LoadLibrary(path)
        except OSError as e:
            raise ImportError(e)

    def getpaths(self,libname):
        """Return a list of paths where the library might be found."""
        if os.path.isabs(libname):
            yield libname
        else:
            # FIXME / TODO return '.' and os.path.dirname(__file__)
            for path in self.getplatformpaths(libname):
                yield path

            path = ctypes.util.find_library(libname)
            if path: yield path

    def getplatformpaths(self, libname):
        return []

# Darwin (Mac OS X)

class DarwinLibraryLoader(LibraryLoader):
    name_formats = ["lib%s.dylib", "lib%s.so", "lib%s.bundle", "%s.dylib",
                "%s.so", "%s.bundle", "%s"]

    def getplatformpaths(self,libname):
        if os.path.pathsep in libname:
            names = [libname]
        else:
            names = [format % libname for format in self.name_formats]

        for dir in self.getdirs(libname):
            for name in names:
                yield os.path.join(dir,name)

    def getdirs(self,libname):
        '''Implements the dylib search as specified in Apple documentation:

        http://developer.apple.com/documentation/DeveloperTools/Conceptual/
            DynamicLibraries/Articles/DynamicLibraryUsageGuidelines.html

        Before commencing the standard search, the method first checks
        the bundle's ``Frameworks`` directory if the application is running
        within a bundle (OS X .app).
        '''

        dyld_fallback_library_path = _environ_path("DYLD_FALLBACK_LIBRARY_PATH")
        if not dyld_fallback_library_path:
            dyld_fallback_library_path = [os.path.expanduser('~/lib'),
                                          '/usr/local/lib', '/usr/lib']

        dirs = []

        if '/' in libname:
            dirs.extend(_environ_path("DYLD_LIBRARY_PATH"))
        else:
            dirs.extend(_environ_path("LD_LIBRARY_PATH"))
            dirs.extend(_environ_path("DYLD_LIBRARY_PATH"))

        dirs.extend(self.other_dirs)
        dirs.append(".")
        dirs.append(os.path.dirname(__file__))

        if hasattr(sys, 'frozen') and sys.frozen == 'macosx_app':
            dirs.append(os.path.join(
                os.environ['RESOURCEPATH'],
                '..',
                'Frameworks'))

        dirs.extend(dyld_fallback_library_path)

        return dirs

# Posix

class PosixLibraryLoader(LibraryLoader):
    _ld_so_cache = None

    def _create_ld_so_cache(self):
        # Recreate search path followed by ld.so.  This is going to be
        # slow to build, and incorrect (ld.so uses ld.so.cache, which may
        # not be up-to-date).  Used only as fallback for distros without
        # /sbin/ldconfig.
        #
        # We assume the DT_RPATH and DT_RUNPATH binary sections are omitted.

        directories = []
        for name in ("LD_LIBRARY_PATH",
                     "SHLIB_PATH", # HPUX
                     "LIBPATH", # OS/2, AIX
                     "LIBRARY_PATH", # BE/OS
                    ):
            if name in os.environ:
                directories.extend(os.environ[name].split(os.pathsep))
        directories.extend("/usr/local/lib")
        directories.extend(self.other_dirs)
        directories.append(".")
        directories.append(os.path.dirname(__file__))

        try: directories.extend([dir.strip() for dir in open('/etc/ld.so.conf')])
        except IOError: pass

        unix_lib_dirs_list = ['/lib', '/usr/lib', '/lib64', '/usr/lib64']
        if sys.platform.startswith('linux'):
            # Try and support multiarch work in Ubuntu
            # https://wiki.ubuntu.com/MultiarchSpec
            bitage = platform.architecture()[0]
            if bitage.startswith('32'):
                # Assume Intel/AMD x86 compat
                unix_lib_dirs_list += ['/lib/i386-linux-gnu', '/usr/lib/i386-linux-gnu']
            elif bitage.startswith('64'):
                # Assume Intel/AMD x86 compat
                unix_lib_dirs_list += ['/lib/x86_64-linux-gnu', '/usr/lib/x86_64-linux-gnu']
            else:
                # guess...
                unix_lib_dirs_list += glob.glob('/lib/*linux-gnu')
        directories.extend(unix_lib_dirs_list)

        cache = {}
        lib_re = re.compile(r'lib(.*)\.s[ol]')
        ext_re = re.compile(r'\.s[ol]$')
        for dir in directories:
            try:
                for path in glob.glob("%s/*.s[ol]*" % dir):
                    file = os.path.basename(path)

                    # Index by filename
                    if file not in cache:
                        cache[file] = path

                    # Index by library name
                    match = lib_re.match(file)
                    if match:
                        library = match.group(1)
                        if library not in cache:
                            cache[library] = path
            except OSError:
                pass

        self._ld_so_cache = cache

    def getplatformpaths(self, libname):
        if self._ld_so_cache is None:
            self._create_ld_so_cache()

        result = self._ld_so_cache.get(libname)
        if result: yield result

        path = ctypes.util.find_library(libname)
        if path: yield os.path.join("/lib",path)

# Windows

class _WindowsLibrary(object):
    def __init__(self, path):
        self.cdll = ctypes.cdll.LoadLibrary(path)
        self.windll = ctypes.windll.LoadLibrary(path)

    def __getattr__(self, name):
        try: return getattr(self.cdll,name)
        except AttributeError:
            try: return getattr(self.windll,name)
            except AttributeError:
                raise

class WindowsLibraryLoader(LibraryLoader):
    name_formats = ["%s.dll", "lib%s.dll", "%slib.dll"]

    def load_library(self, libname):
        try:
            result = LibraryLoader.load_library(self, libname)
        except ImportError:
            result = None
            if os.path.sep not in libname:
                for name in self.name_formats:
                    try:
                        result = getattr(ctypes.cdll, name % libname)
                        if result:
                            break
                    except OSError:
                        result = None
            if result is None:
                try:
                    result = getattr(ctypes.cdll, libname)
                except OSError:
                    result = None
            if result is None:
                raise ImportError("%s not found." % libname)
        return result

    def load(self, path):
        return _WindowsLibrary(path)

    def getplatformpaths(self, libname):
        if os.path.sep not in libname:
            for name in self.name_formats:
                dll_in_current_dir = os.path.abspath(name % libname)
                if os.path.exists(dll_in_current_dir):
                    yield dll_in_current_dir
                path = ctypes.util.find_library(name % libname)
                if path:
                    yield path

# Platform switching

# If your value of sys.platform does not appear in this dict, please contact
# the Ctypesgen maintainers.

loaderclass = {
    "darwin":   DarwinLibraryLoader,
    "cygwin":   WindowsLibraryLoader,
    "win32":    WindowsLibraryLoader
}

loader = loaderclass.get(sys.platform, PosixLibraryLoader)()

def add_library_search_dirs(other_dirs):
    loader.other_dirs = other_dirs

load_library = loader.load_library

del loaderclass

# End loader

add_library_search_dirs(['/usr/local/lib'])

# Begin libraries

_libs["sssapisw"] = load_library("sssapisw")

# 1 libraries
# End libraries

# No modules

U8 = c_uint8# ../../hostlib/hostLib/libCommon/infra/sm_types.h

U16 = c_uint16
U32 = c_uint32
enum_anon_6 = c_int # ../../sss/inc/fsl_sss_policy.h

KPolicy_None = 0

KPolicy_Session = (KPolicy_None + 1)

KPolicy_Sym_Key = (KPolicy_Session + 1)

KPolicy_Asym_Key = (KPolicy_Sym_Key + 1)

KPolicy_UserID = (KPolicy_Asym_Key + 1)

KPolicy_File = (KPolicy_UserID + 1)

KPolicy_Counter = (KPolicy_File + 1)

KPolicy_PCR = (KPolicy_Counter + 1)

KPolicy_Common = (KPolicy_PCR + 1)

KPolicy_Common_PCR_Value = (KPolicy_Common + 1)

sss_policy_type_u = enum_anon_6
class struct_anon_7(Structure):
    pass


struct_anon_7.__slots__ = [
    'maxOperationsInSession',
    'maxDurationOfSession_sec',
    'has_MaxOperationsInSession',
    'has_MaxDurationOfSession_sec',
    'allowRefresh',
]
struct_anon_7._fields_ = [
    ('maxOperationsInSession', c_uint16),
    ('maxDurationOfSession_sec', c_uint16),
    ('has_MaxOperationsInSession', c_uint8, 1),
    ('has_MaxDurationOfSession_sec', c_uint8, 1),
    ('allowRefresh', c_uint8, 1),
]

sss_policy_session_u = struct_anon_7
class struct_anon_8(Structure):
    pass


struct_anon_8.__slots__ = [
    'can_Sign',
    'can_Verify',
    'can_Encrypt',
    'can_Decrypt',
    'can_KD',
    'can_Wrap',
    'can_Write',
    'can_Gen',
    'can_Desfire_Auth',
    'can_Desfire_Dump',
    'can_Import_Export',
    'forbid_Derived_Output',
    'allow_kdf_ext_rnd',
]
struct_anon_8._fields_ = [
    ('can_Sign', c_uint8, 1),
    ('can_Verify', c_uint8, 1),
    ('can_Encrypt', c_uint8, 1),
    ('can_Decrypt', c_uint8, 1),
    ('can_KD', c_uint8, 1),
    ('can_Wrap', c_uint8, 1),
    ('can_Write', c_uint8, 1),
    ('can_Gen', c_uint8, 1),
    ('can_Desfire_Auth', c_uint8, 1),
    ('can_Desfire_Dump', c_uint8, 1),
    ('can_Import_Export', c_uint8, 1),
    ('forbid_Derived_Output', c_uint8, 1),
    ('allow_kdf_ext_rnd', c_uint8, 1),
]

sss_policy_sym_key_u = struct_anon_8
class struct_anon_9(Structure):
    pass


struct_anon_9.__slots__ = [
    'can_Sign',
    'can_Verify',
    'can_Encrypt',
    'can_Decrypt',
    'can_KD',
    'can_Wrap',
    'can_Write',
    'can_Gen',
    'can_Import_Export',
    'can_KA',
    'can_Read',
    'can_Attest',
    'forbid_Derived_Output',
]
struct_anon_9._fields_ = [
    ('can_Sign', c_uint8, 1),
    ('can_Verify', c_uint8, 1),
    ('can_Encrypt', c_uint8, 1),
    ('can_Decrypt', c_uint8, 1),
    ('can_KD', c_uint8, 1),
    ('can_Wrap', c_uint8, 1),
    ('can_Write', c_uint8, 1),
    ('can_Gen', c_uint8, 1),
    ('can_Import_Export', c_uint8, 1),
    ('can_KA', c_uint8, 1),
    ('can_Read', c_uint8, 1),
    ('can_Attest', c_uint8, 1),
    ('forbid_Derived_Output', c_uint8, 1),
]

sss_policy_asym_key_u = struct_anon_9
class struct_anon_10(Structure):
    pass


struct_anon_10.__slots__ = [
    'can_Write',
    'can_Read',
]
struct_anon_10._fields_ = [
    ('can_Write', c_uint8, 1),
    ('can_Read', c_uint8, 1),
]

sss_policy_file_u = struct_anon_10
class struct_anon_11(Structure):
    pass


struct_anon_11.__slots__ = [
    'can_Write',
    'can_Read',
]
struct_anon_11._fields_ = [
    ('can_Write', c_uint8, 1),
    ('can_Read', c_uint8, 1),
]

sss_policy_counter_u = struct_anon_11
class struct_anon_12(Structure):
    pass


struct_anon_12.__slots__ = [
    'can_Write',
    'can_Read',
]
struct_anon_12._fields_ = [
    ('can_Write', c_uint8, 1),
    ('can_Read', c_uint8, 1),
]

sss_policy_pcr_u = struct_anon_12
class struct_anon_13(Structure):
    pass


struct_anon_13.__slots__ = [
    'can_Write',
]
struct_anon_13._fields_ = [
    ('can_Write', c_uint8, 1),
]

sss_policy_userid_u = struct_anon_13
class struct_anon_14(Structure):
    pass


struct_anon_14.__slots__ = [
    'forbid_All',
    'can_Delete',
    'req_Sm',
]
struct_anon_14._fields_ = [
    ('forbid_All', c_uint8, 1),
    ('can_Delete', c_uint8, 1),
    ('req_Sm', c_uint8, 1),
]

sss_policy_common_u = struct_anon_14
class struct_anon_15(Structure):
    pass


struct_anon_15.__slots__ = [
    'pcrObjId',
    'pcrExpectedValue',
]
struct_anon_15._fields_ = [
    ('pcrObjId', c_uint32),
    ('pcrExpectedValue', c_uint8 * 32),
]

sss_policy_common_pcr_value_u = struct_anon_15
class union_anon_16(Union):
    pass


union_anon_16.__slots__ = [
    'file',
    'counter',
    'pcr',
    'symmkey',
    'asymmkey',
    'pin',
    'common',
    'common_pcr_value',
    'session',
]
union_anon_16._fields_ = [
    ('file', sss_policy_file_u),
    ('counter', sss_policy_counter_u),
    ('pcr', sss_policy_pcr_u),
    ('symmkey', sss_policy_sym_key_u),
    ('asymmkey', sss_policy_asym_key_u),
    ('pin', sss_policy_userid_u),
    ('common', sss_policy_common_u),
    ('common_pcr_value', sss_policy_common_pcr_value_u),
    ('session', sss_policy_session_u),
]

class struct_anon_17(Structure):
    pass


struct_anon_17.__slots__ = [
    'type',
    'auth_obj_id',
    'policy',
]
struct_anon_17._fields_ = [
    ('type', sss_policy_type_u),
    ('auth_obj_id', c_uint32),
    ('policy', union_anon_16),
]

sss_policy_u = struct_anon_17
class struct_anon_18(Structure):
    pass


struct_anon_18.__slots__ = [
    'policies',
    'nPolicies',
]
struct_anon_18._fields_ = [
    ('policies', POINTER(sss_policy_u) * 10),
    ('nPolicies', c_size_t),
]

sss_policy_t = struct_anon_18
enum_anon_19 = c_int # ../../sss/inc/fsl_sss_api.h

kStatus_SSS_Success = 1515870810

kStatus_SSS_Fail = 1010565120

kStatus_SSS_InvalidArgument = 1010565121

kStatus_SSS_ResourceBusy = 1010565122

sss_status_t = enum_anon_19
enum_anon_20 = c_int 
kType_SSS_SubSystem_NONE = 0

kType_SSS_Software = ((1 << 8) | 0)

kType_SSS_mbedTLS = (kType_SSS_Software | 1)

kType_SSS_OpenSSL = (kType_SSS_Software | 2)

kType_SSS_HW = ((2 << 8) | 0)

kType_SSS_SECO = (kType_SSS_HW | 1)

kType_SSS_Isolated_HW = ((4 << 8) | 0)

kType_SSS_Sentinel = (kType_SSS_Isolated_HW | 1)

kType_SSS_Sentinel200 = (kType_SSS_Isolated_HW | 2)

kType_SSS_Sentinel300 = (kType_SSS_Isolated_HW | 3)

kType_SSS_Sentinel400 = (kType_SSS_Isolated_HW | 4)

kType_SSS_Sentinel500 = (kType_SSS_Isolated_HW | 5)

kType_SSS_SecureElement = ((8 << 8) | 0)

kType_SSS_SE_A71CH = (kType_SSS_SecureElement | 1)

kType_SSS_SE_A71CL = (kType_SSS_SecureElement | 2)

kType_SSS_SE_SE05x = (kType_SSS_SecureElement | 3)

kType_SSS_SubSystem_LAST = (kType_SSS_SE_SE05x + 1)

sss_type_t = enum_anon_20
enum_anon_21 = c_int 
kSSS_ConnectionType_Plain = 0

kSSS_ConnectionType_Password = (kSSS_ConnectionType_Plain + 1)

kSSS_ConnectionType_Encrypted = (kSSS_ConnectionType_Password + 1)

sss_connection_type_t = enum_anon_21
enum_anon_22 = c_int 
kAlgorithm_None = 0

kAlgorithm_SSS_AES_ECB = ((0 << 8) | 1)

kAlgorithm_SSS_AES_CBC = ((0 << 8) | 2)

kAlgorithm_SSS_AES_CTR = ((0 << 8) | 3)

kAlgorithm_SSS_AES_GCM = ((0 << 8) | 4)

kAlgorithm_SSS_AES_CCM = ((0 << 8) | 5)

kAlgorithm_SSS_AES_GCM_INT_IV = ((0 << 8) | 6)

kAlgorithm_SSS_CHACHA_POLY = ((1 << 8) | 1)

kAlgorithm_SSS_DES_ECB = ((2 << 8) | 1)

kAlgorithm_SSS_DES_CBC = ((2 << 8) | 2)

kAlgorithm_SSS_DES3_ECB = ((2 << 8) | 3)

kAlgorithm_SSS_DES3_CBC = ((2 << 8) | 4)

kAlgorithm_SSS_SHA1 = ((3 << 8) | 1)

kAlgorithm_SSS_SHA224 = ((3 << 8) | 2)

kAlgorithm_SSS_SHA256 = ((3 << 8) | 3)

kAlgorithm_SSS_SHA384 = ((3 << 8) | 4)

kAlgorithm_SSS_SHA512 = ((3 << 8) | 5)

kAlgorithm_SSS_CMAC_AES = ((4 << 8) | 1)

kAlgorithm_SSS_HMAC_SHA1 = ((4 << 8) | 2)

kAlgorithm_SSS_HMAC_SHA224 = ((4 << 8) | 3)

kAlgorithm_SSS_HMAC_SHA256 = ((4 << 8) | 4)

kAlgorithm_SSS_HMAC_SHA384 = ((4 << 8) | 5)

kAlgorithm_SSS_HMAC_SHA512 = ((4 << 8) | 6)

kAlgorithm_SSS_DH = ((5 << 8) | 1)

kAlgorithm_SSS_ECDH = ((5 << 8) | 2)

kAlgorithm_SSS_DSA_SHA1 = ((6 << 8) | 1)

kAlgorithm_SSS_DSA_SHA224 = ((6 << 8) | 2)

kAlgorithm_SSS_DSA_SHA256 = ((6 << 8) | 3)

kAlgorithm_SSS_RSASSA_PKCS1_V1_5_NO_HASH = ((7 << 8) | 1)

kAlgorithm_SSS_RSASSA_PKCS1_V1_5_SHA1 = ((7 << 8) | 2)

kAlgorithm_SSS_RSASSA_PKCS1_V1_5_SHA224 = ((7 << 8) | 3)

kAlgorithm_SSS_RSASSA_PKCS1_V1_5_SHA256 = ((7 << 8) | 4)

kAlgorithm_SSS_RSASSA_PKCS1_V1_5_SHA384 = ((7 << 8) | 5)

kAlgorithm_SSS_RSASSA_PKCS1_V1_5_SHA512 = ((7 << 8) | 6)

kAlgorithm_SSS_RSASSA_PKCS1_PSS_MGF1_SHA1 = ((8 << 8) | 1)

kAlgorithm_SSS_RSASSA_PKCS1_PSS_MGF1_SHA224 = ((8 << 8) | 2)

kAlgorithm_SSS_RSASSA_PKCS1_PSS_MGF1_SHA256 = ((8 << 8) | 3)

kAlgorithm_SSS_RSASSA_PKCS1_PSS_MGF1_SHA384 = ((8 << 8) | 4)

kAlgorithm_SSS_RSASSA_PKCS1_PSS_MGF1_SHA512 = ((8 << 8) | 5)

kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA1 = ((9 << 8) | 1)

kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA224 = ((9 << 8) | 2)

kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA256 = ((9 << 8) | 3)

kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA384 = ((9 << 8) | 4)

kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA512 = ((9 << 8) | 5)

kAlgorithm_SSS_RSAES_PKCS1_V1_5 = ((10 << 8) | 1)

kAlgorithm_SSS_RSASSA_NO_PADDING = ((11 << 8) | 1)

kAlgorithm_SSS_ECDSA_SHA1 = ((12 << 8) | 1)

kAlgorithm_SSS_ECDSA_SHA224 = ((12 << 8) | 2)

kAlgorithm_SSS_ECDSA_SHA256 = ((12 << 8) | 3)

kAlgorithm_SSS_ECDSA_SHA384 = ((12 << 8) | 4)

kAlgorithm_SSS_ECDSA_SHA512 = ((12 << 8) | 5)

kAlgorithm_SSS_ECDAA = ((13 << 8) | 1)

sss_algorithm_t = enum_anon_22
enum_anon_23 = c_int 
kMode_SSS_Encrypt = 1

kMode_SSS_Decrypt = 2

kMode_SSS_Sign = 3

kMode_SSS_Verify = 4

kMode_SSS_ComputeSharedSecret = 5

kMode_SSS_Digest = 6

kMode_SSS_Mac = 7

kMode_SSS_HKDF_ExpandOnly = 9

sss_mode_t = enum_anon_23
enum_anon_24 = c_int 
kAccessPermission_SSS_Read = (1 << 0)

kAccessPermission_SSS_Write = (1 << 1)

kAccessPermission_SSS_Use = (1 << 2)

kAccessPermission_SSS_Delete = (1 << 3)

kAccessPermission_SSS_ChangeAttributes = (1 << 4)

sss_access_permission_t = enum_anon_24
enum_anon_25 = c_int 
kKeyObject_Mode_None = 0

kKeyObject_Mode_Persistent = 1

kKeyObject_Mode_Transient = 2

sss_key_object_mode_t = enum_anon_25
enum_anon_26 = c_int 
kSSS_KeyPart_NONE = 0

kSSS_KeyPart_Default = 1

kSSS_KeyPart_Public = 2

kSSS_KeyPart_Private = 3

kSSS_KeyPart_Pair = 4

sss_key_part_t = enum_anon_26
enum_anon_27 = c_int 
kSSS_CipherType_NONE = 0

kSSS_CipherType_AES = 10

kSSS_CipherType_DES = 12

kSSS_CipherType_CMAC = 20

kSSS_CipherType_HMAC = 21

kSSS_CipherType_MAC = 30

kSSS_CipherType_RSA = 31

kSSS_CipherType_RSA_CRT = 32

kSSS_CipherType_EC_NIST_P = 40

kSSS_CipherType_EC_NIST_K = 41

kSSS_CipherType_EC_MONTGOMERY = 50

kSSS_CipherType_EC_TWISTED_ED = 51

kSSS_CipherType_EC_BRAINPOOL = 52

kSSS_CipherType_EC_BARRETO_NAEHRIG = 53

kSSS_CipherType_UserID = 70

kSSS_CipherType_Certificate = 71

kSSS_CipherType_Binary = 72

kSSS_CipherType_Count = 73

kSSS_CipherType_PCR = 74

kSSS_CipherType_ReservedPin = 75

sss_cipher_type_t = enum_anon_27
class struct_anon_28(Structure):
    pass


struct_anon_28.__slots__ = [
    'X',
    'Y',
]
struct_anon_28._fields_ = [
    ('X', POINTER(c_uint8)),
    ('Y', POINTER(c_uint8)),
]

sss_ecc_point_t = struct_anon_28
class struct_anon_29(Structure):
    pass


struct_anon_29.__slots__ = [
    'p',
    'a',
    'b',
    'G',
    'n',
    'h',
]
struct_anon_29._fields_ = [
    ('p', POINTER(c_uint8)),
    ('a', POINTER(c_uint8)),
    ('b', POINTER(c_uint8)),
    ('G', POINTER(sss_ecc_point_t)),
    ('n', POINTER(c_uint8)),
    ('h', POINTER(c_uint8)),
]

sss_eccgfp_group_t = struct_anon_29
enum_anon_30 = c_int 
kSSS_SessionProp_u32_NA = 0

kSSS_SessionProp_VerMaj = (kSSS_SessionProp_u32_NA + 1)

kSSS_SessionProp_VerMin = (kSSS_SessionProp_VerMaj + 1)

kSSS_SessionProp_VerDev = (kSSS_SessionProp_VerMin + 1)

kSSS_SessionProp_UIDLen = (kSSS_SessionProp_VerDev + 1)

kSSS_SessionProp_u32_Optional_Start = 16777215

kSSS_KeyStoreProp_FreeMem_Persistant = (kSSS_SessionProp_u32_Optional_Start + 1)

kSSS_KeyStoreProp_FreeMem_Transient = (kSSS_KeyStoreProp_FreeMem_Persistant + 1)

kSSS_SessionProp_u32_Proprietary_Start = 33554431

sss_session_prop_u32_t = enum_anon_30
enum_anon_31 = c_int 
kSSS_SessionProp_au8_NA = 0

kSSS_SessionProp_szName = (kSSS_SessionProp_au8_NA + 1)

kSSS_SessionProp_UID = (kSSS_SessionProp_szName + 1)

kSSS_SessionProp_au8_Optional_Start = 16777215

kSSS_SessionProp_au8_Proprietary_Start = 33554431

sss_session_prop_au8_t = enum_anon_31
class struct_anon_32(Structure):
    pass


struct_anon_32.__slots__ = [
    'data',
]
struct_anon_32._fields_ = [
    ('data', c_uint8 * ((((0 + (1 * sizeof(POINTER(None)))) + (1 * sizeof(POINTER(None)))) + (8 * sizeof(POINTER(None)))) + 16)),
]

class struct_anon_33(Structure):
    pass


struct_anon_33.__slots__ = [
    'subsystem',
    'extension',
]
struct_anon_33._fields_ = [
    ('subsystem', sss_type_t),
    ('extension', struct_anon_32),
]

sss_session_t = struct_anon_33
class struct_anon_34(Structure):
    pass


struct_anon_34.__slots__ = [
    'data',
]
struct_anon_34._fields_ = [
    ('data', c_uint8 * (((0 + (1 * sizeof(POINTER(None)))) + (4 * sizeof(POINTER(None)))) + 16)),
]

class struct_anon_35(Structure):
    pass


struct_anon_35.__slots__ = [
    'session',
    'extension',
]
struct_anon_35._fields_ = [
    ('session', POINTER(sss_session_t)),
    ('extension', struct_anon_34),
]

sss_key_store_t = struct_anon_35
enum_anon_36 = c_int 
kSSS_KeyStoreProp_au8_Optional_Start = 16777215

sss_key_store_prop_au8_t = enum_anon_36
enum_anon_37 = c_int 
kSSS_TunnelDest_None = 0

kSSS_TunnelType_Se05x_Iot_applet = (kSSS_TunnelDest_None + 1)

sss_tunnel_dest_t = enum_anon_37
class struct_anon_38(Structure):
    pass


struct_anon_38.__slots__ = [
    'data',
]
struct_anon_38._fields_ = [
    ('data', c_uint8 * ((((0 + (1 * sizeof(POINTER(None)))) + (2 * sizeof(c_int))) + (4 * sizeof(POINTER(None)))) + 16)),
]

class struct_anon_39(Structure):
    pass


struct_anon_39.__slots__ = [
    'keyStore',
    'objectType',
    'cipherType',
    'keyId',
    'extension',
]
struct_anon_39._fields_ = [
    ('keyStore', POINTER(sss_key_store_t)),
    ('objectType', c_uint32),
    ('cipherType', c_uint32),
    ('keyId', c_uint32),
    ('extension', struct_anon_38),
]

sss_object_t = struct_anon_39
class struct_anon_40(Structure):
    pass


struct_anon_40.__slots__ = [
    'data',
]
struct_anon_40._fields_ = [
    ('data', c_uint8 * ((((((0 + (2 * sizeof(POINTER(None)))) + (2 * sizeof(c_int))) + (2 * sizeof(POINTER(None)))) + 16) + 4) + 16)),
]

class struct_anon_41(Structure):
    pass


struct_anon_41.__slots__ = [
    'session',
    'keyObject',
    'algorithm',
    'mode',
    'extension',
]
struct_anon_41._fields_ = [
    ('session', POINTER(sss_session_t)),
    ('keyObject', POINTER(sss_object_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
    ('extension', struct_anon_40),
]

sss_symmetric_t = struct_anon_41
class struct_anon_42(Structure):
    pass


struct_anon_42.__slots__ = [
    'data',
]
struct_anon_42._fields_ = [
    ('data', c_uint8 * ((((0 + (5 * sizeof(POINTER(None)))) + (6 * sizeof(c_int))) + (5 * sizeof(POINTER(None)))) + 16)),
]

class struct_anon_43(Structure):
    pass


struct_anon_43.__slots__ = [
    'session',
    'keyObject',
    'algorithm',
    'mode',
    'extension',
]
struct_anon_43._fields_ = [
    ('session', POINTER(sss_session_t)),
    ('keyObject', POINTER(sss_object_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
    ('extension', struct_anon_42),
]

sss_aead_t = struct_anon_43
class struct_anon_44(Structure):
    pass


struct_anon_44.__slots__ = [
    'data',
]
struct_anon_44._fields_ = [
    ('data', c_uint8 * ((((0 + (1 * sizeof(POINTER(None)))) + (3 * sizeof(c_int))) + (2 * sizeof(POINTER(None)))) + 16)),
]

class struct_anon_45(Structure):
    pass


struct_anon_45.__slots__ = [
    'session',
    'algorithm',
    'mode',
    'digestFullLen',
    'extension',
]
struct_anon_45._fields_ = [
    ('session', POINTER(sss_session_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
    ('digestFullLen', c_size_t),
    ('extension', struct_anon_44),
]

sss_digest_t = struct_anon_45
class struct_anon_46(Structure):
    pass


struct_anon_46.__slots__ = [
    'data',
]
struct_anon_46._fields_ = [
    ('data', c_uint8 * ((((0 + (2 * sizeof(POINTER(None)))) + (2 * sizeof(c_int))) + (2 * sizeof(POINTER(None)))) + 32)),
]

class struct_anon_47(Structure):
    pass


struct_anon_47.__slots__ = [
    'session',
    'keyObject',
    'algorithm',
    'mode',
    'extension',
]
struct_anon_47._fields_ = [
    ('session', POINTER(sss_session_t)),
    ('keyObject', POINTER(sss_object_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
    ('extension', struct_anon_46),
]

sss_mac_t = struct_anon_47
class struct_anon_48(Structure):
    pass


struct_anon_48.__slots__ = [
    'data',
]
struct_anon_48._fields_ = [
    ('data', c_uint8 * ((((0 + (2 * sizeof(POINTER(None)))) + (3 * sizeof(c_int))) + (2 * sizeof(POINTER(None)))) + 16)),
]

class struct_anon_49(Structure):
    pass


struct_anon_49.__slots__ = [
    'session',
    'keyObject',
    'algorithm',
    'mode',
    'extension',
]
struct_anon_49._fields_ = [
    ('session', POINTER(sss_session_t)),
    ('keyObject', POINTER(sss_object_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
    ('extension', struct_anon_48),
]

sss_asymmetric_t = struct_anon_49
class struct_anon_50(Structure):
    pass


struct_anon_50.__slots__ = [
    'hdr',
]
struct_anon_50._fields_ = [
    ('hdr', c_uint8 * ((((0 + 1) + 1) + 1) + 1)),
]

tlvHeader_t = struct_anon_50
class struct_anon_51(Structure):
    pass


struct_anon_51.__slots__ = [
    'data',
]
struct_anon_51._fields_ = [
    ('data', c_uint8 * ((((0 + (1 * sizeof(POINTER(None)))) + (2 * sizeof(c_int))) + (2 * sizeof(POINTER(None)))) + 16)),
]

class struct_anon_52(Structure):
    pass


struct_anon_52.__slots__ = [
    'session',
    'tunnelType',
    'extension',
]
struct_anon_52._fields_ = [
    ('session', POINTER(sss_session_t)),
    ('tunnelType', c_uint32),
    ('extension', struct_anon_51),
]

sss_tunnel_t = struct_anon_52
class struct_anon_53(Structure):
    pass


struct_anon_53.__slots__ = [
    'data',
]
struct_anon_53._fields_ = [
    ('data', c_uint8 * ((((0 + (2 * sizeof(POINTER(None)))) + (2 * sizeof(c_int))) + (2 * sizeof(POINTER(None)))) + 16)),
]

class struct_anon_54(Structure):
    pass


struct_anon_54.__slots__ = [
    'session',
    'keyObject',
    'algorithm',
    'mode',
    'extension',
]
struct_anon_54._fields_ = [
    ('session', POINTER(sss_session_t)),
    ('keyObject', POINTER(sss_object_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
    ('extension', struct_anon_53),
]

sss_derive_key_t = struct_anon_54
class struct_anon_55(Structure):
    pass


struct_anon_55.__slots__ = [
    'data',
]
struct_anon_55._fields_ = [
    ('data', c_uint8 * (((0 + (1 * sizeof(POINTER(None)))) + (2 * sizeof(POINTER(None)))) + 16)),
]

class struct_anon_56(Structure):
    pass


struct_anon_56.__slots__ = [
    'session',
    'context',
]
struct_anon_56._fields_ = [
    ('session', POINTER(sss_session_t)),
    ('context', struct_anon_55),
]

sss_rng_context_t = struct_anon_56
for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_session_create'):
        continue
    sss_session_create = _lib.sss_session_create
    sss_session_create.argtypes = [POINTER(sss_session_t), sss_type_t, c_uint32, sss_connection_type_t, POINTER(None)]
    sss_session_create.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_session_open'):
        continue
    sss_session_open = _lib.sss_session_open
    sss_session_open.argtypes = [POINTER(sss_session_t), sss_type_t, c_uint32, sss_connection_type_t, POINTER(None)]
    sss_session_open.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_session_prop_get_u32'):
        continue
    sss_session_prop_get_u32 = _lib.sss_session_prop_get_u32
    sss_session_prop_get_u32.argtypes = [POINTER(sss_session_t), c_uint32, POINTER(c_uint32)]
    sss_session_prop_get_u32.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_session_prop_get_au8'):
        continue
    sss_session_prop_get_au8 = _lib.sss_session_prop_get_au8
    sss_session_prop_get_au8.argtypes = [POINTER(sss_session_t), c_uint32, POINTER(c_uint8), POINTER(c_size_t)]
    sss_session_prop_get_au8.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_session_close'):
        continue
    sss_session_close = _lib.sss_session_close
    sss_session_close.argtypes = [POINTER(sss_session_t)]
    sss_session_close.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_session_delete'):
        continue
    sss_session_delete = _lib.sss_session_delete
    sss_session_delete.argtypes = [POINTER(sss_session_t)]
    sss_session_delete.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_store_context_init'):
        continue
    sss_key_store_context_init = _lib.sss_key_store_context_init
    sss_key_store_context_init.argtypes = [POINTER(sss_key_store_t), POINTER(sss_session_t)]
    sss_key_store_context_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_store_allocate'):
        continue
    sss_key_store_allocate = _lib.sss_key_store_allocate
    sss_key_store_allocate.argtypes = [POINTER(sss_key_store_t), c_uint32]
    sss_key_store_allocate.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_store_save'):
        continue
    sss_key_store_save = _lib.sss_key_store_save
    sss_key_store_save.argtypes = [POINTER(sss_key_store_t)]
    sss_key_store_save.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_store_load'):
        continue
    sss_key_store_load = _lib.sss_key_store_load
    sss_key_store_load.argtypes = [POINTER(sss_key_store_t)]
    sss_key_store_load.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_store_set_key'):
        continue
    sss_key_store_set_key = _lib.sss_key_store_set_key
    sss_key_store_set_key.argtypes = [POINTER(sss_key_store_t), POINTER(sss_object_t), POINTER(c_uint8), c_size_t, c_size_t, POINTER(None), c_size_t]
    sss_key_store_set_key.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_store_generate_key'):
        continue
    sss_key_store_generate_key = _lib.sss_key_store_generate_key
    sss_key_store_generate_key.argtypes = [POINTER(sss_key_store_t), POINTER(sss_object_t), c_size_t, POINTER(None)]
    sss_key_store_generate_key.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_store_get_key'):
        continue
    sss_key_store_get_key = _lib.sss_key_store_get_key
    sss_key_store_get_key.argtypes = [POINTER(sss_key_store_t), POINTER(sss_object_t), POINTER(c_uint8), POINTER(c_size_t), POINTER(c_size_t)]
    sss_key_store_get_key.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_store_open_key'):
        continue
    sss_key_store_open_key = _lib.sss_key_store_open_key
    sss_key_store_open_key.argtypes = [POINTER(sss_key_store_t), POINTER(sss_object_t)]
    sss_key_store_open_key.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_store_freeze_key'):
        continue
    sss_key_store_freeze_key = _lib.sss_key_store_freeze_key
    sss_key_store_freeze_key.argtypes = [POINTER(sss_key_store_t), POINTER(sss_object_t)]
    sss_key_store_freeze_key.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_store_erase_key'):
        continue
    sss_key_store_erase_key = _lib.sss_key_store_erase_key
    sss_key_store_erase_key.argtypes = [POINTER(sss_key_store_t), POINTER(sss_object_t)]
    sss_key_store_erase_key.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_store_context_free'):
        continue
    sss_key_store_context_free = _lib.sss_key_store_context_free
    sss_key_store_context_free.argtypes = [POINTER(sss_key_store_t)]
    sss_key_store_context_free.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_object_init'):
        continue
    sss_key_object_init = _lib.sss_key_object_init
    sss_key_object_init.argtypes = [POINTER(sss_object_t), POINTER(sss_key_store_t)]
    sss_key_object_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_object_allocate_handle'):
        continue
    sss_key_object_allocate_handle = _lib.sss_key_object_allocate_handle
    sss_key_object_allocate_handle.argtypes = [POINTER(sss_object_t), c_uint32, sss_key_part_t, sss_cipher_type_t, c_size_t, c_uint32]
    sss_key_object_allocate_handle.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_object_get_handle'):
        continue
    sss_key_object_get_handle = _lib.sss_key_object_get_handle
    sss_key_object_get_handle.argtypes = [POINTER(sss_object_t), c_uint32]
    sss_key_object_get_handle.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_object_set_user'):
        continue
    sss_key_object_set_user = _lib.sss_key_object_set_user
    sss_key_object_set_user.argtypes = [POINTER(sss_object_t), c_uint32, c_uint32]
    sss_key_object_set_user.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_object_set_purpose'):
        continue
    sss_key_object_set_purpose = _lib.sss_key_object_set_purpose
    sss_key_object_set_purpose.argtypes = [POINTER(sss_object_t), sss_mode_t, c_uint32]
    sss_key_object_set_purpose.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_object_set_access'):
        continue
    sss_key_object_set_access = _lib.sss_key_object_set_access
    sss_key_object_set_access.argtypes = [POINTER(sss_object_t), c_uint32, c_uint32]
    sss_key_object_set_access.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_object_set_eccgfp_group'):
        continue
    sss_key_object_set_eccgfp_group = _lib.sss_key_object_set_eccgfp_group
    sss_key_object_set_eccgfp_group.argtypes = [POINTER(sss_object_t), POINTER(sss_eccgfp_group_t)]
    sss_key_object_set_eccgfp_group.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_object_get_user'):
        continue
    sss_key_object_get_user = _lib.sss_key_object_get_user
    sss_key_object_get_user.argtypes = [POINTER(sss_object_t), POINTER(c_uint32)]
    sss_key_object_get_user.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_object_get_purpose'):
        continue
    sss_key_object_get_purpose = _lib.sss_key_object_get_purpose
    sss_key_object_get_purpose.argtypes = [POINTER(sss_object_t), POINTER(sss_mode_t)]
    sss_key_object_get_purpose.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_object_get_access'):
        continue
    sss_key_object_get_access = _lib.sss_key_object_get_access
    sss_key_object_get_access.argtypes = [POINTER(sss_object_t), POINTER(c_uint32)]
    sss_key_object_get_access.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_key_object_free'):
        continue
    sss_key_object_free = _lib.sss_key_object_free
    sss_key_object_free.argtypes = [POINTER(sss_object_t)]
    sss_key_object_free.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_symmetric_context_init'):
        continue
    sss_symmetric_context_init = _lib.sss_symmetric_context_init
    sss_symmetric_context_init.argtypes = [POINTER(sss_symmetric_t), POINTER(sss_session_t), POINTER(sss_object_t), sss_algorithm_t, sss_mode_t]
    sss_symmetric_context_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_cipher_one_go'):
        continue
    sss_cipher_one_go = _lib.sss_cipher_one_go
    sss_cipher_one_go.argtypes = [POINTER(sss_symmetric_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_uint8), c_size_t]
    sss_cipher_one_go.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_cipher_init'):
        continue
    sss_cipher_init = _lib.sss_cipher_init
    sss_cipher_init.argtypes = [POINTER(sss_symmetric_t), POINTER(c_uint8), c_size_t]
    sss_cipher_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_cipher_update'):
        continue
    sss_cipher_update = _lib.sss_cipher_update
    sss_cipher_update.argtypes = [POINTER(sss_symmetric_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t)]
    sss_cipher_update.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_cipher_finish'):
        continue
    sss_cipher_finish = _lib.sss_cipher_finish
    sss_cipher_finish.argtypes = [POINTER(sss_symmetric_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t)]
    sss_cipher_finish.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_cipher_crypt_ctr'):
        continue
    sss_cipher_crypt_ctr = _lib.sss_cipher_crypt_ctr
    sss_cipher_crypt_ctr.argtypes = [POINTER(sss_symmetric_t), POINTER(c_uint8), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_uint8), POINTER(c_size_t)]
    sss_cipher_crypt_ctr.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_symmetric_context_free'):
        continue
    sss_symmetric_context_free = _lib.sss_symmetric_context_free
    sss_symmetric_context_free.argtypes = [POINTER(sss_symmetric_t)]
    sss_symmetric_context_free.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_aead_context_init'):
        continue
    sss_aead_context_init = _lib.sss_aead_context_init
    sss_aead_context_init.argtypes = [POINTER(sss_aead_t), POINTER(sss_session_t), POINTER(sss_object_t), sss_algorithm_t, sss_mode_t]
    sss_aead_context_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_aead_one_go'):
        continue
    sss_aead_one_go = _lib.sss_aead_one_go
    sss_aead_one_go.argtypes = [POINTER(sss_aead_t), POINTER(c_uint8), POINTER(c_uint8), c_size_t, POINTER(c_uint8), c_size_t, POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t)]
    sss_aead_one_go.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_aead_init'):
        continue
    sss_aead_init = _lib.sss_aead_init
    sss_aead_init.argtypes = [POINTER(sss_aead_t), POINTER(c_uint8), c_size_t, c_size_t, c_size_t, c_size_t]
    sss_aead_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_aead_update_aad'):
        continue
    sss_aead_update_aad = _lib.sss_aead_update_aad
    sss_aead_update_aad.argtypes = [POINTER(sss_aead_t), POINTER(c_uint8), c_size_t]
    sss_aead_update_aad.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_aead_update'):
        continue
    sss_aead_update = _lib.sss_aead_update
    sss_aead_update.argtypes = [POINTER(sss_aead_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t)]
    sss_aead_update.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_aead_finish'):
        continue
    sss_aead_finish = _lib.sss_aead_finish
    sss_aead_finish.argtypes = [POINTER(sss_aead_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t), POINTER(c_uint8), POINTER(c_size_t)]
    sss_aead_finish.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_aead_context_free'):
        continue
    sss_aead_context_free = _lib.sss_aead_context_free
    sss_aead_context_free.argtypes = [POINTER(sss_aead_t)]
    sss_aead_context_free.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_digest_context_init'):
        continue
    sss_digest_context_init = _lib.sss_digest_context_init
    sss_digest_context_init.argtypes = [POINTER(sss_digest_t), POINTER(sss_session_t), sss_algorithm_t, sss_mode_t]
    sss_digest_context_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_digest_one_go'):
        continue
    sss_digest_one_go = _lib.sss_digest_one_go
    sss_digest_one_go.argtypes = [POINTER(sss_digest_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t)]
    sss_digest_one_go.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_digest_init'):
        continue
    sss_digest_init = _lib.sss_digest_init
    sss_digest_init.argtypes = [POINTER(sss_digest_t)]
    sss_digest_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_digest_update'):
        continue
    sss_digest_update = _lib.sss_digest_update
    sss_digest_update.argtypes = [POINTER(sss_digest_t), POINTER(c_uint8), c_size_t]
    sss_digest_update.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_digest_finish'):
        continue
    sss_digest_finish = _lib.sss_digest_finish
    sss_digest_finish.argtypes = [POINTER(sss_digest_t), POINTER(c_uint8), POINTER(c_size_t)]
    sss_digest_finish.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_digest_context_free'):
        continue
    sss_digest_context_free = _lib.sss_digest_context_free
    sss_digest_context_free.argtypes = [POINTER(sss_digest_t)]
    sss_digest_context_free.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_mac_context_init'):
        continue
    sss_mac_context_init = _lib.sss_mac_context_init
    sss_mac_context_init.argtypes = [POINTER(sss_mac_t), POINTER(sss_session_t), POINTER(sss_object_t), sss_algorithm_t, sss_mode_t]
    sss_mac_context_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_mac_one_go'):
        continue
    sss_mac_one_go = _lib.sss_mac_one_go
    sss_mac_one_go.argtypes = [POINTER(sss_mac_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t)]
    sss_mac_one_go.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_mac_init'):
        continue
    sss_mac_init = _lib.sss_mac_init
    sss_mac_init.argtypes = [POINTER(sss_mac_t)]
    sss_mac_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_mac_update'):
        continue
    sss_mac_update = _lib.sss_mac_update
    sss_mac_update.argtypes = [POINTER(sss_mac_t), POINTER(c_uint8), c_size_t]
    sss_mac_update.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_mac_finish'):
        continue
    sss_mac_finish = _lib.sss_mac_finish
    sss_mac_finish.argtypes = [POINTER(sss_mac_t), POINTER(c_uint8), POINTER(c_size_t)]
    sss_mac_finish.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_mac_context_free'):
        continue
    sss_mac_context_free = _lib.sss_mac_context_free
    sss_mac_context_free.argtypes = [POINTER(sss_mac_t)]
    sss_mac_context_free.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_asymmetric_context_init'):
        continue
    sss_asymmetric_context_init = _lib.sss_asymmetric_context_init
    sss_asymmetric_context_init.argtypes = [POINTER(sss_asymmetric_t), POINTER(sss_session_t), POINTER(sss_object_t), sss_algorithm_t, sss_mode_t]
    sss_asymmetric_context_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_asymmetric_encrypt'):
        continue
    sss_asymmetric_encrypt = _lib.sss_asymmetric_encrypt
    sss_asymmetric_encrypt.argtypes = [POINTER(sss_asymmetric_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t)]
    sss_asymmetric_encrypt.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_asymmetric_decrypt'):
        continue
    sss_asymmetric_decrypt = _lib.sss_asymmetric_decrypt
    sss_asymmetric_decrypt.argtypes = [POINTER(sss_asymmetric_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t)]
    sss_asymmetric_decrypt.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_asymmetric_sign_digest'):
        continue
    sss_asymmetric_sign_digest = _lib.sss_asymmetric_sign_digest
    sss_asymmetric_sign_digest.argtypes = [POINTER(sss_asymmetric_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t)]
    sss_asymmetric_sign_digest.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_asymmetric_verify_digest'):
        continue
    sss_asymmetric_verify_digest = _lib.sss_asymmetric_verify_digest
    sss_asymmetric_verify_digest.argtypes = [POINTER(sss_asymmetric_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), c_size_t]
    sss_asymmetric_verify_digest.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_asymmetric_context_free'):
        continue
    sss_asymmetric_context_free = _lib.sss_asymmetric_context_free
    sss_asymmetric_context_free.argtypes = [POINTER(sss_asymmetric_t)]
    sss_asymmetric_context_free.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_derive_key_context_init'):
        continue
    sss_derive_key_context_init = _lib.sss_derive_key_context_init
    sss_derive_key_context_init.argtypes = [POINTER(sss_derive_key_t), POINTER(sss_session_t), POINTER(sss_object_t), sss_algorithm_t, sss_mode_t]
    sss_derive_key_context_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_derive_key_go'):
        continue
    sss_derive_key_go = _lib.sss_derive_key_go
    sss_derive_key_go.argtypes = [POINTER(sss_derive_key_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), c_size_t, POINTER(sss_object_t), c_uint16, POINTER(c_uint8), POINTER(c_size_t)]
    sss_derive_key_go.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_derive_key_one_go'):
        continue
    sss_derive_key_one_go = _lib.sss_derive_key_one_go
    sss_derive_key_one_go.argtypes = [POINTER(sss_derive_key_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), c_size_t, POINTER(sss_object_t), c_uint16]
    sss_derive_key_one_go.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_derive_key_sobj_one_go'):
        continue
    sss_derive_key_sobj_one_go = _lib.sss_derive_key_sobj_one_go
    sss_derive_key_sobj_one_go.argtypes = [POINTER(sss_derive_key_t), POINTER(sss_object_t), POINTER(c_uint8), c_size_t, POINTER(sss_object_t), c_uint16]
    sss_derive_key_sobj_one_go.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_derive_key_dh'):
        continue
    sss_derive_key_dh = _lib.sss_derive_key_dh
    sss_derive_key_dh.argtypes = [POINTER(sss_derive_key_t), POINTER(sss_object_t), POINTER(sss_object_t)]
    sss_derive_key_dh.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_derive_key_context_free'):
        continue
    sss_derive_key_context_free = _lib.sss_derive_key_context_free
    sss_derive_key_context_free.argtypes = [POINTER(sss_derive_key_t)]
    sss_derive_key_context_free.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_rng_context_init'):
        continue
    sss_rng_context_init = _lib.sss_rng_context_init
    sss_rng_context_init.argtypes = [POINTER(sss_rng_context_t), POINTER(sss_session_t)]
    sss_rng_context_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_rng_get_random'):
        continue
    sss_rng_get_random = _lib.sss_rng_get_random
    sss_rng_get_random.argtypes = [POINTER(sss_rng_context_t), POINTER(c_uint8), c_size_t]
    sss_rng_get_random.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_rng_context_free'):
        continue
    sss_rng_context_free = _lib.sss_rng_context_free
    sss_rng_context_free.argtypes = [POINTER(sss_rng_context_t)]
    sss_rng_context_free.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_tunnel_context_init'):
        continue
    sss_tunnel_context_init = _lib.sss_tunnel_context_init
    sss_tunnel_context_init.argtypes = [POINTER(sss_tunnel_t), POINTER(sss_session_t)]
    sss_tunnel_context_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_tunnel'):
        continue
    sss_tunnel = _lib.sss_tunnel
    sss_tunnel.argtypes = [POINTER(sss_tunnel_t), POINTER(c_uint8), c_size_t, POINTER(sss_object_t), c_uint32, c_uint32]
    sss_tunnel.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_tunnel_context_free'):
        continue
    sss_tunnel_context_free = _lib.sss_tunnel_context_free
    sss_tunnel_context_free.argtypes = [POINTER(sss_tunnel_t)]
    sss_tunnel_context_free.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_status_sz'):
        continue
    sss_status_sz = _lib.sss_status_sz
    sss_status_sz.argtypes = [sss_status_t]
    if sizeof(c_int) == sizeof(c_void_p):
        sss_status_sz.restype = ReturnString
    else:
        sss_status_sz.restype = String
        sss_status_sz.errcheck = ReturnString
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_cipher_type_sz'):
        continue
    sss_cipher_type_sz = _lib.sss_cipher_type_sz
    sss_cipher_type_sz.argtypes = [sss_cipher_type_t]
    if sizeof(c_int) == sizeof(c_void_p):
        sss_cipher_type_sz.restype = ReturnString
    else:
        sss_cipher_type_sz.restype = String
        sss_cipher_type_sz.errcheck = ReturnString
    break

SST_Index_t = U8# hostlib/hostLib/inc/a71ch_api.h

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetCredentialInfo'):
        continue
    A71_GetCredentialInfo = _lib.A71_GetCredentialInfo
    A71_GetCredentialInfo.argtypes = [POINTER(U8), POINTER(U16)]
    A71_GetCredentialInfo.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetModuleInfo'):
        continue
    A71_GetModuleInfo = _lib.A71_GetModuleInfo
    A71_GetModuleInfo.argtypes = [POINTER(U16), POINTER(U8), POINTER(U8), POINTER(U8), POINTER(U8), POINTER(U8), POINTER(U16)]
    A71_GetModuleInfo.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetRandom'):
        continue
    A71_GetRandom = _lib.A71_GetRandom
    A71_GetRandom.argtypes = [POINTER(U8), U8]
    A71_GetRandom.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_CreateClientHelloRandom'):
        continue
    A71_CreateClientHelloRandom = _lib.A71_CreateClientHelloRandom
    A71_CreateClientHelloRandom.argtypes = [POINTER(U8), U8]
    A71_CreateClientHelloRandom.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetRestrictedKeyPairInfo'):
        continue
    A71_GetRestrictedKeyPairInfo = _lib.A71_GetRestrictedKeyPairInfo
    A71_GetRestrictedKeyPairInfo.argtypes = [POINTER(U8), POINTER(U16), POINTER(U8), POINTER(U16)]
    A71_GetRestrictedKeyPairInfo.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetSha256'):
        continue
    A71_GetSha256 = _lib.A71_GetSha256
    A71_GetSha256.argtypes = [POINTER(U8), U16, POINTER(U8), POINTER(U16)]
    A71_GetSha256.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_Sha256Init'):
        continue
    A71_Sha256Init = _lib.A71_Sha256Init
    A71_Sha256Init.argtypes = []
    A71_Sha256Init.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_Sha256Update'):
        continue
    A71_Sha256Update = _lib.A71_Sha256Update
    A71_Sha256Update.argtypes = [POINTER(U8), U16]
    A71_Sha256Update.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_Sha256Final'):
        continue
    A71_Sha256Final = _lib.A71_Sha256Final
    A71_Sha256Final.argtypes = [POINTER(U8), POINTER(U16)]
    A71_Sha256Final.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetUniqueID'):
        continue
    A71_GetUniqueID = _lib.A71_GetUniqueID
    A71_GetUniqueID.argtypes = [POINTER(U8), POINTER(U16)]
    A71_GetUniqueID.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetCertUid'):
        continue
    A71_GetCertUid = _lib.A71_GetCertUid
    A71_GetCertUid.argtypes = [POINTER(U8), POINTER(U16)]
    A71_GetCertUid.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetKeyPairChallenge'):
        continue
    A71_GetKeyPairChallenge = _lib.A71_GetKeyPairChallenge
    A71_GetKeyPairChallenge.argtypes = [POINTER(U8), POINTER(U16)]
    A71_GetKeyPairChallenge.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetPublicKeyChallenge'):
        continue
    A71_GetPublicKeyChallenge = _lib.A71_GetPublicKeyChallenge
    A71_GetPublicKeyChallenge.argtypes = [POINTER(U8), POINTER(U16)]
    A71_GetPublicKeyChallenge.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetUnlockChallenge'):
        continue
    A71_GetUnlockChallenge = _lib.A71_GetUnlockChallenge
    A71_GetUnlockChallenge.argtypes = [POINTER(U8), POINTER(U16)]
    A71_GetUnlockChallenge.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_InjectLock'):
        continue
    A71_InjectLock = _lib.A71_InjectLock
    A71_InjectLock.argtypes = []
    A71_InjectLock.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_LockModule'):
        continue
    A71_LockModule = _lib.A71_LockModule
    A71_LockModule.argtypes = []
    A71_LockModule.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_UnlockModule'):
        continue
    A71_UnlockModule = _lib.A71_UnlockModule
    A71_UnlockModule.argtypes = [POINTER(U8), U16]
    A71_UnlockModule.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_SetTlsLabel'):
        continue
    A71_SetTlsLabel = _lib.A71_SetTlsLabel
    A71_SetTlsLabel.argtypes = [POINTER(U8), U16]
    A71_SetTlsLabel.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EccVerifyWithKey'):
        continue
    A71_EccVerifyWithKey = _lib.A71_EccVerifyWithKey
    A71_EccVerifyWithKey.argtypes = [POINTER(U8), U16, POINTER(U8), U16, POINTER(U8), U16, POINTER(U8)]
    A71_EccVerifyWithKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GenerateEccKeyPair'):
        continue
    A71_GenerateEccKeyPair = _lib.A71_GenerateEccKeyPair
    A71_GenerateEccKeyPair.argtypes = [SST_Index_t]
    A71_GenerateEccKeyPair.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GenerateEccKeyPairWithChallenge'):
        continue
    A71_GenerateEccKeyPairWithChallenge = _lib.A71_GenerateEccKeyPairWithChallenge
    A71_GenerateEccKeyPairWithChallenge.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_GenerateEccKeyPairWithChallenge.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GenerateEccKeyPairWithCode'):
        continue
    A71_GenerateEccKeyPairWithCode = _lib.A71_GenerateEccKeyPairWithCode
    A71_GenerateEccKeyPairWithCode.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_GenerateEccKeyPairWithCode.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_SetEccKeyPair'):
        continue
    A71_SetEccKeyPair = _lib.A71_SetEccKeyPair
    A71_SetEccKeyPair.argtypes = [SST_Index_t, POINTER(U8), U16, POINTER(U8), U16]
    A71_SetEccKeyPair.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetPublicKeyEccKeyPair'):
        continue
    A71_GetPublicKeyEccKeyPair = _lib.A71_GetPublicKeyEccKeyPair
    A71_GetPublicKeyEccKeyPair.argtypes = [SST_Index_t, POINTER(U8), POINTER(U16)]
    A71_GetPublicKeyEccKeyPair.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetEccKeyPairUsage'):
        continue
    A71_GetEccKeyPairUsage = _lib.A71_GetEccKeyPairUsage
    A71_GetEccKeyPairUsage.argtypes = [SST_Index_t, POINTER(U8), POINTER(U16), POINTER(U16)]
    A71_GetEccKeyPairUsage.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EccSign'):
        continue
    A71_EccSign = _lib.A71_EccSign
    A71_EccSign.argtypes = [SST_Index_t, POINTER(U8), U16, POINTER(U8), POINTER(U16)]
    A71_EccSign.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EccNormalizedAsnSign'):
        continue
    A71_EccNormalizedAsnSign = _lib.A71_EccNormalizedAsnSign
    A71_EccNormalizedAsnSign.argtypes = [SST_Index_t, POINTER(U8), U16, POINTER(U8), POINTER(U16)]
    A71_EccNormalizedAsnSign.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EccRestrictedSign'):
        continue
    A71_EccRestrictedSign = _lib.A71_EccRestrictedSign
    A71_EccRestrictedSign.argtypes = [SST_Index_t, POINTER(U8), U16, POINTER(U8)]
    A71_EccRestrictedSign.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EcdhGetSharedSecret'):
        continue
    A71_EcdhGetSharedSecret = _lib.A71_EcdhGetSharedSecret
    A71_EcdhGetSharedSecret.argtypes = [U8, POINTER(U8), U16, POINTER(U8), POINTER(U16)]
    A71_EcdhGetSharedSecret.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_FreezeEccKeyPair'):
        continue
    A71_FreezeEccKeyPair = _lib.A71_FreezeEccKeyPair
    A71_FreezeEccKeyPair.argtypes = [SST_Index_t]
    A71_FreezeEccKeyPair.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_FreezeEccKeyPairWithChallenge'):
        continue
    A71_FreezeEccKeyPairWithChallenge = _lib.A71_FreezeEccKeyPairWithChallenge
    A71_FreezeEccKeyPairWithChallenge.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_FreezeEccKeyPairWithChallenge.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_FreezeEccKeyPairWithCode'):
        continue
    A71_FreezeEccKeyPairWithCode = _lib.A71_FreezeEccKeyPairWithCode
    A71_FreezeEccKeyPairWithCode.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_FreezeEccKeyPairWithCode.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EraseEccKeyPair'):
        continue
    A71_EraseEccKeyPair = _lib.A71_EraseEccKeyPair
    A71_EraseEccKeyPair.argtypes = [SST_Index_t]
    A71_EraseEccKeyPair.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EraseEccKeyPairWithChallenge'):
        continue
    A71_EraseEccKeyPairWithChallenge = _lib.A71_EraseEccKeyPairWithChallenge
    A71_EraseEccKeyPairWithChallenge.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_EraseEccKeyPairWithChallenge.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EraseEccKeyPairWithCode'):
        continue
    A71_EraseEccKeyPairWithCode = _lib.A71_EraseEccKeyPairWithCode
    A71_EraseEccKeyPairWithCode.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_EraseEccKeyPairWithCode.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_SetEccPublicKey'):
        continue
    A71_SetEccPublicKey = _lib.A71_SetEccPublicKey
    A71_SetEccPublicKey.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_SetEccPublicKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetEccPublicKey'):
        continue
    A71_GetEccPublicKey = _lib.A71_GetEccPublicKey
    A71_GetEccPublicKey.argtypes = [SST_Index_t, POINTER(U8), POINTER(U16)]
    A71_GetEccPublicKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_FreezeEccPublicKey'):
        continue
    A71_FreezeEccPublicKey = _lib.A71_FreezeEccPublicKey
    A71_FreezeEccPublicKey.argtypes = [SST_Index_t]
    A71_FreezeEccPublicKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_FreezeEccPublicKeyWithChallenge'):
        continue
    A71_FreezeEccPublicKeyWithChallenge = _lib.A71_FreezeEccPublicKeyWithChallenge
    A71_FreezeEccPublicKeyWithChallenge.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_FreezeEccPublicKeyWithChallenge.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_FreezeEccPublicKeyWithCode'):
        continue
    A71_FreezeEccPublicKeyWithCode = _lib.A71_FreezeEccPublicKeyWithCode
    A71_FreezeEccPublicKeyWithCode.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_FreezeEccPublicKeyWithCode.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EraseEccPublicKey'):
        continue
    A71_EraseEccPublicKey = _lib.A71_EraseEccPublicKey
    A71_EraseEccPublicKey.argtypes = [SST_Index_t]
    A71_EraseEccPublicKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EraseEccPublicKeyWithChallenge'):
        continue
    A71_EraseEccPublicKeyWithChallenge = _lib.A71_EraseEccPublicKeyWithChallenge
    A71_EraseEccPublicKeyWithChallenge.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_EraseEccPublicKeyWithChallenge.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EraseEccPublicKeyWithCode'):
        continue
    A71_EraseEccPublicKeyWithCode = _lib.A71_EraseEccPublicKeyWithCode
    A71_EraseEccPublicKeyWithCode.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_EraseEccPublicKeyWithCode.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EccVerify'):
        continue
    A71_EccVerify = _lib.A71_EccVerify
    A71_EccVerify.argtypes = [SST_Index_t, POINTER(U8), U16, POINTER(U8), U16, POINTER(U8)]
    A71_EccVerify.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_SetSymKey'):
        continue
    A71_SetSymKey = _lib.A71_SetSymKey
    A71_SetSymKey.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_SetSymKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_SetRfc3394WrappedAesKey'):
        continue
    A71_SetRfc3394WrappedAesKey = _lib.A71_SetRfc3394WrappedAesKey
    A71_SetRfc3394WrappedAesKey.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_SetRfc3394WrappedAesKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_FreezeSymKey'):
        continue
    A71_FreezeSymKey = _lib.A71_FreezeSymKey
    A71_FreezeSymKey.argtypes = [SST_Index_t]
    A71_FreezeSymKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EraseSymKey'):
        continue
    A71_EraseSymKey = _lib.A71_EraseSymKey
    A71_EraseSymKey.argtypes = [SST_Index_t]
    A71_EraseSymKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetHmacSha256'):
        continue
    A71_GetHmacSha256 = _lib.A71_GetHmacSha256
    A71_GetHmacSha256.argtypes = [SST_Index_t, U8, POINTER(U8), U16, POINTER(U8), POINTER(U16)]
    A71_GetHmacSha256.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_HmacSha256Init'):
        continue
    A71_HmacSha256Init = _lib.A71_HmacSha256Init
    A71_HmacSha256Init.argtypes = [SST_Index_t, U8]
    A71_HmacSha256Init.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_HmacSha256Update'):
        continue
    A71_HmacSha256Update = _lib.A71_HmacSha256Update
    A71_HmacSha256Update.argtypes = [SST_Index_t, U8, POINTER(U8), U16]
    A71_HmacSha256Update.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_HmacSha256Final'):
        continue
    A71_HmacSha256Final = _lib.A71_HmacSha256Final
    A71_HmacSha256Final.argtypes = [SST_Index_t, U8, POINTER(U8), POINTER(U16)]
    A71_HmacSha256Final.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_HkdfExpandSymKey'):
        continue
    A71_HkdfExpandSymKey = _lib.A71_HkdfExpandSymKey
    A71_HkdfExpandSymKey.argtypes = [SST_Index_t, U8, POINTER(U8), U16, POINTER(U8), U16]
    A71_HkdfExpandSymKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_HkdfSymKey'):
        continue
    A71_HkdfSymKey = _lib.A71_HkdfSymKey
    A71_HkdfSymKey.argtypes = [SST_Index_t, U8, POINTER(U8), U16, POINTER(U8), U16, POINTER(U8), U16]
    A71_HkdfSymKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_PskDeriveMasterSecret'):
        continue
    A71_PskDeriveMasterSecret = _lib.A71_PskDeriveMasterSecret
    A71_PskDeriveMasterSecret.argtypes = [SST_Index_t, U8, POINTER(U8), U16, POINTER(U8)]
    A71_PskDeriveMasterSecret.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_SetGpData'):
        continue
    A71_SetGpData = _lib.A71_SetGpData
    A71_SetGpData.argtypes = [U16, POINTER(U8), U16]
    A71_SetGpData.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_SetGpDataWithLockCheck'):
        continue
    A71_SetGpDataWithLockCheck = _lib.A71_SetGpDataWithLockCheck
    A71_SetGpDataWithLockCheck.argtypes = [U16, POINTER(U8), U16]
    A71_SetGpDataWithLockCheck.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetGpData'):
        continue
    A71_GetGpData = _lib.A71_GetGpData
    A71_GetGpData.argtypes = [U16, POINTER(U8), U16]
    A71_GetGpData.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_FreezeGpData'):
        continue
    A71_FreezeGpData = _lib.A71_FreezeGpData
    A71_FreezeGpData.argtypes = [U16, U16]
    A71_FreezeGpData.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_IncrementCounter'):
        continue
    A71_IncrementCounter = _lib.A71_IncrementCounter
    A71_IncrementCounter.argtypes = [SST_Index_t]
    A71_IncrementCounter.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_SetCounter'):
        continue
    A71_SetCounter = _lib.A71_SetCounter
    A71_SetCounter.argtypes = [SST_Index_t, U32]
    A71_SetCounter.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_GetCounter'):
        continue
    A71_GetCounter = _lib.A71_GetCounter
    A71_GetCounter.argtypes = [SST_Index_t, POINTER(U32)]
    A71_GetCounter.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_EcdhPskDeriveMasterSecret'):
        continue
    A71_EcdhPskDeriveMasterSecret = _lib.A71_EcdhPskDeriveMasterSecret
    A71_EcdhPskDeriveMasterSecret.argtypes = [SST_Index_t, POINTER(U8), U16, SST_Index_t, U8, POINTER(U8), U16, POINTER(U8)]
    A71_EcdhPskDeriveMasterSecret.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_SetConfigKey'):
        continue
    A71_SetConfigKey = _lib.A71_SetConfigKey
    A71_SetConfigKey.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_SetConfigKey.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'A71_SetRfc3394WrappedConfigKey'):
        continue
    A71_SetRfc3394WrappedConfigKey = _lib.A71_SetRfc3394WrappedConfigKey
    A71_SetRfc3394WrappedConfigKey.argtypes = [SST_Index_t, POINTER(U8), U16]
    A71_SetRfc3394WrappedConfigKey.restype = U16
    break

HLSE_RET_CODE = U16# hostlib/hostLib/inc/HLSETypes.h

HLSE_TYPE = U32
HLSE_OBJECT_HANDLE = HLSE_TYPE
# hostlib/hostLib/inc/HLSEMisc.h
for _lib in list(_libs.values()):
    if not hasattr(_lib, 'HLSE_DisablePlainInjectionMode'):
        continue
    HLSE_DisablePlainInjectionMode = _lib.HLSE_DisablePlainInjectionMode
    HLSE_DisablePlainInjectionMode.argtypes = []
    HLSE_DisablePlainInjectionMode.restype = HLSE_RET_CODE
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'HLSE_ResetContents'):
        continue
    HLSE_ResetContents = _lib.HLSE_ResetContents
    HLSE_ResetContents.argtypes = []
    HLSE_ResetContents.restype = HLSE_RET_CODE
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'HLSE_DbgDisableDebug'):
        continue
    HLSE_DbgDisableDebug = _lib.HLSE_DbgDisableDebug
    HLSE_DbgDisableDebug.argtypes = []
    HLSE_DbgDisableDebug.restype = HLSE_RET_CODE
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'HLSE_DbgReflect'):
        continue
    HLSE_DbgReflect = _lib.HLSE_DbgReflect
    HLSE_DbgReflect.argtypes = [POINTER(U8), U16, POINTER(U8), POINTER(U16)]
    HLSE_DbgReflect.restype = HLSE_RET_CODE
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'HLSE_DbgReset'):
        continue
    HLSE_DbgReset = _lib.HLSE_DbgReset
    HLSE_DbgReset.argtypes = []
    HLSE_DbgReset.restype = HLSE_RET_CODE
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'HLSE_NormalizeECCSignature'):
        continue
    HLSE_NormalizeECCSignature = _lib.HLSE_NormalizeECCSignature
    HLSE_NormalizeECCSignature.argtypes = [POINTER(U8), U16, POINTER(U8), POINTER(U16)]
    HLSE_NormalizeECCSignature.restype = HLSE_RET_CODE
    break

enum_anon_78 = c_int # ../../hostlib/hostLib/libCommon/infra/sm_api.h

kType_SE_Conn_Type_NONE = 0

kType_SE_Conn_Type_SCII2C = (0 + 2)

kType_SE_Conn_Type_VCOM = (0 + 3)

kType_SE_Conn_Type_JRCP_V1 = (0 + 4)

kType_SE_Conn_Type_JRCP_V2 = (0 + 5)

kType_SE_Conn_Type_T1oI2C = (0 + 6)

kType_SE_Conn_Type_NFC = (0 + 7)

kType_SE_Conn_Type_Channel = (0 + 8)

kType_SE_Conn_Type_PCSC = (0 + 9)

kType_SE_Conn_Type_LAST = (kType_SE_Conn_Type_PCSC + 1)

kType_SE_Conn_Type_SIZE = 32767

SSS_Conn_Type_t = enum_anon_78
class struct_anon_79(Structure):
    pass


struct_anon_79.__slots__ = [
    'connType',
    'param1',
    'param2',
    'hostLibVersion',
    'appletVersion',
    'sbVersion',
    'select',
]
struct_anon_79._fields_ = [
    ('connType', U16),
    ('param1', U16),
    ('param2', U16),
    ('hostLibVersion', U16),
    ('appletVersion', U32),
    ('sbVersion', U16),
    ('select', U8),
]

SmCommState_t = struct_anon_79
for _lib in list(_libs.values()):
    if not hasattr(_lib, 'SM_Close'):
        continue
    SM_Close = _lib.SM_Close
    SM_Close.argtypes = [POINTER(None), U8]
    SM_Close.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'SM_Connect'):
        continue
    SM_Connect = _lib.SM_Connect
    SM_Connect.argtypes = [POINTER(None), POINTER(SmCommState_t), POINTER(U8), POINTER(U16)]
    SM_Connect.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'SM_ConnectWithAID'):
        continue
    SM_ConnectWithAID = _lib.SM_ConnectWithAID
    SM_ConnectWithAID.argtypes = [POINTER(SmCommState_t), POINTER(U8), U16, POINTER(U8), POINTER(U16)]
    SM_ConnectWithAID.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'SM_RjctConnect'):
        continue
    SM_RjctConnect = _lib.SM_RjctConnect
    SM_RjctConnect.argtypes = [POINTER(POINTER(None)), String, POINTER(SmCommState_t), POINTER(U8), POINTER(U16)]
    SM_RjctConnect.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'SM_RjctConnectWithAID'):
        continue
    SM_RjctConnectWithAID = _lib.SM_RjctConnectWithAID
    SM_RjctConnectWithAID.argtypes = [String, POINTER(SmCommState_t), POINTER(U8), U16, POINTER(U8), POINTER(U16)]
    SM_RjctConnectWithAID.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'SM_I2CConnect'):
        continue
    SM_I2CConnect = _lib.SM_I2CConnect
    SM_I2CConnect.argtypes = [POINTER(POINTER(None)), POINTER(SmCommState_t), POINTER(U8), POINTER(U16), String]
    SM_I2CConnect.restype = U16
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'SM_SendAPDU'):
        continue
    SM_SendAPDU = _lib.SM_SendAPDU
    SM_SendAPDU.argtypes = [POINTER(U8), U16, POINTER(U8), POINTER(U16)]
    SM_SendAPDU.restype = U16
    break

sscp_status_t = c_uint32# ../../sss/inc/fsl_sscp.h

class struct__sscp_context(Structure):
    pass


sscp_context_t = struct__sscp_context
class struct__sscp_operation(Structure):
    pass


sscp_operation_t = struct__sscp_operation
fn_sscp_invoke_command_t = CFUNCTYPE(UNCHECKED(sscp_status_t), POINTER(sscp_context_t), c_uint32, POINTER(sscp_operation_t), POINTER(c_uint32))
class struct_anon_80(Structure):
    pass


struct_anon_80.__slots__ = [
    'data',
]
struct_anon_80._fields_ = [
    ('data', c_uint8 * sizeof(POINTER(None))),
]

struct__sscp_context.__slots__ = [
    'invoke',
    'context',
]
struct__sscp_context._fields_ = [
    ('invoke', fn_sscp_invoke_command_t),
    ('context', struct_anon_80),
]

class struct__sscp_memref(Structure):
    pass


struct__sscp_memref.__slots__ = [
    'buffer',
    'size',
]
struct__sscp_memref._fields_ = [
    ('buffer', POINTER(None)),
    ('size', c_size_t),
]

sscp_memref_t = struct__sscp_memref
class struct__sscp_value(Structure):
    pass


struct__sscp_value.__slots__ = [
    'a',
    'b',
]
struct__sscp_value._fields_ = [
    ('a', c_uint32),
    ('b', c_uint32),
]

sscp_value_t = struct__sscp_value
class struct__sscp_aggregate_operation(Structure):
    pass


struct__sscp_aggregate_operation.__slots__ = [
    'op',
]
struct__sscp_aggregate_operation._fields_ = [
    ('op', POINTER(sscp_operation_t)),
]

sscp_aggregate_operation_t = struct__sscp_aggregate_operation
class struct__sscp_context_operation(Structure):
    pass


struct__sscp_context_operation.__slots__ = [
    'ptr',
    'type',
]
struct__sscp_context_operation._fields_ = [
    ('ptr', POINTER(None)),
    ('type', c_uint32),
]

sscp_context_reference_t = struct__sscp_context_operation
class union__sscp_parameter(Union):
    pass


union__sscp_parameter.__slots__ = [
    'value',
    'memref',
    'aggregate',
    'context',
]
union__sscp_parameter._fields_ = [
    ('value', sscp_value_t),
    ('memref', sscp_memref_t),
    ('aggregate', sscp_aggregate_operation_t),
    ('context', sscp_context_reference_t),
]

sscp_parameter_t = union__sscp_parameter
struct__sscp_operation.__slots__ = [
    'paramTypes',
    'params',
]
struct__sscp_operation._fields_ = [
    ('paramTypes', c_uint32),
    ('params', sscp_parameter_t * 7),
]

fn_sscp_close_t = CFUNCTYPE(UNCHECKED(None), )# ../../sss/inc/fsl_sss_sscp.h

class struct__sss_sscp_session(Structure):
    pass


struct__sss_sscp_session.__slots__ = [
    'subsystem',
    'sscp_context',
    'mem_sscp_ctx',
    'sessionId',
    'fp_closeConnection',
]
struct__sss_sscp_session._fields_ = [
    ('subsystem', sss_type_t),
    ('sscp_context', POINTER(sscp_context_t)),
    ('mem_sscp_ctx', sscp_context_t),
    ('sessionId', c_uint32),
    ('fp_closeConnection', fn_sscp_close_t),
]

sss_sscp_session_t = struct__sss_sscp_session
# ../../sss/inc/fsl_sss_keyid_map.h
class struct_anon_87(Structure):
    pass


struct_anon_87.__slots__ = [
    'extKeyId',
    'keyPart',
    'accessPermission',
    'cipherType',
    'keyIntIndex',
]
struct_anon_87._fields_ = [
    ('extKeyId', c_uint32),
    ('keyPart', c_uint8),
    ('accessPermission', c_uint8),
    ('cipherType', c_uint8),
    ('keyIntIndex', c_uint8),
]

keyIdAndTypeIndexLookup_t = struct_anon_87
class struct__keyStoreTable_t(Structure):
    pass


struct__keyStoreTable_t.__slots__ = [
    'magic',
    'version',
    'maxEntries',
    'entries',
]
struct__keyStoreTable_t._fields_ = [
    ('magic', c_uint32),
    ('version', c_uint16),
    ('maxEntries', c_uint16),
    ('entries', POINTER(keyIdAndTypeIndexLookup_t)),
]

keyStoreTable_t = struct__keyStoreTable_t
# ../../sss/inc/fsl_sscp_a71ch.h
class struct__sss_a71ch_key_store(Structure):
    pass


struct__sss_a71ch_key_store.__slots__ = [
    'session',
    'keystore_shadow',
    'shadow_handle',
]
struct__sss_a71ch_key_store._fields_ = [
    ('session', POINTER(sss_sscp_session_t)),
    ('keystore_shadow', POINTER(keyStoreTable_t)),
    ('shadow_handle', HLSE_OBJECT_HANDLE),
]

sss_a71ch_key_store_t = struct__sss_a71ch_key_store
class struct__sscp_a71ch_context(Structure):
    pass


struct__sscp_a71ch_context.__slots__ = [
    'invoke',
    'keyStore',
]
struct__sscp_a71ch_context._fields_ = [
    ('invoke', fn_sscp_invoke_command_t),
    ('keyStore', POINTER(sss_a71ch_key_store_t)),
]

sscp_a71ch_context_t = struct__sscp_a71ch_context
for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sscp_a71ch_init'):
        continue
    sscp_a71ch_init = _lib.sscp_a71ch_init
    sscp_a71ch_init.argtypes = [POINTER(sscp_a71ch_context_t), POINTER(sss_a71ch_key_store_t)]
    sscp_a71ch_init.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sscp_a71ch_free'):
        continue
    sscp_a71ch_free = _lib.sscp_a71ch_free
    sscp_a71ch_free.argtypes = [POINTER(sscp_a71ch_context_t)]
    sscp_a71ch_free.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sscp_a71ch_invoke_command'):
        continue
    sscp_a71ch_invoke_command = _lib.sscp_a71ch_invoke_command
    sscp_a71ch_invoke_command.argtypes = [POINTER(sscp_context_t), c_uint32, POINTER(sscp_operation_t), POINTER(c_uint32)]
    sscp_a71ch_invoke_command.restype = sscp_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sscp_a71ch_openSession'):
        continue
    sscp_a71ch_openSession = _lib.sscp_a71ch_openSession
    sscp_a71ch_openSession.argtypes = [POINTER(None), POINTER(sss_sscp_session_t)]
    sscp_a71ch_openSession.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sscp_a71chkey_store_context_free'):
        continue
    sscp_a71chkey_store_context_free = _lib.sscp_a71chkey_store_context_free
    sscp_a71chkey_store_context_free.argtypes = [POINTER(sss_a71ch_key_store_t)]
    sscp_a71chkey_store_context_free.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sscp_a71ch_closeSession'):
        continue
    sscp_a71ch_closeSession = _lib.sscp_a71ch_closeSession
    sscp_a71ch_closeSession.argtypes = [POINTER(sss_sscp_session_t)]
    sscp_a71ch_closeSession.restype = None
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sscp_a71ch_closeConnect'):
        continue
    sscp_a71ch_closeConnect = _lib.sscp_a71ch_closeConnect
    sscp_a71ch_closeConnect.argtypes = []
    sscp_a71ch_closeConnect.restype = None
    break

enum_anon_88 = c_int # hostlib/hostLib/inc/nxScp03_Types.h

kSSS_AuthType_None = 0

kSSS_AuthType_SCP03 = 1

kSSS_AuthType_ID = 2

kSSS_AuthType_AESKey = 3

kSSS_AuthType_ECKey = 4

kSSS_AuthType_INT_ECKey_Counter = 20

kSSS_SIZE = 2147483647

SE_AuthType_t = enum_anon_88
class struct_anon_89(Structure):
    pass


struct_anon_89.__slots__ = [
    'Enc',
    'Mac',
    'Rmac',
    'MCV',
    'cCounter',
    'SecurityLevel',
    'authType',
]
struct_anon_89._fields_ = [
    ('Enc', sss_object_t),
    ('Mac', sss_object_t),
    ('Rmac', sss_object_t),
    ('MCV', c_uint8 * 16),
    ('cCounter', c_uint8 * 16),
    ('SecurityLevel', c_uint8),
    ('authType', SE_AuthType_t),
]

NXSCP03_DynCtx_t = struct_anon_89
class struct_anon_90(Structure):
    pass


struct_anon_90.__slots__ = [
    'keyVerNo',
    'Enc',
    'Mac',
    'Dek',
]
struct_anon_90._fields_ = [
    ('keyVerNo', c_uint8),
    ('Enc', sss_object_t),
    ('Mac', sss_object_t),
    ('Dek', sss_object_t),
]

NXSCP03_StaticCtx_t = struct_anon_90
class struct_anon_91(Structure):
    pass


struct_anon_91.__slots__ = [
    'pStatic_ctx',
    'pDyn_ctx',
]
struct_anon_91._fields_ = [
    ('pStatic_ctx', POINTER(NXSCP03_StaticCtx_t)),
    ('pDyn_ctx', POINTER(NXSCP03_DynCtx_t)),
]

NXSCP03_AuthCtx_t = struct_anon_91
class struct_anon_92(Structure):
    pass


struct_anon_92.__slots__ = [
    'HostEcdsaObj',
    'HostEcKeypair',
    'SeEcPubKey',
    'masterSec',
]
struct_anon_92._fields_ = [
    ('HostEcdsaObj', sss_object_t),
    ('HostEcKeypair', sss_object_t),
    ('SeEcPubKey', sss_object_t),
    ('masterSec', sss_object_t),
]

NXECKey03_StaticCtx_t = struct_anon_92
class struct_anon_93(Structure):
    pass


struct_anon_93.__slots__ = [
    'pStatic_ctx',
    'pDyn_ctx',
]
struct_anon_93._fields_ = [
    ('pStatic_ctx', POINTER(NXECKey03_StaticCtx_t)),
    ('pDyn_ctx', POINTER(NXSCP03_DynCtx_t)),
]

SE05x_AuthCtx_ECKey_t = struct_anon_93
class struct_anon_94(Structure):
    pass


struct_anon_94.__slots__ = [
    'pObj',
]
struct_anon_94._fields_ = [
    ('pObj', POINTER(sss_object_t)),
]

SE05x_AuthCtx_ID_t = struct_anon_94
class struct_anon_95(Structure):
    pass


struct_anon_95.__slots__ = [
    'pKeyEnc',
    'pKeyMac',
    'pKeyDek',
]
struct_anon_95._fields_ = [
    ('pKeyEnc', sss_object_t),
    ('pKeyMac', sss_object_t),
    ('pKeyDek', sss_object_t),
]

SM_SECURE_SCP03_KEYOBJ = struct_anon_95
class struct_anon_96(Structure):
    pass


struct_anon_96.__slots__ = [
    'data',
]
struct_anon_96._fields_ = [
    ('data', c_uint8 * ((0 + (3 * sizeof(POINTER(None)))) + 8)),
]

class union_anon_97(Union):
    pass


union_anon_97.__slots__ = [
    'scp03',
    'eckey',
    'idobj',
    'a71chAuthKeys',
    'extension',
]
union_anon_97._fields_ = [
    ('scp03', NXSCP03_AuthCtx_t),
    ('eckey', SE05x_AuthCtx_ECKey_t),
    ('idobj', SE05x_AuthCtx_ID_t),
    ('a71chAuthKeys', SM_SECURE_SCP03_KEYOBJ),
    ('extension', struct_anon_96),
]

class struct__SE_AuthCtx(Structure):
    pass


struct__SE_AuthCtx.__slots__ = [
    'authType',
    'ctx',
]
struct__SE_AuthCtx._fields_ = [
    ('authType', SE_AuthType_t),
    ('ctx', union_anon_97),
]

SE_AuthCtx_t = struct__SE_AuthCtx
class struct_anon_98(Structure):
    pass


struct_anon_98.__slots__ = [
    'sizeOfStucture',
    'auth',
    'session_policy',
    'tunnelCtx',
    'connType',
    'portName',
    'i2cAddress',
    'refresh_session',
    'skip_select_applet',
]
struct_anon_98._fields_ = [
    ('sizeOfStucture', c_uint16),
    ('auth', SE_AuthCtx_t),
    ('session_policy', POINTER(sss_policy_session_u)),
    ('tunnelCtx', POINTER(sss_tunnel_t)),
    ('connType', SSS_Conn_Type_t),
    ('portName', String),
    ('i2cAddress', U32),
    ('refresh_session', c_uint8, 1),
    ('skip_select_applet', c_uint8, 1),
]

SE_Connect_Ctx_t = struct_anon_98
class struct_anon_99(Structure):
    pass


struct_anon_99.__slots__ = [
    'data',
]
struct_anon_99._fields_ = [
    ('data', c_uint8 * ((0 + (4 * sizeof(POINTER(None)))) + 8)),
]

class struct_anon_100(Structure):
    pass


struct_anon_100.__slots__ = [
    'sizeOfStucture',
    'auth',
    'session_policy',
    'extension',
]
struct_anon_100._fields_ = [
    ('sizeOfStucture', c_uint16),
    ('auth', SE_AuthCtx_t),
    ('session_policy', POINTER(sss_policy_session_u)),
    ('extension', struct_anon_99),
]

sss_connect_ctx_t = struct_anon_100
enum_Se05x_SYMM_CIPHER_MODES = c_int # hostlib/hostLib/inc/se05x_const.h

Se05x_SYMM_MODE_NONE = 0

Se05x_SYMM_CBC = 1

Se05x_SYMM_EBC = 2

Se05x_SYMM_CTR = 8

enum_Se05x_AES_PADDING = c_int 
Se05x_AES_PADDING_NONE = 0

Se05x_AES_PAD_NOPAD = 1

Se05x_AES_PAD_ISO9797_M1 = 2

Se05x_AES_PAD_ISO9797_M2 = 3

enum_Se05x_SHA_TYPE = c_int 
Se05x_SHA_1 = 0

Se05x_SHA_256 = 4

Se05x_SHA_384 = 5

Se05x_SHA_512 = 6

enum_Se05x_MAC_TYPE = c_int 
Se05x_CMAC = 10

enum_Se05x_MAC_Sign_verify = c_int 
Se05x_MAC_Sign = 0

Se05x_MAC_Verify = 1

enum_Se05x_I2CM_RESULT_TYPE = c_int 
Se05x_I2CM_RESULT_SUCCESS = 165

Se05x_I2CM_RESULT_FAILURE = 150

enum_anon_101 = c_int # hostlib/hostLib/inc/se05x_enums.h

kSE05x_AppletResID_NA = 0

kSE05x_AppletResID_TRANSPORT = 2147418624

kSE05x_AppletResID_KP_ECKEY_USER = 2147418625

kSE05x_AppletResID_KP_ECKEY_IMPORT = 2147418626

kSE05x_AppletResID_FEATURE = 2147418628

kSE05x_AppletResID_FACTORY_RESET = 2147418629

kSE05x_AppletResID_UNIQUE_ID = 2147418630

kSE05x_AppletResID_PLATFORM_SCP = 2147418631

kSE05x_AppletResID_I2CM_ACCESS = 2147418632

kSE05x_AppletResID_RESTRICT = 2147418634

SE05x_AppletResID_t = enum_anon_101
enum_anon_102 = c_int 
kSE05x_SW12_NA = 0

kSE05x_SW12_NO_ERROR = 36864

kSE05x_SW12_CONDITIONS_NOT_SATISFIED = 27013

kSE05x_SW12_SECURITY_STATUS = 27010

kSE05x_SW12_WRONG_DATA = 27264

kSE05x_SW12_DATA_INVALID = 27012

kSE05x_SW12_COMMAND_NOT_ALLOWED = 27014

SE05x_SW12_t = enum_anon_102
enum_anon_103 = c_int 
kSE05x_INS_NA = 0

kSE05x_INS_MASK_INS_CHAR = 224

kSE05x_INS_MASK_INSTRUCTION = 31

kSE05x_INS_TRANSIENT = 128

kSE05x_INS_AUTH_OBJECT = 64

kSE05x_INS_ATTEST = 32

kSE05x_INS_WRITE = 1

kSE05x_INS_READ = 2

kSE05x_INS_CRYPTO = 3

kSE05x_INS_MGMT = 4

kSE05x_INS_PROCESS = 5

SE05x_INS_t = enum_anon_103
enum_anon_104 = c_int 
kSE05x_P1_NA = 0

kSE05x_P1_UNUSED = 128

kSE05x_P1_MASK_KEY_TYPE = 96

kSE05x_P1_MASK_CRED_TYPE = 31

kSE05x_P1_KEY_PAIR = 96

kSE05x_P1_PRIVATE = 64

kSE05x_P1_PUBLIC = 32

kSE05x_P1_DEFAULT = 0

kSE05x_P1_EC = 1

kSE05x_P1_RSA = 2

kSE05x_P1_AES = 3

kSE05x_P1_DES = 4

kSE05x_P1_HMAC = 5

kSE05x_P1_BINARY = 6

kSE05x_P1_UserID = 7

kSE05x_P1_COUNTER = 8

kSE05x_P1_PCR = 9

kSE05x_P1_CURVE = 11

kSE05x_P1_SIGNATURE = 12

kSE05x_P1_MAC = 13

kSE05x_P1_CIPHER = 14

kSE05x_P1_TLS = 15

kSE05x_P1_CRYPTO_OBJ = 16

kSE05x_P1_AEAD = 17

kSE05x_P1_AEAD_SP800_38D = 18

SE05x_P1_t = enum_anon_104
enum_anon_105 = c_int 
kSE05x_P2_DEFAULT = 0

kSE05x_P2_GENERATE = 3

kSE05x_P2_CREATE = 4

kSE05x_P2_SIZE = 7

kSE05x_P2_SIGN = 9

kSE05x_P2_VERIFY = 10

kSE05x_P2_INIT = 11

kSE05x_P2_UPDATE = 12

kSE05x_P2_FINAL = 13

kSE05x_P2_ONESHOT = 14

kSE05x_P2_DH = 15

kSE05x_P2_DIVERSIFY = 16

kSE05x_P2_AUTH_FIRST_PART2 = 18

kSE05x_P2_AUTH_NONFIRST_PART2 = 19

kSE05x_P2_DUMP_KEY = 20

kSE05x_P2_CHANGE_KEY_PART1 = 21

kSE05x_P2_CHANGE_KEY_PART2 = 22

kSE05x_P2_KILL_AUTH = 23

kSE05x_P2_IMPORT = 24

kSE05x_P2_EXPORT = 25

kSE05x_P2_SESSION_CREATE = 27

kSE05x_P2_SESSION_CLOSE = 28

kSE05x_P2_SESSION_REFRESH = 30

kSE05x_P2_SESSION_POLICY = 31

kSE05x_P2_VERSION = 32

kSE05x_P2_VERSION_EXT = 33

kSE05x_P2_MEMORY = 34

kSE05x_P2_LIST = 37

kSE05x_P2_TYPE = 38

kSE05x_P2_EXIST = 39

kSE05x_P2_DELETE_OBJECT = 40

kSE05x_P2_DELETE_ALL = 42

kSE05x_P2_SESSION_UserID = 44

kSE05x_P2_HKDF = 45

kSE05x_P2_PBKDF = 46

kSE05x_P2_HKDF_EXPAND_ONLY = 47

kSE05x_P2_I2CM = 48

kSE05x_P2_I2CM_ATTESTED = 49

kSE05x_P2_MAC = 50

kSE05x_P2_UNLOCK_CHALLENGE = 51

kSE05x_P2_CURVE_LIST = 52

kSE05x_P2_SIGN_ECDAA = 53

kSE05x_P2_ID = 54

kSE05x_P2_ENCRYPT_ONESHOT = 55

kSE05x_P2_DECRYPT_ONESHOT = 56

kSE05x_P2_ATTEST = 58

kSE05x_P2_ATTRIBUTES = 59

kSE05x_P2_CPLC = 60

kSE05x_P2_TIME = 61

kSE05x_P2_TRANSPORT = 62

kSE05x_P2_VARIANT = 63

kSE05x_P2_PARAM = 64

kSE05x_P2_DELETE_CURVE = 65

kSE05x_P2_ENCRYPT = 66

kSE05x_P2_DECRYPT = 67

kSE05x_P2_VALIDATE = 68

kSE05x_P2_GENERATE_ONESHOT = 69

kSE05x_P2_VALIDATE_ONESHOT = 70

kSE05x_P2_CRYPTO_LIST = 71

kSE05x_P2_RANDOM = 73

kSE05x_P2_TLS_PMS = 74

kSE05x_P2_TLS_PRF_CLI_HELLO = 75

kSE05x_P2_TLS_PRF_SRV_HELLO = 76

kSE05x_P2_TLS_PRF_CLI_RND = 77

kSE05x_P2_TLS_PRF_SRV_RND = 78

kSE05x_P2_TLS_PRF_BOTH = 90

kSE05x_P2_RAW = 79

kSE05x_P2_IMPORT_EXT = 81

kSE05x_P2_SCP = 82

kSE05x_P2_AUTH_FIRST_PART1 = 83

kSE05x_P2_AUTH_NONFIRST_PART1 = 84

kSE05x_P2_CM_COMMAND = 85

kSE05x_P2_MODE_OF_OPERATION = 86

kSE05x_P2_RESTRICT = 87

kSE05x_P2_SANITY = 88

kSE05x_P2_DH_REVERSE = 89

kSE05x_P2_READ_STATE = 91

SE05x_P2_t = enum_anon_105
enum_anon_106 = c_int 
kSE05x_MemoryType_NA = 0

kSE05x_MemoryType_PERSISTENT = 1

kSE05x_MemoryType_TRANSIENT_RESET = 2

kSE05x_MemoryType_TRANSIENT_DESELECT = 3

SE05x_MemoryType_t = enum_anon_106
enum_anon_107 = c_int 
kSE05x_Origin_NA = 0

kSE05x_Origin_EXTERNAL = 1

kSE05x_Origin_INTERNAL = 2

kSE05x_Origin_PROVISIONED = 3

SE05x_Origin_t = enum_anon_107
enum_anon_108 = c_int 
kSE05x_TAG_NA = 0

kSE05x_TAG_SESSION_ID = 16

kSE05x_TAG_POLICY = 17

kSE05x_TAG_MAX_ATTEMPTS = 18

kSE05x_TAG_IMPORT_AUTH_DATA = 19

kSE05x_TAG_IMPORT_AUTH_KEY_ID = 20

kSE05x_TAG_POLICY_CHECK = 21

kSE05x_TAG_1 = 65

kSE05x_TAG_2 = 66

kSE05x_TAG_3 = 67

kSE05x_TAG_4 = 68

kSE05x_TAG_5 = 69

kSE05x_TAG_6 = 70

kSE05x_TAG_7 = 71

kSE05x_TAG_8 = 72

kSE05x_TAG_9 = 73

kSE05x_TAG_10 = 74

kSE05x_TAG_11 = 75

kSE05x_GP_TAG_CONTRL_REF_PARM = 166

kSE05x_GP_TAG_AID = 79

kSE05x_GP_TAG_KEY_TYPE = 128

kSE05x_GP_TAG_KEY_LEN = 129

kSE05x_GP_TAG_GET_DATA = 131

kSE05x_GP_TAG_DR_SE = 133

kSE05x_GP_TAG_RECEIPT = 134

kSE05x_GP_TAG_SCP_PARMS = 144

SE05x_TAG_t = enum_anon_108
enum_anon_109 = c_int 
kSE05x_ECSignatureAlgo_NA = 0

kSE05x_ECSignatureAlgo_PLAIN = 9

kSE05x_ECSignatureAlgo_SHA = 17

kSE05x_ECSignatureAlgo_SHA_224 = 37

kSE05x_ECSignatureAlgo_SHA_256 = 33

kSE05x_ECSignatureAlgo_SHA_384 = 34

kSE05x_ECSignatureAlgo_SHA_512 = 38

SE05x_ECSignatureAlgo_t = enum_anon_109
enum_anon_110 = c_int 
kSE05x_EDSignatureAlgo_NA = 0

kSE05x_EDSignatureAlgo_ED25519PURE_SHA_512 = 163

SE05x_EDSignatureAlgo_t = enum_anon_110
enum_anon_111 = c_int 
kSE05x_ECDAASignatureAlgo_NA = 0

kSE05x_ECDAASignatureAlgo_ECDAA = 244

SE05x_ECDAASignatureAlgo_t = enum_anon_111
enum_anon_112 = c_int 
kSE05x_RSASignatureAlgo_NA = 0

kSE05x_RSASignatureAlgo_SHA1_PKCS1_PSS = 21

kSE05x_RSASignatureAlgo_SHA224_PKCS1_PSS = 43

kSE05x_RSASignatureAlgo_SHA256_PKCS1_PSS = 44

kSE05x_RSASignatureAlgo_SHA384_PKCS1_PSS = 45

kSE05x_RSASignatureAlgo_SHA512_PKCS1_PSS = 46

kSE05x_RSASignatureAlgo_SHA1_PKCS1 = 10

kSE05x_RSASignatureAlgo_SHA_224_PKCS1 = 39

kSE05x_RSASignatureAlgo_SHA_256_PKCS1 = 40

kSE05x_RSASignatureAlgo_SHA_384_PKCS1 = 41

kSE05x_RSASignatureAlgo_SHA_512_PKCS1 = 42

SE05x_RSASignatureAlgo_t = enum_anon_112
enum_anon_113 = c_int 
kSE05x_RSAEncryptionAlgo_NA = 0

kSE05x_RSAEncryptionAlgo_NO_PAD = 12

kSE05x_RSAEncryptionAlgo_PKCS1 = 10

kSE05x_RSAEncryptionAlgo_PKCS1_OAEP = 15

SE05x_RSAEncryptionAlgo_t = enum_anon_113
enum_anon_114 = c_int 
kSE05x_RSABitLength_NA = 0

kSE05x_RSABitLength_512 = 512

kSE05x_RSABitLength_1024 = 1024

kSE05x_RSABitLength_1152 = 1152

kSE05x_RSABitLength_2048 = 2048

kSE05x_RSABitLength_3072 = 3072

kSE05x_RSABitLength_4096 = 4096

SE05x_RSABitLength_t = enum_anon_114
enum_anon_115 = c_int 
kSE05x_RSAKeyComponent_NA = 255

kSE05x_RSAKeyComponent_MOD = 0

kSE05x_RSAKeyComponent_PUB_EXP = 1

kSE05x_RSAKeyComponent_PRIV_EXP = 2

kSE05x_RSAKeyComponent_P = 3

kSE05x_RSAKeyComponent_Q = 4

kSE05x_RSAKeyComponent_DP = 5

kSE05x_RSAKeyComponent_DQ = 6

kSE05x_RSAKeyComponent_INVQ = 7

SE05x_RSAKeyComponent_t = enum_anon_115
enum_anon_116 = c_int 
kSE05x_DigestMode_NA = 0

kSE05x_DigestMode_NO_HASH = 0

kSE05x_DigestMode_SHA = 1

kSE05x_DigestMode_SHA224 = 7

kSE05x_DigestMode_SHA256 = 4

kSE05x_DigestMode_SHA384 = 5

kSE05x_DigestMode_SHA512 = 6

SE05x_DigestMode_t = enum_anon_116
enum_anon_117 = c_int 
kSE05x_MACAlgo_NA = 0

kSE05x_MACAlgo_HMAC_SHA1 = 24

kSE05x_MACAlgo_HMAC_SHA256 = 25

kSE05x_MACAlgo_HMAC_SHA384 = 26

kSE05x_MACAlgo_HMAC_SHA512 = 27

kSE05x_MACAlgo_CMAC_128 = 49

SE05x_MACAlgo_t = enum_anon_117
enum_anon_118 = c_int 
kSE05x_AeadAlgo_NA = 0

kSE05x_AeadGCMAlgo = 176

kSE05x_AeadGCM_IVAlgo = 243

kSE05x_AeadCCMAlgo = 244

SE05x_AeadAlgo_t = enum_anon_118
enum_anon_119 = c_int 
kSE05x_HkdfMode_NA = 0

kSE05x_HkdfMode_ExtractExpand = 1

kSE05x_HkdfMode_ExpandOnly = 2

SE05x_HkdfMode_t = enum_anon_119
enum_anon_120 = c_int 
kSE05x_ECCurve_NA = 0

kSE05x_ECCurve_NIST_P192 = 1

kSE05x_ECCurve_NIST_P224 = 2

kSE05x_ECCurve_NIST_P256 = 3

kSE05x_ECCurve_NIST_P384 = 4

kSE05x_ECCurve_NIST_P521 = 5

kSE05x_ECCurve_Brainpool160 = 6

kSE05x_ECCurve_Brainpool192 = 7

kSE05x_ECCurve_Brainpool224 = 8

kSE05x_ECCurve_Brainpool256 = 9

kSE05x_ECCurve_Brainpool320 = 10

kSE05x_ECCurve_Brainpool384 = 11

kSE05x_ECCurve_Brainpool512 = 12

kSE05x_ECCurve_Secp160k1 = 13

kSE05x_ECCurve_Secp192k1 = 14

kSE05x_ECCurve_Secp224k1 = 15

kSE05x_ECCurve_Secp256k1 = 16

kSE05x_ECCurve_TPM_ECC_BN_P256 = 17

kSE05x_ECCurve_ECC_ED_25519 = 64

kSE05x_ECCurve_ECC_MONT_DH_25519 = 65

kSE05x_ECCurve_ECC_MONT_DH_448 = 67

SE05x_ECCurve_t = enum_anon_120
enum_anon_121 = c_int 
kSE05x_ECCurveParam_NA = 0

kSE05x_ECCurveParam_PARAM_A = 1

kSE05x_ECCurveParam_PARAM_B = 2

kSE05x_ECCurveParam_PARAM_G = 4

kSE05x_ECCurveParam_PARAM_N = 8

kSE05x_ECCurveParam_PARAM_PRIME = 16

SE05x_ECCurveParam_t = enum_anon_121
enum_anon_122 = c_int 
kSE05x_CipherMode_NA = 0

kSE05x_CipherMode_DES_CBC_NOPAD = 1

kSE05x_CipherMode_DES_CBC_ISO9797_M1 = 2

kSE05x_CipherMode_DES_CBC_ISO9797_M2 = 3

kSE05x_CipherMode_DES_CBC_PKCS5 = 4

kSE05x_CipherMode_DES_ECB_NOPAD = 5

kSE05x_CipherMode_DES_ECB_ISO9797_M1 = 6

kSE05x_CipherMode_DES_ECB_ISO9797_M2 = 7

kSE05x_CipherMode_DES_ECB_PKCS5 = 8

kSE05x_CipherMode_AES_ECB_NOPAD = 14

kSE05x_CipherMode_AES_CBC_NOPAD = 13

kSE05x_CipherMode_AES_CBC_ISO9797_M1 = 22

kSE05x_CipherMode_AES_CBC_ISO9797_M2 = 23

kSE05x_CipherMode_AES_CBC_PKCS5 = 24

kSE05x_CipherMode_AES_GCM = 176

kSE05x_CipherMode_AES_CTR = 240

kSE05x_CipherMode_AES_GCM_INT_IV = 243

kSE05x_CipherMode_AES_CCM = 244

SE05x_CipherMode_t = enum_anon_122
enum_anon_123 = c_int 
kSE05x_AppletConfig_NA = 0

kSE05x_AppletConfig_ECDAA = 1

kSE05x_AppletConfig_ECDSA_ECDH_ECDHE = 2

kSE05x_AppletConfig_EDDSA = 4

kSE05x_AppletConfig_DH_MONT = 8

kSE05x_AppletConfig_HMAC = 16

kSE05x_AppletConfig_RSA_PLAIN = 32

kSE05x_AppletConfig_RSA_CRT = 64

kSE05x_AppletConfig_AES = 128

kSE05x_AppletConfig_DES = 256

kSE05x_AppletConfig_PBKDF = 512

kSE05x_AppletConfig_TLS = 1024

kSE05x_AppletConfig_MIFARE = 2048

kSE05x_AppletConfig_RFU1 = 4096

kSE05x_AppletConfig_I2CM = 8192

kSE05x_AppletConfig_RFU2 = 16384

SE05x_AppletConfig_t = enum_anon_123
enum_anon_124 = c_int 
kSE05x_LockIndicator_NA = 0

kSE05x_LockIndicator_TRANSIENT_LOCK = 1

kSE05x_LockIndicator_PERSISTENT_LOCK = 2

SE05x_LockIndicator_t = enum_anon_124
enum_anon_125 = c_int 
kSE05x_RestrictMode_NA = 0

kSE05x_RestrictMode_RESTRICT_NEW = 1

kSE05x_RestrictMode_RESTRICT_ALL = 2

SE05x_RestrictMode_t = enum_anon_125
enum_anon_126 = c_int 
kSE05x_LockState_NA = 0

kSE05x_LockState_LOCKED = 1

SE05x_LockState_t = enum_anon_126
enum_anon_127 = c_int 
kSE05x_CryptoContext_NA = 0

kSE05x_CryptoContext_DIGEST = 1

kSE05x_CryptoContext_CIPHER = 2

kSE05x_CryptoContext_SIGNATURE = 3

kSE05x_CryptoContext_AEAD = 4

SE05x_CryptoContext_t = enum_anon_127
enum_anon_128 = c_int 
kSE05x_Result_NA = 0

kSE05x_Result_SUCCESS = 1

kSE05x_Result_FAILURE = 2

SE05x_Result_t = enum_anon_128
enum_anon_129 = c_int 
kSE05x_TransientIndicator_NA = 0

kSE05x_TransientIndicator_PERSISTENT = 1

kSE05x_TransientIndicator_TRANSIENT = 2

SE05x_TransientIndicator_t = enum_anon_129
enum_anon_130 = c_int 
kSE05x_SetIndicator_NA = 0

kSE05x_SetIndicator_NOT_SET = 1

kSE05x_SetIndicator_SET = 2

SE05x_SetIndicator_t = enum_anon_130
enum_anon_131 = c_int 
kSE05x_MoreIndicator_NA = 0

kSE05x_MoreIndicator_NO_MORE = 1

kSE05x_MoreIndicator_MORE = 2

SE05x_MoreIndicator_t = enum_anon_131
enum_anon_132 = c_int 
kSE05x_HealthCheckMode_NA = 0

kSE05x_HealthCheckMode_FIPS = 63750

kSE05x_HealthCheckMode_CODE_SIGNATURE = 65025

kSE05x_HealthCheckMode_DYNAMIC_FLASH_INTEGRITY = 64770

kSE05x_HealthCheckMode_SHIELDING = 64260

kSE05x_HealthCheckMode_SENSOR = 64005

kSE05x_HealthCheckMode_SFR_CHECK = 64515

SE05x_HealthCheckMode_t = enum_anon_132
enum_anon_133 = c_int 
kSE05x_PlatformSCPRequest_NA = 0

kSE05x_PlatformSCPRequest_REQUIRED = 1

kSE05x_PlatformSCPRequest_NOT_REQUIRED = 2

SE05x_PlatformSCPRequest_t = enum_anon_133
enum_anon_134 = c_int 
kSE05x_CryptoObject_NA = 0

kSE05x_CryptoObject_DIGEST_SHA = (kSE05x_CryptoObject_NA + 1)

kSE05x_CryptoObject_DIGEST_SHA224 = (kSE05x_CryptoObject_DIGEST_SHA + 1)

kSE05x_CryptoObject_DIGEST_SHA256 = (kSE05x_CryptoObject_DIGEST_SHA224 + 1)

kSE05x_CryptoObject_DIGEST_SHA384 = (kSE05x_CryptoObject_DIGEST_SHA256 + 1)

kSE05x_CryptoObject_DIGEST_SHA512 = (kSE05x_CryptoObject_DIGEST_SHA384 + 1)

kSE05x_CryptoObject_DES_CBC_NOPAD = (kSE05x_CryptoObject_DIGEST_SHA512 + 1)

kSE05x_CryptoObject_DES_CBC_ISO9797_M1 = (kSE05x_CryptoObject_DES_CBC_NOPAD + 1)

kSE05x_CryptoObject_DES_CBC_ISO9797_M2 = (kSE05x_CryptoObject_DES_CBC_ISO9797_M1 + 1)

kSE05x_CryptoObject_DES_CBC_PKCS5 = (kSE05x_CryptoObject_DES_CBC_ISO9797_M2 + 1)

kSE05x_CryptoObject_DES_ECB_NOPAD = (kSE05x_CryptoObject_DES_CBC_PKCS5 + 1)

kSE05x_CryptoObject_DES_ECB_ISO9797_M1 = (kSE05x_CryptoObject_DES_ECB_NOPAD + 1)

kSE05x_CryptoObject_DES_ECB_ISO9797_M2 = (kSE05x_CryptoObject_DES_ECB_ISO9797_M1 + 1)

kSE05x_CryptoObject_DES_ECB_PKCS5 = (kSE05x_CryptoObject_DES_ECB_ISO9797_M2 + 1)

kSE05x_CryptoObject_AES_ECB_NOPAD = (kSE05x_CryptoObject_DES_ECB_PKCS5 + 1)

kSE05x_CryptoObject_AES_CBC_NOPAD = (kSE05x_CryptoObject_AES_ECB_NOPAD + 1)

kSE05x_CryptoObject_AES_CBC_ISO9797_M1 = (kSE05x_CryptoObject_AES_CBC_NOPAD + 1)

kSE05x_CryptoObject_AES_CBC_ISO9797_M2 = (kSE05x_CryptoObject_AES_CBC_ISO9797_M1 + 1)

kSE05x_CryptoObject_AES_CBC_PKCS5 = (kSE05x_CryptoObject_AES_CBC_ISO9797_M2 + 1)

kSE05x_CryptoObject_AES_CTR = (kSE05x_CryptoObject_AES_CBC_PKCS5 + 1)

kSE05x_CryptoObject_HMAC_SHA1 = (kSE05x_CryptoObject_AES_CTR + 1)

kSE05x_CryptoObject_HMAC_SHA256 = (kSE05x_CryptoObject_HMAC_SHA1 + 1)

kSE05x_CryptoObject_HMAC_SHA384 = (kSE05x_CryptoObject_HMAC_SHA256 + 1)

kSE05x_CryptoObject_HMAC_SHA512 = (kSE05x_CryptoObject_HMAC_SHA384 + 1)

kSE05x_CryptoObject_CMAC_128 = (kSE05x_CryptoObject_HMAC_SHA512 + 1)

kSE05x_CryptoObject_AES_GCM = (kSE05x_CryptoObject_CMAC_128 + 1)

kSE05x_CryptoObject_AES_GCM_INT_IV = (kSE05x_CryptoObject_AES_GCM + 1)

kSE05x_CryptoObject_AES_CCM = (kSE05x_CryptoObject_AES_GCM_INT_IV + 1)

SE05x_CryptoObject_t = enum_anon_134
enum_anon_135 = c_int 
kSE05x_SecObjTyp_EC_KEY_PAIR = 1

kSE05x_SecObjTyp_EC_PRIV_KEY = 2

kSE05x_SecObjTyp_EC_PUB_KEY = 3

kSE05x_SecObjTyp_RSA_KEY_PAIR = 4

kSE05x_SecObjTyp_RSA_KEY_PAIR_CRT = 5

kSE05x_SecObjTyp_RSA_PRIV_KEY = 6

kSE05x_SecObjTyp_RSA_PRIV_KEY_CRT = 7

kSE05x_SecObjTyp_RSA_PUB_KEY = 8

kSE05x_SecObjTyp_AES_KEY = 9

kSE05x_SecObjTyp_DES_KEY = 10

kSE05x_SecObjTyp_BINARY_FILE = 11

kSE05x_SecObjTyp_UserID = 12

kSE05x_SecObjTyp_COUNTER = 13

kSE05x_SecObjTyp_PCR = 15

kSE05x_SecObjTyp_CURVE = 16

kSE05x_SecObjTyp_HMAC_KEY = 17

SE05x_SecObjTyp_t = enum_anon_135
SE05x_SecureObjectType_t = SE05x_SecObjTyp_t
enum_anon_136 = c_int 
kSE05x_MemTyp_TRANSIENT_RESET = 1

kSE05x_MemTyp_TRANSIENT_DESELECT = 2

kSE05x_MemTyp_PERSISTENT = 3

SE05x_MemTyp_t = enum_anon_136
enum_anon_137 = c_int 
kSE05x_RSASignAlgo_NA = 0

kSE05x_RSASignAlgo_SHA1_PKCS1_PSS = 21

kSE05x_RSASignAlgo_SHA224_PKCS1_PSS = 43

kSE05x_RSASignAlgo_SHA256_PKCS1_PSS = 44

kSE05x_RSASignAlgo_SHA384_PKCS1_PSS = 45

kSE05x_RSASignAlgo_SHA512_PKCS1_PSS = 46

kSE05x_RSASignAlgo_SHA_224_PKCS1 = 39

kSE05x_RSASignAlgo_SHA_256_PKCS1 = 40

kSE05x_RSASignAlgo_SHA_384_PKCS1 = 41

kSE05x_RSASignAlgo_SHA_512_PKCS1 = 42

SE05x_RSASignAlgo_t = enum_anon_137
enum_anon_138 = c_int 
kSE05x_RSAPubKeyComp_NA = 0

kSE05x_RSAPubKeyComp_MOD = kSE05x_RSAKeyComponent_MOD

kSE05x_RSAPubKeyComp_PUB_EXP = kSE05x_RSAKeyComponent_PUB_EXP

SE05x_RSAPubKeyComp_t = enum_anon_138
class union_anon_139(Union):
    pass


union_anon_139.__slots__ = [
    'digest',
    'cipher',
    'mac',
    'aead',
    'union_8bit',
]
union_anon_139._fields_ = [
    ('digest', SE05x_DigestMode_t),
    ('cipher', SE05x_CipherMode_t),
    ('mac', SE05x_MACAlgo_t),
    ('aead', SE05x_AeadAlgo_t),
    ('union_8bit', c_uint8),
]

SE05x_CryptoModeSubType_t = union_anon_139
enum_anon_140 = c_int 
kSE05x_TAG_I2CM_Config = 1

kSE05x_TAG_I2CM_Write = 3

kSE05x_TAG_I2CM_Read = 4

SE05x_I2CM_TAG_t = enum_anon_140
enum_anon_141 = c_int 
kSE05x_TransientType_Persistent = 0

kSE05x_TransientType_Transient = kSE05x_INS_TRANSIENT

SE05x_TransientType_t = enum_anon_141
enum_anon_142 = c_int 
kSE05x_KeyPart_NA = kSE05x_P1_DEFAULT

kSE05x_KeyPart_Pair = kSE05x_P1_KEY_PAIR

kSE05x_KeyPart_Private = kSE05x_P1_PRIVATE

kSE05x_KeyPart_Public = kSE05x_P1_PUBLIC

SE05x_KeyPart_t = enum_anon_142
enum_anon_143 = c_int 
kSE05x_Cipher_Oper_NA = 0

kSE05x_Cipher_Oper_Encrypt = kSE05x_P2_ENCRYPT

kSE05x_Cipher_Oper_Decrypt = kSE05x_P2_DECRYPT

SE05x_Cipher_Oper_t = enum_anon_143
enum_anon_144 = c_int 
kSE05x_Cipher_Oper_OneShot_NA = 0

kSE05x_Cipher_Oper_OneShot_Encrypt = kSE05x_P2_ENCRYPT_ONESHOT

kSE05x_Cipher_Oper_OneShot_Decrypt = kSE05x_P2_DECRYPT_ONESHOT

SE05x_Cipher_Oper_OneShot_t = enum_anon_144
enum_anon_145 = c_int 
kSE05x_Mac_Oper_NA = 0

kSE05x_Mac_Oper_Generate = kSE05x_P2_GENERATE

kSE05x_Mac_Oper_Validate = kSE05x_P2_VALIDATE

SE05x_Mac_Oper_t = enum_anon_145
enum_anon_146 = c_int 
kSE05x_AttestationType_None = 0

kSE05x_AttestationType_AUTH = kSE05x_INS_AUTH_OBJECT

SE05x_AttestationType_t = enum_anon_146
enum_anon_147 = c_int 
kSE05x_SymmKeyType_AES = kSE05x_P1_AES

kSE05x_SymmKeyType_DES = kSE05x_P1_DES

kSE05x_SymmKeyType_HMAC = kSE05x_P1_HMAC

kSE05x_SymmKeyType_CMAC = kSE05x_P1_AES

SE05x_SymmKeyType_t = enum_anon_147
SE05x_Variant_t = SE05x_AppletConfig_t
enum_anon_148 = c_int 
kSE05x_TLS_PRF_NA = 0

kSE05x_TLS_PRF_CLI_HELLO = kSE05x_P2_TLS_PRF_CLI_HELLO

kSE05x_TLS_PRF_SRV_HELLO = kSE05x_P2_TLS_PRF_SRV_HELLO

kSE05x_TLS_PRF_CLI_RND = kSE05x_P2_TLS_PRF_CLI_RND

kSE05x_TLS_PRF_SRV_RND = kSE05x_P2_TLS_PRF_SRV_RND

kSE05x_TLS_PRF_BOTH = kSE05x_P2_TLS_PRF_BOTH

SE05x_TLSPerformPRFType_t = enum_anon_148
enum_anon_149 = c_int 
kSE05x_AttestationAlgo_NA = 0

kSE05x_AttestationAlgo_EC_PLAIN = kSE05x_ECSignatureAlgo_PLAIN

kSE05x_AttestationAlgo_EC_SHA = kSE05x_ECSignatureAlgo_SHA

kSE05x_AttestationAlgo_EC_SHA_224 = kSE05x_ECSignatureAlgo_SHA_224

kSE05x_AttestationAlgo_EC_SHA_256 = kSE05x_ECSignatureAlgo_SHA_256

kSE05x_AttestationAlgo_EC_SHA_384 = kSE05x_ECSignatureAlgo_SHA_384

kSE05x_AttestationAlgo_EC_SHA_512 = kSE05x_ECSignatureAlgo_SHA_512

kSE05x_AttestationAlgo_ED25519PURE_SHA_512 = kSE05x_EDSignatureAlgo_ED25519PURE_SHA_512

kSE05x_AttestationAlgo_ECDAA = kSE05x_ECDAASignatureAlgo_ECDAA

kSE05x_AttestationAlgo_RSA_SHA1_PKCS1_PSS = kSE05x_RSASignatureAlgo_SHA1_PKCS1_PSS

kSE05x_AttestationAlgo_RSA_SHA224_PKCS1_PSS = kSE05x_RSASignatureAlgo_SHA224_PKCS1_PSS

kSE05x_AttestationAlgo_RSA_SHA256_PKCS1_PSS = kSE05x_RSASignatureAlgo_SHA256_PKCS1_PSS

kSE05x_AttestationAlgo_RSA_SHA384_PKCS1_PSS = kSE05x_RSASignatureAlgo_SHA384_PKCS1_PSS

kSE05x_AttestationAlgo_RSA_SHA512_PKCS1_PSS = kSE05x_RSASignatureAlgo_SHA512_PKCS1_PSS

kSE05x_AttestationAlgo_RSA_SHA_224_PKCS1 = kSE05x_RSASignatureAlgo_SHA_224_PKCS1

kSE05x_AttestationAlgo_RSA_SHA_256_PKCS1 = kSE05x_RSASignatureAlgo_SHA_256_PKCS1

kSE05x_AttestationAlgo_RSA_SHA_384_PKCS1 = kSE05x_RSASignatureAlgo_SHA_384_PKCS1

kSE05x_AttestationAlgo_RSA_SHA_512_PKCS1 = kSE05x_RSASignatureAlgo_SHA_512_PKCS1

SE05x_AttestationAlgo_t = enum_anon_149
enum_anon_150 = c_int 
kSE05x_RSAKeyFormat_CRT = kSE05x_P2_DEFAULT

kSE05x_RSAKeyFormat_RAW = kSE05x_P2_RAW

SE05x_RSAKeyFormat_t = enum_anon_150
SE05x_MacOperation_t = SE05x_MACAlgo_t
SE05x_KeyID_t = c_uint32
SE05x_MaxAttemps_t = c_uint16
enum_anon_151 = c_int # ../../hostlib/hostLib/inc/se05x_tlv.h

smStatus_t = enum_anon_151
class struct_Se05xSession(Structure):
    pass


# sss/inc/fsl_sss_se05x_types.h
class struct__sss_se05x_tunnel_context(Structure):
    pass


struct_Se05xSession.__slots__ = [
    'value',
    'hasSession',
    'authType',
    'fp_TXn',
    'fp_Transform',
    'fp_DeCrypt',
    'fp_RawTXn',
    'pChannelCtx',
    'fp_Transmit',
    'pdynScp03Ctx',
    'conn_ctx',
]
struct_Se05xSession._fields_ = [
    ('value', c_uint8 * 8),
    ('hasSession', c_uint8, 1),
    ('authType', SE_AuthType_t),
    ('fp_TXn', CFUNCTYPE(UNCHECKED(smStatus_t), POINTER(struct_Se05xSession), POINTER(tlvHeader_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t), c_uint8)),
    ('fp_Transform', CFUNCTYPE(UNCHECKED(smStatus_t), POINTER(struct_Se05xSession), POINTER(tlvHeader_t), POINTER(c_uint8), c_size_t, POINTER(tlvHeader_t), POINTER(c_uint8), POINTER(c_size_t), c_uint8)),
    ('fp_DeCrypt', CFUNCTYPE(UNCHECKED(smStatus_t), POINTER(struct_Se05xSession), c_size_t, POINTER(c_uint8), POINTER(c_size_t), c_uint8)),
    ('fp_RawTXn', CFUNCTYPE(UNCHECKED(smStatus_t), POINTER(None), POINTER(struct__sss_se05x_tunnel_context), SE_AuthType_t, POINTER(tlvHeader_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t), c_uint8)),
    ('pChannelCtx', POINTER(struct__sss_se05x_tunnel_context)),
    ('fp_Transmit', CFUNCTYPE(UNCHECKED(smStatus_t), SE_AuthType_t, POINTER(tlvHeader_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t), c_uint8)),
    ('pdynScp03Ctx', POINTER(NXSCP03_DynCtx_t)),
    ('conn_ctx', POINTER(None)),
]

Se05xSession_t = struct_Se05xSession# ../../hostlib/hostLib/inc/se05x_tlv.h

class struct_anon_154(Structure):
    pass


struct_anon_154.__slots__ = [
    'value',
    'value_len',
]
struct_anon_154._fields_ = [
    ('value', POINTER(c_uint8)),
    ('value_len', c_size_t),
]

Se05xPolicy_t = struct_anon_154
class struct_anon_155(Structure):
    pass


struct_anon_155.__slots__ = [
    'ts',
]
struct_anon_155._fields_ = [
    ('ts', c_uint8 * 12),
]

SE05x_TimeStamp_t = struct_anon_155
pSe05xSession_t = POINTER(Se05xSession_t)
pSe05xPolicy_t = POINTER(Se05xPolicy_t)
# sss/inc/fsl_sss_se05x_types.h
class struct__sss_se05x_session(Structure):
    pass


struct__sss_se05x_tunnel_context.__slots__ = [
    'se05x_session',
    'tunnelDest',
]
struct__sss_se05x_tunnel_context._fields_ = [
    ('se05x_session', POINTER(struct__sss_se05x_session)),
    ('tunnelDest', sss_tunnel_dest_t),
]

sss_se05x_tunnel_context_t = struct__sss_se05x_tunnel_context
struct__sss_se05x_session.__slots__ = [
    'subsystem',
    's_ctx',
    'ptun_ctx',
]
struct__sss_se05x_session._fields_ = [
    ('subsystem', sss_type_t),
    ('s_ctx', Se05xSession_t),
    ('ptun_ctx', POINTER(sss_se05x_tunnel_context_t)),
]

sss_se05x_session_t = struct__sss_se05x_session
class struct__sss_se05x_object(Structure):
    pass


class struct_anon_158(Structure):
    pass


struct_anon_158.__slots__ = [
    'session',
    'kekKey',
]
struct_anon_158._fields_ = [
    ('session', POINTER(sss_se05x_session_t)),
    ('kekKey', POINTER(struct__sss_se05x_object)),
]

sss_se05x_key_store_t = struct_anon_158
struct__sss_se05x_object.__slots__ = [
    'keyStore',
    'objectType',
    'cipherType',
    'keyId',
    'curve_id',
    'isPersistant',
]
struct__sss_se05x_object._fields_ = [
    ('keyStore', POINTER(sss_se05x_key_store_t)),
    ('objectType', c_uint32),
    ('cipherType', c_uint32),
    ('keyId', c_uint32),
    ('curve_id', SE05x_ECCurve_t),
    ('isPersistant', c_uint8, 1),
]

sss_se05x_object_t = struct__sss_se05x_object
class struct_anon_159(Structure):
    pass


struct_anon_159.__slots__ = [
    'session',
    'keyObject',
    'algorithm',
    'mode',
]
struct_anon_159._fields_ = [
    ('session', POINTER(sss_se05x_session_t)),
    ('keyObject', POINTER(sss_se05x_object_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
]

sss_se05x_derive_key_t = struct_anon_159
class struct_anon_160(Structure):
    pass


struct_anon_160.__slots__ = [
    'session',
    'keyObject',
    'algorithm',
    'mode',
]
struct_anon_160._fields_ = [
    ('session', POINTER(sss_se05x_session_t)),
    ('keyObject', POINTER(sss_se05x_object_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
]

sss_se05x_asymmetric_t = struct_anon_160
class struct_anon_161(Structure):
    pass


struct_anon_161.__slots__ = [
    'session',
    'keyObject',
    'algorithm',
    'mode',
    'cryptoObjectId',
    'cache_data',
    'cache_data_len',
]
struct_anon_161._fields_ = [
    ('session', POINTER(sss_se05x_session_t)),
    ('keyObject', POINTER(sss_se05x_object_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
    ('cryptoObjectId', SE05x_CryptoObject_t),
    ('cache_data', c_uint8 * 16),
    ('cache_data_len', c_size_t),
]

sss_se05x_symmetric_t = struct_anon_161
class struct_anon_162(Structure):
    pass


struct_anon_162.__slots__ = [
    'session',
    'keyObject',
    'algorithm',
    'mode',
    'cryptoObjectId',
]
struct_anon_162._fields_ = [
    ('session', POINTER(sss_se05x_session_t)),
    ('keyObject', POINTER(sss_se05x_object_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
    ('cryptoObjectId', SE05x_CryptoObject_t),
]

sss_se05x_mac_t = struct_anon_162
class struct_anon_163(Structure):
    pass


struct_anon_163.__slots__ = [
    'session',
    'keyObject',
    'algorithm',
    'mode',
    'cryptoObjectId',
    'cache_data',
    'cache_data_len',
]
struct_anon_163._fields_ = [
    ('session', POINTER(sss_se05x_session_t)),
    ('keyObject', POINTER(sss_se05x_object_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
    ('cryptoObjectId', SE05x_CryptoObject_t),
    ('cache_data', c_uint8 * 16),
    ('cache_data_len', c_size_t),
]

sss_se05x_aead_t = struct_anon_163
class struct_anon_164(Structure):
    pass


struct_anon_164.__slots__ = [
    'session',
    'algorithm',
    'mode',
    'digestFullLen',
    'cryptoObjectId',
]
struct_anon_164._fields_ = [
    ('session', POINTER(sss_se05x_session_t)),
    ('algorithm', sss_algorithm_t),
    ('mode', sss_mode_t),
    ('digestFullLen', c_size_t),
    ('cryptoObjectId', SE05x_CryptoObject_t),
]

sss_se05x_digest_t = struct_anon_164
class struct_anon_165(Structure):
    pass


struct_anon_165.__slots__ = [
    'session',
]
struct_anon_165._fields_ = [
    ('session', POINTER(sss_se05x_session_t)),
]

sss_se05x_rng_context_t = struct_anon_165
enum_anon_166 = c_int 
kSSS_SE05x_SessionProp_CertUID = (kSSS_SessionProp_au8_Proprietary_Start + 1)

sss_s05x_sesion_prop_au8_t = enum_anon_166
enum_anon_167 = c_int 
kSSS_SE05x_SessionProp_CertUIDLen = (kSSS_SessionProp_u32_Optional_Start + 1)

sss_s05x_sesion_prop_u32_t = enum_anon_167
class struct_anon_168(Structure):
    pass


struct_anon_168.__slots__ = [
    'AppletConfig_ECDAA',
    'AppletConfig_ECDSA_ECDH_ECDHE',
    'AppletConfig_EDDSA',
    'AppletConfig_DH_MONT',
    'AppletConfig_HMAC',
    'AppletConfig_RSA_PLAIN',
    'AppletConfig_RSA_CRT',
    'AppletConfig_AES',
    'AppletConfig_DES',
    'AppletConfig_PBKDF',
    'AppletConfig_TLS',
    'AppletConfig_MIFARE',
    'AppletConfig_RFU1',
    'AppletConfig_I2CM',
    'AppletConfig_RFU21',
]
struct_anon_168._fields_ = [
    ('AppletConfig_ECDAA', c_uint8, 1),
    ('AppletConfig_ECDSA_ECDH_ECDHE', c_uint8, 1),
    ('AppletConfig_EDDSA', c_uint8, 1),
    ('AppletConfig_DH_MONT', c_uint8, 1),
    ('AppletConfig_HMAC', c_uint8, 1),
    ('AppletConfig_RSA_PLAIN', c_uint8, 1),
    ('AppletConfig_RSA_CRT', c_uint8, 1),
    ('AppletConfig_AES', c_uint8, 1),
    ('AppletConfig_DES', c_uint8, 1),
    ('AppletConfig_PBKDF', c_uint8, 1),
    ('AppletConfig_TLS', c_uint8, 1),
    ('AppletConfig_MIFARE', c_uint8, 1),
    ('AppletConfig_RFU1', c_uint8, 1),
    ('AppletConfig_I2CM', c_uint8, 1),
    ('AppletConfig_RFU21', c_uint8, 1),
]

SE05x_Applet_Feature_t = struct_anon_168
class struct_anon_169(Structure):
    pass


struct_anon_169.__slots__ = [
    'EXTCFG_FORBID_ECDH',
    'EXTCFG_FORBID_ECDAA',
    'EXTCFG_FORBID_RSA_LT_2K',
    'EXTCFG_FORBID_RSA_SHA1',
    'EXTCFG_FORBID_AES_GCM',
    'EXTCFG_FORBID_AES_GCM_EXT_IV',
    'EXTCFG_FORBID_HKDF_EXTRACT',
]
struct_anon_169._fields_ = [
    ('EXTCFG_FORBID_ECDH', c_uint8, 1),
    ('EXTCFG_FORBID_ECDAA', c_uint8, 1),
    ('EXTCFG_FORBID_RSA_LT_2K', c_uint8, 1),
    ('EXTCFG_FORBID_RSA_SHA1', c_uint8, 1),
    ('EXTCFG_FORBID_AES_GCM', c_uint8, 1),
    ('EXTCFG_FORBID_AES_GCM_EXT_IV', c_uint8, 1),
    ('EXTCFG_FORBID_HKDF_EXTRACT', c_uint8, 1),
]

SE05x_Applet_Feature_Disable_t = struct_anon_169
class struct_anon_170(Structure):
    pass


struct_anon_170.__slots__ = [
    'outrandom',
    'outrandomLen',
    'timeStamp',
    'timeStampLen',
    'chipId',
    'chipIdLen',
    'attribute',
    'attributeLen',
    'signature',
    'signatureLen',
]
struct_anon_170._fields_ = [
    ('outrandom', c_uint8 * 16),
    ('outrandomLen', c_size_t),
    ('timeStamp', SE05x_TimeStamp_t),
    ('timeStampLen', c_size_t),
    ('chipId', c_uint8 * 18),
    ('chipIdLen', c_size_t),
    ('attribute', c_uint8 * (256 + 15)),
    ('attributeLen', c_size_t),
    ('signature', c_uint8 * 512),
    ('signatureLen', c_size_t),
]

sss_se05x_attst_comp_data_t = struct_anon_170
class struct_anon_171(Structure):
    pass


struct_anon_171.__slots__ = [
    'data',
    'valid_number',
]
struct_anon_171._fields_ = [
    ('data', sss_se05x_attst_comp_data_t * 2),
    ('valid_number', c_uint8),
]

sss_se05x_attst_data_t = struct_anon_171
enum_anon_172 = c_int 
kSE05x_I2CM_None = 0

kSE05x_I2CM_Configure = (kSE05x_I2CM_None + 1)

kSE05x_I2CM_Write = 3

kSE05x_I2CM_Read = (kSE05x_I2CM_Write + 1)

kSE05x_I2CM_StructuralIssue = 255

SE05x_I2CM_TLV_type_t = enum_anon_172
enum_anon_173 = c_int 
kSE05x_I2CM_Success = 90

kSE05x_I2CM_I2C_Nack_Fail = 1

kSE05x_I2CM_I2C_Write_Error = 2

kSE05x_I2CM_I2C_Read_Error = 3

kSE05x_I2CM_I2C_Time_Out_Error = 5

kSE05x_I2CM_Invalid_Tag = 17

kSE05x_I2CM_Invalid_Length = 18

kSE05x_I2CM_Invalid_Length_Encode = 19

kSE05x_I2CM_I2C_Config = 33

SE05x_I2CM_status_t = enum_anon_173
enum_anon_174 = c_int 
kSE05x_Security_None = 0

kSE05x_Sign_Request = (kSE05x_Security_None + 1)

kSE05x_Sign_Enc_Request = (kSE05x_Sign_Request + 1)

SE05x_I2CM_securityReq_t = enum_anon_174
enum_anon_175 = c_int 
kSE05x_I2CM_Baud_Rate_100Khz = 0

kSE05x_I2CM_Baud_Rate_400Khz = (kSE05x_I2CM_Baud_Rate_100Khz + 1)

SE05x_I2CM_Baud_Rate_t = enum_anon_175
class struct_anon_176(Structure):
    pass


struct_anon_176.__slots__ = [
    'I2C_addr',
    'I2C_baudRate',
    'status',
]
struct_anon_176._fields_ = [
    ('I2C_addr', c_uint8),
    ('I2C_baudRate', SE05x_I2CM_Baud_Rate_t),
    ('status', SE05x_I2CM_status_t),
]

SE05x_I2CM_configData_t = struct_anon_176
class struct_anon_177(Structure):
    pass


struct_anon_177.__slots__ = [
    'operation',
    'keyObject',
]
struct_anon_177._fields_ = [
    ('operation', SE05x_I2CM_securityReq_t),
    ('keyObject', c_uint32),
]

SE05x_I2CM_securityData_t = struct_anon_177
class struct_anon_178(Structure):
    pass


struct_anon_178.__slots__ = [
    'writeLength',
    'wrStatus',
    'writebuf',
]
struct_anon_178._fields_ = [
    ('writeLength', c_uint8),
    ('wrStatus', SE05x_I2CM_status_t),
    ('writebuf', POINTER(c_uint8)),
]

SE05x_I2CM_writeData_t = struct_anon_178
class struct_anon_179(Structure):
    pass


struct_anon_179.__slots__ = [
    'readLength',
    'rdStatus',
    'rdBuf',
]
struct_anon_179._fields_ = [
    ('readLength', c_uint16),
    ('rdStatus', SE05x_I2CM_status_t),
    ('rdBuf', POINTER(c_uint8)),
]

SE05x_I2CM_readData_t = struct_anon_179
class struct_anon_180(Structure):
    pass


struct_anon_180.__slots__ = [
    'issueStatus',
]
struct_anon_180._fields_ = [
    ('issueStatus', SE05x_I2CM_status_t),
]

SE05x_I2CM_structuralIssue_t = struct_anon_180
class union_anon_181(Union):
    pass


union_anon_181.__slots__ = [
    'cfg',
    'sec',
    'w',
    'rd',
    'issue',
]
union_anon_181._fields_ = [
    ('cfg', SE05x_I2CM_configData_t),
    ('sec', SE05x_I2CM_securityData_t),
    ('w', SE05x_I2CM_writeData_t),
    ('rd', SE05x_I2CM_readData_t),
    ('issue', SE05x_I2CM_structuralIssue_t),
]

SE05x_I2CM_INS_type_t = union_anon_181
class struct__SE05x_I2CM_cmd(Structure):
    pass


struct__SE05x_I2CM_cmd.__slots__ = [
    'type',
    'cmd',
]
struct__SE05x_I2CM_cmd._fields_ = [
    ('type', SE05x_I2CM_TLV_type_t),
    ('cmd', SE05x_I2CM_INS_type_t),
]

SE05x_I2CM_cmd_t = struct__SE05x_I2CM_cmd
for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_se05x_mac_validate_one_go'):
        continue
    sss_se05x_mac_validate_one_go = _lib.sss_se05x_mac_validate_one_go
    sss_se05x_mac_validate_one_go.argtypes = [POINTER(sss_se05x_mac_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), c_size_t]
    sss_se05x_mac_validate_one_go.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_se05x_asymmetric_sign'):
        continue
    sss_se05x_asymmetric_sign = _lib.sss_se05x_asymmetric_sign
    sss_se05x_asymmetric_sign.argtypes = [POINTER(sss_se05x_asymmetric_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t)]
    sss_se05x_asymmetric_sign.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_se05x_asymmetric_verify'):
        continue
    sss_se05x_asymmetric_verify = _lib.sss_se05x_asymmetric_verify
    sss_se05x_asymmetric_verify.argtypes = [POINTER(sss_se05x_asymmetric_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), c_size_t]
    sss_se05x_asymmetric_verify.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_se05x_key_store_get_key_attst'):
        continue
    sss_se05x_key_store_get_key_attst = _lib.sss_se05x_key_store_get_key_attst
    sss_se05x_key_store_get_key_attst.argtypes = [POINTER(sss_se05x_key_store_t), POINTER(sss_se05x_object_t), POINTER(c_uint8), POINTER(c_size_t), POINTER(c_size_t), POINTER(sss_se05x_object_t), sss_algorithm_t, POINTER(c_uint8), c_size_t, POINTER(sss_se05x_attst_data_t)]
    sss_se05x_key_store_get_key_attst.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'se05x_sssKeyTypeLenToCurveId'):
        continue
    se05x_sssKeyTypeLenToCurveId = _lib.se05x_sssKeyTypeLenToCurveId
    se05x_sssKeyTypeLenToCurveId.argtypes = [sss_cipher_type_t, c_size_t]
    se05x_sssKeyTypeLenToCurveId.restype = c_uint32
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'Se05x_i2c_master_txn'):
        continue
    Se05x_i2c_master_txn = _lib.Se05x_i2c_master_txn
    Se05x_i2c_master_txn.argtypes = [POINTER(sss_session_t), POINTER(SE05x_I2CM_cmd_t), c_uint8]
    Se05x_i2c_master_txn.restype = smStatus_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'Se05x_i2c_master_attst_txn'):
        continue
    Se05x_i2c_master_attst_txn = _lib.Se05x_i2c_master_attst_txn
    Se05x_i2c_master_attst_txn.argtypes = [POINTER(sss_session_t), POINTER(sss_object_t), POINTER(SE05x_I2CM_cmd_t), POINTER(c_uint8), c_size_t, SE05x_AttestationAlgo_t, POINTER(SE05x_TimeStamp_t), POINTER(c_size_t), POINTER(c_uint8), POINTER(c_size_t), POINTER(c_uint8), POINTER(c_size_t), POINTER(c_uint8), POINTER(c_size_t), c_uint8]
    Se05x_i2c_master_attst_txn.restype = smStatus_t
    break

# pycli/scripts/fsl_sss_python_export.h
for _lib in list(_libs.values()):
    if not hasattr(_lib, 'Se05x_API_DeleteAll_Iterative'):
        continue
    Se05x_API_DeleteAll_Iterative = _lib.Se05x_API_DeleteAll_Iterative
    Se05x_API_DeleteAll_Iterative.argtypes = [pSe05xSession_t]
    Se05x_API_DeleteAll_Iterative.restype = smStatus_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'Se05x_API_WritePCR'):
        continue
    Se05x_API_WritePCR = _lib.Se05x_API_WritePCR
    Se05x_API_WritePCR.argtypes = [pSe05xSession_t, pSe05xPolicy_t, c_uint32, POINTER(c_uint8), c_size_t, POINTER(c_uint8), c_size_t]
    Se05x_API_WritePCR.restype = smStatus_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'Se05x_API_ReadIDList'):
        continue
    Se05x_API_ReadIDList = _lib.Se05x_API_ReadIDList
    Se05x_API_ReadIDList.argtypes = [pSe05xSession_t, c_uint16, c_uint8, POINTER(c_uint8), POINTER(c_uint8), POINTER(c_size_t)]
    Se05x_API_ReadIDList.restype = smStatus_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'Se05x_API_ReadSize'):
        continue
    Se05x_API_ReadSize = _lib.Se05x_API_ReadSize
    Se05x_API_ReadSize.argtypes = [pSe05xSession_t, c_uint32, POINTER(c_uint16)]
    Se05x_API_ReadSize.restype = smStatus_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'Se05x_API_ReadCryptoObjectList'):
        continue
    Se05x_API_ReadCryptoObjectList = _lib.Se05x_API_ReadCryptoObjectList
    Se05x_API_ReadCryptoObjectList.argtypes = [pSe05xSession_t, POINTER(c_uint8), POINTER(c_size_t)]
    Se05x_API_ReadCryptoObjectList.restype = smStatus_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_util_openssl_write_pkcs12'):
        continue
    sss_util_openssl_write_pkcs12 = _lib.sss_util_openssl_write_pkcs12
    sss_util_openssl_write_pkcs12.argtypes = [POINTER(sss_session_t), POINTER(sss_key_store_t), POINTER(sss_object_t), String, String, String, c_long, String, String]
    sss_util_openssl_write_pkcs12.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_util_openssl_read_pkcs12'):
        continue
    sss_util_openssl_read_pkcs12 = _lib.sss_util_openssl_read_pkcs12
    sss_util_openssl_read_pkcs12.argtypes = [String, String, POINTER(c_uint8), POINTER(c_uint8)]
    sss_util_openssl_read_pkcs12.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'Se05x_API_WriteSymmKey'):
        continue
    Se05x_API_WriteSymmKey = _lib.Se05x_API_WriteSymmKey
    Se05x_API_WriteSymmKey.argtypes = [pSe05xSession_t, pSe05xPolicy_t, SE05x_MaxAttemps_t, c_uint32, SE05x_KeyID_t, POINTER(c_uint8), c_size_t, SE05x_INS_t, SE05x_SymmKeyType_t]
    Se05x_API_WriteSymmKey.restype = smStatus_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'Se05x_API_WriteECKey'):
        continue
    Se05x_API_WriteECKey = _lib.Se05x_API_WriteECKey
    Se05x_API_WriteECKey.argtypes = [pSe05xSession_t, pSe05xPolicy_t, SE05x_MaxAttemps_t, c_uint32, SE05x_ECCurve_t, POINTER(c_uint8), c_size_t, POINTER(c_uint8), c_size_t, SE05x_INS_t, SE05x_KeyPart_t]
    Se05x_API_WriteECKey.restype = smStatus_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_se05x_create_object_policy_buffer'):
        continue
    sss_se05x_create_object_policy_buffer = _lib.sss_se05x_create_object_policy_buffer
    sss_se05x_create_object_policy_buffer.argtypes = [POINTER(sss_policy_t), POINTER(c_uint8), POINTER(c_size_t)]
    sss_se05x_create_object_policy_buffer.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_se05x_refresh_session'):
        continue
    sss_se05x_refresh_session = _lib.sss_se05x_refresh_session
    sss_se05x_refresh_session.argtypes = [POINTER(sss_se05x_session_t), POINTER(None)]
    sss_se05x_refresh_session.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_se05x_asymmetric_sign'):
        continue
    sss_se05x_asymmetric_sign = _lib.sss_se05x_asymmetric_sign
    sss_se05x_asymmetric_sign.argtypes = [POINTER(sss_se05x_asymmetric_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), POINTER(c_size_t)]
    sss_se05x_asymmetric_sign.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'sss_se05x_asymmetric_verify'):
        continue
    sss_se05x_asymmetric_verify = _lib.sss_se05x_asymmetric_verify
    sss_se05x_asymmetric_verify.argtypes = [POINTER(sss_se05x_asymmetric_t), POINTER(c_uint8), c_size_t, POINTER(c_uint8), c_size_t]
    sss_se05x_asymmetric_verify.restype = sss_status_t
    break

for _lib in list(_libs.values()):
    if not hasattr(_lib, 'Se05x_API_GetVersion'):
        continue
    Se05x_API_GetVersion = _lib.Se05x_API_GetVersion
    Se05x_API_GetVersion.argtypes = [pSe05xSession_t, POINTER(c_uint8), POINTER(c_size_t)]
    Se05x_API_GetVersion.restype = smStatus_t
    break

# ../../sss/inc/fsl_sss_api.h
try:
    SSS_API_VERSION = 1
except:
    pass

try:
    SSS_AES_BLOCK_SIZE = 16
except:
    pass

try:
    SSS_DES_BLOCK_SIZE = 8
except:
    pass

try:
    SSS_DES_KEY_SIZE = 8
except:
    pass

try:
    SSS_DES_IV_SIZE = 8
except:
    pass

def SSS_ENUM(GROUP, 
INDEX):    return (GROUP | INDEX)

try:
    SSS_ALGORITHM_START_AES = 0
except:
    pass

try:
    SSS_ALGORITHM_START_CHACHA = 1
except:
    pass

try:
    SSS_ALGORITHM_START_DES = 2
except:
    pass

try:
    SSS_ALGORITHM_START_SHA = 3
except:
    pass

try:
    SSS_ALGORITHM_START_MAC = 4
except:
    pass

try:
    SSS_ALGORITHM_START_DH = 5
except:
    pass

try:
    SSS_ALGORITHM_START_DSA = 6
except:
    pass

try:
    SSS_ALGORITHM_START_RSASSA_PKCS1_V1_5 = 7
except:
    pass

try:
    SSS_ALGORITHM_START_RSASSA_PKCS1_PSS_MGF1 = 8
except:
    pass

try:
    SSS_ALGORITHM_START_RSAES_PKCS1_OAEP = 9
except:
    pass

try:
    SSS_ALGORITHM_START_RSAES_PKCS1_V1_5 = 10
except:
    pass

try:
    SSS_ALGORITHM_START_RSASSA_NO_PADDING = 11
except:
    pass

try:
    SSS_ALGORITHM_START_ECDSA = 12
except:
    pass

try:
    SSS_ALGORITHM_START_ECDAA = 13
except:
    pass

try:
    kAlgorithm_SSS_RSASSA_PKCS1_OEAP_SHA1 = kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA1
except:
    pass

try:
    kAlgorithm_SSS_RSASSA_PKCS1_OEAP_SHA224 = kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA224
except:
    pass

try:
    kAlgorithm_SSS_RSASSA_PKCS1_OEAP_SHA256 = kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA256
except:
    pass

try:
    kAlgorithm_SSS_RSASSA_PKCS1_OEAP_SHA384 = kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA384
except:
    pass

try:
    kAlgorithm_SSS_RSASSA_PKCS1_OEAP_SHA512 = kAlgorithm_SSS_RSAES_PKCS1_OAEP_SHA512
except:
    pass

try:
    kAlgorithm_SSS_RSAES_PKCS1_V1_5_SHA1 = kAlgorithm_SSS_RSAES_PKCS1_V1_5
except:
    pass

try:
    kAlgorithm_SSS_RSAES_PKCS1_V1_5_SHA224 = kAlgorithm_SSS_RSAES_PKCS1_V1_5
except:
    pass

try:
    kAlgorithm_SSS_RSAES_PKCS1_V1_5_SHA256 = kAlgorithm_SSS_RSAES_PKCS1_V1_5
except:
    pass

try:
    kAlgorithm_SSS_RSAES_PKCS1_V1_5_SHA384 = kAlgorithm_SSS_RSAES_PKCS1_V1_5
except:
    pass

try:
    kAlgorithm_SSS_RSAES_PKCS1_V1_5_SHA512 = kAlgorithm_SSS_RSAES_PKCS1_V1_5
except:
    pass

# hostlib/hostLib/inc/a71ch_api.h
try:
    A71CH_INJECT_LOCK_STATE_LOCKED = 1
except:
    pass

try:
    A71CH_INJECT_LOCK_STATE_UNLOCKED = 2
except:
    pass

try:
    A71CH_TRANSPORT_LOCK_STATE_LOCKED = 1
except:
    pass

try:
    A71CH_TRANSPORT_LOCK_STATE_UNLOCKED = 2
except:
    pass

try:
    A71CH_TRANSPORT_LOCK_STATE_ALLOW_LOCK = 3
except:
    pass

try:
    A71CH_NO_RESTRICTED_KP = 15
except:
    pass

try:
    A71CH_KEY_PAIR_0 = 0
except:
    pass

try:
    A71CH_KEY_PAIR_1 = 1
except:
    pass

try:
    A71CH_KEY_PAIR_2 = 2
except:
    pass

try:
    A71CH_KEY_PAIR_3 = 3
except:
    pass

try:
    A71CH_PUBLIC_KEY_0 = 0
except:
    pass

try:
    A71CH_PUBLIC_KEY_1 = 1
except:
    pass

try:
    A71CH_PUBLIC_KEY_2 = 2
except:
    pass

try:
    A71CH_SYM_KEY_0 = 0
except:
    pass

try:
    A71CH_SYM_KEY_1 = 1
except:
    pass

try:
    A71CH_SYM_KEY_2 = 2
except:
    pass

try:
    A71CH_SYM_KEY_3 = 3
except:
    pass

try:
    A71CH_SYM_KEY_4 = 4
except:
    pass

try:
    A71CH_SYM_KEY_5 = 5
except:
    pass

try:
    A71CH_SYM_KEY_6 = 6
except:
    pass

try:
    A71CH_SYM_KEY_7 = 7
except:
    pass

try:
    A71CH_COUNTER_0 = 0
except:
    pass

try:
    A71CH_COUNTER_1 = 1
except:
    pass

try:
    A71CH_CFG_KEY_IDX_MODULE_LOCK = 0
except:
    pass

try:
    A71CH_CFG_KEY_IDX_PRIVATE_KEYS = 1
except:
    pass

try:
    A71CH_CFG_KEY_IDX_PUBLIC_KEYS = 2
except:
    pass

try:
    A71CH_SYM_KEY_COMBINED_MAX = 4
except:
    pass

try:
    A71CH_MAP_SIZE_MAX = 203
except:
    pass

try:
    A71CH_MAX_CMD_PAYLOAD_SIZE = 255
except:
    pass

try:
    A71CH_SCP03_MAX_PAYLOAD_SIZE = 239
except:
    pass

try:
    A71CH_GP_STORAGE_SIZE_A = 1024
except:
    pass

try:
    A71CH_GP_STORAGE_SIZE_B = 4096
except:
    pass

try:
    A71CH_GP_STORAGE_GRANULARITY = 32
except:
    pass

try:
    A71CH_GP_STORAGE_MAX_DATA_CHUNK = A71CH_SCP03_MAX_PAYLOAD_SIZE
except:
    pass

try:
    DERIVE_KEYDATA_FROM_SHARED_SECRET_MAX_INFO = 192
except:
    pass

try:
    DERIVE_KEYDATA_FROM_SHARED_SECRET_MAX_DERIVED_DATA = 255
except:
    pass

try:
    A71CH_HKDF_MAX_SALT = 32
except:
    pass

try:
    A71CH_HMAC_SHA256_MAX_DATA_CHUNK = A71CH_SCP03_MAX_PAYLOAD_SIZE
except:
    pass

try:
    A71CH_SHA256_MAX_DATA_CHUNK = A71CH_SCP03_MAX_PAYLOAD_SIZE
except:
    pass

try:
    A71CH_TLS_MAX_LABEL = 24
except:
    pass

try:
    A71CH_MODULE_UNLOCK_CHALLENGE_LEN = 16
except:
    pass

try:
    A71CH_MODULE_UNIQUE_ID_LEN = 18
except:
    pass

try:
    A71CH_MODULE_CERT_UID_LEN = 10
except:
    pass

try:
    A71CH_WRAPPED_KEY_LEN = 24
except:
    pass

try:
    A71CH_PUB_KEY_LEN = 65
except:
    pass

try:
    AX_SHA256_LEN = 32
except:
    pass

try:
    AX_TLS_PSK_MASTER_SECRET_LEN = 48
except:
    pass

try:
    AX_TLS_PSK_HELLO_RANDOM_LEN = 32
except:
    pass

try:
    SESSION_ID_LEN = 4
except:
    pass

try:
    MONOTONIC_COUNTER_BYTE_COUNT = 4
except:
    pass

try:
    A71CH_SCP_MANDATORY = 1
except:
    pass

try:
    A71CH_SCP_NOT_SET_UP = 2
except:
    pass

try:
    A71CH_SCP_KEYS_SET = 3
except:
    pass

try:
    A71CH_SCP_CHANNEL_STATE_UNKNOWN = 15
except:
    pass

try:
    A71CH_UID_IC_TYPE_OFFSET = 2
except:
    pass

try:
    A71CH_UID_IC_FABRICATION_DATA_OFFSET = 8
except:
    pass

try:
    A71CH_UID_IC_SERIAL_NR_OFFSET = 10
except:
    pass

try:
    A71CH_UID_IC_BATCH_ID_OFFSET = 13
except:
    pass

try:
    MAX_CHUNK_LENGTH_LINK = 256
except:
    pass

# ../../hostlib/hostLib/inc/PlugAndTrust_HostLib_Ver.h
try:
    PLUGANDTRUST_HOSTLIB_VER_MAJOR = 3
except:
    pass

try:
    PLUGANDTRUST_HOSTLIB_VER_MINOR = 1
except:
    pass

# ../../hostlib/hostLib/libCommon/infra/sm_api.h
try:
    AX_HOST_LIB_MAJOR = PLUGANDTRUST_HOSTLIB_VER_MAJOR
except:
    pass

try:
    AX_HOST_LIB_MINOR = PLUGANDTRUST_HOSTLIB_VER_MINOR
except:
    pass

try:
    SE_CONNECT_TYPE_START = 0
except:
    pass

try:
    SELECT_APPLET = 0
except:
    pass

try:
    SELECT_NONE = 1
except:
    pass

try:
    SELECT_SSD = 2
except:
    pass

# hostlib/hostLib/inc/nxScp03_Types.h
try:
    kSSS_AuthType_INT_FastSCP_Counter = kSSS_AuthType_INT_ECKey_Counter
except:
    pass

try:
    kSSS_AuthType_FastSCP_Counter = kSSS_AuthType_INT_ECKey_Counter
except:
    pass

try:
    kSSS_AuthType_FastSCP = kSSS_AuthType_ECKey
except:
    pass

try:
    kSSS_AuthType_AppletSCP03 = kSSS_AuthType_AESKey
except:
    pass

SE05x_AuthCtx_t = SE_AuthCtx_t
try:
    kSE05x_AuthType_None = kSSS_AuthType_None
except:
    pass

try:
    kSE05x_AuthType_SCP03 = kSSS_AuthType_SCP03
except:
    pass

try:
    kSE05x_AuthType_UserID = kSSS_AuthType_ID
except:
    pass

try:
    kSE05x_AuthType_AESKey = kSSS_AuthType_AESKey
except:
    pass

try:
    kSE05x_AuthType_ECKey = kSSS_AuthType_ECKey
except:
    pass

SE05x_AuthType_t = SE_AuthType_t
# hostlib/hostLib/inc/se05x_const.h
try:
    SE05X_SESSIONID_LEN = 8
except:
    pass

try:
    SE05X_MAX_BUF_SIZE_CMD = 1024
except:
    pass

try:
    SE05X_MAX_BUF_SIZE_RSP = 1024
except:
    pass

try:
    SE050_MODULE_UNIQUE_ID_LEN = 18
except:
    pass

try:
    SE05X_I2CM_MAX_BUF_SIZE_CMD = 271
except:
    pass

try:
    SE05X_I2CM_MAX_BUF_SIZE_RSP = 271
except:
    pass

try:
    SE05X_I2CM_MAX_TIMESTAMP_SIZE = 12
except:
    pass

try:
    SE05X_I2CM_MAX_FRESHNESS_SIZE = 16
except:
    pass

try:
    SE05X_I2CM_MAX_CHIP_ID_SIZE = 18
except:
    pass

try:
    SE05X_MAX_ATTST_DATA = 2
except:
    pass

try:
    START_SE05X_ID_CURVE_START = 0
except:
    pass

try:
    CIPHER_BLOCK_SIZE = 16
except:
    pass

try:
    AEAD_BLOCK_SIZE = 16
except:
    pass

try:
    BINARY_WRITE_MAX_LEN = 500
except:
    pass

try:
    MAX_OBJ_PCR_VALUE_SIZE = 32
except:
    pass

try:
    MAX_POLICY_BUFFER_SIZE = 256
except:
    pass

try:
    MAX_OBJ_POLICY_SIZE = 47
except:
    pass

try:
    MAX_OBJ_POLICY_TYPES = 6
except:
    pass

try:
    DEFAULT_OBJECT_POLICY_SIZE = 8
except:
    pass

try:
    OBJ_POLICY_HEADER_OFFSET = 5
except:
    pass

try:
    OBJ_POLICY_LENGTH_OFFSET = 0
except:
    pass

try:
    OBJ_POLICY_AUTHID_OFFSET = 1
except:
    pass

try:
    OBJ_POLICY_EXT_OFFSET = 9
except:
    pass

try:
    OBJ_POLICY_PCR_DATA_SIZE = (4 + MAX_OBJ_PCR_VALUE_SIZE)
except:
    pass

try:
    OBJ_POLICY_AUTH_DATA_SIZE = 2
except:
    pass

try:
    SESSION_POLICY_LENGTH_OFFSET = 0
except:
    pass

try:
    SESSION_POLICY_AR_HEADER_OFFSET = 1
except:
    pass

try:
    DEFAULT_SESSION_POLICY_SIZE = 3
except:
    pass

try:
    POLICY_OBJ_FORBID_ALL = 536870912
except:
    pass

try:
    POLICY_OBJ_ALLOW_SIGN = 268435456
except:
    pass

try:
    POLICY_OBJ_ALLOW_VERIFY = 134217728
except:
    pass

try:
    POLICY_OBJ_ALLOW_KA = 67108864
except:
    pass

try:
    POLICY_OBJ_ALLOW_ENC = 33554432
except:
    pass

try:
    POLICY_OBJ_ALLOW_DEC = 16777216
except:
    pass

try:
    POLICY_OBJ_ALLOW_KDF = 8388608
except:
    pass

try:
    POLICY_OBJ_ALLOW_WRAP = 4194304
except:
    pass

try:
    POLICY_OBJ_ALLOW_READ = 2097152
except:
    pass

try:
    POLICY_OBJ_ALLOW_WRITE = 1048576
except:
    pass

try:
    POLICY_OBJ_ALLOW_GEN = 524288
except:
    pass

try:
    POLICY_OBJ_ALLOW_DELETE = 262144
except:
    pass

try:
    POLICY_OBJ_REQUIRE_SM = 131072
except:
    pass

try:
    POLICY_OBJ_REQUIRE_PCR_VALUE = 65536
except:
    pass

try:
    POLICY_OBJ_ALLOW_ATTESTATION = 32768
except:
    pass

try:
    POLICY_OBJ_ALLOW_DESFIRE_AUTHENTICATION = 16384
except:
    pass

try:
    POLICY_OBJ_ALLOW_DESFIRE_DUMP_SESSION_KEYS = 8192
except:
    pass

try:
    POLICY_OBJ_ALLOW_IMPORT_EXPORT = 4096
except:
    pass

try:
    POLICY_OBJ_FORBID_DERIVED_OUTPUT = 2048
except:
    pass

try:
    POLICY_OBJ_ALLOW_KDF_EXT_RANDOM = 1024
except:
    pass

try:
    POLICY_SESSION_MAX_APDU = 32768
except:
    pass

try:
    POLICY_SESSION_MAX_TIME = 16384
except:
    pass

try:
    POLICY_SESSION_ALLOW_REFRESH = 8192
except:
    pass

# hostlib/hostLib/inc/se05x_enums.h
try:
    kSE05x_TAG_GP_CONTRL_REF_PARM = kSE05x_GP_TAG_CONTRL_REF_PARM
except:
    pass

try:
    kSE05x_ECCurve_RESERVED_ID_ECC_ED_25519 = kSE05x_ECCurve_ECC_ED_25519
except:
    pass

try:
    kSE05x_ECCurve_RESERVED_ID_ECC_MONT_DH_25519 = kSE05x_ECCurve_ECC_MONT_DH_25519
except:
    pass

try:
    kSE05x_ECCurve_RESERVED_ID_ECC_MONT_DH_448 = kSE05x_ECCurve_ECC_MONT_DH_448
except:
    pass

try:
    kSE05x_ECCurve_Total_Weierstrass_Curves = kSE05x_ECCurve_TPM_ECC_BN_P256
except:
    pass

SE05x_CryptoObjectID_t = SE05x_CryptoObject_t
try:
    SE050_MAX_NUMBER_OF_SESSIONS = 2
except:
    pass

try:
    SE050_OBJECT_IDENTIFIER_SIZE = 4
except:
    pass

try:
    SE050_MAX_I2CM_COMMAND_LENGTH = 255
except:
    pass

try:
    SE050_MAX_APDU_PAYLOAD_LENGTH = 896
except:
    pass

try:
    SE050_INS_MASK_INS_CHAR = 224
except:
    pass

try:
    SE050_INS_MASK_INSTRUCTION = 31
except:
    pass

try:
    SE05x_KeyID_KEK_NONE = 0
except:
    pass

try:
    SE05x_KeyID_MFDF_NONE = 0
except:
    pass

try:
    SE05x_MaxAttemps_UNLIMITED = 0
except:
    pass

try:
    SE05x_MaxAttemps_NA = 0
except:
    pass

try:
    kSE05x_INS_READ_With_Attestation = (kSE05x_INS_READ | kSE05x_INS_ATTEST)
except:
    pass

try:
    kSE05x_INS_I2CM_Attestation = (kSE05x_INS_CRYPTO | kSE05x_INS_ATTEST)
except:
    pass

# sss/inc/fsl_sss_se05x_types.h
def SSS_SUBSYSTEM_TYPE_IS_SE05X(subsystem):    return (subsystem == kType_SSS_SE_SE05x)

def SSS_SESSION_TYPE_IS_SE05X(session):    return (session and (SSS_SUBSYSTEM_TYPE_IS_SE05X ((session.contents.subsystem))))

def SSS_KEY_STORE_TYPE_IS_SE05X(keyStore):    return (keyStore and (SSS_SESSION_TYPE_IS_SE05X ((keyStore.contents.session))))

def SSS_OBJECT_TYPE_IS_SE05X(pObject):    return (pObject and (SSS_KEY_STORE_TYPE_IS_SE05X ((pObject.contents.keyStore))))

def SSS_ASYMMETRIC_TYPE_IS_SE05X(context):    return (context and (SSS_SESSION_TYPE_IS_SE05X ((context.contents.session))))

def SSS_DERIVE_KEY_TYPE_IS_SE05X(context):    return (context and (SSS_SESSION_TYPE_IS_SE05X ((context.contents.session))))

def SSS_SYMMETRIC_TYPE_IS_SE05X(context):    return (context and (SSS_SESSION_TYPE_IS_SE05X ((context.contents.session))))

def SSS_MAC_TYPE_IS_SE05X(context):    return (context and (SSS_SESSION_TYPE_IS_SE05X ((context.contents.session))))

def SSS_RNG_CONTEXT_TYPE_IS_SE05X(context):    return (context and (SSS_SESSION_TYPE_IS_SE05X ((context.contents.session))))

def SSS_DIGEST_TYPE_IS_SE05X(context):    return (context and (SSS_SESSION_TYPE_IS_SE05X ((context.contents.session))))

def SSS_AEAD_TYPE_IS_SE05X(context):    return (context and (SSS_SESSION_TYPE_IS_SE05X ((context.contents.session))))

def SSS_TUNNEL_CONTEXT_TYPE_IS_SE05X(context):    return (context and (SSS_SESSION_TYPE_IS_SE05X ((context.contents.session))))

def SSS_TUNNEL_TYPE_IS_SE05X(context):    return (context and (SSS_SESSION_TYPE_IS_SE05X ((context.contents.session))))

SE05x_Connect_Ctx_t = SE_Connect_Ctx_t
se05x_auth_context_t = SE_Connect_Ctx_t
_sss_a71ch_key_store = struct__sss_a71ch_key_store# ../../sss/inc/fsl_sscp_a71ch.h

_sscp_a71ch_context = struct__sscp_a71ch_context
_SE_AuthCtx = struct__SE_AuthCtx# hostlib/hostLib/inc/nxScp03_Types.h

_sss_se05x_tunnel_context = struct__sss_se05x_tunnel_context# sss/inc/fsl_sss_se05x_types.h

_sss_se05x_session = struct__sss_se05x_session
_sss_se05x_object = struct__sss_se05x_object
_SE05x_I2CM_cmd = struct__SE05x_I2CM_cmd
# No inserted files