asn1.c

Go to the documentation of this file.

/*
 This file is part of BitPunch
 Copyright (C) 2015 Frantisek Uhrecky <frantisek.uhrecky[what here]gmail.com>

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program 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 General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "asn1.h"

#ifdef BPU_CONF_ASN1
#include <bitpunch/debugio.h>

#include <libtasn1.h>
#include <stdlib.h>

int BPU_asn1EncodePriKey(char **buffer, int *size, const BPU_T_Mecs_Ctx *ctx) {
    int rc = 0;
    asn1_node definitions = NULL;
    asn1_node asn1_element = NULL;
    char error_desc[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
    BPU_T_GF2_16x *h_mat = NULL;
    uint32_t h_mat_bs;
    int i, j;
    *size = 0;
    // TODO: structure cleanup on error
    rc = asn1_parser2tree(BPU_STR_ASN1_MECS_PRI_KEY, &definitions, error_desc);

    if (rc != ASN1_SUCCESS) {
        BPU_printError("ErrorDescription = %s\n\n", error_desc);
        return rc;
    }
    rc = asn1_create_element(definitions, BPU_STR_ASN1_MECS_PRI_KEY_NAME, &asn1_element);
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_create_element(): %d", rc);
        return rc;
    }
    // write elements
    rc = -1;
    if (ctx->type == BPU_EN_MECS_BASIC_GOPPA) {
        rc = asn1_write_value(asn1_element, "oid", BPU_STR_ASN1_OID_MECS_BASIC_GOPPA, strlen(BPU_STR_ASN1_OID_MECS_BASIC_GOPPA));
    }
#ifdef BPU_CONF_MECS_CCA2_POINTCHEVAL_GOPPA
    if (ctx->type == BPU_EN_MECS_CCA2_POINTCHEVAL_GOPPA) {
        rc = asn1_write_value(asn1_element, "oid", BPU_STR_ASN1_OID_MECS_CCA2_POINTCHEVAL_GOPPA, strlen(BPU_STR_ASN1_OID_MECS_CCA2_POINTCHEVAL_GOPPA));
    }
#endif
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_write_value(): oid %d", rc);
        return rc;
    }
    rc = asn1_write_value(asn1_element, "m", (void *)&(ctx->code_ctx->math_ctx->mod_deg), sizeof((ctx->code_ctx->math_ctx->mod_deg)));
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_write_value(): m %d", rc);
        return rc;
    }
    rc = asn1_write_value(asn1_element, "t", (void *)&(ctx->code_ctx->t), sizeof((ctx->code_ctx->t)));
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_write_value(): t %d", rc);
        return rc;
    }
    rc = asn1_write_value(asn1_element, "mod", (void *)&(ctx->code_ctx->math_ctx->mod), sizeof(ctx->code_ctx->math_ctx->mod));
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_write_value(): mod %d", rc);
        return rc;
    }
    rc = asn1_write_value(asn1_element, "g", (void *)(ctx->code_ctx->code_spec->goppa->g->coef), sizeof(ctx->code_ctx->code_spec->goppa->g->coef[0]) * (ctx->code_ctx->code_spec->goppa->g->deg + 1));
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_write_value(): g %d", rc);
        return rc;
    }
    rc = asn1_write_value(asn1_element, "p", (void *)(ctx->code_ctx->code_spec->goppa->permutation->elements), sizeof(ctx->code_ctx->code_spec->goppa->permutation->elements[0]) * ctx->code_ctx->code_spec->goppa->permutation->size);
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_write_value(): p %d", rc);
        return rc;
    }
    if (ctx->code_ctx->type == BPU_EN_CODE_GOPPA) {
        if (!ctx->code_ctx->code_spec->goppa->h_mat) {
            BPU_printError("not supported w/o H");
            return -1;
        }
        // prepare H matrix
        h_mat_bs = sizeof(BPU_T_GF2_16x) * (ctx->code_ctx->code_spec->goppa->h_mat->k * ctx->code_ctx->code_spec->goppa->h_mat->n);
        h_mat = (BPU_T_GF2_16x *) malloc(h_mat_bs);

        if (!h_mat) {
            BPU_printError("Can not allocate memory for H matrix export");
            return -1;
        }
        j = 0;
        for (i = 0; i < ctx->code_ctx->code_spec->goppa->h_mat->k; i++) {
            memcpy(h_mat + j, ctx->code_ctx->code_spec->goppa->h_mat->elements[i], ctx->code_ctx->code_spec->goppa->h_mat->n * sizeof(BPU_T_GF2_16x));
            j += ctx->code_ctx->code_spec->goppa->h_mat->n;
        }
    }
    else {
        BPU_printError("Not supported for this CODE type.");
        return -1;
    }
    rc = asn1_write_value(asn1_element, "h_mat", (void *)(h_mat), h_mat_bs);
    free(h_mat);

    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_write_value(): h_mat %d", rc);

        return rc;
    }
    /* Clear the definition structures */
    asn1_delete_structure(&definitions);

    // get size of data
    asn1_der_coding(asn1_element, "", NULL, size, NULL);
    *buffer = (char *) malloc(*size);

    rc = asn1_der_coding(asn1_element, "", *buffer, size, NULL);
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_der_coding(): %d", rc);
        return rc;
    }
    /* Clear the definition structures */
    asn1_delete_structure(&asn1_element);
    return rc;
}

int BPU_asn1DecodePriKey(BPU_T_Mecs_Ctx **ctx, const char *buffer, const int size) {
    int rc = 0;
    asn1_node definitions = NULL;
    asn1_node asn1_element = NULL;
    int tmp_len;
    char error_desc[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
    char *tmp_buf;
    BPU_T_EN_Mecs_Types type;
        BPU_T_UN_Mecs_Params params;
    uint8_t m, t;
    int i, j;

    // TODO:structure cleanup on error
    rc = asn1_parser2tree(BPU_STR_ASN1_MECS_PRI_KEY, &definitions, error_desc);

    if (rc != ASN1_SUCCESS) {
        BPU_printError("ErrorDescription = %s", error_desc);
        return rc;
    }
    rc = asn1_create_element(definitions, BPU_STR_ASN1_MECS_PRI_KEY_NAME, &asn1_element);
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_create_element(): %d", rc);
        return rc;
    }
    /* Clear the definition structures */
    asn1_delete_structure(&definitions);

    // decode buffer
    rc = asn1_der_decoding(&asn1_element, buffer, size, error_desc);
    if (rc != ASN1_SUCCESS) {
        BPU_printError("Decoding error %d %s", rc, error_desc);
        return rc;
    }
    // section of data decoding
    type = BPU_asn1GetMecsTypeFromOid(asn1_element);
    if (type == -1) {
        BPU_printError("Wrong OID");
        return -1;
    }
        if (BPU_asn1ReadValue(&tmp_buf, &tmp_len, 1, "m", asn1_element)) {
        return -1;
    }
    m = *(uint8_t *) tmp_buf;
    free(tmp_buf);

        if (BPU_asn1ReadValue(&tmp_buf, &tmp_len, 1, "t", asn1_element)) {
        return -1;
    }
    t = *(uint8_t *) tmp_buf;
    free(tmp_buf);

        if (BPU_asn1ReadValue(&tmp_buf, &tmp_len, sizeof(BPU_T_GF2_16x), "mod", asn1_element)) {
        return -1;
    }
        if (type == BPU_EN_MECS_BASIC_GOPPA || type == BPU_EN_MECS_CCA2_POINTCHEVAL_GOPPA) {
                if (BPU_mecsInitParamsGoppa(&params, m, t, *((BPU_T_GF2_16x *) tmp_buf))) {
                        return -1;
                }
                free(tmp_buf);
                if (BPU_mecsInitCtx(ctx, &params, type)) {
                        return -1;
                }
                BPU_mecsFreeParamsGoppa(&params);
                if (BPU_asn1ReadValue(&tmp_buf, &tmp_len, sizeof(BPU_T_GF2_16x) * (t + 1), "g", asn1_element)) {
            return -1;
        }
        if (BPU_gf2xPolyMalloc(&((*ctx)->code_ctx->code_spec->goppa->g), t)) {
            return -1;
        }
        memcpy((*ctx)->code_ctx->code_spec->goppa->g->coef, tmp_buf, tmp_len);
        (*ctx)->code_ctx->code_spec->goppa->g->deg = t;
        free(tmp_buf);
    }
    else {
        BPU_printError("Not supported for this code type.");
        return -1;
    }
        if (BPU_asn1ReadValue(&tmp_buf, &tmp_len, sizeof(BPU_T_Perm_Element) * (*ctx)->code_ctx->code_len, "p", asn1_element)) {
        return -1;
    }
    if (BPU_permMalloc(&((*ctx)->code_ctx->code_spec->goppa->permutation), (*ctx)->code_ctx->code_len)) {
        return -1;
    }
    memcpy((*ctx)->code_ctx->code_spec->goppa->permutation->elements, tmp_buf, tmp_len);
    free(tmp_buf);

        if (BPU_asn1ReadValue(&tmp_buf, &tmp_len, sizeof(BPU_T_GF2_16x) * (*ctx)->code_ctx->t * (*ctx)->code_ctx->code_len, "h_mat", asn1_element)) {
        return -1;
    }
    if (BPU_gf2xMatMalloc(&((*ctx)->code_ctx->code_spec->goppa->h_mat), (*ctx)->code_ctx->t, (*ctx)->code_ctx->code_len)) {
        return -1;
    }
    j = 0;
    for (i = 0; i < (*ctx)->code_ctx->code_spec->goppa->h_mat->k; i++) {
        memcpy((*ctx)->code_ctx->code_spec->goppa->h_mat->elements[i], tmp_buf + j, (*ctx)->code_ctx->code_spec->goppa->h_mat->n * sizeof(BPU_T_GF2_16x));
        j += (*ctx)->code_ctx->code_spec->goppa->h_mat->n * sizeof(BPU_T_GF2_16x);
    }
    free(tmp_buf);

    asn1_delete_structure(&asn1_element);
    return rc;
}

int BPU_asn1EncodePubKey(char **buffer, int *size, const BPU_T_Mecs_Ctx *ctx) {
    int rc = 0;
    asn1_node definitions = NULL;
    asn1_node asn1_element = NULL;
    char error_desc[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
    BPU_T_GF2 *g_mat = NULL;
    uint32_t g_mat_bs;
    int i, j;
    *size = 0;
    // TODO:structure cleanup on error
    rc = asn1_parser2tree(BPU_STR_ASN1_MECS_PUB_KEY, &definitions, error_desc);

    if (rc != ASN1_SUCCESS) {
        BPU_printError("ErrorDescription = %s", error_desc);
        return rc;
    }
    rc = asn1_create_element(definitions, BPU_STR_ASN1_MECS_PUB_KEY_NAME, &asn1_element);
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_create_element(): %d", rc);
        return rc;
    }
    // write elements
    rc = -1;
    if (ctx->type == BPU_EN_MECS_BASIC_GOPPA) {
        rc = asn1_write_value(asn1_element, "oid", BPU_STR_ASN1_OID_MECS_BASIC_GOPPA, strlen(BPU_STR_ASN1_OID_MECS_BASIC_GOPPA));
    }
#ifdef BPU_CONF_MECS_CCA2_POINTCHEVAL_GOPPA
    if (ctx->type == BPU_EN_MECS_CCA2_POINTCHEVAL_GOPPA) {
        rc = asn1_write_value(asn1_element, "oid", BPU_STR_ASN1_OID_MECS_CCA2_POINTCHEVAL_GOPPA, strlen(BPU_STR_ASN1_OID_MECS_CCA2_POINTCHEVAL_GOPPA));
    }
#endif
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_write_value(): oid %d", rc);
        return rc;
    }
    rc = asn1_write_value(asn1_element, "m", (void *)&(ctx->code_ctx->math_ctx->mod_deg), sizeof((ctx->code_ctx->math_ctx->mod_deg)));
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_write_value(): m %d", rc);
        return rc;
    }
    rc = asn1_write_value(asn1_element, "t", (void *)&(ctx->code_ctx->t), sizeof((ctx->code_ctx->t)));
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_write_value(): t %d", rc);
        return rc;
    }
    if (ctx->code_ctx->type == BPU_EN_CODE_GOPPA) {
        g_mat_bs = sizeof(BPU_T_GF2) * (ctx->code_ctx->code_spec->goppa->g_mat->k * ctx->code_ctx->code_spec->goppa->g_mat->elements_in_row);

        // prepare G matrix
        g_mat = (BPU_T_GF2 *) malloc(g_mat_bs);

        if (!g_mat) {
            BPU_printError("Can not allocate memory for G matrix export");
            return -1;
        }
        j = 0;
        for (i = 0; i < ctx->code_ctx->code_spec->goppa->g_mat->k; i++) {
            memcpy(g_mat + j, ctx->code_ctx->code_spec->goppa->g_mat->elements[i], ctx->code_ctx->code_spec->goppa->g_mat->elements_in_row * sizeof(BPU_T_GF2));
            j += ctx->code_ctx->code_spec->goppa->g_mat->elements_in_row;
        }
    }
    else {
        BPU_printError("Not supported for this MECS type.");
        return -1;
    }
    rc = asn1_write_value(asn1_element, "g_mat", (void *)(g_mat), g_mat_bs);
    free(g_mat);

    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_write_value(): g_mat %d", rc);
        return rc;
    }
    /* Clear the definition structures */
    asn1_delete_structure(&definitions);

    // get size of data
    asn1_der_coding(asn1_element, "", NULL, size, NULL);
    *buffer = (char *) malloc(*size);

    rc = asn1_der_coding(asn1_element, "", *buffer, size, NULL);
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_der_coding(): %d", rc);
    }
    /* Clear the definition structures */
    asn1_delete_structure(&asn1_element);
    return rc;
}

int BPU_asn1DecodePubKey(BPU_T_Mecs_Ctx **ctx, const char *buffer, const int size) {
    int rc = 0;
    asn1_node definitions = NULL;
    asn1_node asn1_element = NULL;
    int tmp_len;
    char error_desc[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
    char *tmp_buf = NULL;
    BPU_T_EN_Mecs_Types type;
        BPU_T_UN_Mecs_Params params;
    uint8_t m, t;
    int i, j, tmp;

    // TODO:structure cleanup on error
    rc = asn1_parser2tree(BPU_STR_ASN1_MECS_PUB_KEY, &definitions, error_desc);

    if (rc != ASN1_SUCCESS) {
        BPU_printError("ErrorDescription = %s", error_desc);
        return rc;
    }
    rc = asn1_create_element(definitions, BPU_STR_ASN1_MECS_PUB_KEY_NAME, &asn1_element);
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_create_element(): %d", rc);
        return rc;
    }
    /* Clear the definition structures */
    asn1_delete_structure(&definitions);

    // decode buffer
    rc = asn1_der_decoding(&asn1_element, buffer, size, error_desc);
    if (rc != ASN1_SUCCESS) {
        BPU_printError("Decoding error %d, %s", rc, error_desc);
        return rc;
    }
    // section of data decoding
    type = BPU_asn1GetMecsTypeFromOid(asn1_element);
    if (type == -1) {
        BPU_printError("Wrong OID");
        return -1;
    }
        if (BPU_asn1ReadValue(&tmp_buf, &tmp_len, 1, "m", asn1_element)) {
        return -1;
    }
    m = *(uint8_t *) tmp_buf;
    free(tmp_buf);

        if (BPU_asn1ReadValue(&tmp_buf, &tmp_len, 1, "t", asn1_element)) {
        return -1;
    }
    t = *(uint8_t *) tmp_buf;
    free(tmp_buf);

    // init mecs context without mod
        if (type == BPU_EN_MECS_BASIC_GOPPA || type == BPU_EN_MECS_CCA2_POINTCHEVAL_GOPPA) {
                if (BPU_mecsInitParamsGoppa(&params, m, t, -1)) {
                        return -1;
                }
        }
        else {
                BPU_printError("Type not supported");
                return -1;
        }
        if ((rc = BPU_mecsInitCtx(ctx, &params, type))) {
        BPU_printError("can not initialize mecs ctx");

        return rc;
    }
        BPU_mecsFreeParamsGoppa(&params);

        if (BPU_asn1ReadValue(&tmp_buf, &tmp_len, (*ctx)->code_ctx->code_len * (*ctx)->code_ctx->msg_len, "g_mat", asn1_element)) {
        return -1;
    }
    if (BPU_gf2MatMalloc(&((*ctx)->code_ctx->code_spec->goppa->g_mat), (*ctx)->code_ctx->code_len - (*ctx)->code_ctx->msg_len, (*ctx)->code_ctx->msg_len)) {
        return -1;
    }
    j = 0;
    tmp = (*ctx)->code_ctx->code_spec->goppa->g_mat->elements_in_row * ((*ctx)->code_ctx->code_spec->goppa->g_mat->element_bit_size / 8);
    for (i = 0; i < (*ctx)->code_ctx->code_spec->goppa->g_mat->k; i++) {
        memcpy((*ctx)->code_ctx->code_spec->goppa->g_mat->elements[i], tmp_buf + j, tmp);
        j += tmp;
    }
    free(tmp_buf);

    asn1_delete_structure(&asn1_element);
    return rc;
}

int BPU_asn1ReadValue(char **buffer, int *len, const int max_len, const char *name, const asn1_node node) {
    int rc;

    // get size and malloc buffer
        if ((rc = BPU_asn1MallocBuffer(buffer, len, max_len, node, name))) {
                return rc;
    }
    // decode data
    rc = asn1_read_value(node, name, *buffer, len);
    BPU_printDebug("data len: %d", *len);
    if (rc != ASN1_SUCCESS) {
        BPU_printError("asn1_read_value(): %s %d", name, rc);
        return -1;
    }
    BPU_printDebug("data %s: %02x", name, **buffer);
    return rc;
}

BPU_T_EN_Mecs_Types BPU_asn1GetMecsTypeFromOid(asn1_node node) {
    int rc, tmp_len;
    char *tmp_buf = NULL;

        if (BPU_asn1ReadValue(&tmp_buf, &tmp_len, 60, "oid", node)) {
        return -1;
    }
    tmp_buf[tmp_len - 1] = '\0';
    BPU_printDebug("data oid: %s", tmp_buf);

    if (!strcmp(tmp_buf, BPU_STR_ASN1_OID_MECS_BASIC_GOPPA)) {
        rc = BPU_EN_MECS_BASIC_GOPPA;
    }
#ifdef BPU_CONF_MECS_CCA2_POINTCHEVAL_GOPPA
    else if (!strcmp(tmp_buf, BPU_STR_ASN1_OID_MECS_CCA2_POINTCHEVAL_GOPPA)) {
        rc = BPU_EN_MECS_CCA2_POINTCHEVAL_GOPPA;
    }
#endif
    else {
        rc = -1;
    }
    free(tmp_buf);

    return rc;
}

int BPU_asn1MallocBuffer(char **buffer, int *len, const int max_len, const asn1_node node, const char *name) {
    int rc;

    rc = asn1_read_value(node, name, NULL, len);

        if (*len > max_len) {
                BPU_printError("requested length %d is bigger than max expected %d", *len, max_len);
                return -1;
        }
        else if (*len > 0) {
        // malloc data
        *buffer = (char *) malloc(*len);

        if (!(*buffer)) {
            BPU_printError("can not allocate memory.");
            return -1;
        }
    }
    else {
        BPU_printError("can not get size of data");
        return rc;
    }
    return 0;
}

int BPU_asn1LoadFileToBuffer(char **buffer, long *size, const char *file_name) {
    FILE *fp = fopen(file_name, "rb");
    long tmp;

    if (!fp) {
        BPU_printError("can not open private key file: %s", file_name);
        return -1;
    }
    fseek(fp, 0L, SEEK_END);
    *size = ftell(fp);
    fseek(fp, 0L, SEEK_SET);

    if (*size == -1L) {
        BPU_printError("can get file size");
        fclose(fp);

        return -1;
    }
    *buffer = (char *) malloc(*size);

    if (!*buffer) {
        BPU_printError("can malloc buffer");
        fclose(fp);

        return -1;
    }
    tmp = fread(*buffer, 1, *size, fp);

    if (tmp != *size) {
        BPU_printError("can not read data from file, read only %ld B, instead of %ld B", tmp, *size);
        free(*buffer);
        fclose(fp);

        return -1;
    }
    fclose(fp);
    return 0;
}

int BPU_asn1LoadKeyPair(BPU_T_Mecs_Ctx **ctx, const char *pri_key_file, const char *pub_key_file) {
    if (BPU_asn1LoadPriKey(ctx, pri_key_file) || BPU_asn1LoadPubKey(ctx, pub_key_file)) {
        BPU_printError("can not load key pair");
        return -1;
    }
    return 0;
}

int BPU_asn1LoadPriKey(BPU_T_Mecs_Ctx **ctx, const char *pri_key_file) {
    long size;
    char *buffer;

    if (BPU_asn1LoadFileToBuffer(&buffer, &size, pri_key_file)) {
        return -1;
    }
    if (BPU_asn1DecodePriKey(ctx, buffer, size)) {
        free(buffer);

        return -1;
    }
    free(buffer);

    return 0;
}

int BPU_asn1LoadPubKey(BPU_T_Mecs_Ctx **ctx, const char *pub_key_file) {
    long size;
    char *buffer;

    if (BPU_asn1LoadFileToBuffer(&buffer, &size, pub_key_file)) {
        return -1;
    }
    if (BPU_asn1DecodePubKey(ctx, buffer, size)) {
        free(buffer);

        return -1;
    }
    free(buffer);

    return 0;
}

int BPU_asn1SaveKeyPair(const BPU_T_Mecs_Ctx *ctx, const char *pri_key_file, const char *pub_key_file) {
    if (BPU_asn1SavePriKey(ctx, pri_key_file) || BPU_asn1SavePubKey(ctx, pub_key_file)) {
        BPU_printError("can not save key pair");
        return -1;
    }
    return 0;
}

int BPU_asn1SavePriKey(const BPU_T_Mecs_Ctx *ctx, const char *pri_key_file) {
    char *buffer = NULL;
    int size;

    if (BPU_asn1EncodePriKey(&buffer, &size, ctx)) {
        return -1;
    }
    if (BPU_asn1WriteBufferToFile(buffer, size, pri_key_file)) {
        BPU_printError("can not write pri key data");
        free(buffer);

        return -1;
    }
    free(buffer);

    return 0;
}

int BPU_asn1SavePubKey(const BPU_T_Mecs_Ctx *ctx, const char *pub_key_file) {
    char *buffer = NULL;
    int size;

    if (BPU_asn1EncodePubKey(&buffer, &size, ctx)) {
        return -1;
    }
    if (BPU_asn1WriteBufferToFile(buffer, size, pub_key_file)) {
        BPU_printError("can not write pub key data");
        free(buffer);

        return -1;
    }
    free(buffer);

    return 0;
}

int BPU_asn1WriteBufferToFile(const char *buffer, const long size, const char *file_name) {
    FILE *fp;
    long tmp;

    fp = fopen(file_name, "wb");

    if (!fp) {
        BPU_printError("can not open file %s", file_name);

        return -1;
    }
    tmp = fwrite(buffer, 1, size, fp);

    if (tmp != size) {
        BPU_printError("can not write buffer to file, written %ld B, instead of %ld B", tmp, size);
        fclose(fp);

        return -1;
    }
    fclose(fp);

    return 0;
}
#endif // BPU_CONF_ASN1