Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • car/libdap-crypto
1 result
Show changes
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 11463 additions and 188 deletions
src/GOST/block_chipher.h 0 → 100644
View file @ fb1c4cbf
/** @file
* @brief ?????????? ??????? ??????????? ?????? ?????? ??????? ??????????
*
* @copyright InfoTeCS. All rights reserved.
*/
#ifndef BLOCK_CHIPHER_H
#define BLOCK_CHIPHER_H
#include "dll_import.h"
#include "callback_print.h"
/** @brief ?????? ????????? ??? ?????? ?????????? ECB ????????? "????????" */
#define kEcb14ContextLen 0x38
/** @brief ?????? ????????? ??? ?????? ?????????? ECB ????????? 28147-89 */
#define kEcb89ContextLen 0x38
/** @brief ?????? ????????? ??? ?????? ?????????? CBC ????????? "????????" */
#define kCbc14ContextLen 0x60
/** @brief ?????? ????????? ??? ?????? ?????????? CBC ????????? 28147-89 */
#define kCbc89ContextLen 0x60
/** @brief ?????? ????????? ??? ?????? ?????????? CTR ????????? "????????" */
#define kCtr14ContextLen 0x48
/** @brief ?????? ????????? ??? ?????? ?????????? CTR ????????? 28147-89 */
#define kCtr89ContextLen 0x48
/** @brief ?????? ????????? ??? ?????? ?????????? OFB ????????? "????????" */
#define kOfb14ContextLen 0x60
/** @brief ?????? ????????? ??? ?????? ?????????? OFB ????????? 28147-89 */
#define kOfb89ContextLen 0x60
/** @brief ?????? ????????? ??? ?????? ?????????? CFB ????????? "????????" */
#define kCfb14ContextLen 0x60
/** @brief ?????? ????????? ??? ?????? ?????????? CFB ????????? 28147-89 */
#define kCfb89ContextLen 0x60
/** @brief ?????? ????????? ??? ?????? ???????????? ???????????? ????????? "????????" */
#define kImit14ContextLen 0x88
/** @brief ?????? ????????? ??? ?????? ???????????? ???????????? ????????? 28147-89 */
#define kImit89ContextLen 0x88
/** @brief ?????? ????? ????????? "????????" */
#define kBlockLen14 16
/** @brief ?????? ????? ????????? 28147-89 */
#define kBlockLen89 8
/** @brief ?????? ????? ????????? "????????" */
#define kKeyLen14 32
/** @brief ?????? ????? ????????? 28147-89 */
#define kKeyLen89 32
#ifdef __cplusplus
extern "C" {
#endif
/* *** ?????? ?????????? ***
* ?????? ?????????? ???????? ? ?????????????? ????????
* ?????????????????? ??????????????
*/
/** @brief ????????????? ????????? ?????????? ? ?????? ECB ??? ????????? "????????"
*
* @param[in] key ????
* @param[out] ctx ???????? cbc
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_ecb_14(unsigned char *key, void* ctx, printout_byte_array print, printout_uint_array print_uint);
/** @brief ????????????? ????????? ?????????? ? ?????? ECB ??? ????????? 28147-89
*
* @param[in] key ????
* @param[out] ctx ???????? cbc
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_ecb_89(unsigned char *key, void* ctx, printout_byte_array print, printout_uint_array print_uint);
/** @brief ???????? ????????? ecb
*
* @param[in] ctx ???????? ecb
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
void DLL_IMPORT free_ecb(void* ctx);
/** @brief ????????????? ????????? ?????????? ? ?????? CBC ??? ????????? "????????"
*
* @param[in] key ????
* @param[out] ctx ???????? cbc
* @param[in] iv ?????????????
* @param[in] ivLength ????? ?????????????
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_cbc_14(unsigned char *key, void* ctx, unsigned char *iv, size_t ivLength, printout_byte_array print, printout_uint_array print_uint);
/** @brief ????????????? ????????? ?????????? ? ?????? CBC ??? ????????? 28147-89
*
* @param[in] key ????
* @param[out] ctx ???????? cbc
* @param[in] iv ?????????????
* @param[in] ivLength ????? ?????????????
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_cbc_89(unsigned char *key, void* ctx, unsigned char *iv, size_t ivLength, printout_byte_array print, printout_uint_array print_uint);
/** @brief ???????? ????????? cbc
*
* @param[in] ctx ???????? cbc
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
void DLL_IMPORT free_cbc(void* ctx);
/** @brief ????????????? ????????? ?????????? ? ?????? CTR ??? ????????? "????????"
*
* @param[in] key ????
* @param[out] ctx ???????? ctr
* @param[in] iv ?????????????
* @param[in] length ????? ?????????????
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_ctr_14(unsigned char* key, unsigned char *iv, size_t length, void *ctx, printout_byte_array print, printout_uint_array print_uint);
/** @brief ????????????? ????????? ?????????? ? ?????? CTR ??? ????????? 28147-89
*
* @param[in] key ????
* @param[out] ctx ???????? ctr
* @param[in] iv ?????????????
* @param[in] length ????? ?????????????
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_ctr_89(unsigned char* key, unsigned char *iv, size_t length, void *ctx, printout_byte_array print, printout_uint_array print_uint);
/** @brief ???????? ????????? ctr
*
* @param[in] ctx ???????? ctr
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
void DLL_IMPORT free_ctr(void* ctx);
/** @brief ????????????? ????????? ?????????? ? ?????? OFB ??? ????????? "????????"
*
* @param[in] key ????
* @param[out] ctx ???????? ofb
* @param[in] s ???????? S
* @param[in] iv ?????????????
* @param[in] ivLength ????? ?????????????
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_ofb_14(unsigned char *key, void *ctx, size_t s, const unsigned char *iv, size_t ivLength, printout_byte_array print, printout_uint_array print_uint);
/** @brief ????????????? ????????? ?????????? ? ?????? OFB ??? ????????? 28147-89
*
* @param[in] key ????
* @param[out] ctx ???????? ofb
* @param[in] s ???????? S
* @param[in] iv ?????????????
* @param[in] ivLength ????? ?????????????
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_ofb_89(unsigned char *key, void *ctx, size_t s, unsigned char *iv, size_t ivLength, printout_byte_array print, printout_uint_array print_uint);
/** @brief ???????? ????????? ofb
*
* @param[in] ctx ???????? ofb
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
void DLL_IMPORT free_ofb(void* ctx);
/** @brief ????????????? ????????? ?????????? ? ?????? CFB ??? ????????? "????????"
*
* @param[in] key ????
* @param[out] ctx ???????? cfb
* @param[in] s ???????? S
* @param[in] iv ?????????????
* @param[in] ivLength ????? ?????????????
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_cfb_14(unsigned char *key, void *ctx, size_t s, unsigned char *iv, size_t ivLength, printout_byte_array print, printout_uint_array print_uint);
/** @brief ????????????? ????????? ?????????? ? ?????? CFB ??? ????????? 28147-89
*
* @param[in] key ????
* @param[out] ctx ???????? cfb
* @param[in] s ???????? S
* @param[in] iv ?????????????
* @param[in] ivLength ????? ?????????????
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_cfb_89(unsigned char *key, void *ctx, size_t s, unsigned char *iv, size_t ivLength, printout_byte_array print, printout_uint_array print_uint);
/** @brief ???????? ????????? cfb
*
* @param[in] ctx ???????? cfb
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
void DLL_IMPORT free_cfb(void* ctx);
/** @brief ????????????? ????????? ??????????? ??? ????????? "????????"
*
* @param[out] ctx ???????? ????????????
* @param[in] key ????
* @param[in] s ???????? S
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_imit_14(unsigned char *key, size_t s, void *ctx, printout_byte_array print, printout_uint_array print_uint);
/** @brief ????????????? ????????? ??????????? ??? ????????? 28147-89
*
* @param[in] key ????
* @param[in] s ???????? S
* @param[out] ctx ???????? ????????????
* @param[in] print ??????? ???????????
* @param[in] print_uint ??????? ???????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT init_imit_89(unsigned char *key, size_t s, void *ctx, printout_byte_array print, printout_uint_array print_uint);
/** @brief ???????? ????????? ????????????
*
* @param[in] ctx ???????? ????????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
void DLL_IMPORT free_imit(void* ctx);
/** @brief ?????????? ???????????? ?????????? ? ?????? ??????? ?????? ??? ?????? ??????? ??????? ?????
*
* @param[in] ctx ???????? ECB
* @param[in] indata ???????? ?????
* @param[out] outdata ????????????? ?????
* @param[in] length ????? ??????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT encrypt_ecb(void *ctx, const unsigned char *indata, unsigned char *outdata, size_t length);
/** @brief ?????????? ????????????? ?????????? ? ?????? ??????? ?????? ??? ?????? ??????? ??????? ?????
*
* @param[in] ctx ???????? ECB
* @param[in] indata ???????? ?????
* @param[out] outdata ????????????? ?????
* @param[in] length ????? ??????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT decrypt_ecb(void *ctx, const unsigned char *indata, unsigned char *outdata, size_t length);
/** @brief ?????????? ???????????? ?????????? ? ?????? ??????? ?????? ? ??????????? ??? ?????? ??????? ??????? ?????
*
* @param[in] ctx ???????? CBC
* @param[in] indata ???????? ?????
* @param[out] outdata ????????????? ?????
* @param[in] length ????? ??????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT encrypt_cbc(void *ctx, const unsigned char *indata, unsigned char *outdata, size_t length);
/** @brief ?????????? ???????????? ?????????? ? ?????? ??????? ?????? ? ??????????? ??? ?????? ??????? ??????? ?????
*
* @param[in] ctx ???????? CBC
* @param[in] indata ????????????? ?????
* @param[out] outdata ?????????????? ?????
* @param[in] length ????? ??????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT decrypt_cbc(void *ctx, const unsigned char *indata, unsigned char *outdata, size_t length);
/** @brief ?????????? ?????????? (???????????? ??? ?????????????) ? ?????? ????????????
* @details ???????? ?????? ????? ???? ?????? ????????? ????, ??? ??????? ?????????? ????? ???????? ????????? ????? ???????????? ??????
*
* @param[in] ctx ???????? CTR
* @param[in] indata ??????? ?????????
* @param[out] outdata ?????????
* @param[in] length ????? ?????????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT crypt_ctr(void *ctx, const unsigned char *indata, unsigned char *outdata, size_t length);
/** @brief ?????????? ??????? ?????????? ?????????? ? ?????? ???????????? ? ???????? ??????
* @details ???????? ?????? ????? ???? ?????? ????????? ????, ??? ??????? ?????????? ????? ???????? ????????? ????? ???????????? ??????
*
* @param[in] ctx ???????? OFB
* @param[in] indata ??????? ????
* @param[out] outdata ????????? ??????????????
* @param[in] inlength ????? ??????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT crypt_ofb(void *ctx, const unsigned char *indata, unsigned char *outdata, size_t inlength);
/** @brief ?????????? ???????????? ?????????? ? ?????? ???????????? ? ???????? ??????
*
* @param[in] ctx ???????? OFB
* @param[in] indata ???????? ?????
* @param[out] outdata ????????????? ?????
* @param[in] inlength ????? ??????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT encrypt_ofb(void *ctx, const unsigned char *indata, unsigned char *outdata, size_t inlength);
/** @brief ?????????? ????????????? ?????????? ? ?????? ???????????? ? ???????? ??????
*
* @param[in] ctx ???????? OFB
* @param[in] indata ????????????? ?????
* @param[out] outdata ?????????????? ?????
* @param[in] inlength ????? ??????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT decrypt_ofb(void *ctx, const unsigned char *indata, unsigned char *outdata, size_t inlength);
/** @brief ?????????? ???????????? ?????????? ? ?????? ???????????? ? ???????? ?????? ?? ??????????
* @details ???????? ?????? ????? ???? ?????? ????????? ????, ??? ??????? ?????????? ????? ???????? ????????? ????? ???????????? ??????
*
* @param[in] ctx ???????? CFB
* @param[in] indata ???????? ?????
* @param[out] outdata ????????????? ?????
* @param[in] inlength ????? ??????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT encrypt_cfb(void *ctx, const unsigned char *indata, unsigned char *outdata, size_t inlength);
/** @brief ?????????? ????????????? ?????????? ? ?????? ???????????? ? ???????? ?????? ?? ??????????
* @details ???????? ?????? ????? ???? ?????? ????????? ????, ??? ??????? ?????????? ????? ???????? ????????? ????? ???????????? ??????
*
* @param[in] ctx ???????? CFB
* @param[in] indata ????????????? ?????
* @param[out] outdata ?????????????? ?????
* @param[in] inlength ????? ??????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT decrypt_cfb(void *ctx, const unsigned char *indata, unsigned char *outdata, size_t inlength);
/** @brief ?????????? ?????????? ???????????? ?? ?????? ??????? ??????? ?????
*
* @param[in] ctx ???????? ????????????
* @param[in] indata ???????? ?????
* @param[in] length ????? ??????
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT imit(void *ctx, unsigned char *indata, size_t length);
/** @brief ?????????? ????????? ????????????
*
* @param[in] ctx ???????? ????????????
* @param[out] value
* @return 0 ???? ??? ?????????????? ?????? ???????
* @return -1 ???? ????????? ??????
*/
int DLL_IMPORT done_imit(void *ctx, unsigned char *value);
/** @brief ?????????? ?????? ?? ??????? ?????.
*
* @param[in] data ?????????. ?????? ??? ?????? data ?????? ???? ???????? ??????????? ??? ??????????.
* @param[in] length ?????? ?????????
* @param[in] blockLen ????? ?????
* @return ?????? ?????????
*/
size_t DLL_IMPORT padd(unsigned char *data, size_t length, size_t blockLen);
/** @brief ???????? ??????????? ??????. ??? ??????? ???????????? ???????? -1
*
* @param[in] data ?????????
* @param[in] length ?????? ?????????
* @return ?????? ?????????
*/
size_t DLL_IMPORT unpadd(unsigned char *data, size_t length);
#ifdef __cplusplus
}
#endif
#endif
src/GOST/callback_print.h 0 → 100644
View file @ fb1c4cbf
/** @file
* @brief callback
*
* @copyright InfoTeCS. All rights reserved.
*/
#ifndef CALLBACK_PRINT_H
#define CALLBACK_PRINT_H
#include "dll_import.h"
/** @brief callback byte */
typedef void (DLL_IMPORT *printout_byte_array)(const char* text, unsigned char* value, unsigned int valueSize);
/** @brief callback unsigned int32 */
typedef void (DLL_IMPORT *printout_uint_array)(const char* text, unsigned int* value, unsigned int valueSize);
#endif
src/GOST/dll_import.h 0 → 100644
View file @ fb1c4cbf
/** @file
* @brief ""
*
* @copyright InfoTeCS. All rights reserved.
*/
/** @brief file guard */
#ifndef DLL_IMPORT_H
#define DLL_IMPORT_H
#ifdef WIN32
#define DLL_IMPORT __stdcall
#else
#define DLL_IMPORT
#endif
#endif
src/GOST/print_data.c 0 → 100644
View file @ fb1c4cbf
/** @file
* @brief
*
* @copyright InfoTeCS. All rights reserved.
*/
#include <memory.h>
#include <string.h>
#include <stdio.h>
#include "print_data.h"
int PrintTest(const char* caption, int result)
{
const char ok[] = "OK.";
const char failed[] = "FAILED.";
char line[LINE_WIDTH] = "";
const char * testResult;
memset(line, ' ', LINE_WIDTH-1);
line[LINE_WIDTH-1] = '\0';
testResult = result ? failed : ok;
memcpy(line, caption, strlen(caption));
memcpy(line + LINE_WIDTH - strlen(testResult) - 1, testResult, strlen(testResult));
PrintLine(line);
PrintSplitLine();
return result;
}
void PrintCharSingle(char c)
{
printf("%c", c);
}
void PrintChar(char c, size_t count)
{
size_t i;
for(i = 0; i < count; ++i)
{
PrintCharSingle(c);
}
}
void PrintStr(const char* s)
{
printf("%s", s);
}
void PrintStrAlign(const char* s, size_t width)
{
size_t len = strlen(s);
PrintStr(s);
if(len < width)
{
PrintChar(' ', width - len);
}
}
void PrintBlockLeft(const char* label, unsigned int d)
{
PrintChar(' ', TAB_WIDTH);
PrintStr(label);
PrintUInt32(d);
PrintEmptyLine();
}
void PrintLineLeft(const char* label)
{
PrintChar(' ', TAB_WIDTH);
PrintStr(label);
PrintEmptyLine();
}
void PrintLine(const char* line)
{
PrintStr(line);
PrintEmptyLine();
}
void PrintEmptyLine()
{
printf("\n");
}
void PrintSplitLine()
{
PrintChar('-', LINE_WIDTH);
PrintEmptyLine();
}
void PrintLabel(const char* label)
{
PrintSplitLine();
PrintLine(label);
PrintEmptyLine();
}
void PrintHex(unsigned char value)
{
unsigned char a, b , c;
a = (value & 0xf0) >> 4;
c = a < 0xa ? a + 48 : a + 87;
PrintCharSingle(c);
b = (value & 0x0f);
c = b < 0xa ? b + 48 : b + 87;
PrintCharSingle(c);
}
void PrintHexArray(unsigned char* value, size_t size)
{
size_t i;
for(i = 0; i < size; ++i)
{
PrintHex(value[i]);
}
}
void PrintUInt32(unsigned int d)
{
printf("%x", d);
}
void PrintBlockInt(const char* label, unsigned int value)
{
PrintChar(' ', TAB_WIDTH);
PrintStrAlign(label, LINE_WIDTH - TAB_WIDTH - 8);
PrintUInt32(value);
PrintEmptyLine();
}
void PrintBlock(const char* label, unsigned char* value, size_t valueSize, size_t blockSize)
{
unsigned char a, b, c;
size_t width, tab;
size_t j, i;
width = LINE_WIDTH;
tab = TAB_WIDTH;
PrintChar(' ', tab);
PrintStrAlign(label, width - tab - (blockSize*2));
PrintHexArray(value, blockSize > valueSize ? valueSize : blockSize);
PrintEmptyLine();
for(j = 1; j < valueSize / blockSize; ++j)
{
PrintChar(' ', width-(blockSize*2));
for(i = 0; i < blockSize; ++i)
{
a = (value[ j * blockSize + i] & 0xf0) >> 4;
c = a < 0xa ? a + 48 : a + 87;
PrintCharSingle(c);
b = (value[ j * blockSize + i] & 0x0f);
c = b < 0xa ? b + 48 : b + 87;
PrintCharSingle(c);
}
PrintEmptyLine();
}
}
void DLL_IMPORT print_array(const char* label, unsigned char* value, unsigned int valueSize)
{
unsigned int i;
printf("%s ", label);
for(i = 0; i < valueSize; ++i)
{
printf("%02x", value[i]);
}
printf("\n");
}
void DLL_IMPORT print_uint_array(const char* label, unsigned int* value, unsigned int valueSize)
{
unsigned int i;
printf("%s ", label);
for(i = 0; i < valueSize; ++i)
{
printf("%08x", value[i]);
}
printf("\n");
}
src/GOST/print_data.h 0 → 100644
View file @ fb1c4cbf
/** @file
* @brief
*
* @copyright InfoTeCS. All rights reserved.
*/
#ifndef PRINT_DATA_H
#define PRINT_DATA_H
#include "dll_import.h"
/** @brief */
#define LINE_WIDTH 60
/** @brief */
#define TAB_WIDTH 4
/** @brief
*
* @param[in] caption
* @param[in] result
*/
int PrintTest(const char* caption, int result);
/** @brief */
void PrintCharSingle(char c);
/** @brief c count */
void PrintChar(char c, size_t count);
/** @brief */
void PrintStr(const char* s);
/** @brief */
void PrintStrAlign(const char* s, size_t width);
/** @brief */
void PrintLine(const char* line);
/** @brief */
void PrintEmptyLine();
/** @brief */
void PrintLineLeft(const char* label);
/** @brief */
void PrintSplitLine();
/** @brief , */
void PrintLabel(const char* label);
/** @brief HEX */
void PrintHex(unsigned char value);
/** @brief HEX */
void PrintHexArray(unsigned char* value, size_t size);
/** @brief int32 HEX */
void PrintUInt32(unsigned int d);
/** @brief */
void PrintBlock(const char* label, unsigned char* value, size_t valueSize, size_t blockSize);
/** @brief */
void PrintBlockInt(const char* label, unsigned int value);
/** @brief */
void PrintBlockLeft(const char* label, unsigned int value);
/** @brief callback byte */
void DLL_IMPORT print_array(const char* label, unsigned char* value, unsigned int valueSize);
/** @brief callback unsigned int32 */
void DLL_IMPORT print_uint_array(const char* label, unsigned int* value, unsigned int valueSize);
#endif
src/GOST/table.h 0 → 100644
View file @ fb1c4cbf
This diff is collapsed.
src/GOST/test_data.inc 0 → 100644
View file @ fb1c4cbf
/*----------------------------------------------------------------------
*
*/
/* S */
unsigned char kSData[5][kBlockLen14] =
{
{0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x00},
{0xb6, 0x6c, 0xd8, 0x88, 0x7d, 0x38, 0xe8, 0xd7, 0x77, 0x65, 0xae, 0xea, 0x0c, 0x9a, 0x7e, 0xfc},
{0x55, 0x9d, 0x8d, 0xd7, 0xbd, 0x06, 0xcb, 0xfe, 0x7e, 0x7b, 0x26, 0x25, 0x23, 0x28, 0x0d, 0x39},
{0x0c, 0x33, 0x22, 0xfe, 0xd5, 0x31, 0xe4, 0x63, 0x0d, 0x80, 0xef, 0x5c, 0x5a, 0x81, 0xc5, 0x0b},
{0x23, 0xae, 0x65, 0x63, 0x3f, 0x84, 0x2d, 0x29, 0xc5, 0xdf, 0x52, 0x9c, 0x13, 0xf5, 0xac, 0xda}
};
/* R */
unsigned char kRData[5][kBlockLen14] =
{
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00},
{0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01},
{0xa5, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x64, 0xa5, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x0d, 0x64, 0xa5, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
};
/* L */
unsigned char kLData[5][kBlockLen14] =
{
{0x64, 0xa5, 0x94, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0xd4, 0x56, 0x58, 0x4d, 0xd0, 0xe3, 0xe8, 0x4c, 0xc3, 0x16, 0x6e, 0x4b, 0x7f, 0xa2, 0x89, 0x0d},
{0x79, 0xd2, 0x62, 0x21, 0xb8, 0x7b, 0x58, 0x4c, 0xd4, 0x2f, 0xbc, 0x4f, 0xfe, 0xa5, 0xde, 0x9a},
{0x0e, 0x93, 0x69, 0x1a, 0x0c, 0xfc, 0x60, 0x40, 0x8b, 0x7b, 0x68, 0xf6, 0x6b, 0x51, 0x3c, 0x13},
{0xe6, 0xa8, 0x09, 0x4f, 0xee, 0x0a, 0xa2, 0x04, 0xfd, 0x97, 0xbc, 0xb0, 0xb4, 0x4b, 0x85, 0x80}
};
/* */
static const unsigned char kKData[10][kBlockLen14] =
{
{0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77},
{0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef},
{0xdb, 0x31, 0x48, 0x53, 0x15, 0x69, 0x43, 0x43, 0x22, 0x8d, 0x6a, 0xef, 0x8c, 0xc7, 0x8c, 0x44},
{0x3d, 0x45, 0x53, 0xd8, 0xe9, 0xcf, 0xec, 0x68, 0x15, 0xeb, 0xad, 0xc4, 0x0a, 0x9f, 0xfd, 0x04},
{0x57, 0x64, 0x64, 0x68, 0xc4, 0x4a, 0x5e, 0x28, 0xd3, 0xe5, 0x92, 0x46, 0xf4, 0x29, 0xf1, 0xac},
{0xbd, 0x07, 0x94, 0x35, 0x16, 0x5c, 0x64, 0x32, 0xb5, 0x32, 0xe8, 0x28, 0x34, 0xda, 0x58, 0x1b},
{0x51, 0xe6, 0x40, 0x75, 0x7e, 0x87, 0x45, 0xde, 0x70, 0x57, 0x27, 0x26, 0x5a, 0x00, 0x98, 0xb1},
{0x5a, 0x79, 0x25, 0x01, 0x7b, 0x9f, 0xdd, 0x3e, 0xd7, 0x2a, 0x91, 0xa2, 0x22, 0x86, 0xf9, 0x84},
{0xbb, 0x44, 0xe2, 0x53, 0x78, 0xc7, 0x31, 0x23, 0xa5, 0xf3, 0x2f, 0x73, 0xcd, 0xb6, 0xe5, 0x17},
{0x72, 0xe9, 0xdd, 0x74, 0x16, 0xbc, 0xf4, 0x5b, 0x75, 0x5d, 0xba, 0xa8, 0x8e, 0x4a, 0x40, 0x43},
};
/* - */
unsigned char kMasterKeyData[32] =
{
0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,0x77,
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef
};
/* */
unsigned char kPlainTextData[] =
{
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x00, 0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88
};
/* */
unsigned char kChipherTextData[] =
{
0x7f, 0x67, 0x9d, 0x90, 0xbe, 0xbc, 0x24, 0x30, 0x5a, 0x46, 0x8d, 0x42, 0xb9, 0xd4, 0xed, 0xcd
};
/* L */
unsigned char kReverseLData[2][kBlockLen14] =
{
{0x0d, 0x8e, 0x40, 0xe4, 0xa8, 0x00, 0xd0, 0x6b, 0x2f, 0x1b, 0x37, 0xea, 0x37, 0x9e, 0xad, 0x8e},
{0x8a, 0x6b, 0x93, 0x0a, 0x52, 0x21, 0x1b, 0x45, 0xc5, 0xba, 0xa4, 0x3f, 0xf8, 0xb9, 0x13, 0x19},
};
/* LSX */
unsigned char kReverseLSXData[10][kBlockLen14] =
{
{0x8a, 0x6b, 0x93, 0x0a, 0x52, 0x21, 0x1b, 0x45, 0xc5, 0xba, 0xa4, 0x3f, 0xf8, 0xb9, 0x13, 0x19},
{0x76, 0xca, 0x14, 0x9e, 0xef, 0x27, 0xdl, 0xbl, 0x0d, 0x17, 0xe3, 0xd5, 0xd6, 0x8e, 0x5a, 0x72},
{0x5d, 0x9b, 0x06, 0xd4, 0x1b, 0x9d, 0x1d, 0x2d, 0x04, 0xdf, 0x77, 0x55, 0x36, 0x3e, 0x94, 0xa9},
{0x79, 0x48, 0x71, 0x92, 0xaa, 0x45, 0x70, 0x9c, 0x11, 0x55, 0x59, 0xd6, 0xe9, 0x28, 0x0f, 0x6e},
{0xae, 0x50, 0x69, 0x24, 0xc8, 0xce, 0x33, 0x1b, 0xb9, 0x18, 0xfc, 0x5b, 0xdf, 0xbl, 0x95, 0xfa},
{0xbb, 0xff, 0xbf, 0xc8, 0x93, 0x9e, 0xaa, 0xff, 0xaf, 0xb8, 0xe2, 0x27, 0x69, 0xe3, 0x23, 0xaa},
{0x3c, 0xc2, 0xf0, 0x7c, 0xc0, 0x7a, 0x8b, 0xec, 0x0f, 0x3e, 0xa0, 0xed, 0x2a, 0xe3, 0x3e, 0x4a},
{0xf3, 0x6f, 0x01, 0x29, 0x1d, 0x0b, 0x96, 0xd5, 0x91, 0xe2, 0x28, 0xb7, 0x2d, 0x01, 0x1c, 0x36},
{0x1c, 0x4b, 0x0c, 0x1e, 0x95, 0x01, 0x82, 0xbl, 0xce, 0x69, 0x6a, 0xf5, 0xc0, 0xbf, 0xc5, 0xdf},
{0x99, 0xbb, 0x99, 0xff, 0x99, 0xbb, 0x99, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
};
unsigned char kGost14SV[8] =
{
0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef
};
unsigned char kGost14PlainText[64] =
{
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x00, 0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88,
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xee, 0xff, 0x0a,
0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xee, 0xff, 0x0a, 0x00,
0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xee, 0xff, 0x0a, 0x00, 0x11
};
unsigned char kGost14EcbEncText[64] =
{
0x7f, 0x67, 0x9d, 0x90, 0xbe, 0xbc, 0x24, 0x30, 0x5a, 0x46, 0x8d, 0x42, 0xb9, 0xd4, 0xed, 0xcd,
0xb4, 0x29, 0x91, 0x2c, 0x6e, 0x00, 0x32, 0xf9, 0x28, 0x54, 0x52, 0xd7, 0x67, 0x18, 0xd0, 0x8b,
0xf0, 0xca, 0x33, 0x54, 0x9d, 0x24, 0x7c, 0xee, 0xf3, 0xf5, 0xa5, 0x31, 0x3b, 0xd4, 0xb1, 0x57,
0xd0, 0xb0, 0x9c, 0xcd, 0xe8, 0x30, 0xb9, 0xeb, 0x3a, 0x02, 0xc4, 0xc5, 0xaa, 0x8a, 0xda, 0x98
};
unsigned char kGost14CtrSV[16] =
{
0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xce, 0xf0, 0xa1, 0xb2, 0xc3, 0xd4, 0xe5, 0xf0, 0x01, 0x12
};
unsigned char kGost14CtrC[64] =
{
0xf1, 0x95, 0xd8, 0xbe, 0xc1, 0x0e, 0xd1, 0xdb, 0xd5, 0x7b, 0x5f, 0xa2, 0x40, 0xbd, 0xa1, 0xb8,
0x85, 0xee, 0xe7, 0x33, 0xf6, 0xa1, 0x3e, 0x5d, 0xf3, 0x3c, 0xe4, 0xb3, 0x3c, 0x45, 0xde, 0xe4,
0xa5, 0xea, 0xe8, 0x8b, 0xe6, 0x35, 0x6e, 0xd3, 0xd5, 0xe8, 0x77, 0xf1, 0x35, 0x64, 0xa3, 0xa5,
0xcb, 0x91, 0xfa, 0xb1, 0xf2, 0x0c, 0xba, 0xb6, 0xd1, 0xc6, 0xd1, 0x58, 0x20, 0xbd, 0xba, 0x73
};
unsigned char kGost14OfbSV[32] =
{
0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xce, 0xf0, 0xa1, 0xb2, 0xc3, 0xd4, 0xe5, 0xf0, 0x01, 0x12,
0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x90, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19
};
unsigned char kGost14OfbC[64] =
{
0x81, 0x80, 0x0a, 0x59, 0xb1, 0x84, 0x2b, 0x24, 0xff, 0x1f, 0x79, 0x5e, 0x89, 0x7a, 0xbd, 0x95,
0xed, 0x5b, 0x47, 0xa7, 0x04, 0x8c, 0xfa, 0xb4, 0x8f, 0xb5, 0x21, 0x36, 0x9d, 0x93, 0x26, 0xbf,
0x66, 0xa2, 0x57, 0xac, 0x3c, 0xa0, 0xb8, 0xb1, 0xc8, 0x0f, 0xe7, 0xfc, 0x10, 0x28, 0x8a, 0x13,
0x20, 0x3e, 0xbb, 0xc0, 0x66, 0x13, 0x86, 0x60, 0xa0, 0x29, 0x22, 0x43, 0xf6, 0x90, 0x31, 0x50
};
unsigned char kGost14CbcSV[32] =
{
0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xce, 0xf0, 0xa1, 0xb2, 0xc3, 0xd4, 0xe5, 0xf0, 0x01, 0x12,
0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x90, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19
};
unsigned char kGost14CbcC[64] =
{
0x68, 0x99, 0x72, 0xd4, 0xa0, 0x85, 0xfa, 0x4d, 0x90, 0xe5, 0x2e, 0x3d, 0x6d, 0x7d, 0xcc, 0x27,
0x28, 0x26, 0xe6, 0x61, 0xb4, 0x78, 0xec, 0xa6, 0xaf, 0x1e, 0x8e, 0x44, 0x8d, 0x5e, 0xa5, 0xac,
0xfe, 0x7b, 0xab, 0xf1, 0xe9, 0x19, 0x99, 0xe8, 0x56, 0x40, 0xe8, 0xb0, 0xf4, 0x9d, 0x90, 0xd0,
0x16, 0x76, 0x88, 0x06, 0x5a, 0x89, 0x5c, 0x63, 0x1a, 0x2d, 0x9a, 0x15, 0x60, 0xb6, 0x39, 0x70
};
unsigned char kGost14CfbSV[32] =
{
0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xce, 0xf0, 0xa1, 0xb2, 0xc3, 0xd4, 0xe5, 0xf0, 0x01, 0x12,
0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x90, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19
};
unsigned char kGost14CfbC[64] =
{
0x81, 0x80, 0x0a, 0x59, 0xb1, 0x84, 0x2b, 0x24, 0xff, 0x1f, 0x79, 0x5e, 0x89, 0x7a, 0xbd, 0x95,
0xed, 0x5b, 0x47, 0xa7, 0x04, 0x8c, 0xfa, 0xb4, 0x8f, 0xb5, 0x21, 0x36, 0x9d, 0x93, 0x26, 0xbf,
0x79, 0xf2, 0xa8, 0xeb, 0x5c, 0xc6, 0x8d, 0x38, 0x84, 0x2d, 0x26, 0x4e, 0x97, 0xa2, 0x38, 0xb5,
0x4f, 0xfe, 0xbe, 0xcd, 0x4e, 0x92, 0x2d, 0xe6, 0xc7, 0x5b, 0xd9, 0xdd, 0x44, 0xfb, 0xf4, 0xd1
};
unsigned char kGost14ImitS[8] =
{
0x33, 0x6f, 0x4d, 0x29, 0x60, 0x59, 0xfb, 0xe3
};
/* -------------------------------------------------------- */
unsigned char kMasterKeyGost89[] =
{
0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa, 0x99, 0x88,
0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
};
/* 89 */
unsigned char kGost89StandartPlainText[] =
{
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
};
unsigned char kGost89StandartEncrText[] =
{
0x4e, 0xe9, 0x01, 0xe5, 0xc2, 0xd8, 0xca, 0x3d
};
/* t, */
unsigned int kTData[5] =
{
0xfdb97531, 0x2a196f34, 0xebd9f03a, 0xb039bb3d, 0x68695433
};
/* g, */
unsigned int kgData[4][3] =
{
{0x87654321, 0xfedcba98, 0xfdcbc20c},
{0xfdcbc20c, 0x87654321, 0x7e791a4b},
{0x7e791a4b, 0xfdcbc20c, 0xc76549ec},
{0xc76549ec, 0x7e791a4b, 0x9791c849}
};
unsigned char kGost89PlaintText[32] =
{
0x92, 0xde, 0xf0, 0x6b, 0x3c, 0x13, 0x0a, 0x59,
0xdb, 0x54, 0xc7, 0x04, 0xf8, 0x18, 0x9d, 0x20,
0x4a, 0x98, 0xfb, 0x2e, 0x67, 0xa8, 0x02, 0x4c,
0x89, 0x12, 0x40, 0x9b, 0x17, 0xb5, 0x7e, 0x41,
};
unsigned char kGost89EcbC[32] =
{
0x2b, 0x07, 0x3f, 0x04, 0x94, 0xf3, 0x72, 0xa0,
0xde, 0x70, 0xe7, 0x15, 0xd3, 0x55, 0x6e, 0x48,
0x11, 0xd8, 0xd9, 0xe9, 0xea, 0xcf, 0xbc, 0x1e,
0x7c, 0x68, 0x26, 0x09, 0x96, 0xc6, 0x7e, 0xfb
};
unsigned char kGost89CtrSV[4] =
{
0x12, 0x34, 0x56, 0x78
};
unsigned char kGost89CtrC[32] =
{
0x4e, 0x98, 0x11, 0x0c, 0x97, 0xb7, 0xb9, 0x3c,
0x3e, 0x25, 0x0d, 0x93, 0xd6, 0xe8, 0x5d, 0x69,
0x13, 0x6d, 0x86, 0x88, 0x07, 0xb2, 0xdb, 0xef,
0x56, 0x8e, 0xb6, 0x80, 0xab, 0x52, 0xa1, 0x2d
};
unsigned char kGost89OfbSV[16] =
{
0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
0x23, 0x45, 0x67, 0x89, 0x0a, 0xbc, 0xde, 0xf1
};
unsigned char kGost89OfbC[32] =
{
0xdb, 0x37, 0xe0, 0xe2, 0x66, 0x90, 0x3c, 0x83,
0x0d, 0x46, 0x64, 0x4c, 0x1f, 0x9a, 0x08, 0x9c,
0xa0, 0xf8, 0x30, 0x62, 0x43, 0x0e, 0x32, 0x7e,
0xc8, 0x24, 0xef, 0xb8, 0xbd, 0x4f, 0xdb, 0x05
};
unsigned char kGost89CbcSV[24] =
{
0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
0x23, 0x45, 0x67, 0x89, 0x0a, 0xbc, 0xde, 0xf1,
0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 0x12,
};
unsigned char kGost89CbcC[32] =
{
0x96, 0xd1, 0xb0, 0x5e, 0xea, 0x68, 0x39, 0x19,
0xaf, 0xf7, 0x61, 0x29, 0xab, 0xb9, 0x37, 0xb9,
0x50, 0x58, 0xb4, 0xa1, 0xc4, 0xbc, 0x00, 0x19,
0x20, 0xb7, 0x8b, 0x1a, 0x7c, 0xd7, 0xe6, 0x67,
};
unsigned char kGost89CfbSV[16] =
{
0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
0x23, 0x45, 0x67, 0x89, 0x0a, 0xbc, 0xde, 0xf1
};
unsigned char kGost89CfbC[32] =
{
0xdb, 0x37, 0xe0, 0xe2, 0x66, 0x90, 0x3c, 0x83,
0x0d, 0x46, 0x64, 0x4c, 0x1f, 0x9a, 0x08, 0x9c,
0x24, 0xbd, 0xd2, 0x03, 0x53, 0x15, 0xd3, 0x8b,
0xbc, 0xc0, 0x32, 0x14, 0x21, 0x07, 0x55, 0x05
};
unsigned char kGost89ImitS[8] =
{
0x15, 0x4e, 0x72, 0x10, 0x20, 0x30, 0xc5, 0xbb
};
/* ----------------------------------------------------- */
unsigned char kPaddingText[16] =
{
2, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
unsigned char kPaddingText2[32] =
{
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
unsigned char paddingBufferText[16] =
{
2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
unsigned char paddingBufferText2[32] =
{
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
src/GOST/testgost.c 0 → 100644
View file @ fb1c4cbf
/** @file
* @brief "" 28147-89.
*
* @copyright InfoTeCS. All rights reserved.
*/
#include <memory.h>
#include "28147_14.h"
#include "block_chipher.h"
#include "28147_89.h"
#include "test_data.inc"
#include "print_data.h"
/** @brief "" */
#define textLen14 sizeof(kGost14PlainText)
/** @brief "28147-89" */
#define textLen89 sizeof(kGost89PlaintText)
/** @brief S "" */
int testS()
{
unsigned char tmp[kBlockLen14];
unsigned int i;
PrintLabel("Test S function start.");
for(i = 0; i < 4; ++i)
{
funcS(kSData[i], tmp, 0);
PrintBlockLeft("Test ", i+1);
PrintBlock("Input Value: ", kSData[i], kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", tmp, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control Value: ", kSData[i+1], kBlockLen14, kBlockLen14);
PrintEmptyLine();
if(memcmp(tmp, kSData[i+1], kBlockLen14))
return -1;
}
return 0;
}
/** @brief R "" */
int testR()
{
unsigned char tmp[kBlockLen14];
int i;
PrintLabel("Test R function start.");
for(i =0; i < 4; ++i)
{
if(funcR(kRData[i], tmp, 0))
return -1;
PrintBlockLeft("Test ", i+1);
PrintBlock("Input Value: ", kRData[i], kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", tmp, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control Value: ", kRData[i+1], kBlockLen14, kBlockLen14);
PrintEmptyLine();
if(memcmp(tmp, kRData[i+1], kBlockLen14))
return -1;
}
return 0;
}
/** @brief L "" */
int testL()
{
unsigned char tmp[kBlockLen14];
int i;
PrintLabel("Test L function start.");
for(i =0; i < 4; ++i)
{
if(funcL(kLData[i], tmp, 0))
return -1;
PrintBlockLeft("Test ", i+1);
PrintBlock("Input Value: ", kLData[i], kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", tmp, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control Value: ", kLData[i+1], kBlockLen14, kBlockLen14);
PrintEmptyLine();
if( memcmp(tmp, kLData[i+1], kBlockLen14))
return -1;
}
return 0;
}
/** @brief "" */
int testExpandKey()
{
const size_t keyLen = sizeof(kMasterKeyData)/sizeof(kMasterKeyData[0]);
unsigned char keys[160];
int i;
PrintLabel("Test Expand Key function start.");
if(ExpandKey(kMasterKeyData, keys, 0))
return -1;
PrintBlock("Master Key: ", kMasterKeyData, keyLen, kBlockLen14);
PrintEmptyLine();
for(i = 0; i < 10; ++i)
{
PrintBlock("Output Key: ", keys+i*kBlockLen14, kBlockLen14, kBlockLen14);
PrintBlock("Control Key: ", (unsigned char*)kKData[i], kBlockLen14, kBlockLen14);
PrintEmptyLine();
if( memcmp(keys+i*kBlockLen14, kKData[i], kBlockLen14))
return -1;
}
return 0;
}
/** @brief "" */
int testEncrypt()
{
const size_t keyLen = sizeof(kMasterKeyData)/sizeof(kMasterKeyData[0]);
unsigned char ctx[kEcb14ContextLen];
unsigned char output[kBlockLen14];
PrintLabel("Test Encrypt start.");
if(init_ecb_14(kMasterKeyData, ctx, 0, 0))
return -1;
if(encrypt_ecb(ctx, kPlainTextData, output, kBlockLen14))
return -1;
PrintBlock("Master Key: ", kMasterKeyData, keyLen, kBlockLen14);
PrintEmptyLine();
PrintBlock("Input Value: ", kPlainTextData, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", output, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kChipherTextData, kBlockLen14, kBlockLen14);
PrintEmptyLine();
if( memcmp(output, kChipherTextData, kBlockLen14))
return -1;
return 0;
}
/** @brief "" */
int testDecrypt()
{
const size_t keyLen = sizeof(kMasterKeyData)/sizeof(kMasterKeyData[0]);
unsigned char ctx[kEcb14ContextLen];
unsigned char output[kBlockLen14];
PrintLabel("Test Decrypt start.");
if(init_ecb_14(kMasterKeyData, ctx, 0, 0))
return -1;
if(decrypt_ecb(ctx, kChipherTextData, output, kBlockLen14))
return -1;
PrintBlock("Master Key: ", kMasterKeyData, keyLen, kBlockLen14);
PrintEmptyLine();
PrintBlock("Input Value: ", kChipherTextData, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", output, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kPlainTextData, kBlockLen14, kBlockLen14);
PrintEmptyLine();
if( memcmp(output, kPlainTextData, kBlockLen14) )
return -1;
free_ecb(ctx);
return 0;
}
/** @brief ecb "" */
int gost14_ECB_test()
{
unsigned char ctx[kEcb14ContextLen];
unsigned char output[textLen14];
unsigned char outputE[textLen14];
PrintLabel("Ecb mode 28147-14 test start.");
if(init_ecb_14(kMasterKeyData, ctx, print_array, print_uint_array))
return -1;
if(encrypt_ecb(ctx, kGost14PlainText, output, textLen14))
return -1;
PrintBlock("Master Key: ", kMasterKeyData, 32, kBlockLen14);
PrintEmptyLine();
PrintLineLeft("Test Encrypt.");
PrintEmptyLine();
PrintBlock("Input Value: ", kGost14PlainText, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", output, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kGost14EcbEncText, kBlockLen14, kBlockLen14);
PrintEmptyLine();
if( memcmp(output, kGost14EcbEncText, textLen14))
return -1;
if(init_ecb_14(kMasterKeyData, ctx, print_array, print_uint_array))
return -1;
if(decrypt_ecb(ctx, output, outputE, textLen14))
return -1;
PrintLineLeft("Test Decrypt.");
PrintEmptyLine();
PrintBlock("Input Value: ", output, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", outputE, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kGost14PlainText, kBlockLen14, kBlockLen14);
PrintEmptyLine();
if( memcmp(outputE, kGost14PlainText, textLen14))
return -1;
free_ecb(ctx);
return 0;
}
/** @brief ctr "" */
int gost14_CTR_test()
{
const size_t svLen = sizeof(kGost14CtrSV);
unsigned char outText[textLen14];
unsigned char ctx[kCtr14ContextLen];
PrintLabel("CTR mode 28147-14 test start.");
if(init_ctr_14(kMasterKeyData, kGost14CtrSV, svLen, ctx, print_array, print_uint_array))
return -1;
if(crypt_ctr(ctx, kGost14PlainText, outText, textLen14))
return -1;
free_ctr(ctx);
PrintBlock("Master Key: ", kMasterKeyData, 32, kBlockLen14);
PrintEmptyLine();
PrintBlock("SV: ", kGost14CtrSV, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Input Value: ", kGost14PlainText, textLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", outText, textLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kGost14CtrC, textLen14, kBlockLen14);
PrintEmptyLine();
return memcmp(outText, kGost14CtrC, textLen14);
}
/** @brief ofb "" */
int gost14_OFB_test()
{
const size_t svLen = sizeof(kGost14OfbSV);
unsigned char outText[textLen14];
unsigned char ctx[kOfb14ContextLen];
PrintLabel("OFB mode 28147-14 test start.");
if(init_ofb_14(kMasterKeyData, ctx, kBlockLen14, kGost14OfbSV, svLen, print_array, print_uint_array))
return -1;
if(crypt_ofb(ctx, kGost14PlainText, outText, textLen14))
return -1;
free_ofb(ctx);
PrintBlock("Master Key: ", kMasterKeyData, 32, kBlockLen14);
PrintEmptyLine();
PrintBlock("SV: ", kGost14OfbSV, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Input Value: ", kGost14PlainText, textLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", outText, textLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kGost14OfbC, textLen14, kBlockLen14);
PrintEmptyLine();
return memcmp(outText, kGost14OfbC, textLen14);
}
/** @brief cbc "" */
int gost14_CBC_test()
{
const size_t svLen = sizeof(kGost14CbcSV);
unsigned char outText[textLen14];
unsigned char outTextDec[textLen14];
unsigned char ctx[kCbc14ContextLen];
PrintLabel("CBC mode 28147-14 test start.");
if(init_cbc_14(kMasterKeyData, ctx, kGost14CbcSV, svLen, print_array, print_uint_array))
return -1;
if(encrypt_cbc(ctx, kGost14PlainText, outText, textLen14))
return -1;
free_cbc(ctx);
PrintBlock("Master Key: ", kMasterKeyData, 32, kBlockLen14);
PrintEmptyLine();
PrintLineLeft("Test Encrypt.");
PrintEmptyLine();
PrintBlock("SV: ", kGost14CbcSV, svLen, kBlockLen14);
PrintEmptyLine();
PrintBlock("Input Value: ", kGost14PlainText, textLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", outText, textLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kGost14CbcC, textLen14, kBlockLen14);
PrintEmptyLine();
if(init_cbc_14(kMasterKeyData, ctx, kGost14CbcSV, svLen, print_array, print_uint_array))
return -1;
if(decrypt_cbc(ctx, outText, outTextDec, textLen14))
return -1;
free_cbc(ctx);
PrintLineLeft("Test Decrypt.");
PrintEmptyLine();
PrintBlock("Input Value: ", outText, textLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", outTextDec, textLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kGost14PlainText, textLen14, kBlockLen14);
PrintEmptyLine();
if(memcmp(outTextDec, kGost14PlainText, textLen14))
return -1;
return memcmp(outText, kGost14CbcC, textLen14);
}
/** @brief cfb "" */
int gost14_CFB_test()
{
const size_t svLen = sizeof(kGost14CfbSV);
unsigned char outText[textLen14];
unsigned char outTextDec[textLen14];
unsigned char ctx[kCfb14ContextLen];
PrintLabel("CFB mode 28147-14 test start.");
if(init_cfb_14(kMasterKeyData, ctx, kBlockLen14, kGost14CfbSV, svLen, print_array, print_uint_array))
return -1;
if(encrypt_cfb(ctx, kGost14PlainText, outText, textLen89))
return -1;
if(memcmp(outText, kGost14CfbC, textLen89))
return -1;
PrintBlock("Master Key: ", kMasterKeyData, 32, kBlockLen14);
PrintEmptyLine();
PrintBlock("SV: ", kGost14CfbSV, svLen, kBlockLen14);
PrintEmptyLine();
PrintLineLeft("Test Encrypt.");
PrintEmptyLine();
PrintBlock("Input Value: ", kGost14PlainText, textLen89, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", outText, textLen89, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kGost14CfbC, textLen89, kBlockLen14);
PrintEmptyLine();
free_cfb(ctx);
if(init_cfb_14(kMasterKeyData, ctx, 16, kGost14CfbSV, svLen, print_array, print_uint_array))
return -1;
if(decrypt_cfb(ctx, outText, outTextDec, textLen89))
return -1;
PrintLineLeft("Test Decrypt.");
PrintEmptyLine();
PrintBlock("Input Value: ", outText, textLen89, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", outTextDec, textLen89, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kGost14PlainText, textLen89, kBlockLen14);
PrintEmptyLine();
if(memcmp(outTextDec, kGost14PlainText, textLen89))
return -1;
free_cfb(ctx);
return 0;
}
/** @brief "" */
int gost14_imita_test()
{
const size_t imitLen = sizeof(kGost14ImitS);
unsigned char outText[16];
unsigned char ctx[kImit14ContextLen];
PrintLabel("Imita mode 28147-14 test start.");
if(init_imit_14(kMasterKeyData, kBlockLen14, ctx, print_array, print_uint_array))
return -1;
if(imit(ctx, kGost14PlainText, textLen14))
return 0;
done_imit(ctx, outText);
PrintBlock("Input Value: ", kGost14PlainText, textLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", outText, imitLen, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kGost14ImitS, imitLen, kBlockLen14);
PrintEmptyLine();
free_imit(ctx);
return memcmp(outText, kGost14ImitS, imitLen);
}
/** @brief ecb 28147-89 */
int gost89_ECB_test()
{
unsigned char ctx[kEcb89ContextLen];
unsigned char output[textLen89];
unsigned char outputDec[textLen89];
PrintLabel("Ecb mode 28147-89 test start.");
if(init_ecb_89(kMasterKeyGost89, ctx, print_array, print_uint_array))
return -1;
if(encrypt_ecb(ctx, kGost89PlaintText, output, textLen89))
return -1;
PrintBlock("Master Key: ", kMasterKeyGost89, 32, kBlockLen89);
PrintEmptyLine();
PrintBlock("Input Value: ", kGost89PlaintText, textLen89, kBlockLen89);
PrintEmptyLine();
PrintBlock("Output Value: ", output, textLen89, kBlockLen89);
PrintEmptyLine();
PrintBlock("Control value: ", kGost89EcbC, textLen89, kBlockLen89);
PrintEmptyLine();
if(memcmp(output, kGost89EcbC, textLen89))
return -1;
free_ecb(ctx);
if(init_ecb_89(kMasterKeyGost89, ctx, print_array, print_uint_array))
return -1;
if(decrypt_ecb(ctx, output, outputDec, textLen89))
return -1;
if(memcmp(outputDec, kGost89PlaintText, textLen89))
return -1;
free_ecb(ctx);
return 0;
}
/** @brief ctr 28147-89 */
int gost89_CTR_test()
{
const size_t SvLen = sizeof(kGost89CtrSV);
unsigned char outText[textLen89];
unsigned char ctx[kCtr89ContextLen];
PrintLabel("Ctr mode 28147-89 test start.");
if(init_ctr_89(kMasterKeyGost89, kGost89CtrSV, kBlockLen89, ctx, print_array, print_uint_array))
return -1;
if(crypt_ctr(ctx, kGost89PlaintText, outText, textLen89))
return -1;
free_ctr(ctx);
PrintBlock("Master Key: ", kMasterKeyGost89, 32, kBlockLen89);
PrintEmptyLine();
PrintBlock("SV: ", kGost89CtrSV, SvLen, kBlockLen89);
PrintEmptyLine();
PrintBlock("Input Value: ", kGost89PlaintText, textLen89, kBlockLen89);
PrintEmptyLine();
PrintBlock("Output Value: ", outText, textLen89, kBlockLen89);
PrintEmptyLine();
PrintBlock("Control value: ", kGost89CtrC, textLen89, kBlockLen89);
PrintEmptyLine();
return memcmp(outText, kGost89CtrC, textLen89);
}
/** @brief ofb 28147-89 */
int gost89_OFB_test()
{
const size_t SvLen = sizeof(kGost89OfbSV);
unsigned char outText[textLen89];
unsigned char ctx[kOfb89ContextLen];
PrintLabel("Ofb mode 28147-89 test start.");
if(init_ofb_89(kMasterKeyGost89, ctx, kBlockLen89, kGost89OfbSV, SvLen, print_array, print_uint_array))
return -1;
if(crypt_ofb(ctx, kGost89PlaintText, outText, textLen89))
return -1;
PrintBlock("Master Key: ", kMasterKeyGost89, 32, kBlockLen89);
PrintEmptyLine();
PrintBlock("SV: ", kGost89OfbSV, SvLen, kBlockLen89);
PrintEmptyLine();
PrintBlock("Input Value: ", kGost89PlaintText, textLen89, kBlockLen89);
PrintEmptyLine();
PrintBlock("Output Value: ", outText, textLen89, kBlockLen89);
PrintEmptyLine();
PrintBlock("Control value: ", kGost89OfbC, textLen89, kBlockLen89);
PrintEmptyLine();
free_ofb(ctx);
return memcmp(outText, kGost89OfbC, textLen89);
}
/** @brief cbc 28147-89 */
int gost89_CBC_test()
{
const size_t SvLen = sizeof(kGost89CbcSV);
unsigned char outText[textLen89];
unsigned char outTextDec[textLen89];
unsigned char ctx[kCbc89ContextLen];
PrintLabel("Cbc mode 28147-89 test start.");
if(init_cbc_89(kMasterKeyGost89, ctx, kGost89CbcSV, SvLen, print_array, print_uint_array))
return -1;
if(encrypt_cbc(ctx, kGost89PlaintText, outText, textLen89))
return 0;
free_cbc(ctx);
PrintBlock("Master Key: ", kMasterKeyGost89, 32, kBlockLen89);
PrintEmptyLine();
PrintBlock("SV: ", kGost89CbcSV, SvLen, kBlockLen89);
PrintEmptyLine();
PrintBlock("Input Value: ", kGost89PlaintText, textLen89, kBlockLen89);
PrintEmptyLine();
PrintBlock("Output Value: ", outText, textLen89, kBlockLen89);
PrintEmptyLine();
PrintBlock("Control value: ", kGost89CbcC, textLen89, kBlockLen89);
PrintEmptyLine();
if(init_cbc_89(kMasterKeyGost89, ctx, kGost89CbcSV, SvLen, print_array, print_uint_array))
return -1;
if(decrypt_cbc(ctx, outText, outTextDec, textLen89))
return -1;
free_cbc(ctx);
if(memcmp(outTextDec, kGost89PlaintText, textLen89))
return -1;
return memcmp(outText, kGost89CbcC, textLen89);
}
/** @brief 28147-89 */
int standart_89_encr_test()
{
const size_t textLen = sizeof(kGost89StandartPlainText);
unsigned char ctx[kEcb89ContextLen];
unsigned char output[sizeof(kGost89StandartPlainText)];
unsigned char outputE[sizeof(kGost89StandartPlainText)];
PrintLabel("Standart 28147-89 encryption test start.");
if(init_ecb_89(kMasterKeyGost89, ctx, print_array, print_uint_array))
return -1;
if(encrypt_ecb(ctx, kGost89StandartPlainText, output, textLen))
return -1;
PrintBlock("Master Key: ", kMasterKeyGost89, 32, kBlockLen89);
PrintEmptyLine();
PrintBlock("Input Value: ", kGost89StandartPlainText, textLen, kBlockLen89);
PrintEmptyLine();
PrintBlock("Output Value: ", output, textLen, kBlockLen89);
PrintEmptyLine();
PrintBlock("Control value: ", kGost89StandartEncrText, textLen, kBlockLen89);
PrintEmptyLine();
if(memcmp(output, kGost89StandartEncrText, textLen))
return -1;
free_ecb(ctx);
if(init_ecb_89(kMasterKeyGost89, ctx, print_array, print_uint_array))
return -1;
if(decrypt_ecb(ctx, output, outputE, textLen))
return -1;
if(memcmp(outputE, kGost89StandartPlainText, textLen))
return -1;
free_ecb(ctx);
return 0;
}
/** @brief cfb 28147-89 */
int gost89_CFB_test()
{
const size_t SvLen = sizeof(kGost89CfbSV);
unsigned char outText[textLen89];
unsigned char outTextDec[textLen89];
unsigned char ctx[kCfb89ContextLen];
PrintLabel("Cfb mode 28147-89 test start.");
if(init_cfb_89(kMasterKeyGost89, ctx, kBlockLen89, kGost89CfbSV, SvLen, print_array, print_uint_array))
return -1;
if(encrypt_cfb(ctx, kGost89PlaintText, outText, textLen89))
return -1;
PrintBlock("Master Key: ", kMasterKeyGost89, 32, kBlockLen89);
PrintEmptyLine();
PrintBlock("SV: ", kGost89CfbSV, SvLen, kBlockLen89);
PrintEmptyLine();
PrintBlock("Input Value: ", kGost89PlaintText, textLen89, kBlockLen89);
PrintEmptyLine();
PrintBlock("Output Value: ", outText, textLen89, kBlockLen89);
PrintEmptyLine();
PrintBlock("Control value: ", kGost89CfbC, textLen89, kBlockLen89);
PrintEmptyLine();
if(memcmp(outText, kGost89CfbC, textLen89))
return -1;
free_cfb(ctx);
if(init_cfb_89(kMasterKeyGost89, ctx, kBlockLen89, kGost89CfbSV, SvLen, print_array, print_uint_array))
return -1;
if(decrypt_cfb(ctx, outText, outTextDec, textLen89))
return -1;
if(memcmp(outTextDec, kGost89PlaintText, textLen89))
return -1;
free_cfb(ctx);
return 0;
}
#include<stdio.h>
/** @brief 28147-89 */
int gost89_imita_test()
{
const size_t imitLen = sizeof(kGost89ImitS);
unsigned char outText[sizeof(kGost89ImitS)];
unsigned char ctx[kImit89ContextLen];
PrintLabel("Imita mode 28147-89 test start.");
if(init_imit_89(kMasterKeyGost89, kBlockLen89, ctx, print_array, print_uint_array))
return -1;
if(imit(ctx, kGost89PlaintText, textLen89))
return -1;
done_imit(ctx, outText);
free_imit(ctx);
PrintBlock("Master Key: ", kMasterKeyGost89, 32, kBlockLen89);
PrintEmptyLine();
PrintBlock("Input Value: ", kGost89PlaintText, textLen89, kBlockLen89);
PrintEmptyLine();
PrintBlock("Output Value: ", outText, imitLen, kBlockLen89);
PrintEmptyLine();
PrintBlock("Control value: ", kGost89ImitS, imitLen, kBlockLen89);
PrintEmptyLine();
return memcmp(outText, kGost89ImitS, imitLen);
}
/** @brief */
int testPadding()
{
const size_t len = sizeof(kPaddingText)/sizeof(kPaddingText[0]);
const size_t len2 = sizeof(kPaddingText2)/sizeof(kPaddingText2[0]);
padd(paddingBufferText, 1, kBlockLen14);
padd(paddingBufferText2, kBlockLen14, 2*kBlockLen14);
PrintLineLeft("Test 1");
PrintBlock("Input Value: ", paddingBufferText, 1, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", paddingBufferText, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kPaddingText, len, kBlockLen14);
PrintEmptyLine();
// if(memcmp(paddingBufferText, kPaddingText, len))
// return -1;
PrintLineLeft("Test 2");
PrintBlock("Input Value: ", paddingBufferText2, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", paddingBufferText2, 2*kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kPaddingText2, len2, kBlockLen14);
PrintEmptyLine();
fflush(stdout);
// if(memcmp(paddingBufferText2, kPaddingText2, len2))
// return -1;
return 0;
}
/** @brief */
int testCut()
{
size_t rLen, rLen2;
padd(paddingBufferText, 1, kBlockLen14);
padd(paddingBufferText2, kBlockLen14, 2*kBlockLen14);
rLen = unpadd(paddingBufferText, kBlockLen14);
rLen2 = unpadd(paddingBufferText2, 2*kBlockLen14);
PrintLabel("Cut padding test start.");
PrintLineLeft("Test 1");
PrintBlock("Input Value: ", paddingBufferText, kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", paddingBufferText, rLen, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kPaddingText, 1, kBlockLen14);
PrintEmptyLine();
PrintLineLeft("Test 2");
PrintBlock("Input Value: ", paddingBufferText2, 2*kBlockLen14, kBlockLen14);
PrintEmptyLine();
PrintBlock("Output Value: ", paddingBufferText2, rLen2, kBlockLen14);
PrintEmptyLine();
PrintBlock("Control value: ", kPaddingText2, kBlockLen14, kBlockLen14);
PrintEmptyLine();
if(rLen !=1 )
return -1;
if(rLen2 != kBlockLen14)
return -1;
return 0;
}
/** @brief t 28147-89 */
int testFuncT()
{
int i;
PrintLabel("Test 28147-89 function T start.");
for(i = 0; i < 4; ++i)
{
unsigned int ans;
ans = funcT(kTData[i], 0);
PrintBlockLeft("Test ", i+1);
PrintBlockInt("Input value", kTData[i]);
PrintBlockInt("Ouput value", ans);
PrintBlockInt("Control value", kTData[i+1]);
PrintEmptyLine();
if(ans != kTData[i+1])
return -1;
}
return 0;
}
/** @brief g 28147-89 */
int testG()
{
int i;
PrintLabel("Test 28147-89 function G start.");
for(i = 0; i < 4; ++i)
{
unsigned int ans;
ans = funcG(kgData[i][0], kgData[i][1], 0);
PrintBlockLeft("Test ", i+1);
PrintBlockInt("Input value", kgData[i][0]);
PrintBlockInt("Key value", kgData[i][1]);
PrintBlockInt("Ouput value", ans);
PrintBlockInt("Control value", kgData[i][2]);
PrintEmptyLine();
if( ans!= kgData[i][2])
return -1;
}
return 0;
}
/** @brief */
int main_gost_test()
{
int testRes = 0;
PrintLine("TEST start.");
PrintEmptyLine();
PrintLine("TEST 28147-14 standart start.");
testRes |= PrintTest("S function test end", testS());
testRes |= PrintTest("R function test.", testR());
testRes |= PrintTest("L function test.", testL());
testRes |= PrintTest("Expand Key 28147-14 test.", testExpandKey());
testRes |= PrintTest("Encrypt test.", testEncrypt());
testRes |= PrintTest("Decrypt test.", testDecrypt());
PrintEmptyLine();
PrintLine("TEST 28147-89 standart test.");
testRes |= PrintTest("28147-89 T function test.", testFuncT());
testRes |= PrintTest("28147-89 G function test.", testG());
testRes |= PrintTest("Encrypt test.", standart_89_encr_test());
PrintEmptyLine();
PrintLine("TEST 28147-14 mode test.");
testRes |= PrintTest("Ecb mode 28147-14 test.", gost14_ECB_test());
testRes |= PrintTest("CTR mode 28147-14 test.", gost14_CTR_test());
testRes |= PrintTest("OFB mode 28147-14 test.", gost14_OFB_test());
testRes |= PrintTest("CBC mode 28147-14 test.", gost14_CBC_test());
testRes |= PrintTest("CFB mode 28147-14 test.", gost14_CFB_test());
testRes |= PrintTest("Imita mode 28147-14 test.", gost14_imita_test());
PrintEmptyLine();
PrintLine("TEST 28147-89 mode test.");
testRes |= PrintTest("Ecb mode 28147-89 test.", gost89_ECB_test());
testRes |= PrintTest("CTR mode 28147-89 test.", gost89_CTR_test());
testRes |= PrintTest("OFB mode 28147-89 test.", gost89_OFB_test());
testRes |= PrintTest("CBC mode 28147-89 test.", gost89_CBC_test());
testRes |= PrintTest("CFB mode 28147-89 test.", gost89_CFB_test());
testRes |= PrintTest("Imita mode 28147-89 test.", gost89_imita_test());
PrintEmptyLine();
PrintLine("TEST padding test.");
testRes |= PrintTest("Add padding test.", testPadding());
testRes |= PrintTest("Cut padding test.", testCut());
PrintEmptyLine();
if ( testRes )
{
PrintLine("FAILED TESTS EXIST!!!!!.");
}
else
{
PrintLine("ALL TEST OK.");
}
return testRes;
}
src/blowfish/bf_cfb64.c 0 → 100644
View file @ fb1c4cbf
#include "bf_local.h"
#include"blowfish.h"
/*
* The input and output encrypted as though 64bit cfb mode is being used.
* The extra state information to record how much of the 64bit block we have
* used is contained in *num;
*/
void BF_cfb64_encrypt(const unsigned char *in, unsigned char *out,
long length, const BF_KEY *schedule,
unsigned char *ivec, int *num, int encrypt)
{
register BF_LONG v0, v1, t;
register int n = *num;
register long l = length;
BF_LONG ti[2];
unsigned char *iv, c, cc;
iv = (unsigned char *)ivec;
if (encrypt) {
while (l--) {
if (n == 0) {
n2l(iv, v0);
ti[0] = v0;
n2l(iv, v1);
ti[1] = v1;
BF_encrypt((BF_LONG *)ti, schedule);
iv = (unsigned char *)ivec;
t = ti[0];
l2n(t, iv);
t = ti[1];
l2n(t, iv);
iv = (unsigned char *)ivec;
}
c = *(in++) ^ iv[n];
*(out++) = c;
iv[n] = c;
n = (n + 1) & 0x07;
}
} else {
while (l--) {
if (n == 0) {
n2l(iv, v0);
ti[0] = v0;
n2l(iv, v1);
ti[1] = v1;
BF_encrypt((BF_LONG *)ti, schedule);
iv = (unsigned char *)ivec;
t = ti[0];
l2n(t, iv);
t = ti[1];
l2n(t, iv);
iv = (unsigned char *)ivec;
}
cc = *(in++);
c = iv[n];
iv[n] = cc;
*(out++) = c ^ cc;
n = (n + 1) & 0x07;
}
}
v0 = v1 = ti[0] = ti[1] = t = c = cc = 0;
*num = n;
}
src/blowfish/bf_ecb.c 0 → 100644
View file @ fb1c4cbf
#include "blowfish.h"
#include "bf_local.h"
/*
* Blowfish as implemented from 'Blowfish: Springer-Verlag paper' (From
* LECTURE NOTES IN COMPUTER SCIENCE 809, FAST SOFTWARE ENCRYPTION, CAMBRIDGE
* SECURITY WORKSHOP, CAMBRIDGE, U.K., DECEMBER 9-11, 1993)
*/
const char *BF_options(void)
{
return "blowfish(ptr)";
}
void BF_ecb_encrypt(const unsigned char *in, unsigned char *out,
const BF_KEY *key, int encrypt)
{
BF_LONG l, d[2];
n2l(in, l);
d[0] = l;
n2l(in, l);
d[1] = l;
if (encrypt)
BF_encrypt(d, key);
else
BF_decrypt(d, key);
l = d[0];
l2n(l, out);
l = d[1];
l2n(l, out);
l = d[0] = d[1] = 0;
}
src/blowfish/bf_enc.c 0 → 100644
View file @ fb1c4cbf
#include "blowfish.h"
#include "bf_local.h"
/*
* Blowfish as implemented from 'Blowfish: Springer-Verlag paper' (From
* LECTURE NOTES IN COMPUTER SCIENCE 809, FAST SOFTWARE ENCRYPTION, CAMBRIDGE
* SECURITY WORKSHOP, CAMBRIDGE, U.K., DECEMBER 9-11, 1993)
*/
#if (BF_ROUNDS != 16) && (BF_ROUNDS != 20)
# error If you set BF_ROUNDS to some value other than 16 or 20, you will have \
to modify the code.
#endif
//#include<stdio.h>
void BF_encrypt(BF_LONG *data, const BF_KEY *key)
{
register BF_LONG l, r;
register const BF_LONG *p, *s;
p = key->P;
s = &(key->S[0]);
l = data[0];
r = data[1];
l ^= p[0];
BF_ENC(r, l, s, p[1]);
BF_ENC(l, r, s, p[2]);
BF_ENC(r, l, s, p[3]);
BF_ENC(l, r, s, p[4]);
BF_ENC(r, l, s, p[5]);
BF_ENC(l, r, s, p[6]);
BF_ENC(r, l, s, p[7]);
BF_ENC(l, r, s, p[8]);
BF_ENC(r, l, s, p[9]);
BF_ENC(l, r, s, p[10]);
BF_ENC(r, l, s, p[11]);
BF_ENC(l, r, s, p[12]);
BF_ENC(r, l, s, p[13]);
BF_ENC(l, r, s, p[14]);
BF_ENC(r, l, s, p[15]);
BF_ENC(l, r, s, p[16]);
# if BF_ROUNDS == 20
BF_ENC(r, l, s, p[17]);
BF_ENC(l, r, s, p[18]);
BF_ENC(r, l, s, p[19]);
BF_ENC(l, r, s, p[20]);
# endif
r ^= p[BF_ROUNDS + 1];
data[1] = l & 0xffffffffU;
data[0] = r & 0xffffffffU;
}
void BF_decrypt(BF_LONG *data, const BF_KEY *key)
{
register BF_LONG l, r;
register const BF_LONG *p, *s;
p = key->P;
s = &(key->S[0]);
l = data[0];
r = data[1];
l ^= p[BF_ROUNDS + 1];
# if BF_ROUNDS == 20
BF_ENC(r, l, s, p[20]);
BF_ENC(l, r, s, p[19]);
BF_ENC(r, l, s, p[18]);
BF_ENC(l, r, s, p[17]);
# endif
BF_ENC(r, l, s, p[16]);
BF_ENC(l, r, s, p[15]);
BF_ENC(r, l, s, p[14]);
BF_ENC(l, r, s, p[13]);
BF_ENC(r, l, s, p[12]);
BF_ENC(l, r, s, p[11]);
BF_ENC(r, l, s, p[10]);
BF_ENC(l, r, s, p[9]);
BF_ENC(r, l, s, p[8]);
BF_ENC(l, r, s, p[7]);
BF_ENC(r, l, s, p[6]);
BF_ENC(l, r, s, p[5]);
BF_ENC(r, l, s, p[4]);
BF_ENC(l, r, s, p[3]);
BF_ENC(r, l, s, p[2]);
BF_ENC(l, r, s, p[1]);
r ^= p[0];
data[1] = l & 0xffffffffU;
data[0] = r & 0xffffffffU;
}
void BF_cbc_encrypt(const unsigned char *in, unsigned char *out, long length,
const BF_KEY *schedule, unsigned char *ivec, int encrypt)
{
register BF_LONG tin0, tin1;
register BF_LONG tout0, tout1, xor0, xor1;
register long l = length;
BF_LONG tin[2];
if (encrypt) {
n2l(ivec, tout0);
n2l(ivec, tout1);
ivec -= 8;
for (l -= 8; l >= 0; l -= 8) {
n2l(in, tin0);
n2l(in, tin1);
tin0 ^= tout0;
tin1 ^= tout1;
tin[0] = tin0;
tin[1] = tin1;
BF_encrypt(tin, schedule);
tout0 = tin[0];
tout1 = tin[1];
l2n(tout0, out);
l2n(tout1, out);
}
if (1||l != -8) {
unsigned char tmpin[16];
unsigned char *ptmpin = tmpin;
memcpy(tmpin, in, l + 8);
memcpy(tmpin + l + 8, &length, 4);
int pad_length = (8-(l + 8 + 4 + 1)%8)%8;
for(int i = 0; i < pad_length; ++i)
{
tmpin[l+8+4+i]=16;//prng better
}
tmpin[l+8+4+pad_length]=pad_length;
// for(int i = 0; i < l + 8 + 4 +1 +pad_length; ++i)
// {
// printf("%.2x ", tmpin[i]);
// }
// printf("\n");fflush(stdout);
n2l(ptmpin, tin0);
n2l(ptmpin, tin1);
tin0 ^= tout0;
tin1 ^= tout1;
tin[0] = tin0;
tin[1] = tin1;
BF_encrypt(tin, schedule);
tout0 = tin[0];
tout1 = tin[1];
l2n(tout0, out);
l2n(tout1, out);
if(l+8+4+pad_length + 1 == 16)
{
n2l(ptmpin, tin0);
n2l(ptmpin, tin1);
tin0 ^= tout0;
tin1 ^= tout1;
tin[0] = tin0;
tin[1] = tin1;
BF_encrypt(tin, schedule);
tout0 = tin[0];
tout1 = tin[1];
l2n(tout0, out);
l2n(tout1, out);
}
// n2ln(in, tin0, tin1, l + 8);
// tin0 ^= tout0;
// tin1 ^= tout1;
// tin[0] = tin0;
// tin[1] = tin1;
// BF_encrypt(tin, schedule);
// tout0 = tin[0];
// tout1 = tin[1];
// l2n(tout0, out);
// l2n(tout1, out);
}
l2n(tout0, ivec);
l2n(tout1, ivec);
} else {
n2l(ivec, xor0);
n2l(ivec, xor1);
ivec -= 8;
for (l -= 8; l >= 0; l -= 8) {
n2l(in, tin0);
n2l(in, tin1);
tin[0] = tin0;
tin[1] = tin1;
BF_decrypt(tin, schedule);
tout0 = tin[0] ^ xor0;
tout1 = tin[1] ^ xor1;
l2n(tout0, out);
l2n(tout1, out);
xor0 = tin0;
xor1 = tin1;
}
if (l != -8) {
n2l(in, tin0);
n2l(in, tin1);
tin[0] = tin0;
tin[1] = tin1;
BF_decrypt(tin, schedule);
tout0 = tin[0] ^ xor0;
tout1 = tin[1] ^ xor1;
l2nn(tout0, tout1, out, l + 8);
xor0 = tin0;
xor1 = tin1;
}
l2n(xor0, ivec);
l2n(xor1, ivec);
}
tin0 = tin1 = tout0 = tout1 = xor0 = xor1 = 0;
tin[0] = tin[1] = 0;
}
src/blowfish/bf_local.h 0 → 100644
View file @ fb1c4cbf
#ifndef BF_LOCAL_H
# define BF_LOCAL_H
/* NOTE - c is not incremented as per n2l */
# define n2ln(c,l1,l2,n) { \
c+=n; \
l1=l2=0; \
switch (n) { \
case 8: l2 =((unsigned long)(*(--(c)))) ; \
/* fall thru */ \
case 7: l2|=((unsigned long)(*(--(c))))<< 8; \
/* fall thru */ \
case 6: l2|=((unsigned long)(*(--(c))))<<16; \
/* fall thru */ \
case 5: l2|=((unsigned long)(*(--(c))))<<24; \
/* fall thru */ \
case 4: l1 =((unsigned long)(*(--(c)))) ; \
/* fall thru */ \
case 3: l1|=((unsigned long)(*(--(c))))<< 8; \
/* fall thru */ \
case 2: l1|=((unsigned long)(*(--(c))))<<16; \
/* fall thru */ \
case 1: l1|=((unsigned long)(*(--(c))))<<24; \
} \
}
/* NOTE - c is not incremented as per l2n */
# define l2nn(l1,l2,c,n) { \
c+=n; \
switch (n) { \
case 8: *(--(c))=(unsigned char)(((l2) )&0xff); \
/* fall thru */ \
case 7: *(--(c))=(unsigned char)(((l2)>> 8)&0xff); \
/* fall thru */ \
case 6: *(--(c))=(unsigned char)(((l2)>>16)&0xff); \
/* fall thru */ \
case 5: *(--(c))=(unsigned char)(((l2)>>24)&0xff); \
/* fall thru */ \
case 4: *(--(c))=(unsigned char)(((l1) )&0xff); \
/* fall thru */ \
case 3: *(--(c))=(unsigned char)(((l1)>> 8)&0xff); \
/* fall thru */ \
case 2: *(--(c))=(unsigned char)(((l1)>>16)&0xff); \
/* fall thru */ \
case 1: *(--(c))=(unsigned char)(((l1)>>24)&0xff); \
} \
}
# undef n2l
# define n2l(c,l) (l =((unsigned long)(*((c)++)))<<24L, \
l|=((unsigned long)(*((c)++)))<<16L, \
l|=((unsigned long)(*((c)++)))<< 8L, \
l|=((unsigned long)(*((c)++))))
# undef l2n
# define l2n(l,c) (*((c)++)=(unsigned char)(((l)>>24L)&0xff), \
*((c)++)=(unsigned char)(((l)>>16L)&0xff), \
*((c)++)=(unsigned char)(((l)>> 8L)&0xff), \
*((c)++)=(unsigned char)(((l) )&0xff))
/*
* This is actually a big endian algorithm, the most significant byte is used
* to lookup array 0
*/
# define BF_ENC(LL,R,S,P) ( \
LL^=P, \
LL^=((( S[ ((R>>24)&0xff)] + \
S[0x0100+((R>>16)&0xff)])^ \
S[0x0200+((R>> 8)&0xff)])+ \
S[0x0300+((R )&0xff)])&0xffffffffU \
)
#endif
src/blowfish/bf_ofb64.c 0 → 100644
View file @ fb1c4cbf
#include "blowfish.h"
#include "bf_local.h"
/*
* The input and output encrypted as though 64bit ofb mode is being used.
* The extra state information to record how much of the 64bit block we have
* used is contained in *num;
*/
void BF_ofb64_encrypt(const unsigned char *in, unsigned char *out,
long length, const BF_KEY *schedule,
unsigned char *ivec, int *num)
{
register BF_LONG v0, v1, t;
register int n = *num;
register long l = length;
unsigned char d[8];
register char *dp;
BF_LONG ti[2];
unsigned char *iv;
int save = 0;
iv = (unsigned char *)ivec;
n2l(iv, v0);
n2l(iv, v1);
ti[0] = v0;
ti[1] = v1;
dp = (char *)d;
l2n(v0, dp);
l2n(v1, dp);
while (l--) {
if (n == 0) {
BF_encrypt((BF_LONG *)ti, schedule);
dp = (char *)d;
t = ti[0];
l2n(t, dp);
t = ti[1];
l2n(t, dp);
save++;
}
*(out++) = *(in++) ^ d[n];
n = (n + 1) & 0x07;
}
if (save) {
v0 = ti[0];
v1 = ti[1];
iv = (unsigned char *)ivec;
l2n(v0, iv);
l2n(v1, iv);
}
t = v0 = v1 = ti[0] = ti[1] = 0;
*num = n;
}
src/blowfish/bf_pi.h 0 → 100644
View file @ fb1c4cbf
static const BF_KEY bf_init = {
{
0x243f6a88L, 0x85a308d3L, 0x13198a2eL, 0x03707344L,
0xa4093822L, 0x299f31d0L, 0x082efa98L, 0xec4e6c89L,
0x452821e6L, 0x38d01377L, 0xbe5466cfL, 0x34e90c6cL,
0xc0ac29b7L, 0xc97c50ddL, 0x3f84d5b5L, 0xb5470917L,
0x9216d5d9L, 0x8979fb1b}, {
0xd1310ba6L, 0x98dfb5acL, 0x2ffd72dbL,
0xd01adfb7L,
0xb8e1afedL, 0x6a267e96L, 0xba7c9045L,
0xf12c7f99L,
0x24a19947L, 0xb3916cf7L, 0x0801f2e2L,
0x858efc16L,
0x636920d8L, 0x71574e69L, 0xa458fea3L,
0xf4933d7eL,
0x0d95748fL, 0x728eb658L, 0x718bcd58L,
0x82154aeeL,
0x7b54a41dL, 0xc25a59b5L, 0x9c30d539L,
0x2af26013L,
0xc5d1b023L, 0x286085f0L, 0xca417918L,
0xb8db38efL,
0x8e79dcb0L, 0x603a180eL, 0x6c9e0e8bL,
0xb01e8a3eL,
0xd71577c1L, 0xbd314b27L, 0x78af2fdaL,
0x55605c60L,
0xe65525f3L, 0xaa55ab94L, 0x57489862L,
0x63e81440L,
0x55ca396aL, 0x2aab10b6L, 0xb4cc5c34L,
0x1141e8ceL,
0xa15486afL, 0x7c72e993L, 0xb3ee1411L,
0x636fbc2aL,
0x2ba9c55dL, 0x741831f6L, 0xce5c3e16L,
0x9b87931eL,
0xafd6ba33L, 0x6c24cf5cL, 0x7a325381L,
0x28958677L,
0x3b8f4898L, 0x6b4bb9afL, 0xc4bfe81bL,
0x66282193L,
0x61d809ccL, 0xfb21a991L, 0x487cac60L,
0x5dec8032L,
0xef845d5dL, 0xe98575b1L, 0xdc262302L,
0xeb651b88L,
0x23893e81L, 0xd396acc5L, 0x0f6d6ff3L,
0x83f44239L,
0x2e0b4482L, 0xa4842004L, 0x69c8f04aL,
0x9e1f9b5eL,
0x21c66842L, 0xf6e96c9aL, 0x670c9c61L,
0xabd388f0L,
0x6a51a0d2L, 0xd8542f68L, 0x960fa728L,
0xab5133a3L,
0x6eef0b6cL, 0x137a3be4L, 0xba3bf050L,
0x7efb2a98L,
0xa1f1651dL, 0x39af0176L, 0x66ca593eL,
0x82430e88L,
0x8cee8619L, 0x456f9fb4L, 0x7d84a5c3L,
0x3b8b5ebeL,
0xe06f75d8L, 0x85c12073L, 0x401a449fL,
0x56c16aa6L,
0x4ed3aa62L, 0x363f7706L, 0x1bfedf72L,
0x429b023dL,
0x37d0d724L, 0xd00a1248L, 0xdb0fead3L,
0x49f1c09bL,
0x075372c9L, 0x80991b7bL, 0x25d479d8L,
0xf6e8def7L,
0xe3fe501aL, 0xb6794c3bL, 0x976ce0bdL,
0x04c006baL,
0xc1a94fb6L, 0x409f60c4L, 0x5e5c9ec2L,
0x196a2463L,
0x68fb6fafL, 0x3e6c53b5L, 0x1339b2ebL,
0x3b52ec6fL,
0x6dfc511fL, 0x9b30952cL, 0xcc814544L,
0xaf5ebd09L,
0xbee3d004L, 0xde334afdL, 0x660f2807L,
0x192e4bb3L,
0xc0cba857L, 0x45c8740fL, 0xd20b5f39L,
0xb9d3fbdbL,
0x5579c0bdL, 0x1a60320aL, 0xd6a100c6L,
0x402c7279L,
0x679f25feL, 0xfb1fa3ccL, 0x8ea5e9f8L,
0xdb3222f8L,
0x3c7516dfL, 0xfd616b15L, 0x2f501ec8L,
0xad0552abL,
0x323db5faL, 0xfd238760L, 0x53317b48L,
0x3e00df82L,
0x9e5c57bbL, 0xca6f8ca0L, 0x1a87562eL,
0xdf1769dbL,
0xd542a8f6L, 0x287effc3L, 0xac6732c6L,
0x8c4f5573L,
0x695b27b0L, 0xbbca58c8L, 0xe1ffa35dL,
0xb8f011a0L,
0x10fa3d98L, 0xfd2183b8L, 0x4afcb56cL,
0x2dd1d35bL,
0x9a53e479L, 0xb6f84565L, 0xd28e49bcL,
0x4bfb9790L,
0xe1ddf2daL, 0xa4cb7e33L, 0x62fb1341L,
0xcee4c6e8L,
0xef20cadaL, 0x36774c01L, 0xd07e9efeL,
0x2bf11fb4L,
0x95dbda4dL, 0xae909198L, 0xeaad8e71L,
0x6b93d5a0L,
0xd08ed1d0L, 0xafc725e0L, 0x8e3c5b2fL,
0x8e7594b7L,
0x8ff6e2fbL, 0xf2122b64L, 0x8888b812L,
0x900df01cL,
0x4fad5ea0L, 0x688fc31cL, 0xd1cff191L,
0xb3a8c1adL,
0x2f2f2218L, 0xbe0e1777L, 0xea752dfeL,
0x8b021fa1L,
0xe5a0cc0fL, 0xb56f74e8L, 0x18acf3d6L,
0xce89e299L,
0xb4a84fe0L, 0xfd13e0b7L, 0x7cc43b81L,
0xd2ada8d9L,
0x165fa266L, 0x80957705L, 0x93cc7314L,
0x211a1477L,
0xe6ad2065L, 0x77b5fa86L, 0xc75442f5L,
0xfb9d35cfL,
0xebcdaf0cL, 0x7b3e89a0L, 0xd6411bd3L,
0xae1e7e49L,
0x00250e2dL, 0x2071b35eL, 0x226800bbL,
0x57b8e0afL,
0x2464369bL, 0xf009b91eL, 0x5563911dL,
0x59dfa6aaL,
0x78c14389L, 0xd95a537fL, 0x207d5ba2L,
0x02e5b9c5L,
0x83260376L, 0x6295cfa9L, 0x11c81968L,
0x4e734a41L,
0xb3472dcaL, 0x7b14a94aL, 0x1b510052L,
0x9a532915L,
0xd60f573fL, 0xbc9bc6e4L, 0x2b60a476L,
0x81e67400L,
0x08ba6fb5L, 0x571be91fL, 0xf296ec6bL,
0x2a0dd915L,
0xb6636521L, 0xe7b9f9b6L, 0xff34052eL,
0xc5855664L,
0x53b02d5dL, 0xa99f8fa1L, 0x08ba4799L,
0x6e85076aL,
0x4b7a70e9L, 0xb5b32944L, 0xdb75092eL,
0xc4192623L,
0xad6ea6b0L, 0x49a7df7dL, 0x9cee60b8L,
0x8fedb266L,
0xecaa8c71L, 0x699a17ffL, 0x5664526cL,
0xc2b19ee1L,
0x193602a5L, 0x75094c29L, 0xa0591340L,
0xe4183a3eL,
0x3f54989aL, 0x5b429d65L, 0x6b8fe4d6L,
0x99f73fd6L,
0xa1d29c07L, 0xefe830f5L, 0x4d2d38e6L,
0xf0255dc1L,
0x4cdd2086L, 0x8470eb26L, 0x6382e9c6L,
0x021ecc5eL,
0x09686b3fL, 0x3ebaefc9L, 0x3c971814L,
0x6b6a70a1L,
0x687f3584L, 0x52a0e286L, 0xb79c5305L,
0xaa500737L,
0x3e07841cL, 0x7fdeae5cL, 0x8e7d44ecL,
0x5716f2b8L,
0xb03ada37L, 0xf0500c0dL, 0xf01c1f04L,
0x0200b3ffL,
0xae0cf51aL, 0x3cb574b2L, 0x25837a58L,
0xdc0921bdL,
0xd19113f9L, 0x7ca92ff6L, 0x94324773L,
0x22f54701L,
0x3ae5e581L, 0x37c2dadcL, 0xc8b57634L,
0x9af3dda7L,
0xa9446146L, 0x0fd0030eL, 0xecc8c73eL,
0xa4751e41L,
0xe238cd99L, 0x3bea0e2fL, 0x3280bba1L,
0x183eb331L,
0x4e548b38L, 0x4f6db908L, 0x6f420d03L,
0xf60a04bfL,
0x2cb81290L, 0x24977c79L, 0x5679b072L,
0xbcaf89afL,
0xde9a771fL, 0xd9930810L, 0xb38bae12L,
0xdccf3f2eL,
0x5512721fL, 0x2e6b7124L, 0x501adde6L,
0x9f84cd87L,
0x7a584718L, 0x7408da17L, 0xbc9f9abcL,
0xe94b7d8cL,
0xec7aec3aL, 0xdb851dfaL, 0x63094366L,
0xc464c3d2L,
0xef1c1847L, 0x3215d908L, 0xdd433b37L,
0x24c2ba16L,
0x12a14d43L, 0x2a65c451L, 0x50940002L,
0x133ae4ddL,
0x71dff89eL, 0x10314e55L, 0x81ac77d6L,
0x5f11199bL,
0x043556f1L, 0xd7a3c76bL, 0x3c11183bL,
0x5924a509L,
0xf28fe6edL, 0x97f1fbfaL, 0x9ebabf2cL,
0x1e153c6eL,
0x86e34570L, 0xeae96fb1L, 0x860e5e0aL,
0x5a3e2ab3L,
0x771fe71cL, 0x4e3d06faL, 0x2965dcb9L,
0x99e71d0fL,
0x803e89d6L, 0x5266c825L, 0x2e4cc978L,
0x9c10b36aL,
0xc6150ebaL, 0x94e2ea78L, 0xa5fc3c53L,
0x1e0a2df4L,
0xf2f74ea7L, 0x361d2b3dL, 0x1939260fL,
0x19c27960L,
0x5223a708L, 0xf71312b6L, 0xebadfe6eL,
0xeac31f66L,
0xe3bc4595L, 0xa67bc883L, 0xb17f37d1L,
0x018cff28L,
0xc332ddefL, 0xbe6c5aa5L, 0x65582185L,
0x68ab9802L,
0xeecea50fL, 0xdb2f953bL, 0x2aef7dadL,
0x5b6e2f84L,
0x1521b628L, 0x29076170L, 0xecdd4775L,
0x619f1510L,
0x13cca830L, 0xeb61bd96L, 0x0334fe1eL,
0xaa0363cfL,
0xb5735c90L, 0x4c70a239L, 0xd59e9e0bL,
0xcbaade14L,
0xeecc86bcL, 0x60622ca7L, 0x9cab5cabL,
0xb2f3846eL,
0x648b1eafL, 0x19bdf0caL, 0xa02369b9L,
0x655abb50L,
0x40685a32L, 0x3c2ab4b3L, 0x319ee9d5L,
0xc021b8f7L,
0x9b540b19L, 0x875fa099L, 0x95f7997eL,
0x623d7da8L,
0xf837889aL, 0x97e32d77L, 0x11ed935fL,
0x16681281L,
0x0e358829L, 0xc7e61fd6L, 0x96dedfa1L,
0x7858ba99L,
0x57f584a5L, 0x1b227263L, 0x9b83c3ffL,
0x1ac24696L,
0xcdb30aebL, 0x532e3054L, 0x8fd948e4L,
0x6dbc3128L,
0x58ebf2efL, 0x34c6ffeaL, 0xfe28ed61L,
0xee7c3c73L,
0x5d4a14d9L, 0xe864b7e3L, 0x42105d14L,
0x203e13e0L,
0x45eee2b6L, 0xa3aaabeaL, 0xdb6c4f15L,
0xfacb4fd0L,
0xc742f442L, 0xef6abbb5L, 0x654f3b1dL,
0x41cd2105L,
0xd81e799eL, 0x86854dc7L, 0xe44b476aL,
0x3d816250L,
0xcf62a1f2L, 0x5b8d2646L, 0xfc8883a0L,
0xc1c7b6a3L,
0x7f1524c3L, 0x69cb7492L, 0x47848a0bL,
0x5692b285L,
0x095bbf00L, 0xad19489dL, 0x1462b174L,
0x23820e00L,
0x58428d2aL, 0x0c55f5eaL, 0x1dadf43eL,
0x233f7061L,
0x3372f092L, 0x8d937e41L, 0xd65fecf1L,
0x6c223bdbL,
0x7cde3759L, 0xcbee7460L, 0x4085f2a7L,
0xce77326eL,
0xa6078084L, 0x19f8509eL, 0xe8efd855L,
0x61d99735L,
0xa969a7aaL, 0xc50c06c2L, 0x5a04abfcL,
0x800bcadcL,
0x9e447a2eL, 0xc3453484L, 0xfdd56705L,
0x0e1e9ec9L,
0xdb73dbd3L, 0x105588cdL, 0x675fda79L,
0xe3674340L,
0xc5c43465L, 0x713e38d8L, 0x3d28f89eL,
0xf16dff20L,
0x153e21e7L, 0x8fb03d4aL, 0xe6e39f2bL,
0xdb83adf7L,
0xe93d5a68L, 0x948140f7L, 0xf64c261cL,
0x94692934L,
0x411520f7L, 0x7602d4f7L, 0xbcf46b2eL,
0xd4a20068L,
0xd4082471L, 0x3320f46aL, 0x43b7d4b7L,
0x500061afL,
0x1e39f62eL, 0x97244546L, 0x14214f74L,
0xbf8b8840L,
0x4d95fc1dL, 0x96b591afL, 0x70f4ddd3L,
0x66a02f45L,
0xbfbc09ecL, 0x03bd9785L, 0x7fac6dd0L,
0x31cb8504L,
0x96eb27b3L, 0x55fd3941L, 0xda2547e6L,
0xabca0a9aL,
0x28507825L, 0x530429f4L, 0x0a2c86daL,
0xe9b66dfbL,
0x68dc1462L, 0xd7486900L, 0x680ec0a4L,
0x27a18deeL,
0x4f3ffea2L, 0xe887ad8cL, 0xb58ce006L,
0x7af4d6b6L,
0xaace1e7cL, 0xd3375fecL, 0xce78a399L,
0x406b2a42L,
0x20fe9e35L, 0xd9f385b9L, 0xee39d7abL,
0x3b124e8bL,
0x1dc9faf7L, 0x4b6d1856L, 0x26a36631L,
0xeae397b2L,
0x3a6efa74L, 0xdd5b4332L, 0x6841e7f7L,
0xca7820fbL,
0xfb0af54eL, 0xd8feb397L, 0x454056acL,
0xba489527L,
0x55533a3aL, 0x20838d87L, 0xfe6ba9b7L,
0xd096954bL,
0x55a867bcL, 0xa1159a58L, 0xcca92963L,
0x99e1db33L,
0xa62a4a56L, 0x3f3125f9L, 0x5ef47e1cL,
0x9029317cL,
0xfdf8e802L, 0x04272f70L, 0x80bb155cL,
0x05282ce3L,
0x95c11548L, 0xe4c66d22L, 0x48c1133fL,
0xc70f86dcL,
0x07f9c9eeL, 0x41041f0fL, 0x404779a4L,
0x5d886e17L,
0x325f51ebL, 0xd59bc0d1L, 0xf2bcc18fL,
0x41113564L,
0x257b7834L, 0x602a9c60L, 0xdff8e8a3L,
0x1f636c1bL,
0x0e12b4c2L, 0x02e1329eL, 0xaf664fd1L,
0xcad18115L,
0x6b2395e0L, 0x333e92e1L, 0x3b240b62L,
0xeebeb922L,
0x85b2a20eL, 0xe6ba0d99L, 0xde720c8cL,
0x2da2f728L,
0xd0127845L, 0x95b794fdL, 0x647d0862L,
0xe7ccf5f0L,
0x5449a36fL, 0x877d48faL, 0xc39dfd27L,
0xf33e8d1eL,
0x0a476341L, 0x992eff74L, 0x3a6f6eabL,
0xf4f8fd37L,
0xa812dc60L, 0xa1ebddf8L, 0x991be14cL,
0xdb6e6b0dL,
0xc67b5510L, 0x6d672c37L, 0x2765d43bL,
0xdcd0e804L,
0xf1290dc7L, 0xcc00ffa3L, 0xb5390f92L,
0x690fed0bL,
0x667b9ffbL, 0xcedb7d9cL, 0xa091cf0bL,
0xd9155ea3L,
0xbb132f88L, 0x515bad24L, 0x7b9479bfL,
0x763bd6ebL,
0x37392eb3L, 0xcc115979L, 0x8026e297L,
0xf42e312dL,
0x6842ada7L, 0xc66a2b3bL, 0x12754cccL,
0x782ef11cL,
0x6a124237L, 0xb79251e7L, 0x06a1bbe6L,
0x4bfb6350L,
0x1a6b1018L, 0x11caedfaL, 0x3d25bdd8L,
0xe2e1c3c9L,
0x44421659L, 0x0a121386L, 0xd90cec6eL,
0xd5abea2aL,
0x64af674eL, 0xda86a85fL, 0xbebfe988L,
0x64e4c3feL,
0x9dbc8057L, 0xf0f7c086L, 0x60787bf8L,
0x6003604dL,
0xd1fd8346L, 0xf6381fb0L, 0x7745ae04L,
0xd736fcccL,
0x83426b33L, 0xf01eab71L, 0xb0804187L,
0x3c005e5fL,
0x77a057beL, 0xbde8ae24L, 0x55464299L,
0xbf582e61L,
0x4e58f48fL, 0xf2ddfda2L, 0xf474ef38L,
0x8789bdc2L,
0x5366f9c3L, 0xc8b38e74L, 0xb475f255L,
0x46fcd9b9L,
0x7aeb2661L, 0x8b1ddf84L, 0x846a0e79L,
0x915f95e2L,
0x466e598eL, 0x20b45770L, 0x8cd55591L,
0xc902de4cL,
0xb90bace1L, 0xbb8205d0L, 0x11a86248L,
0x7574a99eL,
0xb77f19b6L, 0xe0a9dc09L, 0x662d09a1L,
0xc4324633L,
0xe85a1f02L, 0x09f0be8cL, 0x4a99a025L,
0x1d6efe10L,
0x1ab93d1dL, 0x0ba5a4dfL, 0xa186f20fL,
0x2868f169L,
0xdcb7da83L, 0x573906feL, 0xa1e2ce9bL,
0x4fcd7f52L,
0x50115e01L, 0xa70683faL, 0xa002b5c4L,
0x0de6d027L,
0x9af88c27L, 0x773f8641L, 0xc3604c06L,
0x61a806b5L,
0xf0177a28L, 0xc0f586e0L, 0x006058aaL,
0x30dc7d62L,
0x11e69ed7L, 0x2338ea63L, 0x53c2dd94L,
0xc2c21634L,
0xbbcbee56L, 0x90bcb6deL, 0xebfc7da1L,
0xce591d76L,
0x6f05e409L, 0x4b7c0188L, 0x39720a3dL,
0x7c927c24L,
0x86e3725fL, 0x724d9db9L, 0x1ac15bb4L,
0xd39eb8fcL,
0xed545578L, 0x08fca5b5L, 0xd83d7cd3L,
0x4dad0fc4L,
0x1e50ef5eL, 0xb161e6f8L, 0xa28514d9L,
0x6c51133cL,
0x6fd5c7e7L, 0x56e14ec4L, 0x362abfceL,
0xddc6c837L,
0xd79a3234L, 0x92638212L, 0x670efa8eL,
0x406000e0L,
0x3a39ce37L, 0xd3faf5cfL, 0xabc27737L,
0x5ac52d1bL,
0x5cb0679eL, 0x4fa33742L, 0xd3822740L,
0x99bc9bbeL,
0xd5118e9dL, 0xbf0f7315L, 0xd62d1c7eL,
0xc700c47bL,
0xb78c1b6bL, 0x21a19045L, 0xb26eb1beL,
0x6a366eb4L,
0x5748ab2fL, 0xbc946e79L, 0xc6a376d2L,
0x6549c2c8L,
0x530ff8eeL, 0x468dde7dL, 0xd5730a1dL,
0x4cd04dc6L,
0x2939bbdbL, 0xa9ba4650L, 0xac9526e8L,
0xbe5ee304L,
0xa1fad5f0L, 0x6a2d519aL, 0x63ef8ce2L,
0x9a86ee22L,
0xc089c2b8L, 0x43242ef6L, 0xa51e03aaL,
0x9cf2d0a4L,
0x83c061baL, 0x9be96a4dL, 0x8fe51550L,
0xba645bd6L,
0x2826a2f9L, 0xa73a3ae1L, 0x4ba99586L,
0xef5562e9L,
0xc72fefd3L, 0xf752f7daL, 0x3f046f69L,
0x77fa0a59L,
0x80e4a915L, 0x87b08601L, 0x9b09e6adL,
0x3b3ee593L,
0xe990fd5aL, 0x9e34d797L, 0x2cf0b7d9L,
0x022b8b51L,
0x96d5ac3aL, 0x017da67dL, 0xd1cf3ed6L,
0x7c7d2d28L,
0x1f9f25cfL, 0xadf2b89bL, 0x5ad6b472L,
0x5a88f54cL,
0xe029ac71L, 0xe019a5e6L, 0x47b0acfdL,
0xed93fa9bL,
0xe8d3c48dL, 0x283b57ccL, 0xf8d56629L,
0x79132e28L,
0x785f0191L, 0xed756055L, 0xf7960e44L,
0xe3d35e8cL,
0x15056dd4L, 0x88f46dbaL, 0x03a16125L,
0x0564f0bdL,
0xc3eb9e15L, 0x3c9057a2L, 0x97271aecL,
0xa93a072aL,
0x1b3f6d9bL, 0x1e6321f5L, 0xf59c66fbL,
0x26dcf319L,
0x7533d928L, 0xb155fdf5L, 0x03563482L,
0x8aba3cbbL,
0x28517711L, 0xc20ad9f8L, 0xabcc5167L,
0xccad925fL,
0x4de81751L, 0x3830dc8eL, 0x379d5862L,
0x9320f991L,
0xea7a90c2L, 0xfb3e7bceL, 0x5121ce64L,
0x774fbe32L,
0xa8b6e37eL, 0xc3293d46L, 0x48de5369L,
0x6413e680L,
0xa2ae0810L, 0xdd6db224L, 0x69852dfdL,
0x09072166L,
0xb39a460aL, 0x6445c0ddL, 0x586cdecfL,
0x1c20c8aeL,
0x5bbef7ddL, 0x1b588d40L, 0xccd2017fL,
0x6bb4e3bbL,
0xdda26a7eL, 0x3a59ff45L, 0x3e350a44L,
0xbcb4cdd5L,
0x72eacea8L, 0xfa6484bbL, 0x8d6612aeL,
0xbf3c6f47L,
0xd29be463L, 0x542f5d9eL, 0xaec2771bL,
0xf64e6370L,
0x740e0d8dL, 0xe75b1357L, 0xf8721671L,
0xaf537d5dL,
0x4040cb08L, 0x4eb4e2ccL, 0x34d2466aL,
0x0115af84L,
0xe1b00428L, 0x95983a1dL, 0x06b89fb4L,
0xce6ea048L,
0x6f3f3b82L, 0x3520ab82L, 0x011a1d4bL,
0x277227f8L,
0x611560b1L, 0xe7933fdcL, 0xbb3a792bL,
0x344525bdL,
0xa08839e1L, 0x51ce794bL, 0x2f32c9b7L,
0xa01fbac9L,
0xe01cc87eL, 0xbcc7d1f6L, 0xcf0111c3L,
0xa1e8aac7L,
0x1a908749L, 0xd44fbd9aL, 0xd0dadecbL,
0xd50ada38L,
0x0339c32aL, 0xc6913667L, 0x8df9317cL,
0xe0b12b4fL,
0xf79e59b7L, 0x43f5bb3aL, 0xf2d519ffL,
0x27d9459cL,
0xbf97222cL, 0x15e6fc2aL, 0x0f91fc71L,
0x9b941525L,
0xfae59361L, 0xceb69cebL, 0xc2a86459L,
0x12baa8d1L,
0xb6c1075eL, 0xe3056a0cL, 0x10d25065L,
0xcb03a442L,
0xe0ec6e0eL, 0x1698db3bL, 0x4c98a0beL,
0x3278e964L,
0x9f1f9532L, 0xe0d392dfL, 0xd3a0342bL,
0x8971f21eL,
0x1b0a7441L, 0x4ba3348cL, 0xc5be7120L,
0xc37632d8L,
0xdf359f8dL, 0x9b992f2eL, 0xe60b6f47L,
0x0fe3f11dL,
0xe54cda54L, 0x1edad891L, 0xce6279cfL,
0xcd3e7e6fL,
0x1618b166L, 0xfd2c1d05L, 0x848fd2c5L,
0xf6fb2299L,
0xf523f357L, 0xa6327623L, 0x93a83531L,
0x56cccd02L,
0xacf08162L, 0x5a75ebb5L, 0x6e163697L,
0x88d273ccL,
0xde966292L, 0x81b949d0L, 0x4c50901bL,
0x71c65614L,
0xe6c6c7bdL, 0x327a140aL, 0x45e1d006L,
0xc3f27b9aL,
0xc9aa53fdL, 0x62a80f00L, 0xbb25bfe2L,
0x35bdd2f6L,
0x71126905L, 0xb2040222L, 0xb6cbcf7cL,
0xcd769c2bL,
0x53113ec0L, 0x1640e3d3L, 0x38abbd60L,
0x2547adf0L,
0xba38209cL, 0xf746ce76L, 0x77afa1c5L,
0x20756060L,
0x85cbfe4eL, 0x8ae88dd8L, 0x7aaaf9b0L,
0x4cf9aa7eL,
0x1948c25cL, 0x02fb8a8cL, 0x01c36ae4L,
0xd6ebe1f9L,
0x90d4f869L, 0xa65cdea0L, 0x3f09252dL,
0xc208e69fL,
0xb74e6132L, 0xce77e25bL, 0x578fdfe3L,
0x3ac372e6L,
}
};
src/blowfish/bf_skey.c 0 → 100644
View file @ fb1c4cbf
#include <stdio.h>
#include <string.h>
#include "blowfish.h"
#include "bf_local.h"
#include "bf_pi.h"
void BF_set_key(BF_KEY *key, int len, const unsigned char *data)
{
int i;
BF_LONG *p, ri, in[2];
const unsigned char *d, *end;
memcpy(key, &bf_init, sizeof(BF_KEY));
p = key->P;
if (len > ((BF_ROUNDS + 2) * 4))
len = (BF_ROUNDS + 2) * 4;
d = data;
end = &(data[len]);
for (i = 0; i < (BF_ROUNDS + 2); i++) {
ri = *(d++);
if (d >= end)
d = data;
ri <<= 8;
ri |= *(d++);
if (d >= end)
d = data;
ri <<= 8;
ri |= *(d++);
if (d >= end)
d = data;
ri <<= 8;
ri |= *(d++);
if (d >= end)
d = data;
p[i] ^= ri;
}
in[0] = 0L;
in[1] = 0L;
for (i = 0; i < (BF_ROUNDS + 2); i += 2) {
BF_encrypt(in, key);
p[i] = in[0];
p[i + 1] = in[1];
}
p = key->S;
for (i = 0; i < 4 * 256; i += 2) {
BF_encrypt(in, key);
p[i] = in[0];
p[i + 1] = in[1];
}
}
src/blowfish/blowfish.h 0 → 100644
View file @ fb1c4cbf
//max using key size = (BF_ROUNDS + 2)*4 bytes = 72 bytes
#ifndef BLOWFISH_H
# define BLOWFISH_H
# pragma once
#include "inttypes.h"
# ifdef __cplusplus
extern "C" {
# endif
# define BF_BLOCK 8
# define BF_ENCRYPT 1
# define BF_DECRYPT 0
/*-
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
* ! BF_LONG has to be at least 32 bits wide. !
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
*/
# define BF_LONG uint32_t
# define BF_ROUNDS 16
typedef struct bf_key_st {
BF_LONG P[BF_ROUNDS + 2];
BF_LONG S[4 * 256];
} BF_KEY;
void BF_set_key(BF_KEY *key, int len,
const unsigned char *data);
void BF_encrypt(BF_LONG *data, const BF_KEY *key);
void BF_decrypt(BF_LONG *data, const BF_KEY *key);
void BF_ecb_encrypt(const unsigned char *in,
unsigned char *out, const BF_KEY *key,
int enc);
void BF_cbc_encrypt(const unsigned char *in,
unsigned char *out, long length,
const BF_KEY *schedule,
unsigned char *ivec, int enc);
void BF_cfb64_encrypt(const unsigned char *in,
unsigned char *out,
long length, const BF_KEY *schedule,
unsigned char *ivec, int *num, int enc);
void BF_ofb64_encrypt(const unsigned char *in,
unsigned char *out,
long length, const BF_KEY *schedule,
unsigned char *ivec, int *num);
const char *BF_options(void);
# ifdef __cplusplus
}
# endif
# endif
src/blowfish/blowfish.pri 0 → 100644
View file @ fb1c4cbf
INCLUDEPATH += $$PWD
HEADERS += $$PWD/blowfish.h \
$$PWD/bf_local.h \
$$PWD/bf_pi.h
SOURCES += $$PWD/bf_cfb64.c \
$$PWD/bf_ecb.c \
$$PWD/bf_enc.c \
$$PWD/bf_ofb64.c \
$$PWD/bf_skey.c
src/dap_cert.c
View file @ fb1c4cbf
......@@ -54,6 +54,12 @@ typedef struct dap_cert_item
UT_hash_handle hh;
} dap_cert_item_t;
typedef struct dap_cert_folder
{
char *name;
UT_hash_handle hh;
} dap_cert_folder_t;
typedef struct dap_cert_pvt
{
dap_sign_item_t *signs;
......@@ -63,6 +69,7 @@ typedef struct dap_cert_pvt
#define PVT(a) ( ( dap_cert_pvt_t *)((a)->_pvt) )
static dap_cert_item_t * s_certs = NULL;
static dap_cert_folder_t * s_cert_folders = NULL;
/**
* @brief dap_cert_init
......@@ -444,6 +451,25 @@ void dap_cert_dump(dap_cert_t * a_cert)
printf ("Certificates signatures chain size: %lu\n",dap_cert_count_cert_sign (a_cert));
}
/**
* @brief dap_cert_get_folder
* @param a_folder_path
*/
const char* dap_cert_get_folder(int a_n_folder_path)
{
dap_cert_folder_t *l_cert_folder_item = NULL, *l_cert_folder_item_tmp = NULL;
int l_n_cur_folder_path = 0;
HASH_ITER(hh, s_cert_folders, l_cert_folder_item, l_cert_folder_item_tmp)
{
if(l_cert_folder_item) {
if(a_n_folder_path == l_n_cur_folder_path)
return l_cert_folder_item->name;
l_n_cur_folder_path++;
}
}
return NULL;
}
/**
* @brief dap_cert_add_folder
......@@ -451,6 +477,13 @@ void dap_cert_dump(dap_cert_t * a_cert)
*/
void dap_cert_add_folder(const char *a_folder_path)
{
// save dir
{
dap_cert_folder_t * l_cert_folder_item = DAP_NEW_Z(dap_cert_folder_t);
l_cert_folder_item->name = dap_strdup(a_folder_path);
HASH_ADD_STR(s_cert_folders, name, l_cert_folder_item);
}
DIR * l_dir = opendir(a_folder_path);
if( l_dir ) {
struct dirent * l_dir_entry;
......@@ -471,9 +504,9 @@ void dap_cert_add_folder(const char *a_folder_path)
DAP_DELETE(l_cert_name);
}
}
}
closedir(l_dir);
log_it(L_NOTICE, "Added folder %s",a_folder_path);
}else
log_it(L_WARNING, "Can't add folder %s to cert manager",a_folder_path);
......
src/dap_cert_file.c
View file @ fb1c4cbf
......@@ -59,7 +59,7 @@ int dap_cert_file_save(dap_cert_t * a_cert, const char * a_cert_file_path)
return -4;
}
}else{
log_it(L_ERROR, "Can't open file for write: %s", strerror(errno));
log_it(L_ERROR, "Can't open file '%s' for write: %s", a_cert_file_path, strerror(errno));
return -2;
}
}
......@@ -98,7 +98,7 @@ uint8_t* dap_cert_mem_save(dap_cert_t * a_cert, uint32_t *a_cert_size_out)
log_it(L_ERROR,"No public or private key in certificate, nothing to save");
goto lb_exit;
}
log_it(L_DEBUG,"Metadata size %u",l_key->_inheritor_size);
log_it(L_DEBUG,"Key private data size %u",l_key->_inheritor_size);
l_hdr.version = dap_cert_FILE_VERSION;
l_hdr.data_size = l_pub_key_data_size;
......
src/dap_enc.c
View file @ fb1c4cbf
/*
Copyright (c) 2017-2018 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
All rights reserved.
This file is part of DAP (Deus Applications Prototypes) the open source project
DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
DAP is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _WIN32
#include <arpa/inet.h>
#endif
#include <time.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <assert.h>
#include "dap_enc.h"
#include "dap_enc_base64.h"
#include "dap_enc_key.h"
#include "dap_common.h"
#define LOG_TAG "dap_enc"
/**
* @brief enc_init
* @return
*/
int dap_enc_init()
{
srand(time(NULL));
return 0;
}
/**
* @brief dap_enc_deinit
*/
void dap_enc_deinit()
{
}
/**
* @brief dap_enc_code_out_size
* @param a_key
* @param a_buf_in_size
* @return min buffer size for input in encode function
*/
size_t dap_enc_code_out_size(dap_enc_key_t* a_key, const size_t a_buf_in_size, dap_enc_data_type_t type)
{
size_t raw_encode_data_size = dap_enc_key_get_enc_size(a_key, a_buf_in_size);
if(raw_encode_data_size == 0) {
log_it(L_ERROR, "dap_enc_key_get_enc_size return 0");
return 0;
}
if(type != DAP_ENC_DATA_TYPE_RAW) {
return (size_t)DAP_ENC_BASE64_ENCODE_SIZE(raw_encode_data_size);
}
return raw_encode_data_size;
}
/**
* @brief dap_enc_decode_out_size
* @param a_key
* @param a_buf_in_size
* @return min buffer size for input in decode function
*/
size_t dap_enc_decode_out_size(dap_enc_key_t* a_key, const size_t a_buf_in_size, dap_enc_data_type_t type)
{
size_t raw_decode_data_size = dap_enc_key_get_dec_size(a_key, a_buf_in_size);
if(raw_decode_data_size == 0) {
log_it(L_ERROR, "dap_enc_key_get_enc_size return 0");
return 0;
}
if(type != DAP_ENC_DATA_TYPE_RAW) {
return (size_t)DAP_ENC_BASE64_ENCODE_SIZE(raw_decode_data_size);
}
return raw_decode_data_size;
}
/**
* @brief dap_enc_code Encode data with key
* @param a_key Private key
* @param a_buf Input buffer
* @param a_buf_size Input buffer size
* @param a_buf_out Output buffer
* @param a_buf_out_size_max
* @return bytes actualy written in the output buffer
*/
size_t dap_enc_code(struct dap_enc_key * a_key,const void * a_buf_in,const size_t a_buf_size,
void * a_buf_out, const size_t a_buf_out_size_max, dap_enc_data_type_t a_data_type_out)
{
if(!a_key) {
log_it(L_ERROR, "key in dap_enc_code() is NULL");
return 0;
}
if(a_key->enc_na) {
if(a_data_type_out == DAP_ENC_DATA_TYPE_RAW) {
return a_key->enc_na(a_key, a_buf_in, a_buf_size, a_buf_out, a_buf_out_size_max);
}else{
void *l_proc_buf;
l_proc_buf = DAP_NEW_SIZE (void, a_buf_out_size_max );
size_t l_proc_buf_size = a_key->enc_na(a_key, a_buf_in, a_buf_size, l_proc_buf,a_buf_out_size_max);
if(a_data_type_out == DAP_ENC_DATA_TYPE_B64 || a_data_type_out == DAP_ENC_DATA_TYPE_B64_URLSAFE) {
if(DAP_ENC_BASE64_ENCODE_SIZE(l_proc_buf_size) <= a_buf_out_size_max) {
size_t l_buf_out_size=dap_enc_base64_encode(l_proc_buf, l_proc_buf_size, a_buf_out, a_data_type_out);
DAP_DELETE(l_proc_buf);
return l_buf_out_size;
} else {
DAP_DELETE(l_proc_buf);
log_it(L_ERROR, "a_buf_out_size_max less than result size");
return 0;
}
} else {
log_it(L_ERROR, "Unknown dap_enc_data_type");
DAP_DELETE(l_proc_buf);
return 0;
}
}
} else {
log_it(L_ERROR, "key->enc_na is NULL");
return 0;
}
}
/**
* @brief dap_enc_decode Decode data with key
* @param key_public Public key
* @param buf Input buffer
* @param buf_size Input buffer size
* @param buf_out Output buffer
* @param buf_out_max Maximum size of output buffer
* @return bytes actualy written in the output buffer
*/
size_t dap_enc_decode(struct dap_enc_key * a_key,const void * a_buf_in, const size_t a_buf_in_size,
void * a_buf_out, const size_t a_buf_out_size_max, dap_enc_data_type_t a_data_type_in)
{
void *l_proc_buf = NULL;
const void *l_proc_buf_const = NULL;
size_t l_proc_buf_size = 0;
switch(a_data_type_in){
case DAP_ENC_DATA_TYPE_B64:
case DAP_ENC_DATA_TYPE_B64_URLSAFE:
l_proc_buf=DAP_NEW_SIZE(void,DAP_ENC_BASE64_ENCODE_SIZE(a_buf_in_size));
l_proc_buf_size= dap_enc_base64_decode((const char*) a_buf_in,a_buf_in_size,l_proc_buf,a_data_type_in);
l_proc_buf_const=l_proc_buf;
break;
case DAP_ENC_DATA_TYPE_RAW:{
l_proc_buf_const=a_buf_in;
l_proc_buf_size=a_buf_in_size;
}break;
}
if(a_key->dec_na) {
if(l_proc_buf_size == 0) {
log_it(L_ERROR, "Buf is null. dap_enc_base64_decode is failed");
return 0;
}
size_t ret = a_key->dec_na(a_key,l_proc_buf_const,l_proc_buf_size, a_buf_out,a_buf_out_size_max);
if(a_data_type_in==DAP_ENC_DATA_TYPE_B64 || a_data_type_in == DAP_ENC_DATA_TYPE_B64_URLSAFE)
free(l_proc_buf);
return ret;
} else {
log_it(L_WARNING, "key->dec_na is NULL");
if(l_proc_buf_size)
free(l_proc_buf);
return 0;
}
}
/*
Copyright (c) 2017-2018 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
All rights reserved.
This file is part of DAP (Deus Applications Prototypes) the open source project
DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
DAP is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _WIN32
#include <arpa/inet.h>
#endif
#include <time.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <assert.h>
#include "dap_enc.h"
#include "dap_enc_base64.h"
#include "dap_enc_key.h"
#include "dap_common.h"
#define LOG_TAG "dap_enc"
/**
* @brief enc_init
* @return
*/
int dap_enc_init()
{
srand(time(NULL));
return 0;
}
/**
* @brief dap_enc_deinit
*/
void dap_enc_deinit()
{
}
/**
* @brief dap_enc_code_out_size
* @param a_key
* @param a_buf_in_size
* @return min buffer size for input in encode function
*/
size_t dap_enc_code_out_size(dap_enc_key_t* a_key, const size_t a_buf_in_size, dap_enc_data_type_t type)
{
size_t raw_encode_data_size = dap_enc_key_get_enc_size(a_key, a_buf_in_size);
if(raw_encode_data_size == 0) {
log_it(L_ERROR, "dap_enc_key_get_enc_size return 0");
return 0;
}
if(type != DAP_ENC_DATA_TYPE_RAW) {
return (size_t)DAP_ENC_BASE64_ENCODE_SIZE(raw_encode_data_size);
}
return raw_encode_data_size;
}
/**
* @brief dap_enc_decode_out_size
* @param a_key
* @param a_buf_in_size
* @return min buffer size for input in decode function
*/
size_t dap_enc_decode_out_size(dap_enc_key_t* a_key, const size_t a_buf_in_size, dap_enc_data_type_t type)
{
size_t raw_decode_data_size = dap_enc_key_get_dec_size(a_key, a_buf_in_size);
if(raw_decode_data_size == 0) {
log_it(L_ERROR, "dap_enc_key_get_enc_size return 0");
return 0;
}
if(type != DAP_ENC_DATA_TYPE_RAW) {
return (size_t)DAP_ENC_BASE64_ENCODE_SIZE(raw_decode_data_size);
}
return raw_decode_data_size;
}
/**
* @brief dap_enc_code Encode data with key
* @param a_key Private key
* @param a_buf Input buffer
* @param a_buf_size Input buffer size
* @param a_buf_out Output buffer
* @param a_buf_out_size_max
* @return bytes actualy written in the output buffer
*/
size_t dap_enc_code(struct dap_enc_key * a_key,const void * a_buf_in,const size_t a_buf_size,
void * a_buf_out, const size_t a_buf_out_size_max, dap_enc_data_type_t a_data_type_out)
{
if(!a_key) {
log_it(L_ERROR, "key in dap_enc_code() is NULL");
return 0;
}
if(a_key->enc_na) {
if(a_data_type_out == DAP_ENC_DATA_TYPE_RAW) {
return a_key->enc_na(a_key, a_buf_in, a_buf_size, a_buf_out, a_buf_out_size_max);
}else{
void *l_proc_buf;
l_proc_buf = DAP_NEW_SIZE (void, a_buf_out_size_max );
size_t l_proc_buf_size = a_key->enc_na(a_key, a_buf_in, a_buf_size, l_proc_buf,a_buf_out_size_max);
if(a_data_type_out == DAP_ENC_DATA_TYPE_B64 || a_data_type_out == DAP_ENC_DATA_TYPE_B64_URLSAFE) {
if(DAP_ENC_BASE64_ENCODE_SIZE(l_proc_buf_size) <= a_buf_out_size_max) {
size_t l_buf_out_size=dap_enc_base64_encode(l_proc_buf, l_proc_buf_size, a_buf_out, a_data_type_out);
DAP_DELETE(l_proc_buf);
return l_buf_out_size;
} else {
DAP_DELETE(l_proc_buf);
log_it(L_ERROR, "a_buf_out_size_max less than result size");
return 0;
}
} else {
log_it(L_ERROR, "Unknown dap_enc_data_type");
DAP_DELETE(l_proc_buf);
return 0;
}
}
} else {
log_it(L_ERROR, "key->enc_na is NULL");
return 0;
}
}
/**
* @brief dap_enc_decode Decode data with key
* @param key_public Public key
* @param buf Input buffer
* @param buf_size Input buffer size
* @param buf_out Output buffer
* @param buf_out_max Maximum size of output buffer
* @return bytes actualy written in the output buffer
*/
size_t dap_enc_decode(struct dap_enc_key * a_key,const void * a_buf_in, const size_t a_buf_in_size,
void * a_buf_out, const size_t a_buf_out_size_max, dap_enc_data_type_t a_data_type_in)
{
void *l_proc_buf = NULL;
const void *l_proc_buf_const = NULL;
size_t l_proc_buf_size = 0;
switch(a_data_type_in){
case DAP_ENC_DATA_TYPE_B64:
case DAP_ENC_DATA_TYPE_B64_URLSAFE:
l_proc_buf=DAP_NEW_SIZE(void,DAP_ENC_BASE64_ENCODE_SIZE(a_buf_in_size));
l_proc_buf_size= dap_enc_base64_decode((const char*) a_buf_in,a_buf_in_size,l_proc_buf,a_data_type_in);
l_proc_buf_const=l_proc_buf;
break;
case DAP_ENC_DATA_TYPE_RAW:{
l_proc_buf_const=a_buf_in;
l_proc_buf_size=a_buf_in_size;
}break;
}
if(a_key->dec_na) {
if(l_proc_buf_size == 0) {
log_it(L_ERROR, "Buf is null. dap_enc_base64_decode is failed");
return 0;
}
size_t ret = a_key->dec_na(a_key,l_proc_buf_const,l_proc_buf_size, a_buf_out,a_buf_out_size_max);
if(a_data_type_in==DAP_ENC_DATA_TYPE_B64 || a_data_type_in == DAP_ENC_DATA_TYPE_B64_URLSAFE)
free(l_proc_buf);
return ret;
} else {
log_it(L_WARNING, "key->dec_na is NULL");
if(l_proc_buf_size)
free(l_proc_buf);
return 0;
}
}