pcs_t.h

Go to the documentation of this file.

#ifndef HCS_PCS_T_H
#define HCS_PCS_T_H

#include <gmp.h>
#include "hcs_random.h"
#include "hcs_shares.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct {
    mpz_t e[2];         
    mpz_t u[2];         
    mpz_t a[2];         
    mpz_t z[2];         
    unsigned long m1;   
    unsigned long m2;   
    mpz_t generator;    
} pcs_t_proof;

typedef struct {
    unsigned long n;    
    mpz_t *coeff;       
} pcs_t_polynomial;

typedef struct {
    unsigned long i;    
    mpz_t si;           
} pcs_t_auth_server;

typedef struct {
    unsigned long w; 
    unsigned long l; 
    mpz_t n;         
    mpz_t g;         
    mpz_t n2;        
    mpz_t delta;     
} pcs_t_public_key;

typedef struct {
    unsigned long w; 
    unsigned long l; 
    mpz_t *vi;       
    mpz_t v;         
    mpz_t d;         
    mpz_t n;         
    mpz_t n2;        
    mpz_t nm;        
} pcs_t_private_key;

pcs_t_public_key* pcs_t_init_public_key(void);

pcs_t_private_key* pcs_t_init_private_key(void);

int pcs_t_generate_key_pair(pcs_t_public_key *pk, pcs_t_private_key *vk,
        hcs_random *hr, const unsigned long bits, const unsigned long l,
        const unsigned long w);

void pcs_t_encrypt_r(pcs_t_public_key *pk, mpz_t rop, mpz_t r, mpz_t plain1);

void pcs_t_r_encrypt(pcs_t_public_key *pk, hcs_random *hr,
        mpz_t r, mpz_t rop, mpz_t plain1);

void pcs_t_encrypt(pcs_t_public_key *pk, hcs_random *hr, mpz_t rop, mpz_t plain1);

void pcs_t_reencrypt(pcs_t_public_key *pk, hcs_random *hr, mpz_t rop, mpz_t op);

void pcs_t_ep_add(pcs_t_public_key *pk, mpz_t rop, mpz_t cipher1, mpz_t plain1);

void pcs_t_ee_add(pcs_t_public_key *pk, mpz_t rop, mpz_t cipher1, mpz_t cipher2);

void pcs_t_ep_mul(pcs_t_public_key *pk, mpz_t rop, mpz_t cipher1, mpz_t plain1);

pcs_t_proof* pcs_t_init_proof(void);

void pcs_t_set_proof(pcs_t_proof *pf, mpz_t generator, unsigned long m1,
        unsigned long m2);

void pcs_t_compute_1of2_ns_protocol(pcs_t_public_key *pk, hcs_random *hr,
        pcs_t_proof *pf, mpz_t cipher_m, mpz_t cipher_r, unsigned long nth_power,
        unsigned long id);

int pcs_t_verify_ns_protocol(pcs_t_public_key *pk, pcs_t_proof *pf,
        unsigned long id);

int pcs_t_verify_1of2_ns_protocol(pcs_t_public_key *pk, pcs_t_proof *pf,
        mpz_t cipher, unsigned long id);

void pcs_t_free_proof(pcs_t_proof *pf);

pcs_t_polynomial* pcs_t_init_polynomial(pcs_t_private_key *vk, hcs_random *hr);

void pcs_t_compute_polynomial(pcs_t_private_key *vk, pcs_t_polynomial *px,
                              mpz_t rop, const unsigned long x);

void pcs_t_free_polynomial(pcs_t_polynomial *px);

pcs_t_auth_server* pcs_t_init_auth_server(void);

void pcs_t_set_auth_server(pcs_t_auth_server *au, mpz_t si, unsigned long i);

void pcs_t_share_decrypt(pcs_t_public_key *vk, pcs_t_auth_server *au,
                         mpz_t rop, mpz_t cipher1);

int pcs_t_share_combine(pcs_t_public_key *vk, mpz_t rop, hcs_shares *hs);

void pcs_t_free_auth_server(pcs_t_auth_server *au);

void pcs_t_clear_public_key(pcs_t_public_key *pk);

void pcs_t_clear_private_key(pcs_t_private_key *vk);

void pcs_t_free_public_key(pcs_t_public_key *pk);

void pcs_t_free_private_key(pcs_t_private_key *vk);

int pcs_t_verify_key_pair(pcs_t_public_key *pk, pcs_t_private_key *vk);

int pcs_t_import_public_key(pcs_t_public_key *pk, const char *json);

char *pcs_t_export_public_key(pcs_t_public_key *pk);

char *pcs_t_export_auth_server(pcs_t_auth_server *au);

int pcs_t_import_auth_server(pcs_t_auth_server *au, const char *json);

char *pcs_t_export_verify_values(pcs_t_private_key *vk);

int pcs_t_import_verify_values(pcs_t_private_key *vk, const char *json);

#ifdef __cplusplus
}
#endif

#endif