data.h

Go to the documentation of this file.

 
#ifndef DATA_H
#define DATA_H
 
#include <string.h>
#include <pbc/pbc.h>
#include "define.h"
 
#define IDENTITY_SIZE 32
#define WARRANT_SIZE 64
#define MAX_DIGEST_SIZE 64
#define MAX_PARAM_LINE_SIZE 4096
#define generic_dlog_secure_size_by_security_level(level) ((level)*2)
#define STR_IDENTITY_SIZE(string) strlen(string) > IDENTITY_SIZE ? IDENTITY_SIZE : strlen(string)
 
typedef enum
{
    sha_1,
    sha_256,
    sha_512
} hash_type_t;
 
typedef uint8_t sv_identity_t[IDENTITY_SIZE];
typedef uint8_t serialized_warrant_t[WARRANT_SIZE];
 
struct sv_public_params_struct
{
    pairing_t pairing;     // The pairing used by the scheme.
    element_t pk;          // The public key.
    element_t P;           // The generator of G1.
    int l1;                // Half of number bits of an element in G1.
    int l2;                // Half of number bits of an element in G1.
    int q;                 // Order of the group.
    hash_type_t hash_type; // Hash algorithm used by the scheme.
    short precompute;      // Flag to indicate if the precomputation has been done.
    pairing_pp_t eP_pp;    // Precomputed value of P to speed up pairings e(P,.).
    pairing_pp_t epk_pp;   // Precomputed value of pk to speed up pairings e(pk,.).
    element_pp_t PP_pp;    // Precomputed value of e(P,P) to speed up powers e(P, P)^..
    element_pp_t P_pp;     // Precomputed value of P to speed up multiplications .P.
    element_pp_t pk_pp;    // Precomputed value of pk to speed up multiplications .pk.
};
typedef struct sv_public_params_struct *sv_public_params_ptr;
typedef struct sv_public_params_struct sv_public_params_t[1];
 
struct sv_secret_params_struct
{
    sv_public_params_ptr public_params; // Public parameters of the scheme.
    element_t msk;                      // The master secret key.
};
typedef struct sv_secret_params_struct *sv_secret_params_ptr;
typedef struct sv_secret_params_struct sv_secret_params_t[1];
 
struct sv_user_struct
{
    sv_identity_t id;   // Identity of the user.
    element_t sk;       // The secret key of the user.
    element_t pk;       // The public key of the user.
    element_pp_t sk_pp; // Precomputed value of sk to speed up multiplications .sk.
};
typedef struct sv_user_struct *sv_user_ptr;
typedef struct sv_user_struct sv_user_t[1];
 
struct warrant_struct
{
    sv_identity_t from; // Identity of the user that is delegating the signature.
    sv_identity_t to;   // Identity of the user that is invested with the signature.
};
typedef struct warrant_struct *warrant_ptr;
typedef struct warrant_struct warrant_t[1];
 
struct delegation_struct
{
    warrant_t m; // Warrant of the delegation.
    element_t r; // r value used to verify the delegation (in GT).
    element_t S; // S value used to verify the delegation (in G1).
};
typedef struct delegation_struct *delegation_ptr;
typedef struct delegation_struct delegation_t[1];
 
struct proxy_signature_struct
{
    warrant_t m; // Warrant of the delegation.
    element_t r; // r value used to verify the signature (in GT).
    element_t V; // V value used to verify the signature (in Zr).
    element_t U; // U value used to verify the signature (in G1).
};
typedef struct proxy_signature_struct *proxy_signature_ptr;
typedef struct proxy_signature_struct proxy_signature_t[1];
 
long read_binary_file(uint8_t **data, const char file_path[]);
 
void user_init(sv_user_t user, const sv_identity_t identity, sv_public_params_t public_p);
 
void user_init_str(sv_user_t user, const char identity[], sv_public_params_t public_p);
 
void delegation_init(delegation_t w, sv_public_params_t public_p);
 
void proxy_signature_init(proxy_signature_t p_sig, sv_public_params_t public_p);
 
uint16_t serialize_warrant(uint8_t buffer[WARRANT_SIZE], const warrant_t m);
 
uint16_t deserialize_warrant(warrant_t m, const uint8_t buffer[WARRANT_SIZE]);
 
int serialize_delegation(uint8_t **data, delegation_t w);
 
void deserialize_delegation(delegation_t w, uint8_t data[]);
 
void deserialize_delegation_from_file(delegation_t w, const char file_path[]);
 
void delegation_printf(delegation_t w);
 
void delegation_fprintf(FILE *stream, delegation_t w);
 
int serialize_proxy_signature(uint8_t **data, proxy_signature_t p_sign);
 
void deserialize_proxy_signature(proxy_signature_t p_sign, uint8_t data[]);
 
void deserialize_proxy_signature_from_file(proxy_signature_t p_sig, const char file_path[]);
 
void proxy_signature_printf(proxy_signature_t p_sign);
 
void proxy_signature_fprintf(FILE *stream, proxy_signature_t p_sign);
 
void public_param_clear(sv_public_params_t public_p);
 
void secret_param_clear(sv_secret_params_t secret_p);
 
void user_clear(sv_user_t user);
 
void delegation_clear(delegation_t w);
 
void proxy_signature_clear(proxy_signature_t p_sig);
 
#endif // DATA_H