diff --git a/.gitmodules b/.gitmodules
index 778e626b0812674c6b091cc019869531a26f7dd6..fe53832bfa940bcf97fc3eb099cb09442cb0909b 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,9 +1,6 @@
[submodule "libdap-crypto"]
path = libdap-crypto
- url = https://github.com/cellframe/libdap-crypto.git
+ url = https://gitlab.demlabs.net/cellframe/libdap-crypto.git
[submodule "libdap"]
path = libdap
- url = https://github.com/cellframe/libdap.git
-[submodule "test/libdap-python"]
- path = test/libdap-python
- url = https://github.com/cellframe/libdap-python.git
+ url = https://gitlab.demlabs.net/cellframe/libdap.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
index bfceb387b4773c304c1c11d3cdeaa27dedfa33ac..7ca566b3e5fa53f39d0dbcc11868a1e32e44c700 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,21 +4,28 @@ cmake_minimum_required(VERSION 2.8)
set(CMAKE_VERBOSE_MAKEFILE ON)
set(CMAKE_COLOR_MAKEFILE ON)
set(CMAKE_C_STANDARD 11)
-set(SUBMODULES_NO_BUILD ON)
-
-add_subdirectory(libdap)
+#set(SUBMODULES_NO_BUILD ON)
+add_definitions("-fpic")
+
+if(NOT (${SUBMODULES_NO_BUILD} MATCHES ON))
+ if (NOT (TARGET dap_core))
+ add_subdirectory(libdap)
+ target_compile_options(
+ dap_core PRIVATE
+ "-fpic"
+ )
+ endif()
+endif()
add_subdirectory(libdap-crypto)
-file(GLOB CRYPTO_SRCS src/*.c)
-file(GLOB CRYPTO_HEADERS include/*.h)
+file(GLOB CRYPTO_PYTHON_SRCS src/*.c)
+file(GLOB CRYPTO_PYTHON_HEADERS include/*.h)
set(Python_ADDITIONAL_VERSIONS 3.7)
find_package (PythonLibs REQUIRED)
-#find_package(PkgConfig)
-#pkg_check_modules(PC_JSON-C REQUIRED json-c)
include_directories(${PYTHON_INCLUDE_DIR} include/)
-add_library(${PROJECT_NAME} SHARED ${CRYPTO_SRCS} ${CRYPTO_HEADERS})
+add_library(${PROJECT_NAME} STATIC ${CRYPTO_PYTHON_SRCS} ${CRYPTO_PYTHON_HEADERS})
target_link_libraries(${PROJECT_NAME})
@@ -34,8 +41,21 @@ target_compile_options(
target_link_libraries(${PROJECT_NAME} dap_core dap_crypto)
-#if(BUILD_DAP_PYTHON_TESTS)
-# add_subdirectory(test)
-# enable_testing()
-#endif()
+target_include_directories(${PROJECT_NAME} PUBLIC include/ )
+
+if(BUILD_DAP_CRYPTO_PYTHON_TESTS)
+ add_subdirectory(test)
+ file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test/test_b58.py
+ DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test/)
+ file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test/test_b64.py
+ DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test/)
+ file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test/test_iaes256_cbc.py
+ DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test/)
+ file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test/test_iaes256_cbc.py
+ DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test/)
+ file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/test/test_oaes.py
+ DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test/)
+
+
+endif()
diff --git a/README.md b/README.md
index 8220e1450a0c399cd8b1e760b5868390d176a59e..160dbc91a99d3aba423ef9a16bf4c9fb9d9f1e1c 100644
--- a/README.md
+++ b/README.md
@@ -7,12 +7,9 @@ libdap-crypto python binding
```
mkdir build
cd build
-cmake ../
+cmake -BUILD_DAP_CRYPTO_PYTHON_TESTS=ON ../
make
-cp ../test/test_b58.py ./
-cp ../test/test_b64.py ./
-cp ../test/test_iaes256_cbc.py ./
-cp ../test/test_oaes.py ./
+cd test
python3.7 test_b58.py
python3.7 test_b64.py
python3.7 test_iaes256_cbc.py
diff --git a/include/key_list.h b/include/key_list.h
deleted file mode 100644
index 2159cb9fe6b7d6d50159a19c3586a7b684087357..0000000000000000000000000000000000000000
--- a/include/key_list.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef KEY_LIST_H
-#define KEY_LIST_H
-
-
-#include "dap_common.h"
-#include "dap_enc_key.h"
-#include <stdint.h>
-#include <string.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#undef LOG_TAG
-#define LOG_TAG "key-list"
-
-typedef struct key_list{
- dap_enc_key_t **keys;
- uint8_t lenght;
-}key_list_t;
-
-key_list_t *key_list_init(void);
-void key_list_free(key_list_t* list);
-uint8_t key_list_add_element(key_list_t *list, dap_enc_key_t* key);
-bool key_list_del_element(key_list_t *list, uint8_t key);
-dap_enc_key_t *key_list_get_key(key_list_t *list, uint8_t key);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/include/libdap-crypto-python.h b/include/libdap-crypto-python.h
index d08e40119a00b1061d1787c4566849207c02d3b8..e9027124994509bea803f59e30d24101d71f5d65 100644
--- a/include/libdap-crypto-python.h
+++ b/include/libdap-crypto-python.h
@@ -16,58 +16,84 @@ extern "C" {
#undef LOG_TAG
#define LOG_TAG "libdap-python-crypto"
-static PyObject *dap_crypto_init(PyObject *self, PyObject *args);
+typedef struct PyCrypto{
+ PyObject_HEAD
+}PyCryptoObject;
-static PyObject *dap_crypto_deinit();
+int dap_crypto_init(void);
-static PyObject *dap_log_it_debug(PyObject *self, PyObject *args);
+void dap_crypto_deinit(void);
-static PyObject *dap_log_it_info(PyObject *self, PyObject *args);
-
-static PyMethodDef DapCryptoMethods[] = {
- {"init", dap_crypto_init, METH_VARARGS, "Initialization of the DAP (Deus Applicaions Prototypes) crypto library"},
- {"deinit", dap_crypto_deinit, METH_NOARGS, "Deinitialization of the DAP (Deus Applicaions Prototypes) crypto library"},
- {"encodeBase58", dap_encode_base58_py, METH_VARARGS, "Encrypts information using the base58 algorithm from the DAP crypto library"},
- {"decodeBase58", dap_decode_base58_py, METH_VARARGS, "Dencrypts information using the base58 algorithm from the DAP crypto library"},
- {"encodeBase64", dap_encode_base64_py, METH_VARARGS, "Encrypts information using the base64 algorithm from the DAP crypto library"},
- {"decodeBase64", dap_decode_base64_py, METH_VARARGS, "Dencrypts information using the base64 algorithm from the DAP crypto library"},
- {"logItDebug", dap_log_it_debug, METH_VARARGS, ""},
- {"logItInfo", dap_log_it_info, METH_VARARGS, ""},
- {"newKey", dap_enc_key_new_py, METH_VARARGS, "The function creates a new key, and returns it with PyObject."},
- {"delKey", dap_enc_key_delete_py, METH_VARARGS, ""},
- {"generateNewKey", dap_enc_key_new_generate_py, METH_VARARGS, ""},
- {"getEncSizeKey", dap_enc_key_get_enc_size_py, METH_VARARGS, ""},
- {"getDecSizeKey", dap_enc_key_get_dec_size_py, METH_VARARGS, ""},
+static PyMethodDef CryptoMethods[] = {
+ {"encodeBase58", dap_encode_base58_py, METH_VARARGS | METH_STATIC, "Encrypts information using the base58 algorithm from the DAP crypto library"},
+ {"decodeBase58", dap_decode_base58_py, METH_VARARGS | METH_STATIC, "Dencrypts information using the base58 algorithm from the DAP crypto library"},
+ {"encodeBase64", dap_encode_base64_py, METH_VARARGS | METH_STATIC, "Encrypts information using the base64 algorithm from the DAP crypto library"},
+ {"decodeBase64", dap_decode_base64_py, METH_VARARGS | METH_STATIC, "Dencrypts information using the base64 algorithm from the DAP crypto library"},
+ {"newKey", dap_enc_key_new_py, METH_VARARGS | METH_STATIC, "The function creates a new key, and returns it with PyObject."},
+ {"generateNewKey", dap_enc_key_new_generate_py, METH_VARARGS | METH_STATIC, ""},
+ {"getEncSizeKey", dap_enc_key_get_enc_size_py, METH_VARARGS | METH_STATIC, ""},
+ {"getDecSizeKey", dap_enc_key_get_dec_size_py, METH_VARARGS | METH_STATIC, ""},
/*IAES256*/
- {"newKeyIAES", dap_enc_iaes_key_new_py, METH_VARARGS, ""},
- {"deleteKeyIAES", dap_enc_iaes_key_delete_py, METH_VARARGS, ""},
- {"generateKeyIAES", dap_enc_iaes_key_generate_py, METH_VARARGS, ""},
- {"encodeSizeIAES256", dap_enc_iaes256_calc_encode_size_py, METH_VARARGS, ""},
- {"decodeSizeIAES256", dap_enc_iaes256_calc_decode_size_py, METH_VARARGS, ""},
- {"encryptIAES256CBCFast", dap_enc_iaes256_cbc_encrypt_fast_py, METH_VARARGS, ""},
- {"decryptIAES256CBCFast", dap_enc_iaes256_cbc_decrypt_fast_py, METH_VARARGS, ""},
+ {"newKeyIAES", dap_enc_iaes_key_new_py, METH_VARARGS | METH_STATIC, ""},
+ {"deleteKeyIAES", dap_enc_iaes_key_delete_py, METH_VARARGS | METH_STATIC, ""},
+ {"generateKeyIAES", dap_enc_iaes_key_generate_py, METH_VARARGS | METH_STATIC, ""},
+ {"encodeSizeIAES256", dap_enc_iaes256_calc_encode_size_py, METH_VARARGS | METH_STATIC, ""},
+ {"decodeSizeIAES256", dap_enc_iaes256_calc_decode_size_py, METH_VARARGS | METH_STATIC, ""},
+ {"encryptIAES256CBCFast", dap_enc_iaes256_cbc_encrypt_fast_py, METH_VARARGS | METH_STATIC, ""},
+ {"decryptIAES256CBCFast", dap_enc_iaes256_cbc_decrypt_fast_py, METH_VARARGS | METH_STATIC, ""},
/*OAES*/
- {"newKeyOAES", dap_enc_oaes_key_new_py, METH_VARARGS, ""},
- {"deleteKeyOAES", dap_enc_oaes_key_delete_py, METH_VARARGS, ""},
- {"generateKeyOAES", dap_enc_oaes_key_generate_py, METH_VARARGS, ""},
- {"encodeSizeOAES", dap_enc_oaes_calc_encode_size_py, METH_VARARGS, ""},
- {"decodeSizeOAES", dap_enc_oaes_calc_decode_size_py, METH_VARARGS, ""},
- {"encryptOAESFast", dap_enc_oaes_encrypt_fast_py, METH_VARARGS, ""},
- {"decryptOAESFast", dap_enc_oaes_decrypt_fast_py, METH_VARARGS, ""},
+ {"newKeyOAES", dap_enc_oaes_key_new_py, METH_VARARGS | METH_STATIC, ""},
+ {"deleteKeyOAES", dap_enc_oaes_key_delete_py, METH_VARARGS | METH_STATIC, ""},
+ {"generateKeyOAES", dap_enc_oaes_key_generate_py, METH_VARARGS | METH_STATIC, ""},
+ {"encodeSizeOAES", dap_enc_oaes_calc_encode_size_py, METH_VARARGS | METH_STATIC, ""},
+ {"decodeSizeOAES", dap_enc_oaes_calc_decode_size_py, METH_VARARGS | METH_STATIC, ""},
+ {"encryptOAESFast", dap_enc_oaes_encrypt_fast_py, METH_VARARGS | METH_STATIC, ""},
+ {"decryptOAESFast", dap_enc_oaes_decrypt_fast_py, METH_VARARGS | METH_STATIC, ""},
{NULL, NULL, 0, NULL}
};
-static struct PyModuleDef dapcryptomodule = {
- PyModuleDef_HEAD_INIT,
- "libdap_crypto_python_module", /* name of module */
- NULL, /* module documentation, may be NULL */
- -1, /* size of per-interpreter state of the module,
- or -1 if the module keeps state in global variables. */
- DapCryptoMethods
+static PyTypeObject dapCrypto_dapCryptoType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "CellFrame.Crypto", /* tp_name */
+ sizeof(PyCryptoObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_reserved */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
+ "Crypto objects", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ CryptoMethods, /* tp_methods */
+ 0, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0, /* tp_init */
+ 0, /* tp_alloc */
+ PyType_GenericNew, /* tp_new */
};
-PyMODINIT_FUNC PyInit_libdap_crypto_python_module(void);
-
#ifdef __cplusplus
}
#endif
diff --git a/include/libdap_crypto_data_type.h b/include/libdap_crypto_data_type.h
new file mode 100644
index 0000000000000000000000000000000000000000..1a84d90389a7ed7c388ece6b5045f8a5ebae2417
--- /dev/null
+++ b/include/libdap_crypto_data_type.h
@@ -0,0 +1,74 @@
+#include "Python.h"
+#include "dap_enc_key.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct PyCryptoDataType{
+ PyObject_HEAD
+}PyCryptoDataTypeObjecy;
+
+static PyObject *get_ENC_DATA_TYPE_RAW(){
+ return PyLong_FromLong(DAP_ENC_DATA_TYPE_RAW);
+}
+static PyObject *get_ENC_DATA_TYPE_B64(){
+ return PyLong_FromLong(DAP_ENC_DATA_TYPE_B64);
+}
+static PyObject *get_ENC_DATA_TYPE_B64_URLSAFE(){
+ return PyLong_FromLong(DAP_ENC_DATA_TYPE_B64_URLSAFE);
+}
+
+static PyMethodDef PyCryptoDataTypeObjecyMethods[] = {
+ {"DAP_ENC_DATA_TYPE_RAW", (PyCFunction)get_ENC_DATA_TYPE_RAW, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_DATA_TYPE_B64", (PyCFunction)get_ENC_DATA_TYPE_B64, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_DATA_TYPE_B64_URLSAFE", (PyCFunction)get_ENC_DATA_TYPE_B64_URLSAFE, METH_NOARGS | METH_STATIC, ""},
+
+ {NULL, NULL, 0, NULL}
+};
+
+static PyTypeObject CryptoDataTypeObjecy_CryptoDataTypeObjecyType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "CellFrame.CryptoDataType", /* tp_name */
+ sizeof(PyCryptoDataTypeObjecy), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_reserved */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
+ "Crypto data type objects", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ PyCryptoDataTypeObjecyMethods, /* tp_methods */
+ 0, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0, /* tp_init */
+ 0, /* tp_alloc */
+ PyType_GenericNew, /* tp_new */
+};
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/libdap_crypto_key_python.h b/include/libdap_crypto_key_python.h
new file mode 100644
index 0000000000000000000000000000000000000000..109776d211761d0e9e1d525c370f4f7fadfc6e3a
--- /dev/null
+++ b/include/libdap_crypto_key_python.h
@@ -0,0 +1,48 @@
+#ifndef LIBDAP_CRYPTO_KEY_PYTHON_H_
+#define LIBDAP_CRYPTO_KEY_PYTHON_H_
+
+#include "Python.h"
+#include "dap_enc_key.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct PyCryptoKey{
+ PyObject_HEAD
+ dap_enc_key_t *key;
+}PyCryptoKeyObject;
+
+static void PyCryptoKeyObject_dealloc(PyCryptoKeyObject *cryptoObject){
+ dap_enc_key_delete(cryptoObject->key);
+ Py_TYPE(cryptoObject)->tp_free((PyObject*)cryptoObject);
+}
+
+static PyTypeObject PyCryptoKeyObject_PyCryptoKeyType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "CellFrame.Crypto.Key", /* tp_name */
+ sizeof(PyCryptoKeyObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)PyCryptoKeyObject_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
+ "Crypto key objects", /* tp_doc */
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //LIBDAP_CRYPTO_KEY_PYTHON_H_
diff --git a/include/libdap_crypto_key_type_python.h b/include/libdap_crypto_key_type_python.h
new file mode 100644
index 0000000000000000000000000000000000000000..0ccb9829a1a92f59676a63228b1aeaac29f1a4d2
--- /dev/null
+++ b/include/libdap_crypto_key_type_python.h
@@ -0,0 +1,99 @@
+#include "Python.h"
+#include "dap_enc_key.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct PyCryptoKeyType{
+ PyObject_HEAD
+}PyCryptoKeyTypeObjecy;
+
+PyObject *get_ENC_KEY_TYPE_IAES();
+PyObject *get_ENC_KEY_TYPE_OAES();
+PyObject *get_ENC_KEY_TYPE_RLWE_NEWHOPE();
+PyObject *get_ENC_KEY_TYPE_SIDH_CLN16();
+PyObject *get_ENC_KEY_TYPE_DEFEO();
+PyObject *get_ENC_KEY_TYPE_MSRLN();
+PyObject *get_ENC_KEY_TYPE_MSRLN16();
+PyObject *get_ENC_KEY_TYPE_RLWE_BCNS15();
+PyObject *get_ENC_KEY_TYPE_LWE_FRODO();
+PyObject *get_ENC_KEY_TYPE_SIDH_IQC_REF();
+PyObject *get_ENC_KEY_TYPE_CODE_MCBITS();
+PyObject *get_ENC_KEY_TYPE_NTRU();
+PyObject *get_ENC_KEY_TYPE_MLWE_KYBER();
+PyObject *get_ENC_KEY_TYPE_SIG_PICNIC();
+PyObject *get_ENC_KEY_TYPE_SIG_BLISS();
+PyObject *get_ENC_KEY_TYPE_SIG_TESLA();
+PyObject *get_ENC_KEY_TYPE_SIG_DILITHIUM();
+PyObject *get_ENC_KEY_TYPE_NULL();
+
+static PyMethodDef PyCryptoKeyTypeObjecyMethods[] = {
+ {"DAP_ENC_KEY_TYPE_IAES", (PyCFunction)get_ENC_KEY_TYPE_IAES, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_OAES", (PyCFunction)get_ENC_KEY_TYPE_OAES, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_RLWE_NEWHOPE", (PyCFunction)get_ENC_KEY_TYPE_RLWE_NEWHOPE, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_SIDH_CLN16", (PyCFunction)get_ENC_KEY_TYPE_SIDH_CLN16, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_DEFEO", (PyCFunction)get_ENC_KEY_TYPE_DEFEO, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_MSRLN", (PyCFunction)get_ENC_KEY_TYPE_MSRLN, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_MSRLN16", (PyCFunction)get_ENC_KEY_TYPE_MSRLN16, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_RLWE_BCNS15", (PyCFunction)get_ENC_KEY_TYPE_RLWE_BCNS15, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_LWE_FRODO", (PyCFunction)get_ENC_KEY_TYPE_LWE_FRODO, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_SIDH_IQC_REF", (PyCFunction)get_ENC_KEY_TYPE_SIDH_IQC_REF, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_CODE_MCBITS", (PyCFunction)get_ENC_KEY_TYPE_CODE_MCBITS, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_NTRU", (PyCFunction)get_ENC_KEY_TYPE_NTRU, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_MLWE_KYBER", (PyCFunction)get_ENC_KEY_TYPE_MLWE_KYBER, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_SIG_PICNIC", (PyCFunction)get_ENC_KEY_TYPE_SIG_PICNIC, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_SIG_BLISS", (PyCFunction)get_ENC_KEY_TYPE_SIG_BLISS, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_SIG_TESLA", (PyCFunction)get_ENC_KEY_TYPE_SIG_TESLA, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_SIG_DILITHIUM", (PyCFunction)get_ENC_KEY_TYPE_SIG_DILITHIUM, METH_NOARGS | METH_STATIC, ""},
+ {"DAP_ENC_KEY_TYPE_NULL", (PyCFunction)get_ENC_KEY_TYPE_NULL, METH_NOARGS | METH_STATIC, ""},
+
+
+ {NULL, NULL, 0, NULL}
+};
+
+static PyTypeObject CryptoKeyTypeObjecy_CryptoKeyTypeObjecyType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "CellFrame.CryptoKeyType", /* tp_name */
+ sizeof(PyCryptoKeyTypeObjecy), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_reserved */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
+ "Crypto keys type objects", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ PyCryptoKeyTypeObjecyMethods, /* tp_methods */
+ 0, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0, /* tp_init */
+ 0, /* tp_alloc */
+ PyType_GenericNew, /* tp_new */
+};
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/wrapping_dap_enc_iaes.h b/include/wrapping_dap_enc_iaes.h
index c2a9f0078c6318e74db0bc6fedc855e95bdc2144..e531d6cfd42315b9a65ca0be2139b17e90ec5ee6 100644
--- a/include/wrapping_dap_enc_iaes.h
+++ b/include/wrapping_dap_enc_iaes.h
@@ -1,6 +1,10 @@
+#ifndef WRAPPING_DAP_ENC_IAES_
+#define WRAPPING_DAP_ENC_IAES_
+
#include "Python.h"
#include "dap_enc_iaes.h"
-#include "key_list.h"
+#include "dap_common.h"
+#include "libdap_crypto_key_python.h"
#ifdef __cplusplus
extern "C" {
@@ -9,8 +13,6 @@ extern "C" {
#undef LOG_TAG
#define LOG_TAG "wrapping-dap-enc-iaes"
-key_list_t *keys_iaes;
-
PyObject* dap_enc_iaes_key_new_py(PyObject *self, PyObject *args);
PyObject* dap_enc_iaes_key_delete_py(PyObject *self, PyObject *args);
@@ -30,3 +32,5 @@ PyObject* dap_enc_iaes256_cbc_encrypt_fast_py(PyObject *self, PyObject *args);
#ifdef __cplusplus
}
#endif
+
+#endif //WRAPPING_DAP_ENC_IAES_
diff --git a/include/wrapping_dap_enc_key.h b/include/wrapping_dap_enc_key.h
index b57bd12c5e902e42a36ae901675d4294494c5edd..079c6d66c8efc74d5c66abb2decf26b978ac7c5f 100644
--- a/include/wrapping_dap_enc_key.h
+++ b/include/wrapping_dap_enc_key.h
@@ -1,7 +1,10 @@
+#ifndef WRAPPING_DAP_ENC_KEY_
+#define WRAPPING_DAP_ENC_KEY_
+
#include "dap_enc_key.h"
#include "Python.h"
#include "dap_common.h"
-#include "key_list.h"
+#include "libdap_crypto_key_python.h"
#ifdef __cplusplus
extern "C" {
@@ -10,8 +13,6 @@ extern "C" {
#undef LOG_TAG
#define LOG_TAG "wrapping-dap-enc-key"
-key_list_t *keys;
-
PyObject* dap_enc_key_get_enc_size_py(PyObject *self, PyObject *args);//dap_enc_key_t * a_key, const size_t buf_in_size); -> size_t
PyObject* dap_enc_key_get_dec_size_py(PyObject *self, PyObject *args);//dap_enc_key_t * a_key, const size_t buf_in_size); -> size_t
@@ -36,8 +37,10 @@ PyObject *dap_enc_gen_key_public_size_py(PyObject *self, PyObject *args);//dap_e
PyObject *dap_enc_gen_key_public_py(PyObject *self, PyObject *args);//dap_enc_key_t *a_key, void * a_output); ->int
PyObject *dap_enc_key_signature_delete_py(PyObject *self, PyObject *args);//dap_enc_key_type_t a_key_type, uint8_t *a_sig_buf); ->void
-PyObject *dap_enc_key_delete_py(PyObject *self, PyObject *args);//dap_enc_key_t * a_key); ->void
+
#ifdef __cplusplus
}
#endif
+
+#endif //WRAPPING_DAP_ENC_KEY_
diff --git a/include/wrapping_dap_enc_oaes.h b/include/wrapping_dap_enc_oaes.h
index 1498a9297c79fd364aa4cfe58a26cc374c48acf9..b2bf79dc206414582ab0f07d0ada19874ff4df57 100644
--- a/include/wrapping_dap_enc_oaes.h
+++ b/include/wrapping_dap_enc_oaes.h
@@ -1,32 +1,34 @@
+#ifndef WRAPPING_DAP_ENC_OAES_
+#define WRAPPING_DAP_ENC_OAES_
+
#include "Python.h"
#include "dap_enc_oaes.h"
-#include "key_list.h"
+#include "dap_common.h"
+#include "libdap_crypto_key_python.h"
#ifdef __cplusplus
extern "C" {
#endif
-key_list_t *keys_oaes;
-
-PyObject *dap_enc_oaes_key_new_py(PyObject *self, PyObject *args);//struct dap_enc_key * a_key);
-PyObject *dap_enc_oaes_key_delete_py(PyObject *self, PyObject *args);//struct dap_enc_key *a_key);
-PyObject *dap_enc_oaes_key_generate_py(PyObject *self, PyObject *args);//struct dap_enc_key * a_key, const void *kex_buf,
- //size_t kex_size, const void * seed, size_t seed_size, size_t key_size);
+PyObject *dap_enc_oaes_key_new_py(PyObject *self, PyObject *args);
+PyObject *dap_enc_oaes_key_delete_py(PyObject *self, PyObject *args);
+PyObject *dap_enc_oaes_key_generate_py(PyObject *self, PyObject *args);
-PyObject *dap_enc_oaes_calc_decode_size_py(PyObject *self, PyObject *args);//const size_t size_in);
-PyObject *dap_enc_oaes_calc_encode_size_py(PyObject *self, PyObject *args);//const size_t size_in);
+PyObject *dap_enc_oaes_calc_decode_size_py(PyObject *self, PyObject *args);
+PyObject *dap_enc_oaes_calc_encode_size_py(PyObject *self, PyObject *args);
-PyObject *dap_enc_oaes_decrypt_py(PyObject *self, PyObject *args);//struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out);
-PyObject *dap_enc_oaes_encrypt_py(PyObject *self, PyObject *args);//struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out);
+PyObject *dap_enc_oaes_decrypt_py(PyObject *self, PyObject *args);
+PyObject *dap_enc_oaes_encrypt_py(PyObject *self, PyObject *args);
// Writes result ( out ) in already allocated buffer
-PyObject *dap_enc_oaes_decrypt_fast_py(PyObject *self, PyObject *args);//struct dap_enc_key * a_key, const void * a_in,
- //size_t a_in_size, void * buf_out, size_t buf_out_size);
+PyObject *dap_enc_oaes_decrypt_fast_py(PyObject *self, PyObject *args);
// Writes result ( out ) in already allocated buffer
-PyObject *dap_enc_oaes_encrypt_fast_py(PyObject *self, PyObject *args);//struct dap_enc_key * a_key, const void * a_in,
- //size_t a_in_size, void * buf_out, size_t buf_out_size);
+PyObject *dap_enc_oaes_encrypt_fast_py(PyObject *self, PyObject *args);
+
#ifdef __cplusplus
}
#endif
+
+#endif //WRAPPING_DAP_ENC_OAES_
diff --git a/libdap b/libdap
index 4896ad4eeda5b8d4b3ba92dfe2eb6d4cf34efcc7..f91fb3b3b6a69ef53531c8fd729592cdff4ec442 160000
--- a/libdap
+++ b/libdap
@@ -1 +1 @@
-Subproject commit 4896ad4eeda5b8d4b3ba92dfe2eb6d4cf34efcc7
+Subproject commit f91fb3b3b6a69ef53531c8fd729592cdff4ec442
diff --git a/libdap-crypto b/libdap-crypto
index bcfcef1cd87cc6cfbc7e47887894c0fa3742a218..4d764dfacaaa6aa1d8e5ba3c8242d8466e4faf10 160000
--- a/libdap-crypto
+++ b/libdap-crypto
@@ -1 +1 @@
-Subproject commit bcfcef1cd87cc6cfbc7e47887894c0fa3742a218
+Subproject commit 4d764dfacaaa6aa1d8e5ba3c8242d8466e4faf10
diff --git a/src/key_list.c b/src/key_list.c
deleted file mode 100644
index 83e35a9d20f684f4f2c978b7e2862590c2e3c07a..0000000000000000000000000000000000000000
--- a/src/key_list.c
+++ /dev/null
@@ -1,57 +0,0 @@
-#include "key_list.h"
-
-key_list_t *key_list_init()
-{
- key_list_t *keyList = (key_list_t *)malloc(sizeof(key_list_t));
- keyList->lenght = 0;
- return keyList;
-}
-
-void key_list_free(key_list_t* list){
- for (int i=0; i < list->lenght;i++){
- free(list->keys[i]);
- }
- free(list);
-}
-
-uint8_t key_list_add_element(key_list_t *list, dap_enc_key_t* key){
- uint8_t new_len = list->lenght;
- new_len++;
- dap_enc_key_t **new_keys = calloc(new_len, sizeof(dap_enc_key_t));
- if (list->lenght != 0) {
- memcpy(new_keys, list->keys, list->lenght);
- free(list->keys);
- }
- new_keys[new_len - 1] = key;
- list->keys = new_keys;
- list->lenght = new_len;
- return new_len;
-
-}
-
-bool key_list_del_element(key_list_t *list, uint8_t key_id){
- if ((list->lenght-1) > 0) {
- return false;
- }
- uint8_t new_len = list->lenght;
- new_len--;
- dap_enc_key_t **new_keys = calloc(new_len, sizeof(dap_enc_key_t));
- if (list->lenght - 1 == key_id){
- memcpy(new_keys, list->keys, key_id);
- } else if (list->lenght > 1 && key_id < list->lenght) {
- memcpy(new_keys, list->keys, key_id);
- memcpy(new_keys + key_id, list->keys + (key_id + 1), list->lenght);
- }
- free(list->keys);
- list->keys = new_keys;
- list->lenght = new_len;
- return true;
-}
-
-dap_enc_key_t *key_list_get_key(key_list_t *list, uint8_t key){
- uint8_t index = key - 1;
- if (list->lenght < index) {
- return NULL;
- }
- return list->keys[index];
-}
diff --git a/src/libdap-crypto-python.c b/src/libdap-crypto-python.c
index 74303fd76fa03f4806cbf52fcd17f3fc1abfb182..bc3b74497b739c38dbdccb45074697a52256ca3e 100644
--- a/src/libdap-crypto-python.c
+++ b/src/libdap-crypto-python.c
@@ -1,68 +1,19 @@
#include "libdap-crypto-python.h"
-static PyObject* dap_crypto_init(PyObject *self, PyObject *args){
- dap_common_init("libdap-crypto","libdap-crypto-python-module.txt");
+int dap_crypto_init(void){
if(dap_enc_init()!=0){
log_it(L_CRITICAL,"Can't init encryption module");
- return PyLong_FromLong(-1);
+ return -1;
}
if(dap_enc_key_init()!=0){
log_it(L_CRITICAL,"Can't init encryption key module");
- return PyLong_FromLong(-2);
+ return -2;
}
- keys = key_list_init();
- keys_iaes = keys;
- keys_oaes = keys;
- return PyLong_FromLong(0);
+ PyCryptoKeyObject_PyCryptoKeyType.tp_new = PyType_GenericNew;
+ return 0;
}
-static PyObject* dap_crypto_deinit(){
+void dap_crypto_deinit(void){
dap_enc_key_deinit();
dap_enc_deinit();
- key_list_free(keys);
- return PyLong_FromLong(0);
-}
-
-/* Information */
-static PyObject *dap_log_it_debug(PyObject *self, PyObject *args){
- const char *data;
- if (!PyArg_ParseTuple(args,"s", &data)){
- return NULL;
- }
- log_it(L_DEBUG, data);
- return PyLong_FromLong(0);
-}
-
-static PyObject *dap_log_it_info(PyObject *self, PyObject *args){
- return PyLong_FromLong(0);
-}
-/*==========================================*/
-
-PyMODINIT_FUNC PyInit_libdap_crypto_python_module(void){
- return PyModule_Create(&dapcryptomodule);
-}
-
-int main(int argc, char **argv) {
- wchar_t *program = Py_DecodeLocale(argv[0], NULL);
- if (program == NULL) {
- fprintf(stderr, "Fatal error: cannot decode argv[0]\n");
- exit(1);
- }
-
- /* Add a built-in module, before Py_Initialize */
- PyImport_AppendInittab("libdap_crypto_python_module", PyInit_libdap_crypto_python_module);
-
- /* Pass argv[0] to the Python interpreter */
- Py_SetProgramName(program);
-
- /* Initialize the Python interpreter. Required. */
- Py_Initialize();
-
- /* Optionally import the module; alternatively,
- import can be deferred until the embedded script
- imports it. */
- PyImport_ImportModule("libdap_crypto_python_module");
-
- PyMem_RawFree(program);
- return 0;
}
diff --git a/src/libdap_crypto_key_type_python.c b/src/libdap_crypto_key_type_python.c
new file mode 100644
index 0000000000000000000000000000000000000000..f0ac5f0f660915b408a174d772f51eb78f50bd20
--- /dev/null
+++ b/src/libdap_crypto_key_type_python.c
@@ -0,0 +1,56 @@
+#include "libdap_crypto_key_type_python.h"
+
+PyObject *get_ENC_KEY_TYPE_IAES(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_IAES);
+}
+PyObject *get_ENC_KEY_TYPE_OAES(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_OAES);
+}
+PyObject *get_ENC_KEY_TYPE_RLWE_NEWHOPE(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_RLWE_NEWHOPE);
+}
+PyObject *get_ENC_KEY_TYPE_SIDH_CLN16(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_SIDH_CLN16);
+}
+PyObject *get_ENC_KEY_TYPE_DEFEO(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_DEFEO);
+}
+PyObject *get_ENC_KEY_TYPE_MSRLN(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_MSRLN);
+}
+PyObject *get_ENC_KEY_TYPE_MSRLN16(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_RLWE_MSRLN16);
+}
+PyObject *get_ENC_KEY_TYPE_RLWE_BCNS15(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_RLWE_BCNS15);
+}
+PyObject *get_ENC_KEY_TYPE_LWE_FRODO(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_LWE_FRODO);
+}
+PyObject *get_ENC_KEY_TYPE_SIDH_IQC_REF(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_SIDH_IQC_REF);
+}
+PyObject *get_ENC_KEY_TYPE_CODE_MCBITS(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_CODE_MCBITS);
+}
+PyObject *get_ENC_KEY_TYPE_NTRU(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_NTRU);
+}
+PyObject *get_ENC_KEY_TYPE_MLWE_KYBER(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_MLWE_KYBER);
+}
+PyObject *get_ENC_KEY_TYPE_SIG_PICNIC(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_SIG_PICNIC);
+}
+PyObject *get_ENC_KEY_TYPE_SIG_BLISS(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_SIG_BLISS);
+}
+PyObject *get_ENC_KEY_TYPE_SIG_TESLA(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_SIG_TESLA);
+}
+PyObject *get_ENC_KEY_TYPE_SIG_DILITHIUM(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_SIG_DILITHIUM);
+}
+PyObject *get_ENC_KEY_TYPE_NULL(){
+ return PyLong_FromLong(DAP_ENC_KEY_TYPE_NULL);
+}
diff --git a/src/wrapping_base64.c b/src/wrapping_base64.c
index aaf19232e27938305a4b6fb882e70d6ab9aef2e3..53d562025ec07ebb6e240d67e2b095be02f97ba0 100644
--- a/src/wrapping_base64.c
+++ b/src/wrapping_base64.c
@@ -26,7 +26,6 @@
return NULL;
}
void *res = DAP_NEW_SIZE(void*, DAP_ENC_BASE64_ENCODE_SIZE(strlen(in_str)));
- //size_t decrypted_size = dap_enc_base58_decode(in_str, res);
size_t decrypted_size = dap_enc_base64_decode(in_str, strlen(in_str), res, l_dap_enc_data_type);
PyBytesObject *return_object = (PyBytesObject*)PyBytes_FromStringAndSize(res, (Py_ssize_t)decrypted_size);
return Py_BuildValue("O", return_object);
diff --git a/src/wrapping_dap_enc_iaes.c b/src/wrapping_dap_enc_iaes.c
index d7cc58017d25faf18175ef2adf49dac3aa4c27d6..843ce0cd461c09f8187b31d82c5be0acd3929c8c 100644
--- a/src/wrapping_dap_enc_iaes.c
+++ b/src/wrapping_dap_enc_iaes.c
@@ -2,51 +2,39 @@
PyObject* dap_enc_iaes_key_new_py(PyObject *self, PyObject *args){
- uint8_t key_id;
- if (PyArg_ParseTuple(args, "h", &key_id)){
+ PyObject *obj_key;
+ if (PyArg_ParseTuple(args, "O", &obj_key)){
return NULL;
}
- dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
- if (key == NULL){
- return NULL;
- }
- dap_enc_aes_key_new(key);
+ dap_enc_aes_key_new(((PyCryptoKeyObject*)obj_key)->key);
return PyLong_FromLong(0);
}
PyObject* dap_enc_iaes_key_delete_py(PyObject *self, PyObject *args){
- uint8_t key_id;
- if (PyArg_ParseTuple(args, "h", &key_id)){
+ PyObject *obj_key;
+ if (PyArg_ParseTuple(args, "O", &obj_key)){
return NULL;
}
- dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
- if (key == NULL){
- return NULL;
- }
- dap_enc_key_delete(key);
+ dap_enc_aes_key_delete(((PyCryptoKeyObject*)obj_key)->key);
return PyLong_FromLong(0);
}
PyObject* dap_enc_iaes_key_generate_py(PyObject *self, PyObject *args){
// TODO
- uint8_t in_key_id;
+ PyObject* in_key;
PyBytesObject *in_kex_buf;
size_t in_kex_size;
PyBytesObject *in_seed;
size_t in_seed_size;
- if (PyArg_ParseTuple(args, "h|S|n|S|n", &in_key_id, &in_kex_buf, &in_kex_size, &in_seed, &in_seed_size)){
- return NULL;
- }
- dap_enc_key_t *key = key_list_get_key(keys_iaes, in_key_id);
- if (key == NULL){
+ if (PyArg_ParseTuple(args, "O|S|n|S|n", &in_key, &in_kex_buf, &in_kex_size, &in_seed, &in_seed_size)){
return NULL;
}
- size_t key_size = sizeof(key);
+ size_t key_size = sizeof(((PyCryptoKeyObject*)in_key)->key);
void* kex_buf = NULL;
PyBytes_AsStringAndSize((PyObject*)in_kex_buf, kex_buf, (Py_ssize_t*)in_kex_size);
void* seed_buf = NULL;
PyBytes_AsStringAndSize((PyObject*)in_seed, seed_buf, (Py_ssize_t*)in_seed_size);
- dap_enc_aes_key_generate(key, kex_buf, in_kex_size, seed_buf, in_seed_size, key_size);
+ dap_enc_aes_key_generate(((PyCryptoKeyObject*)in_key)->key, kex_buf, in_kex_size, seed_buf, in_seed_size, key_size);
return PyLong_FromLong(0);
}
@@ -71,80 +59,40 @@ PyObject* dap_enc_iaes256_calc_decode_size_py(PyObject *self, PyObject *args){
PyObject* dap_enc_iaes256_cbc_decrypt_py(PyObject *self, PyObject *args){
//TODO
return PyLong_FromLong(0);
- /*uint8_t key_id;
- PyBytesObject *in_obj;
- size_t in_size;
- void **a_out = NULL;
- if (!PyArg_ParseTuple(args, "h|S|n", &key_id, &in_obj, &in_size)){
- return NULL;
- }
- dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
- if (key == NULL){
- return NULL;
- }
- //void *in = PyBytes_AsString(in_obj);
- void *in_void = PyBytes_AsString((PyObject*)in_obj);
- in_size = (size_t)PyBytes_GET_SIZE(in_obj);
- dap_enc_iaes256_cbc_decrypt(key, in_void, in_size, a_out);
- //TODO
- return Py_BuildValue("O", a_out);*/
}
PyObject* dap_enc_iaes256_cbc_encrypt_py(PyObject *self, PyObject *args){
//TODO
return PyLong_FromLong(0);
- /*uint8_t key_id;
- PyBytesObject *in_obj;
- size_t in_size;
- void **a_out = NULL;
- if (!PyArg_ParseTuple(args, "h|S|n", &key_id, &in_obj, &in_size)){
- return NULL;
- }
- dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
- if (key == NULL){
- return NULL;
- }
- void *in_void = PyBytes_AsString((PyObject*)in_obj);
- in_size = (size_t)PyBytes_GET_SIZE(in_obj);
- dap_enc_iaes256_cbc_encrypt(key, in_void, in_size, a_out);
- return PyBytes_FromFormat("%p", a_out);*/
}
// Writes result ( out ) in already allocated buffer
PyObject* dap_enc_iaes256_cbc_decrypt_fast_py(PyObject *self, PyObject *args){
- uint8_t key_id;
+ PyObject* in_key;
PyBytesObject *a_in;
size_t a_in_size;
size_t buf_out_size;
- if (!PyArg_ParseTuple(args, "h|S|n|n", &key_id, &a_in, &a_in_size, &buf_out_size)){
- return NULL;
- }
- dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
- if (key == NULL){
+ if (!PyArg_ParseTuple(args, "O|S|n|n", &in_key, &a_in, &a_in_size, &buf_out_size)){
return NULL;
}
void *in = PyBytes_AsString((PyObject*)a_in);
void *out = DAP_NEW_SIZE(void*, buf_out_size);
- size_t res_denc_size = dap_enc_iaes256_cbc_decrypt_fast(key, in, a_in_size, out, buf_out_size);
+ size_t res_denc_size = dap_enc_iaes256_cbc_decrypt_fast(((PyCryptoKeyObject*)in_key)->key, in, a_in_size, out, buf_out_size);
PyBytesObject *bytes_out = (PyBytesObject*)PyBytes_FromStringAndSize(out, (Py_ssize_t)res_denc_size);
return Py_BuildValue("S", bytes_out);
}
// if "a_in size mod IAES_BLOCK_SIZE = 0" encryption will be faster
PyObject* dap_enc_iaes256_cbc_encrypt_fast_py(PyObject *self, PyObject *args){
- uint8_t key_id;
+ PyObject *in_key;
PyBytesObject *a_in;
size_t a_in_size;
size_t buf_out_size;
- if (!PyArg_ParseTuple(args, "h|S|n|n", &key_id, &a_in, &a_in_size, &buf_out_size)){
- return NULL;
- }
- dap_enc_key_t *key = key_list_get_key(keys_iaes, key_id);
- if (key == NULL){
+ if (!PyArg_ParseTuple(args, "O|S|n|n", &in_key, &a_in, &a_in_size, &buf_out_size)){
return NULL;
}
void *in = PyBytes_AsString((PyObject*)a_in);
void *out = DAP_NEW_SIZE(void*, buf_out_size);
- size_t res_enc_size = dap_enc_iaes256_cbc_encrypt_fast(key, in, a_in_size, out, buf_out_size);
+ size_t res_enc_size = dap_enc_iaes256_cbc_encrypt_fast(((PyCryptoKeyObject*)in_key)->key, in, a_in_size, out, buf_out_size);
PyBytesObject *bytes_out = (PyBytesObject*)PyBytes_FromStringAndSize(out, (Py_ssize_t)res_enc_size);
return Py_BuildValue("S", bytes_out);
}
diff --git a/src/wrapping_dap_enc_key.c b/src/wrapping_dap_enc_key.c
index 359efebb4bb1bfda3483de3896ed3e5b6863e1f5..6779ad279c804dd9c97b189f99aa196675bd3463 100644
--- a/src/wrapping_dap_enc_key.c
+++ b/src/wrapping_dap_enc_key.c
@@ -1,30 +1,30 @@
#include "wrapping_dap_enc_key.h"
PyObject* dap_enc_key_get_enc_size_py(PyObject *self, PyObject *args){
- uint8_t key_id;
+ PyObject *in_key;
size_t buff_in_size;
- if (!PyArg_ParseTuple(args, "h|i"), &key_id, &buff_in_size){
+ if (!PyArg_ParseTuple(args, "O|i", &in_key, &buff_in_size)){
return NULL;
}
- dap_enc_key_t *key = key_list_get_key(keys, key_id);
- if (key == NULL)
- return NULL;
- size_t size_buff = dap_enc_key_get_enc_size(key, buff_in_size);
+// dap_enc_key_t *key = key_list_get_key(keys, key_id);
+// if (key == NULL)
+// return NULL;
+ size_t size_buff = dap_enc_key_get_enc_size(((PyCryptoKeyObject*)in_key)->key, buff_in_size);
if (size_buff == 0)
return NULL;
return PyLong_FromSize_t(size_buff);
}
PyObject* dap_enc_key_get_dec_size_py(PyObject *self, PyObject *args){
- uint8_t key_id;
+ PyObject *in_key;
size_t buff_in_size;
- if (!PyArg_ParseTuple(args, "h|i"), &key_id, &buff_in_size){
+ if (!PyArg_ParseTuple(args, "O|i", &in_key, &buff_in_size)){
return NULL;
}
- dap_enc_key_t *key = key_list_get_key(keys, key_id);
- if (key == NULL)
- return NULL;
- size_t size_buff = dap_enc_key_get_dec_size(key, buff_in_size);
+// dap_enc_key_t *key = key_list_get_key(keys, key_id);
+// if (key == NULL)
+// return NULL;
+ size_t size_buff = dap_enc_key_get_dec_size(((PyCryptoKeyObject*)in_key)->key, buff_in_size);
if (size_buff == 0)
return NULL;
return PyLong_FromSize_t(size_buff);
@@ -40,8 +40,9 @@ PyObject* dap_enc_key_new_py(PyObject *self, PyObject *args){
return PyLong_FromLong(-1);
}
dap_enc_key_t *new_key = dap_enc_key_new(type_key);
- uint8_t res = key_list_add_element(keys, new_key);
- return PyLong_FromLong(res);
+ PyObject *obj = _PyObject_New(&PyCryptoKeyObject_PyCryptoKeyType);
+ ((PyCryptoKeyObject*)obj)->key = new_key;
+ return Py_BuildValue("O", obj);
}
/// default gen key
@@ -65,22 +66,22 @@ PyObject *dap_enc_key_new_generate_py(PyObject *self, PyObject *args){
kex_buf = PyBytes_AsString((PyObject*)in_kex_buf);
if (in_seed_size != 0)
seed = PyBytes_AsString((PyObject*)in_seed);
- dap_enc_key_t *new_key = dap_enc_key_new_generate(in_type_key, kex_buf, in_kex_size, seed, in_seed_size, in_key_size);
- uint8_t new_key_id = key_list_add_element(keys, new_key);
- return PyLong_FromLong(new_key_id);
+ PyCryptoKeyObject *obj_key = (PyCryptoKeyObject*)_PyObject_New(&PyCryptoKeyObject_PyCryptoKeyType);
+ obj_key->key = dap_enc_key_new_generate(in_type_key, kex_buf, in_kex_size, seed, in_seed_size, in_key_size);
+ return Py_BuildValue("O", (PyObject*)obj_key);
}
// update struct dap_enc_key_t after insert foreign keys
PyObject* dap_enc_key_update_py(PyObject *self, PyObject *args){
- uint8_t key_id;
- if (!PyArg_ParseTuple(args, "h", &key_id)){
- return NULL;
- }
- dap_enc_key_t *key = key_list_get_key(keys, key_id);
- if (key == NULL) {
+ PyObject *in_key;
+ if (!PyArg_ParseTuple(args, "O", &in_key)){
return NULL;
}
- dap_enc_key_update(key);
+// dap_enc_key_t *key = key_list_get_key(keys, key_id);
+// if (key == NULL) {
+// return NULL;
+// }
+ dap_enc_key_update(((PyCryptoKeyObject*)in_key)->key);
return PyLong_FromLong(0);
}
@@ -91,29 +92,29 @@ PyObject *dap_enc_gen_pub_key_from_priv_py(PyObject *self, PyObject *args){ //NO
PyObject *dap_enc_gen_key_public_size_py(PyObject *self, PyObject *args){
- uint8_t key_id;
- if (PyArg_ParseTuple(args, "h", &key_id)){
+ PyObject *in_key;
+ if (PyArg_ParseTuple(args, "h", &in_key)){
return NULL;
}
- dap_enc_key_t *key = key_list_get_key(keys, key_id);
- if (key == NULL){
- return NULL;
- }
- size_t size = dap_enc_gen_key_public_size(key);
+// dap_enc_key_t *key = key_list_get_key(keys, key_id);
+// if (key == NULL){
+// return NULL;
+// }
+ size_t size = dap_enc_gen_key_public_size(((PyCryptoKeyObject*)in_key)->key);
return PyLong_FromSize_t(size);
}
PyObject *dap_enc_gen_key_public_py(PyObject *self, PyObject *args){
- uint8_t key_id;
+ PyObject *in_key;
PyObject *obj;
- if (PyArg_ParseTuple(args, "h|O", &key_id, &obj)){
- return NULL;
- }
- dap_enc_key_t *key = key_list_get_key(keys, key_id);
- if (key == NULL){
+ if (PyArg_ParseTuple(args, "O|O", &in_key, &obj)){
return NULL;
}
- int size = dap_enc_gen_key_public(key, obj);
+// dap_enc_key_t *key = key_list_get_key(keys, key_id);
+// if (key == NULL){
+// return NULL;
+// }
+ int size = dap_enc_gen_key_public(((PyCryptoKeyObject*)in_key)->key, obj);
return PyLong_FromLong(size);
}
@@ -131,18 +132,3 @@ PyObject *dap_enc_key_signature_delete_py(PyObject *self, PyObject *args){
dap_enc_key_signature_delete(type_key, a_sig_buf);
return PyLong_FromLong(0);
}
-
-PyObject *dap_enc_key_delete_py(PyObject *self, PyObject *args){
- //PyObject *obj;
- uint8_t key_id;
- if (!PyArg_ParseTuple(args, "h", &key_id)){
- return NULL;
- }
- dap_enc_key_t *key = key_list_get_key(keys, key_id);
- if (key == NULL) {
- return NULL;
- }
- key_list_del_element(keys, key_id);
- dap_enc_key_delete(key);
- return PyLong_FromLong(0);
-}
diff --git a/src/wrapping_dap_enc_oaes.c b/src/wrapping_dap_enc_oaes.c
index 5e2ef99cc1a67edb24013bc01aab03e84e5f04ea..e3ed4bd9ade18d5f8f83d712d835b83a7095e0a8 100644
--- a/src/wrapping_dap_enc_oaes.c
+++ b/src/wrapping_dap_enc_oaes.c
@@ -2,48 +2,36 @@
PyObject *dap_enc_oaes_key_new_py(PyObject *self, PyObject *args){
- uint8_t key_id;
- if (PyArg_ParseTuple(args, "h", &key_id)){
+ PyObject *in_key;
+ if (PyArg_ParseTuple(args, "O", &in_key)){
return NULL;
}
- dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
- if (key == NULL){
- return NULL;
- }
- dap_enc_oaes_key_new(key);
+ dap_enc_oaes_key_new(((PyCryptoKeyObject*)in_key)->key);
return PyLong_FromLong(0);
}
PyObject *dap_enc_oaes_key_delete_py(PyObject *self, PyObject *args){
- uint8_t key_id;
- if (PyArg_ParseTuple(args, "h", &key_id)){
+ PyObject *in_key;
+ if (PyArg_ParseTuple(args, "O", &in_key)){
return NULL;
}
- dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
- if (key == NULL){
- return NULL;
- }
- dap_enc_key_delete(key);
+ dap_enc_oaes_key_delete(((PyCryptoKeyObject*)in_key)->key);
return PyLong_FromLong(0);
}
PyObject *dap_enc_oaes_key_generate_py(PyObject *self, PyObject *args){
- uint8_t in_key_id;
+ PyObject *in_key;
PyBytesObject *in_kex_buf;
size_t in_kex_size;
PyBytesObject *in_seed;
size_t in_seed_size;
- if (PyArg_ParseTuple(args, "h|S|n|S|n", &in_key_id, &in_kex_buf, &in_kex_size, &in_seed, &in_seed_size)){
- return NULL;
- }
- dap_enc_key_t *key = key_list_get_key(keys_oaes, in_key_id);
- if (key == NULL){
+ if (PyArg_ParseTuple(args, "O|S|n|S|n", &in_key, &in_kex_buf, &in_kex_size, &in_seed, &in_seed_size)){
return NULL;
}
- size_t key_size = sizeof(key);
+ size_t key_size = sizeof(((PyCryptoKeyObject*)in_key)->key);
void* kex_buf = NULL;
PyBytes_AsStringAndSize((PyObject*)in_kex_buf, kex_buf, (Py_ssize_t*)in_kex_size);
void* seed_buf = NULL;
PyBytes_AsStringAndSize((PyObject*)in_seed, seed_buf, (Py_ssize_t*)in_seed_size);
- dap_enc_oaes_key_generate(key, kex_buf, in_kex_size, seed_buf, in_seed_size, key_size);
+ dap_enc_oaes_key_generate(((PyCryptoKeyObject*)in_key)->key, kex_buf, in_kex_size, seed_buf, in_seed_size, key_size);
return PyLong_FromLong(0);
}
@@ -75,39 +63,31 @@ PyObject *dap_enc_oaes_encrypt_py(PyObject *self, PyObject *args){
// Writes result ( out ) in already allocated buffer
PyObject *dap_enc_oaes_decrypt_fast_py(PyObject *self, PyObject *args){
- uint8_t key_id;
+ PyObject *in_key;
PyBytesObject *a_in;
size_t a_in_size;
size_t buf_out_size;
- if (!PyArg_ParseTuple(args, "h|S|n|n", &key_id, &a_in, &a_in_size, &buf_out_size)){
- return NULL;
- }
- dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
- if (key == NULL){
+ if (!PyArg_ParseTuple(args, "O|S|n|n", &in_key, &a_in, &a_in_size, &buf_out_size)){
return NULL;
}
void *in = PyBytes_AsString((PyObject*)a_in);
void *out = DAP_NEW_SIZE(void*, buf_out_size);
- size_t res_denc_size = dap_enc_oaes_decrypt_fast(key, in, a_in_size, out, buf_out_size);
+ size_t res_denc_size = dap_enc_oaes_decrypt_fast(((PyCryptoKeyObject*)in_key)->key, in, a_in_size, out, buf_out_size);
PyBytesObject *bytes_out = (PyBytesObject*)PyBytes_FromStringAndSize(out, (Py_ssize_t)res_denc_size);
return Py_BuildValue("S", bytes_out);
}
// Writes result ( out ) in already allocated buffer
PyObject *dap_enc_oaes_encrypt_fast_py(PyObject *self, PyObject *args){
- uint8_t key_id;
+ PyObject *in_key;
PyBytesObject *a_in;
size_t a_in_size;
size_t buf_out_size;
- if (!PyArg_ParseTuple(args, "h|S|n|n", &key_id, &a_in, &a_in_size, &buf_out_size)){
- return NULL;
- }
- dap_enc_key_t *key = key_list_get_key(keys_oaes, key_id);
- if (key == NULL){
+ if (!PyArg_ParseTuple(args, "O|S|n|n", &in_key, &a_in, &a_in_size, &buf_out_size)){
return NULL;
}
void *in = PyBytes_AsString((PyObject*)a_in);
void *out = DAP_NEW_SIZE(void*, buf_out_size);
- size_t res_enc_size = dap_enc_oaes_encrypt_fast(key, in, a_in_size, out, buf_out_size);
+ size_t res_enc_size = dap_enc_oaes_encrypt_fast(((PyCryptoKeyObject*)in_key)->key, in, a_in_size, out, buf_out_size);
PyBytesObject *bytes_out = (PyBytesObject*)PyBytes_FromStringAndSize(out, (Py_ssize_t)res_enc_size);
return Py_BuildValue("S", bytes_out);
}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..5af5f169d93f062fd3c9ba6defa1cd7593cec620
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1,19 @@
+project(TPO C)
+cmake_minimum_required(VERSION 2.8)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_COLOR_MAKEFILE ON)
+set(CMAKE_C_STANDARD 11)
+
+set(Python_ADDITIONAL_VERSIONS 3.7)
+find_package (PythonLibs REQUIRED)
+include_directories(${PYTHON_INCLUDE_DIR} include/)
+
+file(GLOB TPO_INCLUDES include/*.h)
+file(GLOB TPO_SRCS src/*.c)
+
+add_library(${PROJECT_NAME} SHARED ${TPO_INCLUDES} ${TPO_SRCS} )
+
+target_link_libraries(${PROJECT_NAME} ${PYTHON_LIBRARIES})
+
+target_link_libraries(${PROJECT_NAME} dap_crypto_python_module)
diff --git a/test/include/tpo.h b/test/include/tpo.h
new file mode 100644
index 0000000000000000000000000000000000000000..610a133560775742ec7f2f2fca205450183c08b2
--- /dev/null
+++ b/test/include/tpo.h
@@ -0,0 +1,51 @@
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#include "libdap-crypto-python.h"
+#include "libdap_crypto_data_type.h"
+#include "libdap_crypto_key_type_python.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyObject *TPO_init(PyObject *self, PyObject *args);
+PyObject *TPO_deinit(PyObject *self, PyObject *args);
+
+static PyMethodDef TPOPythonMethods[] = {
+ {"init", TPO_init, METH_VARARGS, "Initialization of the python-cellframe interface DAP (Deus Applicaions Prototypes)"},
+ {"deinit", TPO_deinit, METH_VARARGS, "Deinitialization of the python-cellframe interface DAP (Deus Applicaions Prototypes)"},
+// {"setLogLevel", (PyCFunction)dap_set_log_level, METH_VARARGS, "Setting the logging level"},
+// {"logIt", (PyCFunction)dap_log_it, METH_VARARGS, "The wrapper of the log_it function for the libdap library"},
+// {"logItDebug", (PyCFunction)dap_log_it_debug, METH_VARARGS, "The log_it wrapper for the libdap library displays information with the logging level DEBUG"},
+// {"logItInfo", (PyCFunction)dap_log_it_info, METH_VARARGS, "The log_it wrapper for the libdap library displays information with the logging level INFO"},
+// {"logItNotice", (PyCFunction)dap_log_it_notice, METH_VARARGS, "The log_it wrapper for the libdap library displays information with the logging level NOTICE"},
+// {"logItMessage", (PyCFunction)dap_log_it_message, METH_VARARGS, "The log_it wrapper for the libdap library displays information with the logging level MESSAGE"},
+// {"logItDap", (PyCFunction)dap_log_it_dap, METH_VARARGS, "The log_it wrapper for the libdap library displays information with the logging level DAP"},
+// {"logItWarning", (PyCFunction)dap_log_it_warning, METH_VARARGS, "The log_it wrapper for the libdap library displays information with the logging level WARNING"},
+// {"logItAtt", (PyCFunction)dap_log_it_att, METH_VARARGS, "The log_it wrapper for the libdap library displays information with the logging level ATT"},
+// {"logItError", (PyCFunction)dap_log_it_error, METH_VARARGS, "The log_it wrapper for the libdap library displays information with the logging level ERROR"},
+// {"logItCritical", (PyCFunction)dap_log_it_critical, METH_VARARGS, "The log_it wrapper for the libdap library displays information with the logging level CRITICAL"},
+// {"configGetItem", (PyCFunction)py_m_dap_config_get_item, METH_VARARGS, ""},
+// {"configGetItemDefault", (PyCFunction)py_m_dap_config_get_item_default, METH_VARARGS, ""},
+ //{"deinit", dap_server_core_deinit, METH_NOARGS, "Deinitialization of the DAP (Deus Applicaions Prototypes) server core library"},
+ //{"loop", dap_server_core_loop, METH_VARARGS, ""},
+ //{"listen", dap_server_core_listen, METH_VARARGS, ""},
+ {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef TPOModule = {
+ PyModuleDef_HEAD_INIT,
+ "libTPO", /* name of module */
+ NULL, /* module documentation, may be NULL */
+ -1, /* size of per-interpreter state of the module,
+ or -1 if the module keeps state in global variables. */
+ TPOPythonMethods
+};
+
+PyMODINIT_FUNC PyInit_libTPO(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
diff --git a/test/libdap-python b/test/libdap-python
deleted file mode 160000
index e8d7f4e84f0cbca515236f317e9aa5d079df1962..0000000000000000000000000000000000000000
--- a/test/libdap-python
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit e8d7f4e84f0cbca515236f317e9aa5d079df1962
diff --git a/test/src/tpo.c b/test/src/tpo.c
new file mode 100644
index 0000000000000000000000000000000000000000..0721d93cd5da13fce2f77e6f6f0a2ee9eeec4121
--- /dev/null
+++ b/test/src/tpo.c
@@ -0,0 +1,26 @@
+#include "tpo.h"
+
+PyObject *TPO_init(PyObject *self, PyObject *args){
+ if (dap_crypto_init() != 0)
+ return NULL;
+ return PyLong_FromLong(0);
+}
+PyObject *TPO_deinit(PyObject *self, PyObject *args){
+ dap_common_deinit();
+ return PyLong_FromLong(0);
+}
+
+PyMODINIT_FUNC PyInit_libTPO(void){
+
+ if (PyType_Ready(&dapCrypto_dapCryptoType) < 0 ||
+ PyType_Ready(&CryptoKeyTypeObjecy_CryptoKeyTypeObjecyType) < 0 ||
+ PyType_Ready(&CryptoDataTypeObjecy_CryptoDataTypeObjecyType) < 0)
+ return NULL;
+
+ PyObject *module = PyModule_Create(&TPOModule);
+ PyModule_AddObject(module, "Crypto", (PyObject*)&dapCrypto_dapCryptoType);
+ PyModule_AddObject(module, "CryptoKeyType", (PyObject*)&CryptoKeyTypeObjecy_CryptoKeyTypeObjecyType);
+ PyModule_AddObject(module, "CryptoDataType", (PyObject*)&CryptoDataTypeObjecy_CryptoDataTypeObjecyType);
+ return module;
+}
+
diff --git a/test/test_b58.py b/test/test_b58.py
index fbbbf316c59ce20dfa412d32efbd9da8dc65c344..ff02326fd15342cec3a9bb331f48a3351341637f 100644
--- a/test/test_b58.py
+++ b/test/test_b58.py
@@ -1,4 +1,4 @@
-import libdap_crypto_python_module as crypto
+import libTPO
import pickle
import sys
@@ -7,10 +7,10 @@ s = """Test! I will crush Base58!"""
base_in = pickle.dumps(s)
print ("Input data: "+s)
print (base_in)
-crypt = crypto.encodeBase58(base_in)
+crypt = libTPO.Crypto.encodeBase58(base_in)
print ("Encrypted data: \t")
print(crypt)
-decrypt = crypto.decodeBase58(crypt)
+decrypt = libTPO.Crypto.decodeBase58(crypt)
print ("Decoded data: \t")
print(decrypt)
out_data = pickle.loads(decrypt)
diff --git a/test/test_b64.py b/test/test_b64.py
index 781b6d443ed3a1f1937e319ab16824488c4041eb..a4270ebbc22ed2288d5c7af76fae0b7cf214c4a7 100644
--- a/test/test_b64.py
+++ b/test/test_b64.py
@@ -1,13 +1,13 @@
-import libdap_crypto_python_module as crypto
+import libTPO
import sys
print ("Start test crypto b64")
s = "Test! I will crush Base64!"
print ("Input data: "+s)
-crypt = crypto.encodeBase64(bytes(s, "utf-8"),1)
+crypt = libTPO.Crypto.encodeBase64(bytes(s, "utf-8"), libTPO.CryptoDataType.DAP_ENC_DATA_TYPE_B64())
print ("Encrypted data: \t")
print(crypt)
-decrypt = crypto.decodeBase64(crypt, 1)
+decrypt = libTPO.Crypto.decodeBase64(crypt, libTPO.CryptoDataType.DAP_ENC_DATA_TYPE_B64())
print ("Decoded data: \t")
print(decrypt)
if bytes(s, "utf-8") == decrypt:
@@ -18,8 +18,8 @@ else:
print ("Test Base64 URLSAFE")
u = "http://kelvin.foundation/"
-crypt_u = crypto.encodeBase64(bytes(u, "utf-8"), 2)
-decrypt_u = crypto.decodeBase64(crypt_u)
+crypt_u = libTPO.Crypto.encodeBase64(bytes(u, "utf-8"), libTPO.CryptoDataType.DAP_ENC_DATA_TYPE_B64_URLSAFE())
+decrypt_u = libTPO.Crypto.decodeBase64(crypt_u, libTPO.CryptoDataType.DAP_ENC_DATA_TYPE_B64_URLSAFE())
if bytes(u, "utf-8") == decrypt_u:
print ("TEST 2. Encode/Decode base64 urlsafe done")
else:
diff --git a/test/test_iaes256_cbc.py b/test/test_iaes256_cbc.py
index 396a7517a912511b8cba1a61ad7619b7644b07c5..1a2cc6248a749f0e2f5a26286d311806d4c9e545 100644
--- a/test/test_iaes256_cbc.py
+++ b/test/test_iaes256_cbc.py
@@ -1,21 +1,17 @@
-import libdap_crypto_python_module as crypto
+import libTPO
import sys
print ("Start test crypto iaes256 CBC")
s = "Test! I will crush iaes256!"
-print ("Input data: "+s)
kex_buff = bytes("123", "utf-8")
size_kex_buff = len(kex_buff)
seed = bytes(112771128)
seed_size = len(seed)
-crypto.init()
-key_id = crypto.generateNewKey(0, kex_buff, size_kex_buff, seed, seed_size, 0)
-print(key_id)
+libTPO.init()
+key_id = libTPO.Crypto.generateNewKey(0, kex_buff, size_kex_buff, seed, seed_size, 0)
source = bytes(s, "utf-8")
-enc = crypto.encryptIAES256CBCFast(key_id, source, len(source), 2048)
-decrypt = crypto.decryptIAES256CBCFast(key_id, enc, len(enc), 2048)
-print (decrypt)
-
+enc = libTPO.Crypto.encryptIAES256CBCFast(key_id, source, len(source), 2048)
+decrypt = libTPO.Crypto.decryptIAES256CBCFast(key_id, enc, len(enc), 2048)
if bytes(s, "utf-8") == decrypt:
print ("TEST 1. Encode/Decode IAES256 CBC FAST done")
diff --git a/test/test_oaes.py b/test/test_oaes.py
index 7a4d02f67e41c9c4dbcfca77eec7e44d7875894d..2c36e8e0bbd69239cfe5530368f68a0ce034e09a 100644
--- a/test/test_oaes.py
+++ b/test/test_oaes.py
@@ -1,20 +1,17 @@
-import libdap_crypto_python_module as crypto
+import libTPO
import sys
print ("Start test crypto OAES")
s = "Test! I will crush OAES!"
-print ("Input data: "+s)
kex_buff = bytes("114151400014314485131FGXVGHcJFIH", "utf-8")
size_kex_buff = len(kex_buff)
seed = bytes(112771128)
seed_size = len(seed)
-crypto.init()
-key_id = crypto.generateNewKey(1, kex_buff, size_kex_buff, seed, seed_size, 32)
+libTPO.init()
+key = libTPO.Crypto.generateNewKey(libTPO.CryptoKeyType.DAP_ENC_KEY_TYPE_OAES(), kex_buff, size_kex_buff, seed, seed_size, 32)
source = bytes(s, "utf-8")
-enc = crypto.encryptOAESFast(key_id, source, len(source), 2048)
-decrypt = crypto.decryptOAESFast(key_id, enc, len(enc), 2048)
-print (decrypt)
-
+enc = libTPO.Crypto.encryptOAESFast(key, source, len(source), 2048)
+decrypt = libTPO.Crypto.decryptOAESFast(key, enc, len(enc), 2048)
if bytes(s, "utf-8") == decrypt:
print ("TEST 1. Encode/Decode OAES FAST done")