iqr_toolkit.py

#!/usr/bin/env python3
#
# ISARA Radiate Quantum-safe Toolkit module
#
# https://github.com/isaracorp/Toolkit-Python
#
# Python 3 bindings for the ISARA toolkit.
#
# See the LICENSE file for details:
#
# Copyright (C) 2020-2021, ISARA Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#  https://github.com/isaracorp/Toolkit-Python/blob/develop/LICENSE
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import ctypes
import sys


if sys.platform == 'darwin':
    _iqr_shared_library_name = 'libiqr_toolkit.dylib'
elif sys.platform == 'linux':
    _iqr_shared_library_name = 'libiqr_toolkit.so'
elif sys.platform == 'windows':  # TODO: Check that.
    _iqr_shared_library_name = 'libiqr_toolkit.dll'

ctypes.cdll.LoadLibrary(_iqr_shared_library_name)
_iqr_toolkit = ctypes.CDLL(_iqr_shared_library_name)

if _iqr_toolkit.iqr_VersionCheck(3, 0) != 0:
    raise RuntimeWarning('iqr_toolkit was expecting version 3.0.')


# ----------------------------------------------------------------------------------------------------------------------------------
# ChaCha20 symmetric cipher: iqr_chacha20.h
# ----------------------------------------------------------------------------------------------------------------------------------
class ChaCha20:
    ''' ChaCha20 symmetric cipher.
    '''

    IQR_CHACHA20_KEY_SIZE = 32  # ChaCha20 keys must be exactly 32 bytes.
    IQR_CHACHA20_NONCE_SIZE = 12  # The nonce for ChaCha20 must be exactly 12 bytes.

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_ChaCha20Encrypt.argtypes = [ctypes.c_void_p, ctypes.c_size_t,  # key
                                                 ctypes.c_void_p, ctypes.c_size_t,  # nonce
                                                 ctypes.c_uint32,  # counter
                                                 ctypes.c_void_p, ctypes.c_size_t,  # plaintext
                                                 ctypes.c_void_p, ctypes.c_size_t]  # ciphertext
    _iqr_toolkit.iqr_ChaCha20Encrypt.restype = ctypes.c_int64

    @staticmethod
    def Encrypt(key, nonce, counter, plaintext):
        ''' Encrypt the given plaintext using the key, nonce, and counter.

        Returns ciphertext.
        '''
        cipher = ctypes.create_string_buffer(len(plaintext))

        retval = _iqr_toolkit.iqr_ChaCha20Encrypt(key, len(key),
                                                  nonce, len(nonce),
                                                  counter,
                                                  plaintext, len(plaintext),
                                                  cipher, ctypes.sizeof(cipher))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ChaCha20Encrypt() failed: {0}'.format(Retval.StrError(retval)))

        return cipher.raw

    @staticmethod
    def Decrypt(key, nonce, counter, ciphertext):
        ''' Decrypt the given ciphertext using the key, nonce, and counter.

        Returns plaintext.
        '''
        return ChaCha20.Encrypt(key, nonce, counter, ciphertext)


def test_chacha20():
    ''' Run a simple ChaCha20 test.
    '''
    # Absolutely do not ever create a key and nonce like this.
    chacha_key = b'#' * ChaCha20.IQR_CHACHA20_KEY_SIZE
    chacha_nonce = b'*' * ChaCha20.IQR_CHACHA20_NONCE_SIZE
    chacha_msg = b'ChaCha20 is working.'
    chacha_encrypted = ChaCha20.Encrypt(chacha_key, chacha_nonce, 1, chacha_msg)
    print('{0}'.format(ChaCha20.Decrypt(chacha_key, chacha_nonce, 1, chacha_encrypted)))


# ----------------------------------------------------------------------------------------------------------------------------------
# Toolkit Context: iqr_context.h
# ----------------------------------------------------------------------------------------------------------------------------------
class Context:
    ''' Toolkit Context object.
    '''

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_CreateContext.argtypes = [ctypes.POINTER(ctypes.c_void_p)]  # Context
    _iqr_toolkit.iqr_CreateContext.restype = ctypes.c_int64

    _iqr_toolkit.iqr_DestroyContext.argtypes = [ctypes.POINTER(ctypes.c_void_p)]  # Context
    _iqr_toolkit.iqr_DestroyContext.restype = ctypes.c_int64

    @staticmethod
    def Create():
        ''' Create and initialize a Context object.

        The caller must free the returned ctx using DestroyContext().
        '''
        ctx = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_CreateContext(ctypes.byref(ctx))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_CreateContext() failed: {0}'.format(Retval.StrError(retval)))

        return ctx

    @staticmethod
    def Destroy(ctx):
        ''' Clear and deallocate a Context object.
        '''
        retval = _iqr_toolkit.iqr_DestroyContext(ctypes.byref(ctx))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DestroyContext() failed: {0}'.format(Retval.StrError(retval)))


# ----------------------------------------------------------------------------------------------------------------------------------
# Classic McEliece KEM: iqr_classicmceliece.h
# ----------------------------------------------------------------------------------------------------------------------------------
class ClassicMcEliece:
    ''' Classic McEliece KEM.
    '''

    IQR_CLASSICMCELIECE_SHARED_KEY_SIZE = 32  # The size of the shared key produced by ClassicMcEliece in bytes.

    IQR_CLASSICMCELIECE_6 = _iqr_toolkit.IQR_CLASSICMCELIECE_6  # 6960119 variant (256 bit classical security).
    IQR_CLASSICMCELIECE_8 = _iqr_toolkit.IQR_CLASSICMCELIECE_8  # 8192128 variant (256 bit classical security).

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_ClassicMcElieceCreateParams.argtypes = [ctypes.c_void_p,  # Context
                                                             ctypes.c_void_p,  # RNG
                                                             ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_ClassicMcElieceCreateParams.restype = ctypes.c_int64
    _iqr_toolkit.iqr_ClassicMcElieceDestroyParams.argtypes = [ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_ClassicMcElieceDestroyParams.restype = ctypes.c_int64

    _iqr_toolkit.iqr_ClassicMcElieceGetPublicKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_ClassicMcElieceGetPublicKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_ClassicMcElieceGetPrivateKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_ClassicMcElieceGetPrivateKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_ClassicMcElieceGetCiphertextSize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_ClassicMcElieceGetCiphertextSize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_ClassicMcElieceGetSharedKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_ClassicMcElieceGetSharedKeySize.restype = ctypes.c_int64

    _iqr_toolkit.iqr_ClassicMcElieceCreateKeyPair.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                                              ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_ClassicMcElieceCreateKeyPair.restype = ctypes.c_int64
    _iqr_toolkit.iqr_ClassicMcElieceDestroyPublicKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_ClassicMcElieceDestroyPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_ClassicMcElieceDestroyPrivateKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_ClassicMcElieceDestroyPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_ClassicMcElieceExportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_ClassicMcElieceExportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_ClassicMcElieceExportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_ClassicMcElieceExportPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_ClassicMcElieceImportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                                ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_ClassicMcElieceImportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_ClassicMcElieceImportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                                 ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_ClassicMcElieceImportPrivateKey.restype = ctypes.c_int64

    _iqr_toolkit.iqr_ClassicMcElieceEncapsulate.argtypes = [ctypes.c_void_p,  # Public Key
                                                            ctypes.c_void_p,  # RNG
                                                            ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                            ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_ClassicMcElieceEncapsulate.restype = ctypes.c_int64
    _iqr_toolkit.iqr_ClassicMcElieceDecapsulate.argtypes = [ctypes.c_void_p,  # Private Key
                                                            ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                            ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_ClassicMcElieceDecapsulate.restype = ctypes.c_int64

    @staticmethod
    def CreateParams(ctx, variant):
        ''' Create a parameter object for the ClassicMcEliece cryptographic system.
        '''
        params = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_ClassicMcElieceCreateParams(ctx, variant, ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceCreateParams() failed: {0}'.format(Retval.StrError(retval)))

        return params

    @staticmethod
    def DestroyParams(params):
        ''' Clear and deallocate a ClassicMcEliece parameter object.
        '''
        retval = _iqr_toolkit.iqr_ClassicMcElieceDestroyParams(ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceDestroyParams() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def CreateKeyPair(params, rng):
        pub_key = ctypes.c_void_p(0)
        priv_key = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_ClassicMcElieceCreateKeyPair(params, rng, ctypes.byref(pub_key), ctypes.byref(priv_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceCreateKeyPair() failed: {0}'.format(Retval.StrError(retval)))

        return pub_key, priv_key

    @staticmethod
    def DestroyPublicKey(pub_key):
        ''' Clear and deallocate a ClassicMcEliece public key object.
        '''
        retval = _iqr_toolkit.iqr_ClassicMcElieceDestroyPublicKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceDestroyPublicKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def DestroyPrivateKey(pub_key):
        ''' Clear and deallocate a ClassicMcEliece private object.
        '''
        retval = _iqr_toolkit.iqr_ClassicMcElieceDestroyPrivateKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceDestroyPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def ExportPublicKey(params, pub_key):
        ''' Export a ClassicMcEliece public key object to bytes.
        '''
        pub_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_ClassicMcElieceGetPublicKeySize(params, ctypes.byref(pub_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceGetPublicKeySize() failed: {0}'.format(Retval.StrError(retval)))

        pub_data = ctypes.create_string_buffer(pub_size.value)

        retval = _iqr_toolkit.iqr_ClassicMcElieceExportPublicKey(pub_key, pub_data, pub_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceExportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub_data.raw

    @staticmethod
    def ExportPrivateKey(params, priv_key):
        ''' Export a ClassicMcEliece private key object to bytes.
        '''
        priv_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_ClassicMcElieceGetPrivateKeySize(params, ctypes.byref(priv_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceGetPrivateKeySize() failed: {0}'.format(Retval.StrError(retval)))

        priv_data = ctypes.create_string_buffer(priv_size.value)

        retval = _iqr_toolkit.iqr_ClassicMcElieceExportPrivateKey(priv_key, priv_data, priv_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceExportPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv_data.raw

    @staticmethod
    def ImportPublicKey(params, pub_data):
        ''' Import a ClassicMcEliece public key from bytes.
        '''
        pub = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_ClassicMcElieceImportPublicKey(params, pub_data, len(pub_data), ctypes.byref(pub))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub

    @staticmethod
    def ImportPrivateKey(params, priv_data):
        ''' Import a ClassicMcEliece private key from bytes.
        '''
        priv = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_ClassicMcElieceImportPrivateKey(params, priv_data, len(priv_data), ctypes.byref(priv))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv

    @staticmethod
    def Encapsulate(params, pub, rng):
        ''' Create a ciphertext and shared key from the public key.
        '''
        ciphertext_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_ClassicMcElieceGetCiphertextSize(params, ctypes.byref(ciphertext_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceGetCiphertextSize() failed: {0}'.format(Retval.StrError(retval)))
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_ClassicMcElieceGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        ciphertext = ctypes.create_string_buffer(ciphertext_size.value)
        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_ClassicMcElieceEncapsulate(pub, rng, ciphertext, ciphertext_size, shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceEncapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return ciphertext.raw, shared.raw

    @staticmethod
    def Decapsulate(params, priv, ciphertext):
        ''' Extract the shared key from a private key and ciphertext.
        '''
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_ClassicMcElieceGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_ClassicMcElieceDecapsulate(priv, ciphertext, len(ciphertext), shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceDecapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return shared.raw


def test_ClassicMcEliece():
    ''' Run a simple ClassicMcEliece test.
    '''
    ctx = Context.Create()

    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA2_256, Hash.IQR_HASH_DEFAULT_SHA2_256)

    rng = Rng.CreateHMACDRBG(ctx, Hash.IQR_HASHALGO_SHA2_256)
    Rng.Initialize(rng, b'this is really bad seed data, never do this')

    params = ClassicMcEliece.CreateParams(ctx, ClassicMcEliece.IQR_CLASSICMCELIECE_6)
    pub, priv = ClassicMcEliece.CreateKeyPair(params, rng)

    ciphertext, shared = ClassicMcEliece.Encapsulate(params, pub, rng)
    print('ClassicMcEliece Encapsulate: {0} bytes'.format(len(shared)))
    shared2 = ClassicMcEliece.Decapsulate(params, priv, ciphertext)
    print('ClassicMcEliece Decapsulate: {0} bytes'.format(len(shared2)))

    assert(shared == shared2)

    pub_data = ClassicMcEliece.ExportPublicKey(params, pub)
    priv_data = ClassicMcEliece.ExportPrivateKey(params, priv)

    pub2 = ClassicMcEliece.ImportPublicKey(params, pub_data)
    priv2 = ClassicMcEliece.ImportPrivateKey(params, priv_data)

    ClassicMcEliece.DestroyPublicKey(pub)
    ClassicMcEliece.DestroyPrivateKey(priv)
    ClassicMcEliece.DestroyPublicKey(pub2)
    ClassicMcEliece.DestroyPrivateKey(priv2)
    ClassicMcEliece.DestroyParams(params)

    Rng.Destroy(rng)
    Context.Destroy(ctx)


# ----------------------------------------------------------------------------------------------------------------------------------
# Toolkit Dilithium signatures: iqr_dilithium.h
# ----------------------------------------------------------------------------------------------------------------------------------
class Dilithium:
    ''' Dilithium signature scheme.
    '''

    IQR_DILITHIUM_2 = _iqr_toolkit.IQR_DILITHIUM_2  # Low-security variant.
    IQR_DILITHIUM_3 = _iqr_toolkit.IQR_DILITHIUM_3  # Medium-security variant.
    IQR_DILITHIUM_5 = _iqr_toolkit.IQR_DILITHIUM_3  # High-security variant.

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_DilithiumCreateParams.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_DilithiumCreateParams.restype = ctypes.c_int64
    _iqr_toolkit.iqr_DilithiumDestroyParams.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_DilithiumDestroyParams.restype = ctypes.c_int64

    _iqr_toolkit.iqr_DilithiumCreateKeyPair.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p),
                                                        ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_DilithiumCreateKeyPair.restype = ctypes.c_int64
    _iqr_toolkit.iqr_DilithiumImportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                          ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_DilithiumImportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_DilithiumImportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                           ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_DilithiumImportPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_DilithiumExportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_DilithiumExportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_DilithiumExportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_DilithiumExportPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_DilithiumDestroyPublicKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_DilithiumDestroyPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_DilithiumDestroyPrivateKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_DilithiumDestroyPrivateKey.restype = ctypes.c_int64

    _iqr_toolkit.iqr_DilithiumGetPublicKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_DilithiumGetPublicKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_DilithiumGetPrivateKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_DilithiumGetPrivateKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_DilithiumGetSignatureSize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_DilithiumGetSignatureSize.restype = ctypes.c_int64

    _iqr_toolkit.iqr_DilithiumSign.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                               ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_DilithiumSign.restype = ctypes.c_int64
    _iqr_toolkit.iqr_DilithiumVerify.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                 ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_DilithiumVerify.restype = ctypes.c_int64

    @staticmethod
    def CreateParams(ctx, variant):
        ''' Create a parameter object for the Dilithium cryptographic system.
        '''
        params = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_DilithiumCreateParams(ctx, variant, ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumCreateParams() failed: {0}'.format(Retval.StrError(retval)))

        return params

    @staticmethod
    def DestroyParams(params):
        ''' Clear and deallocate a Dilithium parameter object.
        '''
        retval = _iqr_toolkit.iqr_DilithiumDestroyParams(ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumDestroyParams() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def CreateKeyPair(params, rng):
        pub_key = ctypes.c_void_p(0)
        priv_key = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_DilithiumCreateKeyPair(params, rng, ctypes.byref(pub_key), ctypes.byref(priv_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumCreateKeyPair() failed: {0}'.format(Retval.StrError(retval)))

        return pub_key, priv_key

    @staticmethod
    def DestroyPublicKey(pub_key):
        ''' Clear and deallocate a Dilithium public key object.
        '''
        retval = _iqr_toolkit.iqr_DilithiumDestroyPublicKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumDestroyPublicKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def DestroyPrivateKey(pub_key):
        ''' Clear and deallocate a Dilithium private object.
        '''
        retval = _iqr_toolkit.iqr_DilithiumDestroyPrivateKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumDestroyPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def ExportPublicKey(params, pub_key):
        ''' Export a Dilithium public key object to bytes.
        '''
        pub_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_DilithiumGetPublicKeySize(params, ctypes.byref(pub_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumGetPublicKeySize() failed: {0}'.format(Retval.StrError(retval)))

        pub_data = ctypes.create_string_buffer(pub_size.value)

        retval = _iqr_toolkit.iqr_DilithiumExportPublicKey(pub_key, pub_data, pub_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumExportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub_data.raw

    @staticmethod
    def ExportPrivateKey(params, priv_key):
        ''' Export a Dilithium private key object to bytes.
        '''
        priv_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_DilithiumGetPrivateKeySize(params, ctypes.byref(priv_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumGetPrivateKeySize() failed: {0}'.format(Retval.StrError(retval)))

        priv_data = ctypes.create_string_buffer(priv_size.value)

        retval = _iqr_toolkit.iqr_DilithiumExportPrivateKey(priv_key, priv_data, priv_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumExportPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv_data.raw

    @staticmethod
    def ImportPublicKey(params, pub_data):
        ''' Import a Dilithium public key from bytes.
        '''
        pub = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_DilithiumImportPublicKey(params, pub_data, len(pub_data), ctypes.byref(pub))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub

    @staticmethod
    def ImportPrivateKey(params, priv_data):
        ''' Import a Dilithium private key from bytes.
        '''
        priv = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_DilithiumImportPrivateKey(params, priv_data, len(priv_data), ctypes.byref(priv))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv

    @staticmethod
    def Sign(params, priv, msg):
        ''' Create a signature from the given private key and message.
        '''
        sig_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_DilithiumGetSignatureSize(params, ctypes.byref(sig_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumGetSignatureSize() failed: {0}'.format(Retval.StrError(retval)))

        sig = ctypes.create_string_buffer(sig_size.value)

        retval = _iqr_toolkit.iqr_DilithiumSign(priv, msg, len(msg), sig, sig_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_DilithiumSign() failed: {0}'.format(Retval.StrError(retval)))

        return sig.raw

    @staticmethod
    def Verify(pub, msg, sig):
        ''' Verify a signature.
        '''
        retval = _iqr_toolkit.iqr_DilithiumVerify(pub, msg, len(msg), sig, len(sig))
        if retval == Retval.IQR_EINVSIGNATURE:
            return False
        elif retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceDecapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return True


def test_Dilithium():
    ''' Run a simple Dilithium test.
    '''
    ctx = Context.Create()

    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA2_256, Hash.IQR_HASH_DEFAULT_SHA2_256)

    rng = Rng.CreateHMACDRBG(ctx, Hash.IQR_HASHALGO_SHA2_256)
    Rng.Initialize(rng, b'this is really bad seed data, never do this')

    params = Dilithium.CreateParams(ctx, Dilithium.IQR_DILITHIUM_2)
    pub, priv = Dilithium.CreateKeyPair(params, rng)

    msg = b'This is a short message for signing.'
    sig = Dilithium.Sign(params, priv, msg)
    print('Dilithium signature: {0} bytes'.format(len(sig)))
    valid = Dilithium.Verify(pub, msg, sig)
    print('           verified: {0}'.format(valid))

    pub_data = Dilithium.ExportPublicKey(params, pub)
    priv_data = Dilithium.ExportPrivateKey(params, priv)

    pub2 = Dilithium.ImportPublicKey(params, pub_data)
    priv2 = Dilithium.ImportPrivateKey(params, priv_data)

    Dilithium.DestroyPublicKey(pub)
    Dilithium.DestroyPrivateKey(priv)
    Dilithium.DestroyPublicKey(pub2)
    Dilithium.DestroyPrivateKey(priv2)
    Dilithium.DestroyParams(params)

    Rng.Destroy(rng)
    Context.Destroy(ctx)


# ----------------------------------------------------------------------------------------------------------------------------------
# Frodo KEM: iqr_frodokem.h
# ----------------------------------------------------------------------------------------------------------------------------------
class Frodo:
    ''' Frodo KEM.
    '''
    IQR_FRODOKEM_640_AES = _iqr_toolkit.IQR_FRODOKEM_640_AES  # FrodoKEM using AES, variant with 104 bit quantum security.
    IQR_FRODOKEM_640_SHAKE = _iqr_toolkit.IQR_FRODOKEM_640_SHAKE  # FrodoKEM using SHAKE, variant with 104 bit quantum security.
    IQR_FRODOKEM_976_AES = _iqr_toolkit.IQR_FRODOKEM_976_AES  # FrodoKEM using AES, variant with 150 bit quantum security.
    IQR_FRODOKEM_976_SHAKE = _iqr_toolkit.IQR_FRODOKEM_976_SHAKE  # FrodoKEM using SHAKE, variant with 150 bit quantum security.
    IQR_FRODOKEM_1344_AES = _iqr_toolkit.IQR_FRODOKEM_1344_AES  # FrodoKEM using AES, variant with 197 bit quantum security.
    IQR_FRODOKEM_1344_SHAKE = _iqr_toolkit.IQR_FRODOKEM_1344_SHAKE  # FrodoKEM using SHAKE, variant with 197 bit quantum security.

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_FrodoKEMCreateParams.argtypes = [ctypes.c_void_p,  # Context
                                                      ctypes.c_void_p,  # RNG
                                                      ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_FrodoKEMCreateParams.restype = ctypes.c_int64
    _iqr_toolkit.iqr_FrodoKEMDestroyParams.argtypes = [ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_FrodoKEMDestroyParams.restype = ctypes.c_int64

    _iqr_toolkit.iqr_FrodoKEMGetPublicKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_FrodoKEMGetPublicKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_FrodoKEMGetPrivateKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_FrodoKEMGetPrivateKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_FrodoKEMGetCiphertextSize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_FrodoKEMGetCiphertextSize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_FrodoKEMGetSharedKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_FrodoKEMGetSharedKeySize.restype = ctypes.c_int64

    _iqr_toolkit.iqr_FrodoKEMCreateKeyPair.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                                       ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_FrodoKEMCreateKeyPair.restype = ctypes.c_int64
    _iqr_toolkit.iqr_FrodoKEMDestroyPublicKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_FrodoKEMDestroyPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_FrodoKEMDestroyPrivateKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_FrodoKEMDestroyPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_FrodoKEMExportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_FrodoKEMExportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_FrodoKEMExportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_FrodoKEMExportPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_FrodoKEMImportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                         ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_FrodoKEMImportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_FrodoKEMImportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                          ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_FrodoKEMImportPrivateKey.restype = ctypes.c_int64

    _iqr_toolkit.iqr_FrodoKEMEncapsulate.argtypes = [ctypes.c_void_p,  # Public Key
                                                     ctypes.c_void_p,  # RNG
                                                     ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                     ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_FrodoKEMEncapsulate.restype = ctypes.c_int64
    _iqr_toolkit.iqr_FrodoKEMDecapsulate.argtypes = [ctypes.c_void_p,  # Private Key
                                                     ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                     ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_FrodoKEMDecapsulate.restype = ctypes.c_int64

    @staticmethod
    def CreateParams(ctx, variant):
        ''' Create a parameter object for the FrodoKEM cryptographic system.
        '''
        params = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_FrodoKEMCreateParams(ctx, variant, ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMCreateParams() failed: {0}'.format(Retval.StrError(retval)))

        return params

    @staticmethod
    def DestroyParams(params):
        ''' Clear and deallocate a FrodoKEM parameter object.
        '''
        retval = _iqr_toolkit.iqr_FrodoKEMDestroyParams(ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMDestroyParams() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def CreateKeyPair(params, rng):
        pub_key = ctypes.c_void_p(0)
        priv_key = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_FrodoKEMCreateKeyPair(params, rng, ctypes.byref(pub_key), ctypes.byref(priv_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMCreateKeyPair() failed: {0}'.format(Retval.StrError(retval)))

        return pub_key, priv_key

    @staticmethod
    def DestroyPublicKey(pub_key):
        ''' Clear and deallocate a FrodoKEM public key object.
        '''
        retval = _iqr_toolkit.iqr_FrodoKEMDestroyPublicKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMDestroyPublicKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def DestroyPrivateKey(pub_key):
        ''' Clear and deallocate a FrodoKEM private object.
        '''
        retval = _iqr_toolkit.iqr_FrodoKEMDestroyPrivateKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMDestroyPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def ExportPublicKey(params, pub_key):
        ''' Export a FrodoKEM public key object to bytes.
        '''
        pub_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_FrodoKEMGetPublicKeySize(params, ctypes.byref(pub_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMGetPublicKeySize() failed: {0}'.format(Retval.StrError(retval)))

        pub_data = ctypes.create_string_buffer(pub_size.value)

        retval = _iqr_toolkit.iqr_FrodoKEMExportPublicKey(pub_key, pub_data, pub_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMExportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub_data.raw

    @staticmethod
    def ExportPrivateKey(params, priv_key):
        ''' Export a FrodoKEM private key object to bytes.
        '''
        priv_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_FrodoKEMGetPrivateKeySize(params, ctypes.byref(priv_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMGetPrivateKeySize() failed: {0}'.format(Retval.StrError(retval)))

        priv_data = ctypes.create_string_buffer(priv_size.value)

        retval = _iqr_toolkit.iqr_FrodoKEMExportPrivateKey(priv_key, priv_data, priv_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMExportPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv_data.raw

    @staticmethod
    def ImportPublicKey(params, pub_data):
        ''' Import a FrodoKEM public key from bytes.
        '''
        pub = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_FrodoKEMImportPublicKey(params, pub_data, len(pub_data), ctypes.byref(pub))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub

    @staticmethod
    def ImportPrivateKey(params, priv_data):
        ''' Import a FrodoKEM private key from bytes.
        '''
        priv = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_FrodoKEMImportPrivateKey(params, priv_data, len(priv_data), ctypes.byref(priv))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv

    @staticmethod
    def Encapsulate(params, pub, rng):
        ''' Create a ciphertext and shared key from the public key.
        '''
        ciphertext_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_FrodoKEMGetCiphertextSize(params, ctypes.byref(ciphertext_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMGetCiphertextSize() failed: {0}'.format(Retval.StrError(retval)))
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_FrodoKEMGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        ciphertext = ctypes.create_string_buffer(ciphertext_size.value)
        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_FrodoKEMEncapsulate(pub, rng, ciphertext, ciphertext_size, shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMEncapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return ciphertext.raw, shared.raw

    @staticmethod
    def Decapsulate(params, priv, ciphertext):
        ''' Extract the shared key from a private key and ciphertext.
        '''
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_FrodoKEMGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_FrodoKEMDecapsulate(priv, ciphertext, len(ciphertext), shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_FrodoKEMDecapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return shared.raw


def test_FrodoKEM():
    ''' Run a simple FrodoKEM test.
    '''
    ctx = Context.Create()

    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA2_256, Hash.IQR_HASH_DEFAULT_SHA2_256)

    rng = Rng.CreateHMACDRBG(ctx, Hash.IQR_HASHALGO_SHA2_256)
    Rng.Initialize(rng, b'this is really bad seed data, never do this')

    params = Frodo.CreateParams(ctx, Frodo.IQR_FRODOKEM_640_AES)
    pub, priv = Frodo.CreateKeyPair(params, rng)

    ciphertext, shared = Frodo.Encapsulate(params, pub, rng)
    print('Frodo Encapsulate: {0} bytes'.format(len(shared)))
    shared2 = Frodo.Decapsulate(params, priv, ciphertext)
    print('Frodo Decapsulate: {0} bytes'.format(len(shared2)))

    assert(shared == shared2)

    pub_data = Frodo.ExportPublicKey(params, pub)
    priv_data = Frodo.ExportPrivateKey(params, priv)

    pub2 = Frodo.ImportPublicKey(params, pub_data)
    priv2 = Frodo.ImportPrivateKey(params, priv_data)

    Frodo.DestroyPublicKey(pub)
    Frodo.DestroyPrivateKey(priv)
    Frodo.DestroyPublicKey(pub2)
    Frodo.DestroyPrivateKey(priv2)
    Frodo.DestroyParams(params)

    Rng.Destroy(rng)
    Context.Destroy(ctx)


# ----------------------------------------------------------------------------------------------------------------------------------
# Toolkit hash implementations: iqr_hash.h
# ----------------------------------------------------------------------------------------------------------------------------------
class Hash:
    ''' Hash implementations.

    TODO: Creating/using a Hash object is not currently supported.
    '''

    IQR_HASHALGO_SHA2_256 = 2  # SHA2-256 algorithm type identifier.
    IQR_HASHALGO_SHA2_384 = 3  # SHA2-384 algorithm type identifier.
    IQR_HASHALGO_SHA2_512 = 4  # SHA2-512 algorithm type identifier.
    IQR_HASHALGO_SHA3_256 = 5  # SHA3-256 algorithm type identifier.
    IQR_HASHALGO_SHA3_512 = 6  # SHA3-512 algorithm type identifier.

    IQR_SHA2_256_DIGEST_SIZE = 32  # The size of a SHA2-256 digest in bytes.
    IQR_SHA2_384_DIGEST_SIZE = 48  # The size of a SHA2-384 digest in bytes.
    IQR_SHA2_512_DIGEST_SIZE = 64  # The size of a SHA2-512 digest in bytes.
    IQR_SHA3_256_DIGEST_SIZE = 32  # The size of a SHA3-256 digest in bytes.
    IQR_SHA3_512_DIGEST_SIZE = 64  # The size of a SHA3-512 digest in bytes.

    IQR_HASH_DEFAULT_SHA2_256 = _iqr_toolkit.IQR_HASH_DEFAULT_SHA2_256  # Internal SHA2-256 implementation.
    IQR_HASH_DEFAULT_SHA2_384 = _iqr_toolkit.IQR_HASH_DEFAULT_SHA2_384  # Internal SHA2-384 implementation.
    IQR_HASH_DEFAULT_SHA2_512 = _iqr_toolkit.IQR_HASH_DEFAULT_SHA2_512  # Internal SHA2-512 implementation.
    IQR_HASH_DEFAULT_SHA3_256 = _iqr_toolkit.IQR_HASH_DEFAULT_SHA3_256  # Internal SHA3-256 implementation.
    IQR_HASH_DEFAULT_SHA3_512 = _iqr_toolkit.IQR_HASH_DEFAULT_SHA3_512  # Internal SHA3-512 implementation.

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_HashRegisterCallbacks.argtypes = [ctypes.c_void_p, ctypes.c_int64, ctypes.c_void_p]
    _iqr_toolkit.iqr_HashRegisterCallbacks.restype = ctypes.c_int64

    @staticmethod
    def RegisterCallbacks(ctx, algo, callbacks):
        retval = _iqr_toolkit.iqr_HashRegisterCallbacks(ctx, algo, callbacks)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_HashRegisterCallbacks() failed: {0}'.format(Retval.StrError(retval)))


def test_hash():
    ''' Run a simple Hash test.
    '''
    ctx = Context.Create()

    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA2_256, Hash.IQR_HASH_DEFAULT_SHA2_256)
    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA2_384, Hash.IQR_HASH_DEFAULT_SHA2_384)
    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA2_512, Hash.IQR_HASH_DEFAULT_SHA2_512)
    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA3_256, Hash.IQR_HASH_DEFAULT_SHA3_256)
    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA3_512, Hash.IQR_HASH_DEFAULT_SHA3_512)

    Context.Destroy(ctx)


# ----------------------------------------------------------------------------------------------------------------------------------
# Kyber KEM: iqr_kyber.h
# ----------------------------------------------------------------------------------------------------------------------------------
class Kyber:
    ''' Kyber KEM.
    '''

    IQR_KYBER_512 = _iqr_toolkit.IQR_KYBER_512  # 100 bit quantum security variant.
    IQR_KYBER_768 = _iqr_toolkit.IQR_KYBER_768  # 160 bit quantum security variant.
    IQR_KYBER_1024 = _iqr_toolkit.IQR_KYBER_1024  # 224 bit quantum security variant.

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_KyberCreateParams.argtypes = [ctypes.c_void_p,  # Context
                                                   ctypes.c_void_p,  # RNG
                                                   ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_KyberCreateParams.restype = ctypes.c_int64
    _iqr_toolkit.iqr_KyberDestroyParams.argtypes = [ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_KyberDestroyParams.restype = ctypes.c_int64

    _iqr_toolkit.iqr_KyberGetPublicKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_KyberGetPublicKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_KyberGetPrivateKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_KyberGetPrivateKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_KyberGetCiphertextSize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_KyberGetCiphertextSize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_KyberGetSharedKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_KyberGetSharedKeySize.restype = ctypes.c_int64

    _iqr_toolkit.iqr_KyberCreateKeyPair.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                                    ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_KyberCreateKeyPair.restype = ctypes.c_int64
    _iqr_toolkit.iqr_KyberDestroyPublicKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_KyberDestroyPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_KyberDestroyPrivateKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_KyberDestroyPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_KyberExportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_KyberExportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_KyberExportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_KyberExportPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_KyberImportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                      ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_KyberImportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_KyberImportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                       ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_KyberImportPrivateKey.restype = ctypes.c_int64

    _iqr_toolkit.iqr_KyberEncapsulate.argtypes = [ctypes.c_void_p,  # Public Key
                                                  ctypes.c_void_p,  # RNG
                                                  ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                  ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_KyberEncapsulate.restype = ctypes.c_int64
    _iqr_toolkit.iqr_KyberDecapsulate.argtypes = [ctypes.c_void_p,  # Private Key
                                                  ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                  ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_KyberDecapsulate.restype = ctypes.c_int64

    @staticmethod
    def CreateParams(ctx, variant):
        ''' Create a parameter object for the Kyber cryptographic system.
        '''
        params = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_KyberCreateParams(ctx, variant, ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberCreateParams() failed: {0}'.format(Retval.StrError(retval)))

        return params

    @staticmethod
    def DestroyParams(params):
        ''' Clear and deallocate a Kyber parameter object.
        '''
        retval = _iqr_toolkit.iqr_KyberDestroyParams(ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberDestroyParams() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def CreateKeyPair(params, rng):
        pub_key = ctypes.c_void_p(0)
        priv_key = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_KyberCreateKeyPair(params, rng, ctypes.byref(pub_key), ctypes.byref(priv_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberCreateKeyPair() failed: {0}'.format(Retval.StrError(retval)))

        return pub_key, priv_key

    @staticmethod
    def DestroyPublicKey(pub_key):
        ''' Clear and deallocate a Kyber public key object.
        '''
        retval = _iqr_toolkit.iqr_KyberDestroyPublicKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberDestroyPublicKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def DestroyPrivateKey(pub_key):
        ''' Clear and deallocate a Kyber private object.
        '''
        retval = _iqr_toolkit.iqr_KyberDestroyPrivateKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberDestroyPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def ExportPublicKey(params, pub_key):
        ''' Export a Kyber public key object to bytes.
        '''
        pub_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_KyberGetPublicKeySize(params, ctypes.byref(pub_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberGetPublicKeySize() failed: {0}'.format(Retval.StrError(retval)))

        pub_data = ctypes.create_string_buffer(pub_size.value)

        retval = _iqr_toolkit.iqr_KyberExportPublicKey(pub_key, pub_data, pub_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberExportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub_data.raw

    @staticmethod
    def ExportPrivateKey(params, priv_key):
        ''' Export a Kyber private key object to bytes.
        '''
        priv_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_KyberGetPrivateKeySize(params, ctypes.byref(priv_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberGetPrivateKeySize() failed: {0}'.format(Retval.StrError(retval)))

        priv_data = ctypes.create_string_buffer(priv_size.value)

        retval = _iqr_toolkit.iqr_KyberExportPrivateKey(priv_key, priv_data, priv_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberExportPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv_data.raw

    @staticmethod
    def ImportPublicKey(params, pub_data):
        ''' Import a Kyber public key from bytes.
        '''
        pub = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_KyberImportPublicKey(params, pub_data, len(pub_data), ctypes.byref(pub))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub

    @staticmethod
    def ImportPrivateKey(params, priv_data):
        ''' Import a Kyber private key from bytes.
        '''
        priv = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_KyberImportPrivateKey(params, priv_data, len(priv_data), ctypes.byref(priv))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv

    @staticmethod
    def Encapsulate(params, pub, rng):
        ''' Create a ciphertext and shared key from the public key.
        '''
        ciphertext_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_KyberGetCiphertextSize(params, ctypes.byref(ciphertext_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberGetCiphertextSize() failed: {0}'.format(Retval.StrError(retval)))
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_KyberGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        ciphertext = ctypes.create_string_buffer(ciphertext_size.value)
        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_KyberEncapsulate(pub, rng, ciphertext, ciphertext_size, shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberEncapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return ciphertext.raw, shared.raw

    @staticmethod
    def Decapsulate(params, priv, ciphertext):
        ''' Extract the shared key from a private key and ciphertext.
        '''
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_KyberGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_KyberDecapsulate(priv, ciphertext, len(ciphertext), shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_KyberDecapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return shared.raw


def test_Kyber():
    ''' Run a simple Kyber test.
    '''
    ctx = Context.Create()

    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA3_256, Hash.IQR_HASH_DEFAULT_SHA3_256)
    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA3_512, Hash.IQR_HASH_DEFAULT_SHA3_512)

    rng = Rng.CreateHMACDRBG(ctx, Hash.IQR_HASHALGO_SHA3_256)
    Rng.Initialize(rng, b'this is really bad seed data, never do this')

    params = Kyber.CreateParams(ctx, Kyber.IQR_KYBER_512)
    pub, priv = Kyber.CreateKeyPair(params, rng)

    ciphertext, shared = Kyber.Encapsulate(params, pub, rng)
    print('Kyber Encapsulate: {0} bytes'.format(len(shared)))
    shared2 = Kyber.Decapsulate(params, priv, ciphertext)
    print('Kyber Decapsulate: {0} bytes'.format(len(shared2)))

    assert(shared == shared2)

    pub_data = Kyber.ExportPublicKey(params, pub)
    priv_data = Kyber.ExportPrivateKey(params, priv)

    pub2 = Kyber.ImportPublicKey(params, pub_data)
    priv2 = Kyber.ImportPrivateKey(params, priv_data)

    Kyber.DestroyPublicKey(pub)
    Kyber.DestroyPrivateKey(priv)
    Kyber.DestroyPublicKey(pub2)
    Kyber.DestroyPrivateKey(priv2)
    Kyber.DestroyParams(params)

    Rng.Destroy(rng)
    Context.Destroy(ctx)


# ----------------------------------------------------------------------------------------------------------------------------------
# NTRUPrime KEM: iqr_ntruprime.h
# ----------------------------------------------------------------------------------------------------------------------------------
class NTRUPrime:
    ''' NTRUPrime Prime KEM.
    '''

    IQR_NTRUPRIME_SHARED_KEY_SIZE = 32  # The size of the shared key produced by NTRUPrime in bytes.

    IQR_SNTRUP_653 = _iqr_toolkit.IQR_SNTRUP_653  # NIST category 1 variant.
    IQR_SNTRUP_761 = _iqr_toolkit.IQR_SNTRUP_761  # NIST category 2 variant.
    IQR_SNTRUP_857 = _iqr_toolkit.IQR_SNTRUP_857  # NIST category 2-3 variant.
    IQR_SNTRUP_953 = _iqr_toolkit.IQR_SNTRUP_953  # NIST category 3-4 variant.
    IQR_SNTRUP_1013 = _iqr_toolkit.IQR_SNTRUP_1013  # NIST category 4 variant.
    IQR_SNTRUP_1277 = _iqr_toolkit.IQR_SNTRUP_1277  # NIST category 5 variant.

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_NTRUPrimeCreateParams.argtypes = [ctypes.c_void_p,  # Context
                                                       ctypes.c_void_p,  # RNG
                                                       ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_NTRUPrimeCreateParams.restype = ctypes.c_int64
    _iqr_toolkit.iqr_NTRUPrimeDestroyParams.argtypes = [ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_NTRUPrimeDestroyParams.restype = ctypes.c_int64

    _iqr_toolkit.iqr_NTRUPrimeGetPublicKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_NTRUPrimeGetPublicKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_NTRUPrimeGetPrivateKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_NTRUPrimeGetPrivateKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_NTRUPrimeGetCiphertextSize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_NTRUPrimeGetCiphertextSize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_NTRUPrimeGetSharedKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_NTRUPrimeGetSharedKeySize.restype = ctypes.c_int64

    _iqr_toolkit.iqr_NTRUPrimeCreateKeyPair.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                                        ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_NTRUPrimeCreateKeyPair.restype = ctypes.c_int64
    _iqr_toolkit.iqr_NTRUPrimeDestroyPublicKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_NTRUPrimeDestroyPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_NTRUPrimeDestroyPrivateKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_NTRUPrimeDestroyPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_NTRUPrimeExportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_NTRUPrimeExportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_NTRUPrimeExportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_NTRUPrimeExportPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_NTRUPrimeImportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                          ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_NTRUPrimeImportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_NTRUPrimeImportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                           ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_NTRUPrimeImportPrivateKey.restype = ctypes.c_int64

    _iqr_toolkit.iqr_NTRUPrimeEncapsulate.argtypes = [ctypes.c_void_p,  # Public Key
                                                      ctypes.c_void_p,  # RNG
                                                      ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                      ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_NTRUPrimeEncapsulate.restype = ctypes.c_int64
    _iqr_toolkit.iqr_NTRUPrimeDecapsulate.argtypes = [ctypes.c_void_p,  # Private Key
                                                      ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                      ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_NTRUPrimeDecapsulate.restype = ctypes.c_int64

    @staticmethod
    def CreateParams(ctx, variant):
        ''' Create a parameter object for the NTRUPrime cryptographic system.
        '''
        params = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_NTRUPrimeCreateParams(ctx, variant, ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeCreateParams() failed: {0}'.format(Retval.StrError(retval)))

        return params

    @staticmethod
    def DestroyParams(params):
        ''' Clear and deallocate a NTRUPrime parameter object.
        '''
        retval = _iqr_toolkit.iqr_NTRUPrimeDestroyParams(ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeDestroyParams() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def CreateKeyPair(params, rng):
        pub_key = ctypes.c_void_p(0)
        priv_key = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_NTRUPrimeCreateKeyPair(params, rng, ctypes.byref(pub_key), ctypes.byref(priv_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeCreateKeyPair() failed: {0}'.format(Retval.StrError(retval)))

        return pub_key, priv_key

    @staticmethod
    def DestroyPublicKey(pub_key):
        ''' Clear and deallocate a NTRUPrime public key object.
        '''
        retval = _iqr_toolkit.iqr_NTRUPrimeDestroyPublicKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeDestroyPublicKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def DestroyPrivateKey(pub_key):
        ''' Clear and deallocate a NTRUPrime private object.
        '''
        retval = _iqr_toolkit.iqr_NTRUPrimeDestroyPrivateKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeDestroyPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def ExportPublicKey(params, pub_key):
        ''' Export a NTRUPrime public key object to bytes.
        '''
        pub_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_NTRUPrimeGetPublicKeySize(params, ctypes.byref(pub_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeGetPublicKeySize() failed: {0}'.format(Retval.StrError(retval)))

        pub_data = ctypes.create_string_buffer(pub_size.value)

        retval = _iqr_toolkit.iqr_NTRUPrimeExportPublicKey(pub_key, pub_data, pub_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeExportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub_data.raw

    @staticmethod
    def ExportPrivateKey(params, priv_key):
        ''' Export a NTRUPrime private key object to bytes.
        '''
        priv_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_NTRUPrimeGetPrivateKeySize(params, ctypes.byref(priv_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeGetPrivateKeySize() failed: {0}'.format(Retval.StrError(retval)))

        priv_data = ctypes.create_string_buffer(priv_size.value)

        retval = _iqr_toolkit.iqr_NTRUPrimeExportPrivateKey(priv_key, priv_data, priv_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeExportPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv_data.raw

    @staticmethod
    def ImportPublicKey(params, pub_data):
        ''' Import a NTRUPrime public key from bytes.
        '''
        pub = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_NTRUPrimeImportPublicKey(params, pub_data, len(pub_data), ctypes.byref(pub))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub

    @staticmethod
    def ImportPrivateKey(params, priv_data):
        ''' Import a NTRUPrime private key from bytes.
        '''
        priv = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_NTRUPrimeImportPrivateKey(params, priv_data, len(priv_data), ctypes.byref(priv))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv

    @staticmethod
    def Encapsulate(params, pub, rng):
        ''' Create a ciphertext and shared key from the public key.
        '''
        ciphertext_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_NTRUPrimeGetCiphertextSize(params, ctypes.byref(ciphertext_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeGetCiphertextSize() failed: {0}'.format(Retval.StrError(retval)))
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_NTRUPrimeGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        ciphertext = ctypes.create_string_buffer(ciphertext_size.value)
        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_NTRUPrimeEncapsulate(pub, rng, ciphertext, ciphertext_size, shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeEncapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return ciphertext.raw, shared.raw

    @staticmethod
    def Decapsulate(params, priv, ciphertext):
        ''' Extract the shared key from a private key and ciphertext.
        '''
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_NTRUPrimeGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_NTRUPrimeDecapsulate(priv, ciphertext, len(ciphertext), shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_NTRUPrimeDecapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return shared.raw


def test_NTRUPrime():
    ''' Run a simple NTRUPrime test.
    '''
    ctx = Context.Create()

    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA2_512, Hash.IQR_HASH_DEFAULT_SHA2_512)

    rng = Rng.CreateHMACDRBG(ctx, Hash.IQR_HASHALGO_SHA2_512)
    Rng.Initialize(rng, b'this is really bad seed data, never do this')

    params = NTRUPrime.CreateParams(ctx, NTRUPrime.IQR_SNTRUP_653)
    pub, priv = NTRUPrime.CreateKeyPair(params, rng)

    ciphertext, shared = NTRUPrime.Encapsulate(params, pub, rng)
    print('NTRUPrime Encapsulate: {0} bytes'.format(len(shared)))
    shared2 = NTRUPrime.Decapsulate(params, priv, ciphertext)
    print('NTRUPrime Decapsulate: {0} bytes'.format(len(shared2)))

    assert(shared == shared2)

    pub_data = NTRUPrime.ExportPublicKey(params, pub)
    priv_data = NTRUPrime.ExportPrivateKey(params, priv)

    pub2 = NTRUPrime.ImportPublicKey(params, pub_data)
    priv2 = NTRUPrime.ImportPrivateKey(params, priv_data)

    NTRUPrime.DestroyPublicKey(pub)
    NTRUPrime.DestroyPrivateKey(priv)
    NTRUPrime.DestroyPublicKey(pub2)
    NTRUPrime.DestroyPrivateKey(priv2)
    NTRUPrime.DestroyParams(params)

    Rng.Destroy(rng)
    Context.Destroy(ctx)


# ----------------------------------------------------------------------------------------------------------------------------------
# Toolkit return values: iqr_retval.h
# ----------------------------------------------------------------------------------------------------------------------------------
class Retval:
    ''' ISARA toolkit standard return values.

    For signature schemes, IQR_EINVDATA indicates a corrupted signature
    buffer.

    When validating a signature, IQR_EINVSIGNATURE indicates that the signature,
    public key, and message don't match. This could mean that the message has
    been modified, or that the signature has been tampered with, possibly by an
    adversary.
    '''

    IQR_OK = 0  # Success, function completed successfully.

    # General error values.
    IQR_ENULLPTR = -1001  # A NULL pointer was passed in where a valid pointer was expected.
    IQR_ENOMEM = -1002  # Memory allocation failed.
    IQR_ENOTINIT = -1003  # The specified structure is not initialized.
    IQR_EINVBUFSIZE = -1004  # The provided buffer has an invalid size.
    IQR_EBADVALUE = -1005  # The parameter value is not valid.
    IQR_EOUTOFRANGE = -1006  # The parameter value is out of range.
    IQR_EVALUENOTSUPP = -1007  # The parameter value is valid but not supported.
    IQR_EINVOBJECT = -1008  # The object is invalid.
    IQR_EINVCALLBACKS = -1009  # The provided callback pointers are invalid.
    IQR_ENOTREGISTERED = -1010  # Callbacks to an algorithm were not registered prior to use.
    IQR_EINVDATA = -1011  # The provided data is invalid.
    IQR_EINVPTR = -1012  # Output pointer parameters must be initialized to NULL prior to function call.
    IQR_EPTROVERLAP = -1013  # Input and output pointers must not be overlapping buffers.
    IQR_ELIBRARYMISMATCH = -1014  # Library version does not match header version.
    IQR_EINVSTRATEGY = -1015  # The chosen tree strategy cannot be used for this function.
    IQR_EVERSIONMISMATCH = -1016  # The object version does not match the library version.

    # Algorithm error values.
    IQR_EINVALGOSTATE = -2001  # The algorithm state is invalid.
    IQR_EINVHASHALGO = -2002  # The provided hashing algorithm is not valid for this key type.

    # Key error values.
    IQR_EINVPUBLICKEY = -3001  # The public key is invalid.
    IQR_EINVPRIVATEKEY = -3002  # The private key is invalid.
    IQR_EINVSYMKEY = -3003  # The symmetric key is invalid.
    IQR_EKEYPAIRMISMATCH = -3004  # The public key is not derived from the private key.
    IQR_EINVSIGNATURE = -3006  # The signature of the message is invalid.
    IQR_ESTATEDEPLETED = -3007  # The state cannot be used to create more signatures.

    # Random Number Generator error values.
    IQR_ENOTSEEDED = -4001  # The Random Number Generator has not been seeded.
    IQR_ERESEED = -4002  # The Random Number Generator must be reseeded.

    # Crypto error values.
    IQR_EDECRYPTIONFAILED = -5001  # The decryption algorithm failed to decrypt the ciphertext.

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_StrError.argtypes = [ctypes.c_int64]
    _iqr_toolkit.iqr_StrError.restype = ctypes.c_char_p

    @staticmethod
    def StrError(error_value):
        ''' Return a string representation of the given iqr_retval value.
        '''
        return _iqr_toolkit.iqr_StrError(error_value).decode('utf-8')


# ----------------------------------------------------------------------------------------------------------------------------------
# Toolkit random number generators: iqr_rng.h
# ----------------------------------------------------------------------------------------------------------------------------------
class Rng:
    ''' Toolkit random number generators.

    TODO: Providing your own callbacks is not currently supported.
    '''

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_RNGCreateHMACDRBG.argtypes = [ctypes.c_void_p, ctypes.c_int64, ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_RNGCreateHMACDRBG.restype = ctypes.c_int64
    _iqr_toolkit.iqr_RNGDestroy.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_RNGDestroy.restype = ctypes.c_int64

    _iqr_toolkit.iqr_RNGInitialize.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_RNGInitialize.restype = ctypes.c_int64

    @staticmethod
    def CreateHMACDRBG(ctx, hash_algo):
        rng = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_RNGCreateHMACDRBG(ctx, hash_algo, ctypes.byref(rng))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_RNGCreateHMACDRBG() failed: {0}'.format(Retval.StrError(retval)))

        return rng

    @staticmethod
    def Destroy(rng):
        retval = _iqr_toolkit.iqr_RNGDestroy(ctypes.byref(rng))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_RNGDestroy() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def Initialize(rng, seed):
        retval = _iqr_toolkit.iqr_RNGInitialize(rng, seed, len(seed))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_RNGInitialize() failed: {0}'.format(Retval.StrError(retval)))


def test_rng():
    ''' Run a simple RNG test.
    '''
    ctx = Context.Create()

    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA2_256, Hash.IQR_HASH_DEFAULT_SHA2_256)

    rng = Rng.CreateHMACDRBG(ctx, Hash.IQR_HASHALGO_SHA2_256)
    Rng.Initialize(rng, b'this is really bad seed data, never do this')

    Rng.Destroy(rng)
    Context.Destroy(ctx)


# ----------------------------------------------------------------------------------------------------------------------------------
# Saber KEM: iqr_saber.h
# ----------------------------------------------------------------------------------------------------------------------------------
class Saber:
    ''' Saber KEM.
    '''

    IQR_SABER_SHARED_KEY_SIZE = 32  # The size of the shared key produced by Saber in bytes.

    IQR_LIGHT_SABER = _iqr_toolkit.IQR_LIGHT_SABER
    IQR_SABER = _iqr_toolkit.IQR_SABER
    IQR_FIRE_SABER = _iqr_toolkit.IQR_FIRE_SABER

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_SaberCreateParams.argtypes = [ctypes.c_void_p,  # Context
                                                   ctypes.c_void_p,  # RNG
                                                   ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_SaberCreateParams.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SaberDestroyParams.argtypes = [ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_SaberDestroyParams.restype = ctypes.c_int64

    _iqr_toolkit.iqr_SaberGetPublicKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_SaberGetPublicKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SaberGetPrivateKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_SaberGetPrivateKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SaberGetCiphertextSize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_SaberGetCiphertextSize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SaberGetSharedKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_SaberGetSharedKeySize.restype = ctypes.c_int64

    _iqr_toolkit.iqr_SaberCreateKeyPair.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                                    ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SaberCreateKeyPair.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SaberDestroyPublicKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SaberDestroyPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SaberDestroyPrivateKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SaberDestroyPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SaberExportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_SaberExportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SaberExportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_SaberExportPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SaberImportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                      ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SaberImportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SaberImportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                       ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SaberImportPrivateKey.restype = ctypes.c_int64

    _iqr_toolkit.iqr_SaberEncapsulate.argtypes = [ctypes.c_void_p,  # Public Key
                                                  ctypes.c_void_p,  # RNG
                                                  ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                  ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_SaberEncapsulate.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SaberDecapsulate.argtypes = [ctypes.c_void_p,  # Private Key
                                                  ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                  ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_SaberDecapsulate.restype = ctypes.c_int64

    @staticmethod
    def CreateParams(ctx, variant):
        ''' Create a parameter object for the Saber cryptographic system.
        '''
        params = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_SaberCreateParams(ctx, variant, ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberCreateParams() failed: {0}'.format(Retval.StrError(retval)))

        return params

    @staticmethod
    def DestroyParams(params):
        ''' Clear and deallocate a Saber parameter object.
        '''
        retval = _iqr_toolkit.iqr_SaberDestroyParams(ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberDestroyParams() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def CreateKeyPair(params, rng):
        pub_key = ctypes.c_void_p(0)
        priv_key = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_SaberCreateKeyPair(params, rng, ctypes.byref(pub_key), ctypes.byref(priv_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberCreateKeyPair() failed: {0}'.format(Retval.StrError(retval)))

        return pub_key, priv_key

    @staticmethod
    def DestroyPublicKey(pub_key):
        ''' Clear and deallocate a Saber public key object.
        '''
        retval = _iqr_toolkit.iqr_SaberDestroyPublicKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberDestroyPublicKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def DestroyPrivateKey(pub_key):
        ''' Clear and deallocate a Saber private object.
        '''
        retval = _iqr_toolkit.iqr_SaberDestroyPrivateKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberDestroyPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def ExportPublicKey(params, pub_key):
        ''' Export a Saber public key object to bytes.
        '''
        pub_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SaberGetPublicKeySize(params, ctypes.byref(pub_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberGetPublicKeySize() failed: {0}'.format(Retval.StrError(retval)))

        pub_data = ctypes.create_string_buffer(pub_size.value)

        retval = _iqr_toolkit.iqr_SaberExportPublicKey(pub_key, pub_data, pub_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberExportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub_data.raw

    @staticmethod
    def ExportPrivateKey(params, priv_key):
        ''' Export a Saber private key object to bytes.
        '''
        priv_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SaberGetPrivateKeySize(params, ctypes.byref(priv_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberGetPrivateKeySize() failed: {0}'.format(Retval.StrError(retval)))

        priv_data = ctypes.create_string_buffer(priv_size.value)

        retval = _iqr_toolkit.iqr_SaberExportPrivateKey(priv_key, priv_data, priv_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberExportPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv_data.raw

    @staticmethod
    def ImportPublicKey(params, pub_data):
        ''' Import a Saber public key from bytes.
        '''
        pub = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_SaberImportPublicKey(params, pub_data, len(pub_data), ctypes.byref(pub))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub

    @staticmethod
    def ImportPrivateKey(params, priv_data):
        ''' Import a Saber private key from bytes.
        '''
        priv = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_SaberImportPrivateKey(params, priv_data, len(priv_data), ctypes.byref(priv))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv

    @staticmethod
    def Encapsulate(params, pub, rng):
        ''' Create a ciphertext and shared key from the public key.
        '''
        ciphertext_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SaberGetCiphertextSize(params, ctypes.byref(ciphertext_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberGetCiphertextSize() failed: {0}'.format(Retval.StrError(retval)))
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SaberGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        ciphertext = ctypes.create_string_buffer(ciphertext_size.value)
        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_SaberEncapsulate(pub, rng, ciphertext, ciphertext_size, shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberEncapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return ciphertext.raw, shared.raw

    @staticmethod
    def Decapsulate(params, priv, ciphertext):
        ''' Extract the shared key from a private key and ciphertext.
        '''
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SaberGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_SaberDecapsulate(priv, ciphertext, len(ciphertext), shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SaberDecapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return shared.raw


def test_Saber():
    ''' Run a simple Saber test.
    '''
    ctx = Context.Create()

    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA3_256, Hash.IQR_HASH_DEFAULT_SHA3_256)
    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA3_512, Hash.IQR_HASH_DEFAULT_SHA3_512)

    rng = Rng.CreateHMACDRBG(ctx, Hash.IQR_HASHALGO_SHA3_256)
    Rng.Initialize(rng, b'this is really bad seed data, never do this')

    params = Saber.CreateParams(ctx, Saber.IQR_LIGHT_SABER)
    pub, priv = Saber.CreateKeyPair(params, rng)

    ciphertext, shared = Saber.Encapsulate(params, pub, rng)
    print('Saber Encapsulate: {0} bytes'.format(len(shared)))
    shared2 = Saber.Decapsulate(params, priv, ciphertext)
    print('Saber Decapsulate: {0} bytes'.format(len(shared2)))

    assert(shared == shared2)

    pub_data = Saber.ExportPublicKey(params, pub)
    priv_data = Saber.ExportPrivateKey(params, priv)

    pub2 = Saber.ImportPublicKey(params, pub_data)
    priv2 = Saber.ImportPrivateKey(params, priv_data)

    Saber.DestroyPublicKey(pub)
    Saber.DestroyPrivateKey(priv)
    Saber.DestroyPublicKey(pub2)
    Saber.DestroyPrivateKey(priv2)
    Saber.DestroyParams(params)

    Rng.Destroy(rng)
    Context.Destroy(ctx)


# ----------------------------------------------------------------------------------------------------------------------------------
# SIKE KEM: iqr_sike.h
# ----------------------------------------------------------------------------------------------------------------------------------
class SIKE:
    ''' SIKE KEM.
    '''

    IQR_SIKE_P434 = _iqr_toolkit.IQR_SIKE_P434
    IQR_SIKE_P503 = _iqr_toolkit.IQR_SIKE_P503
    IQR_SIKE_P610 = _iqr_toolkit.IQR_SIKE_P610
    IQR_SIKE_P751 = _iqr_toolkit.IQR_SIKE_P751

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_SIKECreateParams.argtypes = [ctypes.c_void_p,  # Context
                                                  ctypes.c_void_p,  # RNG
                                                  ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_SIKECreateParams.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SIKEDestroyParams.argtypes = [ctypes.POINTER(ctypes.c_void_p)]  # params
    _iqr_toolkit.iqr_SIKEDestroyParams.restype = ctypes.c_int64

    _iqr_toolkit.iqr_SIKEGetPublicKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_SIKEGetPublicKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SIKEGetPrivateKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_SIKEGetPrivateKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SIKEGetCiphertextSize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_SIKEGetCiphertextSize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SIKEGetSharedKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_SIKEGetSharedKeySize.restype = ctypes.c_int64

    _iqr_toolkit.iqr_SIKECreateKeyPair.argtypes = [ctypes.c_void_p, ctypes.c_void_p,
                                                   ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SIKECreateKeyPair.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SIKEDestroyPublicKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SIKEDestroyPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SIKEDestroyPrivateKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SIKEDestroyPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SIKEExportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_SIKEExportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SIKEExportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_SIKEExportPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SIKEImportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                     ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SIKEImportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SIKEImportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                      ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SIKEImportPrivateKey.restype = ctypes.c_int64

    _iqr_toolkit.iqr_SIKEEncapsulate.argtypes = [ctypes.c_void_p,  # Public Key
                                                 ctypes.c_void_p,  # RNG
                                                 ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                 ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_SIKEEncapsulate.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SIKEDecapsulate.argtypes = [ctypes.c_void_p,  # Private Key
                                                 ctypes.c_void_p, ctypes.c_size_t,  # Ciphertext
                                                 ctypes.c_void_p, ctypes.c_size_t]  # Shared Key
    _iqr_toolkit.iqr_SIKEDecapsulate.restype = ctypes.c_int64

    @staticmethod
    def CreateParams(ctx, variant):
        ''' Create a parameter object for the SIKE cryptographic system.
        '''
        params = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_SIKECreateParams(ctx, variant, ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKECreateParams() failed: {0}'.format(Retval.StrError(retval)))

        return params

    @staticmethod
    def DestroyParams(params):
        ''' Clear and deallocate a SIKE parameter object.
        '''
        retval = _iqr_toolkit.iqr_SIKEDestroyParams(ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEDestroyParams() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def CreateKeyPair(params, rng):
        pub_key = ctypes.c_void_p(0)
        priv_key = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_SIKECreateKeyPair(params, rng, ctypes.byref(pub_key), ctypes.byref(priv_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKECreateKeyPair() failed: {0}'.format(Retval.StrError(retval)))

        return pub_key, priv_key

    @staticmethod
    def DestroyPublicKey(pub_key):
        ''' Clear and deallocate a SIKE public key object.
        '''
        retval = _iqr_toolkit.iqr_SIKEDestroyPublicKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEDestroyPublicKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def DestroyPrivateKey(pub_key):
        ''' Clear and deallocate a SIKE private object.
        '''
        retval = _iqr_toolkit.iqr_SIKEDestroyPrivateKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEDestroyPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def ExportPublicKey(params, pub_key):
        ''' Export a SIKE public key object to bytes.
        '''
        pub_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SIKEGetPublicKeySize(params, ctypes.byref(pub_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEGetPublicKeySize() failed: {0}'.format(Retval.StrError(retval)))

        pub_data = ctypes.create_string_buffer(pub_size.value)

        retval = _iqr_toolkit.iqr_SIKEExportPublicKey(pub_key, pub_data, pub_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEExportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub_data.raw

    @staticmethod
    def ExportPrivateKey(params, priv_key):
        ''' Export a SIKE private key object to bytes.
        '''
        priv_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SIKEGetPrivateKeySize(params, ctypes.byref(priv_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEGetPrivateKeySize() failed: {0}'.format(Retval.StrError(retval)))

        priv_data = ctypes.create_string_buffer(priv_size.value)

        retval = _iqr_toolkit.iqr_SIKEExportPrivateKey(priv_key, priv_data, priv_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEExportPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv_data.raw

    @staticmethod
    def ImportPublicKey(params, pub_data):
        ''' Import a SIKE public key from bytes.
        '''
        pub = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_SIKEImportPublicKey(params, pub_data, len(pub_data), ctypes.byref(pub))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub

    @staticmethod
    def ImportPrivateKey(params, priv_data):
        ''' Import a SIKE private key from bytes.
        '''
        priv = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_SIKEImportPrivateKey(params, priv_data, len(priv_data), ctypes.byref(priv))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv

    @staticmethod
    def Encapsulate(params, pub, rng):
        ''' Create a ciphertext and shared key from the public key.
        '''
        ciphertext_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SIKEGetCiphertextSize(params, ctypes.byref(ciphertext_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEGetCiphertextSize() failed: {0}'.format(Retval.StrError(retval)))
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SIKEGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        ciphertext = ctypes.create_string_buffer(ciphertext_size.value)
        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_SIKEEncapsulate(pub, rng, ciphertext, ciphertext_size, shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEEncapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return ciphertext.raw, shared.raw

    @staticmethod
    def Decapsulate(params, priv, ciphertext):
        ''' Extract the shared key from a private key and ciphertext.
        '''
        shared_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SIKEGetSharedKeySize(params, ctypes.byref(shared_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEGetSharedKeySize() failed: {0}'.format(Retval.StrError(retval)))

        shared = ctypes.create_string_buffer(shared_size.value)

        retval = _iqr_toolkit.iqr_SIKEDecapsulate(priv, ciphertext, len(ciphertext), shared, shared_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SIKEDecapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return shared.raw


def test_SIKE():
    ''' Run a simple SIKE test.
    '''
    ctx = Context.Create()

    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA3_256, Hash.IQR_HASH_DEFAULT_SHA3_256)

    rng = Rng.CreateHMACDRBG(ctx, Hash.IQR_HASHALGO_SHA3_256)
    Rng.Initialize(rng, b'this is really bad seed data, never do this')

    params = SIKE.CreateParams(ctx, SIKE.IQR_SIKE_P434)
    pub, priv = SIKE.CreateKeyPair(params, rng)

    ciphertext, shared = SIKE.Encapsulate(params, pub, rng)
    print('SIKE Encapsulate: {0} bytes'.format(len(shared)))
    shared2 = SIKE.Decapsulate(params, priv, ciphertext)
    print('SIKE Decapsulate: {0} bytes'.format(len(shared2)))

    assert(shared == shared2)

    pub_data = SIKE.ExportPublicKey(params, pub)
    priv_data = SIKE.ExportPrivateKey(params, priv)

    pub2 = SIKE.ImportPublicKey(params, pub_data)
    priv2 = SIKE.ImportPrivateKey(params, priv_data)

    SIKE.DestroyPublicKey(pub)
    SIKE.DestroyPrivateKey(priv)
    SIKE.DestroyPublicKey(pub2)
    SIKE.DestroyPrivateKey(priv2)
    SIKE.DestroyParams(params)

    Rng.Destroy(rng)
    Context.Destroy(ctx)


# ----------------------------------------------------------------------------------------------------------------------------------
# Toolkit SPHICS+ signatures: iqr_sphincs.h
# ----------------------------------------------------------------------------------------------------------------------------------
class SPHINCS:
    ''' SPHINCS signature scheme.
    '''

    IQR_SPHINCS_SHA2_256_128F = _iqr_toolkit.IQR_SPHINCS_SHA2_256_128F  # Using SHA-256, fast variant with 128-bit security.
    IQR_SPHINCS_SHA2_256_128S = _iqr_toolkit.IQR_SPHINCS_SHA2_256_128S  # using SHA-256, small variant with 128-bit security.
    IQR_SPHINCS_SHAKE_256_128F = _iqr_toolkit.IQR_SPHINCS_SHAKE_256_128F  # using SHAKE-256, fast variant with 128-bit security.
    IQR_SPHINCS_SHAKE_256_128S = _iqr_toolkit.IQR_SPHINCS_SHAKE_256_128S  # using SHAKE-256, small variant with 128-bit security.
    IQR_SPHINCS_SHA2_256_192F = _iqr_toolkit.IQR_SPHINCS_SHA2_256_192F  # using SHA-256, fast variant with 192-bit security.
    IQR_SPHINCS_SHA2_256_192S = _iqr_toolkit.IQR_SPHINCS_SHA2_256_192S  # using SHA-256, small variant with 192-bit security.
    IQR_SPHINCS_SHAKE_256_192F = _iqr_toolkit.IQR_SPHINCS_SHAKE_256_192F  # using SHAKE-256, fast variant with 192-bit security.
    IQR_SPHINCS_SHAKE_256_192S = _iqr_toolkit.IQR_SPHINCS_SHAKE_256_192S  # using SHAKE-256, small variant with 192-bit security.
    IQR_SPHINCS_SHA2_256_256F = _iqr_toolkit.IQR_SPHINCS_SHA2_256_256F  # using SHA-256, fast variant with 256-bit security.
    IQR_SPHINCS_SHA2_256_256S = _iqr_toolkit.IQR_SPHINCS_SHA2_256_256S  # using SHA-256, small variant with 256-bit security.
    IQR_SPHINCS_SHAKE_256_256F = _iqr_toolkit.IQR_SPHINCS_SHAKE_256_256F  # using SHAKE-256, fast variant with 256-bit security.
    IQR_SPHINCS_SHAKE_256_256S = _iqr_toolkit.IQR_SPHINCS_SHAKE_256_256S  # using SHAKE-256, small variant with 256-bit security.

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_SPHINCSCreateParams.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SPHINCSCreateParams.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SPHINCSDestroyParams.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SPHINCSDestroyParams.restype = ctypes.c_int64

    _iqr_toolkit.iqr_SPHINCSCreateKeyPair.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_void_p),
                                                      ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SPHINCSCreateKeyPair.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SPHINCSImportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                        ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SPHINCSImportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SPHINCSImportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                                         ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SPHINCSImportPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SPHINCSExportPublicKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_SPHINCSExportPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SPHINCSExportPrivateKey.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_SPHINCSExportPrivateKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SPHINCSDestroyPublicKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SPHINCSDestroyPublicKey.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SPHINCSDestroyPrivateKey.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
    _iqr_toolkit.iqr_SPHINCSDestroyPrivateKey.restype = ctypes.c_int64

    _iqr_toolkit.iqr_SPHINCSGetPublicKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_SPHINCSGetPublicKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SPHINCSGetPrivateKeySize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_SPHINCSGetPrivateKeySize.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SPHINCSGetSignatureSize.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_size_t)]
    _iqr_toolkit.iqr_SPHINCSGetSignatureSize.restype = ctypes.c_int64

    _iqr_toolkit.iqr_SPHINCSSign.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                             ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_SPHINCSSign.restype = ctypes.c_int64
    _iqr_toolkit.iqr_SPHINCSVerify.argtypes = [ctypes.c_void_p, ctypes.c_void_p, ctypes.c_size_t,
                                               ctypes.c_void_p, ctypes.c_size_t]
    _iqr_toolkit.iqr_SPHINCSVerify.restype = ctypes.c_int64

    @staticmethod
    def CreateParams(ctx, variant):
        ''' Create a parameter object for the SPHINCS cryptographic system.
        '''
        params = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_SPHINCSCreateParams(ctx, variant, ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSCreateParams() failed: {0}'.format(Retval.StrError(retval)))

        return params

    @staticmethod
    def DestroyParams(params):
        ''' Clear and deallocate a SPHINCS parameter object.
        '''
        retval = _iqr_toolkit.iqr_SPHINCSDestroyParams(ctypes.byref(params))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSDestroyParams() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def CreateKeyPair(params, rng):
        pub_key = ctypes.c_void_p(0)
        priv_key = ctypes.c_void_p(0)

        retval = _iqr_toolkit.iqr_SPHINCSCreateKeyPair(params, rng, ctypes.byref(pub_key), ctypes.byref(priv_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSCreateKeyPair() failed: {0}'.format(Retval.StrError(retval)))

        return pub_key, priv_key

    @staticmethod
    def DestroyPublicKey(pub_key):
        ''' Clear and deallocate a SPHINCS public key object.
        '''
        retval = _iqr_toolkit.iqr_SPHINCSDestroyPublicKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSDestroyPublicKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def DestroyPrivateKey(pub_key):
        ''' Clear and deallocate a SPHINCS private object.
        '''
        retval = _iqr_toolkit.iqr_SPHINCSDestroyPrivateKey(ctypes.byref(pub_key))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSDestroyPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

    @staticmethod
    def ExportPublicKey(params, pub_key):
        ''' Export a SPHINCS public key object to bytes.
        '''
        pub_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SPHINCSGetPublicKeySize(params, ctypes.byref(pub_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSGetPublicKeySize() failed: {0}'.format(Retval.StrError(retval)))

        pub_data = ctypes.create_string_buffer(pub_size.value)

        retval = _iqr_toolkit.iqr_SPHINCSExportPublicKey(pub_key, pub_data, pub_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSExportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub_data.raw

    @staticmethod
    def ExportPrivateKey(params, priv_key):
        ''' Export a SPHINCS private key object to bytes.
        '''
        priv_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SPHINCSGetPrivateKeySize(params, ctypes.byref(priv_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSGetPrivateKeySize() failed: {0}'.format(Retval.StrError(retval)))

        priv_data = ctypes.create_string_buffer(priv_size.value)

        retval = _iqr_toolkit.iqr_SPHINCSExportPrivateKey(priv_key, priv_data, priv_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSExportPrivateKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv_data.raw

    @staticmethod
    def ImportPublicKey(params, pub_data):
        ''' Import a SPHINCS public key from bytes.
        '''
        pub = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_SPHINCSImportPublicKey(params, pub_data, len(pub_data), ctypes.byref(pub))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return pub

    @staticmethod
    def ImportPrivateKey(params, priv_data):
        ''' Import a SPHINCS private key from bytes.
        '''
        priv = ctypes.c_void_p(0)
        retval = _iqr_toolkit.iqr_SPHINCSImportPrivateKey(params, priv_data, len(priv_data), ctypes.byref(priv))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSImportPublicKey() failed: {0}'.format(Retval.StrError(retval)))

        return priv

    @staticmethod
    def Sign(params, priv, rng, msg):
        ''' Create a signature from the given private key and message.
        '''
        sig_size = ctypes.c_size_t(0)
        retval = _iqr_toolkit.iqr_SPHINCSGetSignatureSize(params, ctypes.byref(sig_size))
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSGetSignatureSize() failed: {0}'.format(Retval.StrError(retval)))

        sig = ctypes.create_string_buffer(sig_size.value)

        retval = _iqr_toolkit.iqr_SPHINCSSign(priv, rng, msg, len(msg), sig, sig_size)
        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_SPHINCSSign() failed: {0}'.format(Retval.StrError(retval)))

        return sig.raw

    @staticmethod
    def Verify(pub, msg, sig):
        ''' Verify a signature.
        '''
        retval = _iqr_toolkit.iqr_SPHINCSVerify(pub, msg, len(msg), sig, len(sig))
        if retval == Retval.IQR_EINVSIGNATURE:
            return False
        elif retval != Retval.IQR_OK:
            raise RuntimeError('iqr_ClassicMcElieceDecapsulate() failed: {0}'.format(Retval.StrError(retval)))

        return True


def test_SPHINCS():
    ''' Run a simple SPHINCS test.
    '''
    ctx = Context.Create()

    Hash.RegisterCallbacks(ctx, Hash.IQR_HASHALGO_SHA2_256, Hash.IQR_HASH_DEFAULT_SHA2_256)

    rng = Rng.CreateHMACDRBG(ctx, Hash.IQR_HASHALGO_SHA2_256)
    Rng.Initialize(rng, b'this is really bad seed data, never do this')

    params = SPHINCS.CreateParams(ctx, SPHINCS.IQR_SPHINCS_SHA2_256_128F)
    pub, priv = SPHINCS.CreateKeyPair(params, rng)

    msg = b'This is a short message for signing.'
    sig = SPHINCS.Sign(params, priv, rng, msg)
    print('SPHINCS signature: {0} bytes'.format(len(sig)))
    valid = SPHINCS.Verify(pub, msg, sig)
    print('           verified: {0}'.format(valid))

    pub_data = SPHINCS.ExportPublicKey(params, pub)
    priv_data = SPHINCS.ExportPrivateKey(params, priv)

    pub2 = SPHINCS.ImportPublicKey(params, pub_data)
    priv2 = SPHINCS.ImportPrivateKey(params, priv_data)

    SPHINCS.DestroyPublicKey(pub)
    SPHINCS.DestroyPrivateKey(priv)
    SPHINCS.DestroyPublicKey(pub2)
    SPHINCS.DestroyPrivateKey(priv2)
    SPHINCS.DestroyParams(params)

    Rng.Destroy(rng)
    Context.Destroy(ctx)


# ----------------------------------------------------------------------------------------------------------------------------------
# Toolkit return values: iqr_version.h
# ----------------------------------------------------------------------------------------------------------------------------------
class Version:
    ''' ISARA toolkit version information.
    '''

    IQR_VERSION_MAJOR = 2  # Major version number.
    IQR_VERSION_MINOR = 1  # Minor version number.

    IQR_VERSION_STRING = "ISARA Radiate Quantum-Safe Library 3.0"

    # Type hints for calling into the C library.
    _iqr_toolkit.iqr_VersionCheck.argtypes = [ctypes.c_uint32, ctypes.c_uint32]
    _iqr_toolkit.iqr_VersionCheck.restype = ctypes.c_int32

    _iqr_toolkit.iqr_VersionGetBuildTarget.argtypes = [ctypes.POINTER(ctypes.c_char_p)]
    _iqr_toolkit.iqr_VersionGetBuildTarget.restype = ctypes.c_uint64

    _iqr_toolkit.iqr_VersionGetBuildHash.argtypes = [ctypes.POINTER(ctypes.c_char_p)]
    _iqr_toolkit.iqr_VersionGetBuildHash.restype = ctypes.c_uint64

    @staticmethod
    def Check(major_version, minor_version):
        ''' Does the library's version match major_version.minor_version?
        '''
        return _iqr_toolkit.iqr_VersionCheck(major_version, minor_version)

    @staticmethod
    def GetBuildTarget():
        ''' Get the library build information.
        '''
        target = ctypes.c_char_p(0)  # NULL
        retval = _iqr_toolkit.iqr_VersionGetBuildTarget(ctypes.byref(target))

        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_VersionGetBuildTarget() failed: {0}'.format(Retval.StrError(retval)))

        return target.value.decode('utf-8')

    @staticmethod
    def GetBuildHash():
        ''' Get the library build hash.
        '''
        build = ctypes.c_char_p(0)  # NULL
        retval = _iqr_toolkit.iqr_VersionGetBuildHash(ctypes.byref(build))

        if retval != Retval.IQR_OK:
            raise RuntimeError('iqr_VersionGetBuildHash() failed: {0}'.format(Retval.StrError(retval)))

        return build.value.decode('utf-8')


if __name__ == '__main__':
    # Run me via python3 iqr_toolkit.py
    print(Version.IQR_VERSION_STRING)
    print('Build target: {0}'.format(Version.GetBuildTarget()))
    print('Build hash: {0}'.format(Version.GetBuildHash()))

    # Building blocks. If these don't work, you're in trouble.
    test_chacha20()
    test_hash()
    test_rng()

    # KEMs
    test_ClassicMcEliece()
    test_FrodoKEM()
    test_Kyber()
    test_NTRUPrime()
    test_Saber()
    test_SIKE()

    # Signatures
    test_Dilithium()
    test_SPHINCS()