Example #1
0
int IBE_serialize_params(byte_string_t bs, params_t params)
//put system parameters into a byte_string
{
    int i, j;
    byte_string_t *bsa;

    i = 0;

    bsa = (byte_string_t *) malloc(sizeof(byte_string_t)
	    * (2 * params->sharen + 20));

    byte_string_set(bsa[i++], params->version);
    byte_string_set(bsa[i++], params->id);
    byte_string_set_mpz(bsa[i++], params->p);
    byte_string_set_mpz(bsa[i++], params->q);
    byte_string_set_point(bsa[i++], params->P);
    byte_string_set_point(bsa[i++], params->Ppub);
    byte_string_set_int(bsa[i++], params->sharet);
    byte_string_set_int(bsa[i++], params->sharen);

    for (j=0; j<params->sharen; j++) {
	byte_string_set_mpz(bsa[i++], params->robustx[j]);
	byte_string_set_point(bsa[i++], params->robustP[j]);
    }

    byte_string_encode_array(bs, bsa, i);

    for (j=0; j<i; j++) {
	byte_string_clear(bsa[j]);
    }

    return 1;
}
Example #2
0
int FMT_crypt_load(const char *fname, byte_string_t bs, const char *password)
{
    FILE *infp;
    byte_string_t K, W;
    int result = 0;

    infp = fopen(fname, "r");
    if (!infp) return 0;

    byte_string_set(K, password);

    advance_to("W:", infp);
    mime_get(W, infp);

    if (1 != crypto_decrypt(bs, W, K)) {
	fprintf(stderr, "crypto_decrypt() failed!\n");
    } else {
	result = 1;
    }

    fclose(infp);

    byte_string_clear(K);
    byte_string_clear(W);
    return result;
}
Example #3
0
static void map_to_point(point_t d, const char *id, params_t params)
//converts id into a point of order q on E/F_p
{
    byte_string_t bsid;

    byte_string_set(bsid, id);
    map_byte_string_to_point(d, bsid, params);
    byte_string_clear(bsid);
}
Example #4
0
void IBE_extract_share(byte_string_t share,
	byte_string_t mshare, const char *id, params_t params)
//same as above except takes in char * instead of byte_string
{
    byte_string_t bsid;

    byte_string_set(bsid, id);
    IBE_extract_share_byte_string(share, mshare, bsid, params);
    byte_string_clear(bsid);
}
Example #5
0
void IBE_extract(byte_string_t bs,
	byte_string_t master, const char *id, params_t params)
//same as above, char * version
{
    byte_string_t bsid;

    byte_string_set(bsid, id);
    IBE_extract_byte_string(bs, master, bsid, params);
    byte_string_clear(bsid);
}
Example #6
0
int FMT_crypt_save_fp(FILE *outfp, byte_string_t bs, const char *password)
{
    byte_string_t K, W;

    byte_string_set(K, password);
    crypto_encrypt(W, bs, K);
    fprintf(outfp, "\nW:\n");
    mime_put(W, outfp);

    byte_string_clear(K);
    byte_string_clear(W);

    return 1;
}
Example #7
0
int main()
{
    params_t params;
    byte_string_t priv, pub;
    byte_string_t priv2, pub2;
    byte_string_t sig;
    byte_string_t message;
    byte_string_t master;

    IBE_init();

    IBE_setup(params, master, 512, 160, "test");

    //generate a BLS private/public key pair
    BLS_keygen(priv, pub, params);

    BLS_keygen(priv2, pub2, params);

    byte_string_set(message, "Hello, World");

    BLS_sign(sig, message, priv, params);
    printf("Sig: ");
    byte_string_fprintf(stdout, sig, " %02X");
    printf("\n");

    if (BLS_verify(sig, message, pub, params)) {
        printf("signature verifies\n");
    } else {
        printf("bug: signature does not verify\n");
    }

    if (BLS_verify(sig, message, pub2, params)) {
        printf("bug: signature verifies with wrong public key\n");
    }

    params_clear(params);

    IBE_clear();

    return 0;
}