xref: /freebsd-src/crypto/libecc/src/tests/ec_utils.c (revision f0865ec9906d5a18fa2a3b61381f22ce16e606ad)

/*
 *  Copyright (C) 2017 - This file is part of libecc project
 *
 *  Authors:
 *	Ryad BENADJILA <ryadbenadjila@gmail.com>
 *	Arnaud EBALARD <arnaud.ebalard@ssi.gouv.fr>
 *	Jean-Pierre FLORI <jean-pierre.flori@ssi.gouv.fr>
 *
 *  Contributors:
 *	Nicolas VIVET <nicolas.vivet@ssi.gouv.fr>
 *	Karim KHALFALLAH <karim.khalfallah@ssi.gouv.fr>
 *
 *  This software is licensed under a dual BSD and GPL v2 license.
 *  See LICENSE file at the root folder of the project.
 */

#include <libecc/libsig.h>

#ifdef WITH_STDLIB
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#endif

#define HDR_MAGIC	 0x34215609

typedef enum {
	IMAGE_TYPE_UNKNOWN = 0,
	IMAGE_TYPE0 = 1,
	IMAGE_TYPE1 = 2,
	IMAGE_TYPE2 = 3,
	IMAGE_TYPE3 = 4,
	/* Info: You can add more image header types */
} image_type;

/* Generic header to prepend data */
typedef struct {
	u32 magic;		/* header header */
	u32 type;		/* Type of the signed image */
	u32 version;		/* Version */
	u32 len;		/* length of data after header */
	u32 siglen;		/* length of sig (on header + data) */
} ATTRIBUTE_PACKED metadata_hdr;

/* Max stack working buffer size */
#define MAX_BUF_LEN		8192

typedef enum {
	RAWBIN,
	DOTH,
} export_file_type;

ATTRIBUTE_WARN_UNUSED_RET static int export_private_key(FILE * file, const char *name,
			      const ec_priv_key *priv_key,
			      export_file_type file_type)
{
	u8 export_buf_size, priv_key_buf[EC_STRUCTURED_PRIV_KEY_MAX_EXPORT_SIZE];
	size_t written;
	int ret;
	u32 i;

	MUST_HAVE(file != NULL, ret, err);

	ret = priv_key_check_initialized(priv_key);
	if (ret) {
		printf("Error checking private key\n");
		ret = -1;
		goto err;
	}

	/* Serialize the private key to a buffer */
	export_buf_size = EC_STRUCTURED_PRIV_KEY_EXPORT_SIZE(priv_key);
	ret = ec_structured_priv_key_export_to_buf(priv_key, priv_key_buf,
						   export_buf_size);
	if (ret) {
		printf("Error exporting private key to buffer\n");
		ret = -1;
		goto err;
	}

	/* Export the private key to the file */
	switch (file_type) {
	case DOTH:
		MUST_HAVE(name != NULL, ret, err);
		fprintf(file, "const char %s[] = { ", name);
		for (i = 0; i < export_buf_size; i++) {
			fprintf(file, "0x%02x", priv_key_buf[i]);
			fprintf(file, ", ");
		}
		fprintf(file, "};\n");
		ret = 0;
		break;
	case RAWBIN:
		written = fwrite(priv_key_buf, 1, export_buf_size, file);
		if(written != export_buf_size){
			ret = -1;
			goto err;
		}
		ret = 0;
		break;
	default:
		ret = -1;
	}

 err:
	return ret;
}

ATTRIBUTE_WARN_UNUSED_RET static int export_public_key(FILE * file, const char *name,
			     const ec_pub_key *pub_key,
			     export_file_type file_type)
{
	u8 pub_key_buf[EC_STRUCTURED_PUB_KEY_MAX_EXPORT_SIZE];
	u8 export_buf_size;
	int ret;
	u32 i;
	size_t written;

	MUST_HAVE(file != NULL, ret, err);
	ret = pub_key_check_initialized(pub_key);
	if (ret) {
		printf("Error checking public key\n");
		ret = -1;
		goto err;
	}

	/* Serialize the public key to a buffer */
	export_buf_size = EC_STRUCTURED_PUB_KEY_EXPORT_SIZE(pub_key);
	ret = ec_structured_pub_key_export_to_buf(pub_key, pub_key_buf,
						  export_buf_size);
	if (ret) {
		printf("Error exporting public key to buffer\n");
		ret = -1;
		goto err;
	}

	/* Export the public key to the file */
	switch (file_type) {
	case DOTH:
		MUST_HAVE(name != NULL, ret, err);
		fprintf(file, "const char %s[] = { ", name);
		for (i = 0; i < export_buf_size; i++) {
			fprintf(file, "0x%02x", pub_key_buf[i]);
			if (i != export_buf_size) {
				fprintf(file, ", ");
			}
		}
		fprintf(file, "};\n");
		ret = 0;
		break;
	case RAWBIN:
		written = fwrite(pub_key_buf, 1, export_buf_size, file);
		if(written != export_buf_size){
			ret = -1;
			goto err;
		}
		ret = 0;
		break;
	default:
		ret = -1;
	}

 err:
	return ret;
}

ATTRIBUTE_WARN_UNUSED_RET static int string_to_params(const char *ec_name, const char *ec_sig_name,
			    ec_alg_type * sig_type,
			    const ec_str_params ** ec_str_p,
			    const char *hash_name, hash_alg_type * hash_type)
{
	const ec_str_params *curve_params;
	const ec_sig_mapping *sm;
	const hash_mapping *hm;
	u32 curve_name_len;
	int ret;

	if (sig_type != NULL) {
		/* Get sig type from signature alg name */
		ret = get_sig_by_name(ec_sig_name, &sm);
		if ((ret) || (!sm)) {
			ret = -1;
			printf("Error: signature type %s is unknown!\n",
			       ec_sig_name);
			goto err;
		}
		*sig_type = sm->type;
	}

	if (ec_str_p != NULL) {
		/* Get curve params from curve name */
		ret = local_strlen((const char *)ec_name, &curve_name_len); EG(ret, err);
		curve_name_len += 1;
		if(curve_name_len > 255){
			/* Sanity check */
			ret = -1;
			goto err;
		}
		ret = ec_get_curve_params_by_name((const u8 *)ec_name,
							   (u8)curve_name_len, &curve_params);
		if ((ret) || (!curve_params)) {
			ret = -1;
			printf("Error: EC curve %s is unknown!\n", ec_name);
			goto err;
		}
		*ec_str_p = curve_params;
	}

	if (hash_type != NULL) {
		/* Get hash type from hash alg name */
		ret = get_hash_by_name(hash_name, &hm);
		if ((ret) || (!hm)) {
			ret = -1;
			printf("Error: hash function %s is unknown!\n",
			       hash_name);
			goto err;
		}
		*hash_type = hm->type;
	}

	ret = 0;

 err:
	return ret;
}

ATTRIBUTE_WARN_UNUSED_RET static int generate_and_export_key_pair(const char *ec_name,
					const char *ec_sig_name,
					const char *fname_prefix)
{
	const ec_str_params *ec_str_p;
	char fname[MAX_BUF_LEN];
	char kname[MAX_BUF_LEN];
	const u16 fname_len = sizeof(fname);
	const u16 kname_len = sizeof(kname);
	u16 prefix_len;
	u32 len;
	ec_alg_type sig_type;
	ec_params params;
	ec_key_pair kp;
	FILE *file = NULL;
	int ret;

	MUST_HAVE(ec_name != NULL, ret, err);
	MUST_HAVE(fname_prefix != NULL, ret, err);
	MUST_HAVE(ec_sig_name != NULL, ret, err);

	/* Get parameters from pretty names */
	ret = string_to_params(ec_name, ec_sig_name, &sig_type, &ec_str_p,
			       NULL, NULL);
	if (ret) {
		ret = -1;
		printf("Error: error when importing params\n");
		goto err;
	}

	/* Import the parameters */
	ret = import_params(&params, ec_str_p); EG(ret, err);

	/* Generate the key pair */
	ret = ec_key_pair_gen(&kp, &params, sig_type); EG(ret, err);

	/* Get the unique affine equivalent representation of the projective point for the public key.
	 * This avoids ambiguity when exporting the point, and is mostly here
	 * for compatibility with external libraries.
	 */
	ret = prj_pt_unique(&(kp.pub_key.y), &(kp.pub_key.y)); EG(ret, err);

	/*************************/

	/* Export the private key to the raw binary file */
	ret = local_strnlen(fname_prefix, fname_len, &len); EG(ret, err);
	MUST_HAVE(len <= 0xffff, ret, err);
	prefix_len = (u16)len;
	ret = local_memset(fname, 0, fname_len); EG(ret, err);
	ret = local_memcpy(fname, fname_prefix, prefix_len); EG(ret, err);
	ret = local_strncat(fname, "_private_key.bin", (u32)(fname_len - prefix_len)); EG(ret, err);
	file = fopen(fname, "wb");
	if (file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", fname);
		goto err;
	}

	ret = export_private_key(file, NULL, &(kp.priv_key), RAWBIN);
	if (ret) {
		ret = -1;
		printf("Error exporting the private key\n");
		goto err;
	}
	ret = fclose(file); EG(ret, err);
	file = NULL;

	/* Export the private key to the .h file */
	ret = local_memset(fname, 0, fname_len); EG(ret, err);
	ret = local_memcpy(fname, fname_prefix, prefix_len); EG(ret, err);
	ret = local_strncat(fname, "_private_key.h", (u32)(fname_len - prefix_len)); EG(ret, err);
	file = fopen(fname, "w");
	if (file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", fname);
		goto err;
	}

	snprintf(kname, kname_len, "%s_%s_private_key", ec_name, ec_sig_name);
	ret = export_private_key(file, kname, &(kp.priv_key), DOTH);
	if (ret) {
		ret = -1;
		printf("Error: error exporting the private key\n");
		goto err;
	}
	ret = fclose(file); EG(ret, err);
	file = NULL;

	/*************************/

	/* Export the public key to the raw binary file */
	ret = local_memset(fname, 0, fname_len); EG(ret, err);
	ret = local_memcpy(fname, fname_prefix, prefix_len); EG(ret, err);
	ret = local_strncat(fname, "_public_key.bin", (u32)(fname_len - prefix_len)); EG(ret, err);
	file = fopen(fname, "wb");
	if (file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", fname);
		goto err;
	}
	ret = export_public_key(file, NULL, &(kp.pub_key), RAWBIN);
	if (ret) {
		ret = -1;
		printf("Error exporting the public key\n");
		goto err;
	}
	ret = fclose(file); EG(ret, err);
	file = NULL;

	/* Export the public key to the .h file */
	ret = local_memset(fname, 0, fname_len); EG(ret, err);
	ret = local_memcpy(fname, fname_prefix, prefix_len); EG(ret, err);
	ret = local_strncat(fname, "_public_key.h", (u32)(fname_len - prefix_len)); EG(ret, err);
	file = fopen(fname, "w");
	if (file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", fname);
		goto err;
	}

	snprintf(kname, kname_len, "%s_%s_public_key", ec_name, ec_sig_name);
	ret = export_public_key(file, kname, &(kp.pub_key), DOTH);
	if (ret) {
		ret = -1;
		printf("Error exporting the public key\n");
		goto err;
	}
	ret = fclose(file); EG(ret, err);
	file = NULL;

	ret = 0;

err:
	if(file != NULL){
		if(fclose(file)){
			ret = -1;
		}
	}
	return ret;
}


ATTRIBUTE_WARN_UNUSED_RET static int store_sig(const char *in_fname, const char *out_fname,
		     const u8 *sig, u32 siglen,
		     ec_alg_type sig_type, hash_alg_type hash_type,
		     const u8 curve_name[MAX_CURVE_NAME_LEN],
		     metadata_hdr * hdr)
{
	FILE *in_file = NULL, *out_file = NULL;
	u8 buf[MAX_BUF_LEN];
	size_t read, written;
	int ret;

	MUST_HAVE((in_fname != NULL), ret, err);
	MUST_HAVE((out_fname != NULL), ret, err);
	MUST_HAVE((sig != NULL), ret, err);
	MUST_HAVE((curve_name != NULL), ret, err);
	MUST_HAVE((hdr != NULL), ret, err);
#if (MAX_BUF_LEN <= 255)
	/* No need to check this is sizeof(buf) exceeds 256.
	 * (avoids -Werror,-Wtautological-constant-out-of-range-compare)
	 */
	MUST_HAVE(EC_STRUCTURED_SIG_EXPORT_SIZE(siglen) <= sizeof(buf), ret, err);
#endif
	/* Import the data from the input file */
	in_file = fopen(in_fname, "rb");
	if (in_file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", in_fname);
		goto err;
	}
	out_file = fopen(out_fname, "wb");
	if (out_file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", out_fname);
		goto err;
	}
	if (hdr != NULL) {
		/* Write the metadata header as a prepending information */
		written = fwrite(hdr, 1, sizeof(metadata_hdr), out_file);
		if (written != sizeof(metadata_hdr)) {
			ret = -1;
			goto err;
		}
	}

	while (1) {
		read = fread(buf, 1, sizeof(buf), in_file);
		written = fwrite(buf, 1, read, out_file);
		if (written != read) {
			ret = -1;
			printf("Error: error when writing to %s\n",
			       out_fname);
			goto err;
		}
		if (read != sizeof(buf)) {
			if (feof(in_file)) {
				/* EOF */
				break;
			} else {
				ret = -1;
				printf("Error: error when reading from %s\n",
				       in_fname);
				goto err;
			}
		}

	}

	/* Compute the structured signature */
	ret = ec_structured_sig_export_to_buf(sig, siglen, buf, sizeof(buf),
					      sig_type, hash_type, curve_name);
	if (ret) {
		ret = -1;
		printf("Error: error when exporting signature to structured buffer\n");
		goto err;
	}
	/* Store the signature buffer */
	written =
		fwrite(buf, 1, EC_STRUCTURED_SIG_EXPORT_SIZE(siglen),
		       out_file);
	if (written != EC_STRUCTURED_SIG_EXPORT_SIZE(siglen)) {
		ret = -1;
		printf("Error: error when writing to %s\n", out_fname);
		goto err;
	}

	ret = 0;

 err:
	if(in_file != NULL){
		if(fclose(in_file)){
			ret = -1;
		}
	}
	if(out_file != NULL){
		if(fclose(out_file)){
			ret = -1;
		}
	}
	return ret;
}

/* Get the raw size of a file */
ATTRIBUTE_WARN_UNUSED_RET static int get_file_size(const char *in_fname, size_t *outsz)
{
	FILE *in_file = NULL;
	long size;
	int ret;

	MUST_HAVE(outsz != NULL, ret, err);
	MUST_HAVE(in_fname != NULL, ret, err);

	*outsz = 0;

	in_file = fopen(in_fname, "rb");
	if (in_file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", in_fname);
		goto err;
	}
	/* Compute the size of the file */
	if (fseek(in_file, 0L, SEEK_END)) {
		ret = -1;
		printf("Error: file %s cannot be seeked\n", in_fname);
		goto err;
	}
	size = ftell(in_file);
	if (size < 0) {
		ret = -1;
		printf("Error: cannot compute file %s size\n", in_fname);
		goto err;
	}
	/* Check overflow */
	if ((u64)size > (u64)(0xffffffff)) {
		ret = -1;
		printf("Error: file %s size %ld overflow (>= 2^32)\n",
		       in_fname, size);
		goto err;
	}

	*outsz = (u32)size;
	ret = 0;

 err:
	if(in_file != NULL){
		if(fclose(in_file)){
			ret = -1;
		}
	}
	return ret;
}

/* Generate a proper handler from a given type and other information */
ATTRIBUTE_WARN_UNUSED_RET static int generate_metadata_hdr(metadata_hdr * hdr, const char *hdr_type,
				 const char *version, size_t len, u8 siglen)
{
	unsigned long ver;
	char *endptr; /* for strtoul() */
	int ret, check;

	MUST_HAVE((hdr != NULL), ret, err);
	MUST_HAVE((hdr_type != NULL), ret, err);
	MUST_HAVE((version != NULL), ret, err);

	/* The magic value */
	hdr->magic = HDR_MAGIC;

	/* The given version */
#ifdef WITH_STDLIB
	errno = 0;
#endif
	ver = strtoul(version, &endptr, 0);
#ifdef WITH_STDLIB
	if(errno){
		ret = -1;
		printf("Error: error in strtoul\n");
		goto err;
	}
#endif
	if (*endptr != '\0') {
		ret = -1;
		printf("Error: error getting provided version %s\n", version);
		goto err;
	}
	if ((ver & 0xffffffff) != ver) {
		ret = -1;
		printf("Error: provided version %s is too long!\n", version);
		goto err;
	}
	hdr->version = (u32)ver;

	/* The image type */
	hdr->type = IMAGE_TYPE_UNKNOWN;
	ret = are_str_equal(hdr_type, "IMAGE_TYPE0", &check); EG(ret, err);
	if (check) {
		hdr->type = IMAGE_TYPE0;
	}
	ret = are_str_equal(hdr_type, "IMAGE_TYPE1", &check); EG(ret, err);
	if (check) {
		hdr->type = IMAGE_TYPE1;
	}
	ret = are_str_equal(hdr_type, "IMAGE_TYPE2", &check); EG(ret, err);
	if (check) {
		hdr->type = IMAGE_TYPE2;
	}
	ret = are_str_equal(hdr_type, "IMAGE_TYPE3", &check); EG(ret, err);
	if (check) {
		hdr->type = IMAGE_TYPE3;
	}
	if (hdr->type == IMAGE_TYPE_UNKNOWN) {
		ret = -1;
		printf("Error: unknown header type %s\n", hdr_type);
		goto err;
	}

	/* The length without the signature */
	if ((len & 0xffffffff) != len) {
		ret = -1;
		printf("Error: provided length value %lu is too long!\n", (unsigned long)len);
		goto err;
	}
	hdr->len = (u32)len;

	/* The signature length */
	hdr->siglen = siglen;

	ret = 0;

 err:
	return ret;
}

/* Warn the user that the provided ancillary data won't be used
 * if the algorithm does not need them.
 */
ATTRIBUTE_WARN_UNUSED_RET static int check_ancillary_data(const char *adata, ec_alg_type sig_type, const char *sig_name, int *check)
{
	int ret;

	MUST_HAVE(check != NULL, ret, err);
	MUST_HAVE(adata != NULL, ret, err);
	MUST_HAVE(sig_name != NULL, ret, err);
	MUST_HAVE(sig_type != UNKNOWN_ALG, ret, err);

	(*check) = 0;

#if defined(WITH_SIG_EDDSA25519)
	if(sig_type == EDDSA25519CTX){
		(*check) = 1;
	}
#endif
#if defined(WITH_SIG_EDDSA448)
	if(sig_type == EDDSA448){
		(*check) = 1;
	}
#endif
#if defined(WITH_SIG_SM2)
	if(sig_type == SM2){
		(*check) = 1;
	}
#endif
	if((*check) == 0){
		printf("Warning: you have provided optional ancillary data "\
		       "with a signature algorithm %s that does not need it! "\
		       "This data is ignored.\n", sig_name);
	}

	ret = 0;

err:
	return ret;
}

/*
 * Sign data from file and append signature
 */
ATTRIBUTE_WARN_UNUSED_RET static int sign_bin_file(const char *ec_name, const char *ec_sig_name,
			 const char *hash_algorithm, const char *in_fname,
			 const char *in_key_fname,
			 const char *out_fname, const char *hdr_type,
			 const char *version, const char *adata, u16 adata_len)
{
	u8 sig[EC_MAX_SIGLEN];
	u8 buf[MAX_BUF_LEN];
	u8 siglen;
	FILE *in_file = NULL;
	ec_key_pair key_pair;
	FILE *in_key_file = NULL;
	FILE *out_file = NULL;
	const ec_str_params *ec_str_p;
	ec_params params;
	int ret, check;
	ec_alg_type sig_type;
	hash_alg_type hash_type;
	u8 priv_key_buf[EC_STRUCTURED_PRIV_KEY_MAX_EXPORT_SIZE];
	u8 priv_key_buf_len;
	size_t raw_data_len;
	metadata_hdr hdr;
	size_t read, to_read;
	int eof;
	u8 *allocated_buff = NULL;
	struct ec_sign_context sig_ctx;

	MUST_HAVE(ec_name != NULL, ret, err);
	MUST_HAVE(ec_sig_name != NULL, ret, err);
	MUST_HAVE(hash_algorithm != NULL, ret, err);
	MUST_HAVE(in_fname != NULL, ret, err);
	MUST_HAVE(in_key_fname != NULL, ret, err);
	MUST_HAVE(out_fname != NULL, ret, err);

	/************************************/
	/* Get parameters from pretty names */
	if (string_to_params
	    (ec_name, ec_sig_name, &sig_type, &ec_str_p, hash_algorithm,
	     &hash_type)) {
		ret = -1;
		goto err;
	}
	if(adata != NULL){
		/* Check if ancillary data will be used */
		ret = check_ancillary_data(adata, sig_type, ec_sig_name, &check); EG(ret, err);
	}
	/* Import the parameters */
	ret = import_params(&params, ec_str_p); EG(ret, err);

	/************************************/
	/* Import the private key from the file */
	in_key_file = fopen(in_key_fname, "rb");
	if (in_key_file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", in_key_fname);
		goto err;
	}
	priv_key_buf_len = (u8)fread(priv_key_buf, 1, sizeof(priv_key_buf),
				     in_key_file);
	ret = ec_structured_key_pair_import_from_priv_key_buf(&key_pair,
							      &params,
							      priv_key_buf,
							      priv_key_buf_len,
							      sig_type);
	if (ret) {
		ret = -1;
		printf("Error: error when importing key pair from %s\n",
		       in_key_fname);
		goto err;
	}

	ret = get_file_size(in_fname, &raw_data_len);
	if (ret) {
		ret = -1;
		printf("Error: cannot retrieve file %s size\n", in_fname);
		goto err;
	}
	if(raw_data_len == 0){
		ret = -1;
		printf("Error: file %s seems to be empty!\n", in_fname);
		goto err;
	}
	ret = ec_get_sig_len(&params, sig_type, hash_type, &siglen);
	if (ret) {
		ret = -1;
		printf("Error getting effective signature length from %s\n",
		       (const char *)(ec_str_p->name->buf));
		goto err;
	}

	/* Structured export case, we forge a header */
	if((hdr_type != NULL) && (version != NULL)){
		/************************************/
		/* Forge the header */
		ret = generate_metadata_hdr(&hdr, hdr_type, version, raw_data_len,
					    EC_STRUCTURED_SIG_EXPORT_SIZE(siglen));

		if (ret) {
			ret = -1;
			printf("Error: error when generating metadata\n");
			goto err;
		}
	}

	/* Check if we support streaming */
	ret = is_sign_streaming_mode_supported(sig_type, &check); EG(ret, err);
	if(check){
		/**** We support streaming mode ****/
		/*
		 * Initialize signature context and start signature computation
		 * with generated metadata header.
		 */
		ret = ec_sign_init(&sig_ctx, &key_pair, sig_type, hash_type, (const u8*)adata, adata_len);
		if (ret) {
			ret = -1;
			printf("Error: error when signing\n");
			goto err;
		}

		/* Structured export case, we prepend the header in the signature */
		if((hdr_type != NULL) && (version != NULL)){
			ret = ec_sign_update(&sig_ctx, (const u8 *)&hdr, sizeof(metadata_hdr));
			if (ret) {
				ret = -1;
				printf("Error: error when signing\n");
				goto err;
			}
		}

		/*
		 * Read file content chunk by chunk up to file length, passing each
		 * chunk to signature update function
		 */
		in_file = fopen(in_fname, "rb");
		if (in_file == NULL) {
			ret = -1;
			printf("Error: file %s cannot be opened\n", in_fname);
			goto err;
		}

		eof = 0;
		clearerr(in_file);
		while (raw_data_len && !eof) {
			to_read =
				(raw_data_len <
				sizeof(buf)) ? raw_data_len : sizeof(buf);
			memset(buf, 0, sizeof(buf));
			read = fread(buf, 1, to_read, in_file);
			if (read != to_read) {
				/* Check if this was EOF */
				ret = feof(in_file);
				clearerr(in_file);
				if (ret) {
					eof = 1;
				}
			}

			if (read > raw_data_len) {
				/* we read more than expected: leave! */
				break;
			}

			raw_data_len -= read;

			ret = ec_sign_update(&sig_ctx, buf, (u32)read);
			if (ret) {
				break;
			}
		}

		if (raw_data_len) {
			ret = -1;
			printf("Error: unable to read full file content\n");
			goto err;
		}

		/* We can now complete signature generation */
		ret = ec_sign_finalize(&sig_ctx, sig, siglen);
		if (ret) {
			ret = -1;
			printf("Error: error when signing\n");
			goto err;
		}
	}
	else{
		/**** We do not support streaming mode ****/
		/* Since we don't support streaming mode, we unfortunately have to
		 * use a dynamic allocation here.
		 */
		size_t offset = 0;
		allocated_buff = (u8*)malloc(1);
		if(allocated_buff == NULL){
			ret = -1;
			printf("Error: allocation error\n");
			goto err;
		}
		if((hdr_type != NULL) && (version != NULL)){
			allocated_buff = (u8*)realloc(allocated_buff, sizeof(hdr));
			if(allocated_buff == NULL){
				ret = -1;
				printf("Error: allocation error\n");
				goto err;
			}
			memcpy(allocated_buff, &hdr, sizeof(hdr));
			offset += sizeof(hdr);
		}
		in_file = fopen(in_fname, "rb");
		if (in_file == NULL) {
			ret = -1;
			printf("Error: file %s cannot be opened\n", in_fname);
			goto err;
		}

		eof = 0;
		clearerr(in_file);
		while (raw_data_len && !eof) {
			to_read =
				(raw_data_len <
				sizeof(buf)) ? raw_data_len : sizeof(buf);
			read = fread(buf, 1, to_read, in_file);
			if (read != to_read) {
				/* Check if this was EOF */
				ret = feof(in_file);
				clearerr(in_file);
				if (ret) {
					eof = 1;
				}
			}

			if (read > raw_data_len) {
				/* we read more than expected: leave! */
				break;
			}

			raw_data_len -= read;

			allocated_buff = (u8*)realloc(allocated_buff, offset + read);
			if(allocated_buff == NULL){
				ret = -1;
				printf("Error: allocation error\n");
				goto err;
			}
			memcpy(allocated_buff + offset, buf, read);
			offset += read;
		}

		if (raw_data_len) {
			ret = -1;
			printf("Error: unable to read full file content\n");
			goto err;
		}

		/* Sign */
		ret = ec_sign(sig, siglen, &key_pair, allocated_buff, (u32)offset, sig_type, hash_type, (const u8*)adata, adata_len);
		if(ret){
			ret = -1;
			printf("Error: error when signing\n");
			goto err;
		}
	}

	/* Structured export case, forge the full structured file
	 * with HEADER || raw_binary || signature
	 */
	if((hdr_type != NULL) && (version != NULL)){
		/***********************************/
		/* Store the header, the raw data of the file as well as the signature */
		ret = store_sig(in_fname, out_fname, sig, siglen, sig_type,
				hash_type, params.curve_name, &hdr);
		if (ret) {
			ret = -1;
			printf("Error: error when storing signature to %s\n",
			       out_fname);
			goto err;
		}
	}
	else{
		/* Store the raw binary signature in the output file */
		size_t written;

		out_file = fopen(out_fname, "wb");
		if (out_file == NULL) {
			ret = -1;
			printf("Error: file %s cannot be opened\n", out_fname);
			goto err;
		}
		written = fwrite(sig, 1, siglen, out_file);
		if (written != siglen) {
			ret = -1;
			printf("Error: error when writing to %s\n",
			       out_fname);
			goto err;
		}
	}

	ret = 0;

 err:
	if(in_file != NULL){
		if(fclose(in_file)){
			ret = -1;
		}
	}
	if(in_key_file != NULL){
		if(fclose(in_key_file)){
			ret = -1;
		}
	}
	if(out_file != NULL){
		if(fclose(out_file)){
			ret = -1;
		}
	}
	if(allocated_buff != NULL){
		free(allocated_buff);
	}
	return ret;
}

/* Dump metadata header */
ATTRIBUTE_WARN_UNUSED_RET static int dump_hdr_info(const metadata_hdr * hdr)
{
	int ret;

	if (hdr == NULL) {
		printf("Metadata header pointer is NULL!\n");
		ret = -1;
		goto err;
	}

	/* Dump the header */
	printf("Metadata header info:\n");
	printf("    magic   = 0x%08" PRIx32 "\n", hdr->magic);
	switch (hdr->type) {
	case IMAGE_TYPE0:
		printf("    type    = IMAGE_TYPE0\n");
		break;
	case IMAGE_TYPE1:
		printf("    type    = IMAGE_TYPE1\n");
		break;
	case IMAGE_TYPE2:
		printf("    type    = IMAGE_TYPE2\n");
		break;
	case IMAGE_TYPE3:
		printf("    type    = IMAGE_TYPE3\n");
		break;
	default:
		printf("    type %" PRIu32 " unknown!\n", hdr->type);
		break;
	}
	printf("    version = 0x%08" PRIx32 "\n", hdr->version);
	printf("    len	    = 0x%08" PRIx32 "\n", hdr->len);
	printf("    siglen  = 0x%08" PRIx32 "\n", hdr->siglen);
	ret = 0;

err:
	return ret;
}

/*
 * Verify signature data from file with appended signature
 */
ATTRIBUTE_WARN_UNUSED_RET static int verify_bin_file(const char *ec_name, const char *ec_sig_name,
			   const char *hash_algorithm,
			   const char *in_fname,
			   const char *in_key_fname, const char *in_sig_fname, const char *adata, u16 adata_len)
{
	u8 st_sig[EC_STRUCTURED_SIG_EXPORT_SIZE(EC_MAX_SIGLEN)];
	u8 stored_curve_name[MAX_CURVE_NAME_LEN];
	u8 pub_key_buf[EC_STRUCTURED_PUB_KEY_MAX_EXPORT_SIZE];
	struct ec_verify_context verif_ctx;
	ec_alg_type stored_sig_type;
	hash_alg_type stored_hash_type;
	const ec_str_params *ec_str_p;
	ec_alg_type sig_type;
	hash_alg_type hash_type;
	u8 sig[EC_MAX_SIGLEN];
	u8 siglen, st_siglen;
	size_t read, to_read;
	u8 buf[MAX_BUF_LEN];
	u8 pub_key_buf_len;
	size_t raw_data_len;
	ec_pub_key pub_key;
	FILE *in_key_file = NULL;
	FILE *in_sig_file = NULL;
	ec_params params;
	metadata_hdr hdr;
	size_t exp_len;
	FILE *in_file = NULL;
	int ret, eof, check;
	u8 *allocated_buff = NULL;

	MUST_HAVE(ec_name != NULL, ret, err);
	MUST_HAVE(ec_sig_name != NULL, ret, err);
	MUST_HAVE(hash_algorithm != NULL, ret, err);
	MUST_HAVE(in_fname != NULL, ret, err);
	MUST_HAVE(in_key_fname != NULL, ret, err);

	/************************************/
	/* Get parameters from pretty names */
	ret = string_to_params(ec_name, ec_sig_name, &sig_type, &ec_str_p,
                             hash_algorithm, &hash_type); EG(ret, err);
	if(adata != NULL){
		/* Check if ancillary data will be used */
		ret = check_ancillary_data(adata, sig_type, ec_sig_name, &check); EG(ret, err);
	}
	/* Import the parameters */
	ret = import_params(&params, ec_str_p); EG(ret, err);

	ret = ec_get_sig_len(&params, sig_type, hash_type, &siglen);
	if (ret) {
		ret = -1;
		printf("Error getting effective signature length from %s\n",
		       (const char *)(ec_str_p->name->buf));
		goto err;
	}

	/************************************/
	/* Import the public key from the file */
	in_key_file = fopen(in_key_fname, "rb");
	if (in_key_file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", in_key_fname);
		goto err;
	}
	pub_key_buf_len =(u8)fread(pub_key_buf, 1, sizeof(pub_key_buf),
				   in_key_file);
	ret = ec_structured_pub_key_import_from_buf(&pub_key, &params,
						    pub_key_buf,
						    pub_key_buf_len, sig_type);
	if (ret) {
		ret = -1;
		printf("Error: error when importing public key from %s\n",
		       in_key_fname);
		goto err;
	}

	/* Let's first get file size */
	ret = get_file_size(in_fname, &raw_data_len);
	if (ret) {
		ret = -1;
		printf("Error: cannot retrieve file %s size\n", in_fname);
		goto err;
	}
	if(raw_data_len == 0){
		ret = -1;
		printf("Error: file %s seems to be empty!\n", in_fname);
		goto err;
	}

	/* Open main file to verify ... */
	in_file = fopen(in_fname, "rb");
	if (in_file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", in_fname);
		goto err;
	}

	/*
	 * We are in 'structured' mode, read the header and get the information
	 * from it
	 */
	if (in_sig_fname == NULL) {
		/* ... and first read metadata header */
		read = fread(&hdr, 1, sizeof(hdr), in_file);
		if (read != sizeof(hdr)) {
			ret = -1;
			printf("Error: unable to read metadata header "
			       "from file\n");
			goto err;
		}

		/* Sanity checks on the header we get */
		if (hdr.magic != HDR_MAGIC) {
			ret = -1;
			printf("Error: got magic 0x%08" PRIx32 " instead of 0x%08x "
			       "from metadata header\n", hdr.magic, (unsigned int)HDR_MAGIC);
			goto err;
		}

		st_siglen = EC_STRUCTURED_SIG_EXPORT_SIZE(siglen);
		MUST_HAVE(raw_data_len > (sizeof(hdr) + st_siglen), ret, err);
		exp_len = raw_data_len - sizeof(hdr) - st_siglen;
		if (hdr.len != exp_len) {
			ret = -1;
			printf("Error: got raw size of %" PRIu32 " instead of %lu from "
			       "metadata header\n", hdr.len,
			       (unsigned long)exp_len);
			goto err;
		}

		if (hdr.siglen != st_siglen) {
			ret = -1;
			printf("Error: got siglen %" PRIu32 " instead of %d from "
			       "metadata header\n", hdr.siglen, siglen);
			goto err;
		}

		/* Dump the header */
		ret = dump_hdr_info(&hdr); EG(ret, err);

		/*
		 * We now need to seek in file to get structured signature.
		 * Before doing that, let's first check size is large enough.
		 */
		if (raw_data_len < (sizeof(hdr) + st_siglen)) {
			ret = -1;
			goto err;
		}

		ret = fseek(in_file, (long)(raw_data_len - st_siglen),
			    SEEK_SET);
		if (ret) {
			ret = -1;
			printf("Error: file %s cannot be seeked\n", in_fname);
			goto err;
		}
		read = fread(st_sig, 1, st_siglen, in_file);
		if (read != st_siglen) {
			ret = -1;
			printf("Error: unable to read structure sig from "
			       "file\n");
			goto err;
		}
		/* Import the signature from the structured signature buffer */
		ret = ec_structured_sig_import_from_buf(sig, siglen,
							st_sig, st_siglen,
							&stored_sig_type,
							&stored_hash_type,
							stored_curve_name);
		if (ret) {
			ret = -1;
			printf("Error: error when importing signature "
			       "from %s\n", in_fname);
			goto err;
		}
		if (stored_sig_type != sig_type) {
			ret = -1;
			printf("Error: signature type imported from signature "
			       "mismatches with %s\n", ec_sig_name);
			goto err;
		}
		if (stored_hash_type != hash_type) {
			ret = -1;
			printf("Error: hash algorithm type imported from "
			       "signature mismatches with %s\n",
			       hash_algorithm);
			goto err;
		}
		ret = are_str_equal((char *)stored_curve_name, (char *)params.curve_name, &check); EG(ret, err);
		if (!check) {
			ret = -1;
			printf("Error: curve type '%s' imported from signature "
			       "mismatches with '%s'\n", stored_curve_name,
			       params.curve_name);
			goto err;
		}

		/*
		 * Get back to the beginning of file, at the beginning of header
		 */
		if (fseek(in_file, 0, SEEK_SET)) {
			ret = -1;
			printf("Error: file %s cannot be seeked\n", in_fname);
			goto err;
		}
		exp_len += sizeof(hdr);
	} else {
		/* Get the signature size */
		ret = get_file_size(in_sig_fname, &to_read);
		if (ret) {
			ret = -1;
			printf("Error: cannot retrieve file %s size\n",
			       in_sig_fname);
			goto err;
		}
		if((to_read > EC_MAX_SIGLEN) || (to_read > 255) || (to_read == 0)){
			/* This is not an expected size, get out */
			ret = -1;
			printf("Error: size %d of signature in %s is > max "
			       "signature size %d or > 255",
			       (int)to_read, in_sig_fname, EC_MAX_SIGLEN);
			goto err;
		}
		siglen = (u8)to_read;
		/* Read the raw signature from the signature file */
		in_sig_file = fopen(in_sig_fname, "rb");
		if (in_sig_file == NULL) {
			ret = -1;
			printf("Error: file %s cannot be opened\n",
			       in_sig_fname);
			goto err;
		}
		read = fread(&sig, 1, siglen, in_sig_file);
		if (read != siglen) {
			ret = -1;
			printf("Error: unable to read signature from %s\n",
			       in_sig_fname);
			goto err;
		}
		exp_len = raw_data_len;
	}

	/* Check if we support streaming */
	ret = is_verify_streaming_mode_supported(sig_type, &check); EG(ret, err);
	if(check){
		/**** We support streaming mode ****/
		/*
		 * ... and read file content chunk by chunk to compute signature
		 */
		ret = ec_verify_init(&verif_ctx, &pub_key, sig, siglen,
				     sig_type, hash_type, (const u8*)adata, adata_len);
		if (ret) {
			ret = -1;
			printf("Error: error when verifying ...\n");
			goto err;
		}

		eof = 0;
		clearerr(in_file);
		while (exp_len && !eof) {
			to_read = (exp_len < sizeof(buf)) ? exp_len : sizeof(buf);
			read = fread(buf, 1, to_read, in_file);
			if (read != to_read) {
				/* Check if this was EOF */
				ret = feof(in_file);
				clearerr(in_file);
				if (ret) {
					eof = 1;
				}
			}

			if (read > exp_len) {
				/* we read more than expected: leave! */
				break;
			}

			exp_len -= read;

			ret = ec_verify_update(&verif_ctx, buf, (u32)read);
			if(ret){
				ret = -1;
				printf("Error: error when verifying ...\n");
				goto err;
			}
		}
		if (exp_len) {
			ret = -1;
			printf("Error: unable to read full file content\n");
			goto err;
		}
		ret = ec_verify_finalize(&verif_ctx);
		if (ret) {
			ret = -1;
			goto err;
		}
	}
	else{
		/**** We do not support streaming mode ****/
		/* Since we don't support streaming mode, we unfortunately have to
		 * use a dynamic allocation here.
		 */
		size_t offset = 0;
		allocated_buff = (u8*)malloc(1);

		eof = 0;
		clearerr(in_file);
		while (exp_len && !eof) {
			to_read = (exp_len < sizeof(buf)) ? exp_len : sizeof(buf);
			read = fread(buf, 1, to_read, in_file);
			if (read != to_read) {
				/* Check if this was EOF */
				ret = feof(in_file);
				clearerr(in_file);
				if (ret) {
					eof = 1;
				}
			}

			if (read > exp_len) {
				/* we read more than expected: leave! */
				break;
			}

			exp_len -= read;

			allocated_buff = (u8*)realloc(allocated_buff, offset + read);
			if(allocated_buff == NULL){
				ret = -1;
				printf("Error: allocation error\n");
				goto err;
			}
			memcpy(allocated_buff + offset, buf, read);
			offset += read;
		}
		if (exp_len) {
			ret = -1;
			printf("Error: unable to read full file content\n");
			goto err;
		}

		ret = ec_verify(sig, siglen, &pub_key, allocated_buff, (u32)offset, sig_type, hash_type, (const u8*)adata, adata_len);
		if (ret) {
			ret = -1;
			goto err;
		}

	}

	ret = 0;

 err:
	if(in_file != NULL){
		if(fclose(in_file)){
			ret = -1;
		}
	}
	if(in_key_file != NULL){
		if(fclose(in_key_file)){
			ret = -1;
		}
	}
	if(in_sig_file != NULL){
		if(fclose(in_sig_file)){
			ret = -1;
		}
	}
	if(allocated_buff != NULL){
		free(allocated_buff);
	}
	return ret;
}

/* Compute 'scalar * Point' on the provided curve and prints
 * the result.
 */
ATTRIBUTE_WARN_UNUSED_RET static int ec_scalar_mult(const char *ec_name,
			  const char *scalar_file,
			  const char *point_file,
			  const char *outfile_name)
{
	const ec_str_params *ec_str_p;
	ec_params curve_params;
	int ret;
	u8 buf[MAX_BUF_LEN];
	size_t buf_len;
	FILE *in_file = NULL;
	FILE *out_file = NULL;
	u16 coord_len;

	/* Scalar (natural number) to import */
	nn d;
	/* Point to import */
	prj_pt Q;
	d.magic = Q.magic = WORD(0);

	MUST_HAVE(ec_name != NULL, ret, err);
	MUST_HAVE(scalar_file != NULL, ret, err);
	MUST_HAVE(point_file != NULL, ret, err);
	MUST_HAVE(outfile_name != NULL, ret, err);

	/* Get parameters from pretty names */
	ret = string_to_params(ec_name, NULL, NULL, &ec_str_p,
			       NULL, NULL); EG(ret, err);

	/* Import the parameters */
	ret = import_params(&curve_params, ec_str_p); EG(ret, err);

	/* Import the scalar in the local buffer from the file */
	/* Let's first get file size */
	ret = get_file_size(scalar_file, &buf_len);
	if(buf_len == 0){
		ret = -1;
		printf("Error: file %s seems to be empty!\n", scalar_file);
		goto err;
	}
	if (ret) {
		ret = -1;
		printf("Error: cannot retrieve file %s size\n", scalar_file);
		goto err;
	}
	if(buf_len > sizeof(buf)){
		ret = -1;
		printf("Error: file %s content too large for our local buffers\n", scalar_file);
		goto err;
	}
	/* Open main file to verify ... */
	in_file = fopen(scalar_file, "rb");
	if (in_file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", scalar_file);
		goto err;
	}
	/* Read the content of the file */
	if(fread(buf, 1, buf_len, in_file) != buf_len){
		ret = -1;
		printf("Error: error when reading in %s\n", scalar_file);
		goto err;
	}
	/* Import the scalar */
	ret = nn_init_from_buf(&d, buf, (u16)buf_len); EG(ret, err);

	/* Import the point in the local buffer from the file */
	/* Let's first get file size */
	ret = get_file_size(point_file, &buf_len);
	if (ret) {
		ret = -1;
		printf("Error: cannot retrieve file %s size\n", point_file);
		goto err;
	}
	if(buf_len > sizeof(buf)){
		ret = -1;
		printf("Error: file %s content too large for our local buffers\n", point_file);
		goto err;
	}
	ret = fclose(in_file); EG(ret, err);
	in_file = NULL;
	/* Open main file to verify ... */
	in_file = fopen(point_file, "rb");
	if (in_file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", point_file);
		goto err;
	}
	/* Read the content of the file */
	if(fread(buf, 1, buf_len, in_file) != buf_len){
		ret = -1;
		printf("Error: error when reading in %s\n", point_file);
		goto err;
	}
	/* Import the point */
	if(prj_pt_import_from_buf(&Q, buf, (u16)buf_len, &(curve_params.ec_curve))){
		ret = -1;
		printf("Error: error when importing the projective point from %s\n", point_file);
		goto err;
	}

#ifdef USE_SIG_BLINDING
	/* NB: we use a blind scalar multiplication here since we do not want our
	 * private d to leak ...
	 */
	ret = prj_pt_mul_blind(&Q, &d, &Q); EG(ret, err);
#else
	ret = prj_pt_mul(&Q, &d, &Q); EG(ret, err);
#endif
	/* Get the unique representation of the point */
	ret = prj_pt_unique(&Q, &Q); EG(ret, err);

	/* Export the projective point in the local buffer */
	coord_len = (u16)(3 * BYTECEIL((Q.crv)->a.ctx->p_bitlen));
	if(coord_len > sizeof(buf)){
		ret = -1;
		printf("Error: error when exporting the point\n");
		goto err;
	}
	if(prj_pt_export_to_buf(&Q, buf, coord_len)){
		ret = -1;
		printf("Error: error when exporting the point\n");
		goto err;
	}
	/* Now save the coordinates in the output file */
	out_file = fopen(outfile_name, "wb");
	if (out_file == NULL) {
		ret = -1;
		printf("Error: file %s cannot be opened\n", outfile_name);
		goto err;
	}

	/* Write in the file */
	if(fwrite(buf, 1, coord_len, out_file) != coord_len){
		ret = -1;
		printf("Error: error when writing to %s\n", outfile_name);
		goto err;
	}

	ret = 0;

err:
	/* Uninit local variables */
	nn_uninit(&d);
	prj_pt_uninit(&Q);

	if(in_file != NULL){
		if(fclose(in_file)){
			ret = -1;
		}
	}
	if(out_file != NULL){
		if(fclose(out_file)){
			ret = -1;
		}
	}
	return ret;
}


static void print_curves(void)
{
       u8 i;

       /* Print all the available curves */
       for (i = 0; i < EC_CURVES_NUM; i++) {
	       printf("%s ", (const char *)(ec_maps[i].params->name->buf));
       }

       return;
}

static void print_hash_algs(void)
{
       int i;

       /* Print all the available hash functions */
       for (i = 0; hash_maps[i].type != UNKNOWN_HASH_ALG; i++) {
	       printf("%s ", hash_maps[i].name);
       }

       return;
}

static void print_sig_algs(void)
{
	int i;

	/* Print all the available signature schemes */
	for (i = 0; ec_sig_maps[i].type != UNKNOWN_ALG; i++) {
		printf("%s ", ec_sig_maps[i].name);
	}

	return;
}

static void print_help(const char *prog_name)
{
	printf("%s expects at least one argument\n", prog_name ? prog_name : "NULL");
	printf("\targ1 = 'gen_keys', 'sign', 'verify', 'struct_sign', 'struct_verify' or 'scalar_mult'\n");
}

#ifdef __cplusplus
/* In case of a C++ compiler, preserve our "main"
 * linkage.
 */
extern "C" {
int main(int argc, char *argv[]);
}
#endif

int main(int argc, char *argv[])
{
	int ret, check, found;
	u32 len;
	const char *adata = NULL;
	u16 adata_len = 0;

	if (argc < 2) {
		ret = -1;
		print_help(argv[0]);
		goto err;
	}

	found = 0;
	ret = are_str_equal(argv[1], "gen_keys", &check); EG(ret, err);
	if (check) {
		found = 1;
		/* Generate keys ---------------------------------
		 *
		 * arg1 = curve name ("frp256v1", ...)
		 * arg2 = algorithm type ("ECDSA", "ECKCDSA", ...)
		 * arg3 = file name prefix
		 */
		if (argc != 5){
			ret = -1;
			printf("Bad args number for %s %s:\n", argv[0],
			       argv[1]);
			printf("\targ1 = curve name: ");
			print_curves();
			printf("\n");

			printf("\targ2 = signature algorithm type: ");
			print_sig_algs();
			printf("\n");

			printf("\targ3 = file name prefix\n");
			printf("\n");

			goto err;
		}
		if(generate_and_export_key_pair(argv[2], argv[3], argv[4])){
			ret = -1;
			printf("gen_key error ...\n");
			goto err;
		}
	}
	ret = are_str_equal(argv[1], "sign", &check); EG(ret, err);
	if (check) {
		found = 1;
		/* Sign something --------------------------------
		 * Signature is structured, i.e. the output is a self contained
		 * data image
		 * arg1 = curve name ("frp256v1", ...)
		 * arg2 = signature algorithm type ("ECDSA", "ECKCDSA", ...)
		 * arg3 = hash algorithm type ("SHA256", "SHA512", ...)
		 * arg4 = input file to sign
		 * arg5 = input file containing the private key
		 * arg6 = output file containing the signature
		 * arg7 (optional) = ancillary data to be used
		 */
		if ((argc != 8) && (argc != 9)) {
			ret = -1;
			printf("Bad args number for %s %s:\n", argv[0],
			       argv[1]);
			printf("\targ1 = curve name: ");
			print_curves();
			printf("\n");

			printf("\targ2 = signature algorithm type: ");
			print_sig_algs();
			printf("\n");

			printf("\targ3 = hash algorithm type: ");
			print_hash_algs();
			printf("\n");

			printf("\targ4 = input file to sign\n");
			printf("\targ5 = input file containing the private key (in raw binary format)\n");
			printf("\targ6 = output file containing the signature\n");
			printf("\t<arg7 (optional) = ancillary data to be used>\n");
			goto err;
		}
		if(argc == 9){
			adata = argv[8];
			ret = local_strlen(adata, &len); EG(ret, err);
			MUST_HAVE(len <= 0xffff, ret, err);
			adata_len = (u16)len;
		}
		if(sign_bin_file(argv[2], argv[3], argv[4], argv[5], argv[6],
			      argv[7], NULL, NULL, adata, adata_len)){
			ret = -1;
			printf("sign error ...\n");
			goto err;
		}
	}
	ret = are_str_equal(argv[1], "verify", &check); EG(ret, err);
	if (check) {
		found = 1;
		/* Verify something ------------------------------
		 *
		 * arg1 = curve name ("frp256v1", ...)
		 * arg2 = signature algorithm type ("ECDSA", "ECKCDSA", ...)
		 * arg3 = hash algorithm type ("SHA256", "SHA512", ...)
		 * arg = input file to verify
		 * arg5 = input file with the public key
		 * arg6 = input file containing the signature
		 * arg7 (optional) = ancillary data to be used
		 */
		if ((argc != 8) && (argc != 9)) {
			ret = -1;
			printf("Bad args number for %s %s:\n", argv[0],
			       argv[1]);
			printf("\targ1 = curve name: ");
			print_curves();
			printf("\n");

			printf("\targ2 = signature algorithm type: ");
			print_sig_algs();
			printf("\n");

			printf("\targ3 = hash algorithm type: ");
			print_hash_algs();
			printf("\n");

			printf("\targ4 = input file to verify\n");
			printf("\targ5 = input file containing the public key (in raw binary format)\n");
			printf("\targ6 = input file containing the signature\n");
			printf("\t<arg7 (optional) = ancillary data to be used>\n");
			goto err;
		}
		if(argc == 9){
			adata = argv[8];
			ret = local_strlen(adata, &len); EG(ret, err);
			MUST_HAVE(len <= 0xffff, ret, err);
			adata_len = (u16)len;
		}
		if (verify_bin_file(argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], adata, adata_len)) {
			ret = -1;
			printf("Signature check of %s failed\n", argv[5]);
			goto err;
		} else {
			printf("Signature check of %s OK\n", argv[5]);
		}
	}
	ret = are_str_equal(argv[1], "struct_sign", &check); EG(ret, err);
	if (check) {
		found = 1;
		/* Sign something --------------------------------
		 * Signature is structured, i.e. the output is a self contained
		 * data image
		 * arg1 = curve name ("frp256v1", ...)
		 * arg2 = signature algorithm type ("ECDSA", "ECKCDSA", ...)
		 * arg3 = hash algorithm type ("SHA256", "SHA512", ...)
		 * arg4 = input file to sign
		 * arg5 = input file with the private key
		 * arg6 = output file containing the appended signature
		 * arg7 = metadata header type
		 * arg8 = version of the metadata header
		 * arg9 (optional) = ancillary data to be used
		 */
		if ((argc != 10) && (argc != 11)) {
			ret = -1;
			printf("Bad args number for %s %s:\n", argv[0],
			       argv[1]);
			printf("\targ1 = curve name: ");
			print_curves();
			printf("\n");

			printf("\targ2 = signature algorithm type: ");
			print_sig_algs();
			printf("\n");

			printf("\targ3 = hash algorithm type: ");
			print_hash_algs();
			printf("\n");

			printf("\targ4 = input file to sign\n");
			printf("\targ5 = input file containing the private key (in raw binary format)\n");
			printf("\targ6 = output file containing the appended signature\n");
			printf("\targ7 = metadata header type (IMAGE_TYPE0, IMAGE_TYPE1, ...)\n");
			printf("\targ8 = version of the metadata header\n");
			printf("\t<arg9 (optional) = ancillary data to be used>\n");
			goto err;
		}
		if(argc == 11){
			adata = argv[10];
			ret = local_strlen(adata, &len); EG(ret, err);
			MUST_HAVE(len <= 0xffff, ret, err);
			adata_len = (u16)len;
		}
		if(sign_bin_file(argv[2], argv[3], argv[4], argv[5], argv[6],
			      argv[7], argv[8], argv[9], adata, adata_len)){
			ret = -1;
			printf("struct_sign error ...\n");
			goto err;
		}
	}
	ret = are_str_equal(argv[1], "struct_verify", &check); EG(ret, err);
	if (check) {
		found = 1;
		/* Verify something ------------------------------
		 *
		 * arg1 = curve name ("frp256v1", ...)
		 * arg2 = signature algorithm type ("ECDSA", "ECKCDSA", ...)
		 * arg3 = hash algorithm type ("SHA256", "SHA512", ...)
		 * arg4 = input file to verify
		 * arg5 = input file containing the public key (in raw binary format)
		 * arg6 (optional) = ancillary data to be used
		 */
		if ((argc != 7) && (argc != 8)) {
			ret = -1;
			printf("Bad args number for %s %s:\n", argv[0],
			       argv[1]);
			printf("\targ1 = curve name: ");
			print_curves();
			printf("\n");

			printf("\targ2 = signature algorithm type: ");
			print_sig_algs();
			printf("\n");

			printf("\targ3 = hash algorithm type: ");
			print_hash_algs();
			printf("\n");

			printf("\targ4 = input file to verify\n");
			printf("\targ5 = input file containing the public key (in raw binary format)\n");
			printf("\t<arg6 (optional) = ancillary data to be used>\n");
			goto err;
		}
		if(argc == 8){
			adata = argv[7];
			ret = local_strlen(adata, &len); EG(ret, err);
			MUST_HAVE(len <= 0xffff, ret, err);
			adata_len = (u16)len;
		}
		if (verify_bin_file(argv[2], argv[3], argv[4], argv[5], argv[6], NULL, adata, adata_len)) {
			ret = -1;
			printf("Signature check of %s failed\n", argv[5]);
			goto err;
		} else {
			printf("Signature check of %s OK\n", argv[5]);
		}
	}
	ret = are_str_equal(argv[1], "scalar_mult", &check); EG(ret, err);
	if (check) {
		found = 1;
		/* Point scalar multiplication --------------------
		 *
		 * arg1 = curve name ("frp256v1", ...)
		 * arg2 = scalar
		 * arg3 = point to multiply
		 * arg4 = file name where to save the result
		 */
		if (argc != 6) {
			ret = -1;
			printf("Bad args number for %s %s:\n", argv[0],
			       argv[1]);
			printf("\targ1 = curve name: ");
			print_curves();
			printf("\n");

			printf("\targ2 = scalar bin file\n");
			printf("\targ3 = point to multiply bin file (projective coordinates)\n");
			printf("\targ4 = file name where to save the result\n");
			goto err;
		}
		if(ec_scalar_mult(argv[2], argv[3], argv[4], argv[5])){
			ret = -1;
			printf("Scalar multiplication failed\n");
			goto err;
		}
	}

	if (found == 0) {
		/* Bad first argument, print help */
		ret = -1;
		printf("Bad first argument '%s'\n", argv[1]);
		print_help(argv[0]);
		goto err;
	}

	ret = 0;

err:
	return ret;
}