示例#1
0
文件: nls.c 项目: 0x6d48/bncsutil
MEXP(unsigned long) nls_account_create(nls_t* nls, char* buf, unsigned long bufSize) {
	mpz_t s; /* salt */
    mpz_t v;
    mpz_t x;

    if (!nls)
        return 0;
    if (bufSize < nls->username_len + 65)
        return 0;
    
    mpz_init2(s, 256);
    mpz_urandomb(s, nls->rand, 256);
    mpz_export(buf, (size_t*) 0, -1, 1, 0, 0, s);
	/*memset(buf, 0, 32);*/
    
    nls_get_x(nls, x, buf);
    nls_get_v_mpz(nls, v, x);
    mpz_export(buf + 32, (size_t*) 0, -1, 1, 0, 0, v);
    
	mpz_clear(x);
    mpz_clear(v);
    mpz_clear(s);
    
    strcpy(buf + 64, nls->username);
    return nls->username_len + 65;
}
示例#2
0
文件: rsapub.c 项目: mcr/Openswan
void calculate_rsa_ckaid(osw_public_key *pub)
{
    if(pub->alg == PUBKEY_ALG_RSA) {
        struct RSA_public_key *rsa = &pub->u.rsa;

        if(rsa->key_rfc3110.len == 0) {
            /* key has no 3110 representation, need to cons up one */
            unsigned int e_size     = mpz_sizeinbase(&rsa->e, 256);
            unsigned int key3110len = rsa->k + 1 + e_size;
            rsa->key_rfc3110.ptr = alloc_bytes(key3110len, "rfc3110 format of public key [created]");
            rsa->key_rfc3110.len = key3110len;
            unsigned char *here = rsa->key_rfc3110.ptr;

            here[0] = e_size;
            here++;
            mpz_export(here, NULL, 1, 1, 1, 0, &rsa->e);
            here += e_size;
            mpz_export(here, NULL, 1, 1, 1, 0, &rsa->n);
        }

        /* maybe #ifdef SHA2 ? */
        /* calculate the hash of the public key, using SHA-2 */
        sha256_hash_buffer(rsa->key_rfc3110.ptr, rsa->key_rfc3110.len,
                           pub->key_ckaid, sizeof(pub->key_ckaid));

        datatot(pub->key_ckaid, sizeof(pub->key_ckaid), 'G',
                pub->key_ckaid_print_buf, sizeof(pub->key_ckaid_print_buf));
    }
}
示例#3
0
/* computes: epsilon = H(alpha|beta|z|message)
 * result will be taken mod q
 * this function uses work1 from workspace */
void gmp_pbs_hash_epsilon(mpz_t result, mpz_t alpha, mpz_t beta, mpz_t z,
		char *message, gmp_pbs_parameters *parameters, gmp_pbs_workspace *workspace) {
	int buffer_len, alpha_len, beta_len, z_len, msg_len;
	char *buffer, *pos;

	alpha_len = mpz_sizeinbase(alpha, 2);
	beta_len = mpz_sizeinbase(beta, 2);
	z_len = mpz_sizeinbase(z, 2);
	msg_len = strlen(message);

	/* need space for alpha,beta,z,message */
	buffer_len = alpha_len + beta_len + z_len + msg_len + 1;

	buffer = calloc(1, buffer_len);
	pos = buffer;
	mpz_export(pos, NULL, 1, alpha_len, 0, 0, alpha);
	pos += alpha_len;
	mpz_export(pos, NULL, 1, beta_len, 0, 0, beta);
	pos += beta_len;
	mpz_export(pos, NULL, 1, z_len, 0, 0, z);
	pos += z_len;
	memcpy(pos, message, strlen(message));
	gmp_pbs_Hhash(result, buffer, parameters, workspace);
	free(buffer);
}
示例#4
0
/* Binary segmentation, using import/export method for processing p.
 * Thanks to Dan Bernstein's 2007 Quartic paper.
 */
void poly_mod_mul(mpz_t* px, mpz_t* py, UV r, mpz_t mod, mpz_t p, mpz_t p2, mpz_t t)
{
    UV i, bytes;
    char* s;

    mpz_mul(t, mod, mod);
    mpz_mul_ui(t, t, r);
    bytes = mpz_sizeinbase(t, 256);
    mpz_set_ui(p, 0);
    mpz_set_ui(p2, 0);

    /* 1. Create big integers from px and py with padding. */
    {
        Newz(0, s, r*bytes, char);
        for (i = 0; i < r; i++)
            mpz_export(s + i*bytes, NULL, -1, 1, 0, 0, px[i]);
        mpz_import(p, r*bytes, -1, 1, 0, 0, s);
        Safefree(s);
    }
    if (px != py) {
        Newz(0, s, r*bytes, char);
        for (i = 0; i < r; i++)
            mpz_export(s + i*bytes, NULL, -1, 1, 0, 0, py[i]);
        mpz_import(p2, r*bytes, -1, 1, 0, 0, s);
        Safefree(s);
    }
示例#5
0
guint32 srp_generate_salt_and_v(srp_t *srp, gchar *out)
{
    mpz_t s; /* salt */
    mpz_t v;
    mpz_t x;
    size_t count;

    if (!srp)
        return 0;
    
    mpz_init2(s, 256);
    mpz_urandomb(s, srp->rand, 256);
    mpz_export(out, &count, -1, 1, 0, 0, s);
    /*memset(buf, 0, 32);*/
    
    srp_get_x(srp, x, out);
    srp_get_v_mpz(srp, v, x);
    mpz_export(out + 32, &count, -1, 1, 0, 0, v);
    
    mpz_clear(x);
    mpz_clear(v);
    mpz_clear(s);
    
    return 64;
}
示例#6
0
// mpz_export does not fill leading zeros, thus a prepending of leading 0s is required
void mpz_export_padded(uint8_t* pBufIdx, uint32_t field_size_bytes, mpz_t to_export) {
	size_t size = 0;
	mpz_export(pBufIdx, &size, 1, sizeof(pBufIdx[0]), 0, 0, to_export);

	if (size < field_size_bytes) {
		for (int i = 0; i + size < field_size_bytes; i++) {
			pBufIdx[i] = 0;
		}
		pBufIdx += (field_size_bytes - size);
		mpz_export(pBufIdx, &size, 1, sizeof(pBufIdx[0]), 0, 0, to_export);
	}
}
示例#7
0
static int
ecdsa_verify(unsigned char signature[96], const unsigned char digest[48], const unsigned char pkey[96]){
  unsigned char u1buf[48];
  unsigned char u2buf[48];
  unsigned char point[96];
  mpz_t order;
  mpz_t s;
  mpz_t r;
  mpz_t z;
  mpz_t u1;
  mpz_t u2;
  mpz_t w;
  int ret;
  mpz_init(order);
  mpz_init(s);
  mpz_init(r);
  mpz_init(z);
  mpz_init(u1);
  mpz_init(u2);
  mpz_init(w);
  mpz_set_str(order, "39402006196394479212279040100143613805079739270465446667946905279627659399113263569398956308152294913554433653942643", 10);
  mpz_import(r, 48, -1, 1, 1, 0, signature);
  mpz_import(s, 48, -1, 1, 1, 0, signature+48);
  mpz_import(z, 48, -1, 1, 1, 0, digest);
  mpz_invert(w, s, order);
  mpz_mul(u2, r, w);
  mpz_mul(u1, z, w);
  mpz_mod(u2, u2, order);
  mpz_mod(u1, u1, order);
  for(int i=0; i<48; i++){
    u1buf[i]=0;
    u2buf[i]=0;
  }
  mpz_export(u1buf, NULL, -1, 1, 1, 0, u1);
  mpz_export(u2buf, NULL, -1, 1, 1, 0, u2);
  p384_32_double_scalarmult_base(point, pkey, u1buf, u2buf);
  mpz_import(u1, 48, 1, 1, 1, 0, point);
  mpz_sub(s, r, u1);
  mpz_mod(s, s, order);
  if(mpz_sgn(s)==0){
    ret=1;
  } else {
    ret=0;
  }
  mpz_clear(order);
  mpz_clear(s);
  mpz_clear(r);
  mpz_clear(z);
  mpz_clear(u1);
  mpz_clear(u2);
  mpz_clear(w);
  return ret;
}
示例#8
0
// mpz_export does not fill leading zeros, thus a prepending of leading 0s is required
void BaseOT::mpz_export_padded(BYTE* pBufIdx, int field_size, mpz_t to_export) {
	size_t size = 0;
	mpz_export(pBufIdx, &size, 1, sizeof(pBufIdx[0]), 0, 0, to_export);

	if (size < field_size) {
		for (int i = 0; i + size < field_size; i++) {
			pBufIdx[i] = 0;
		}
		pBufIdx += (field_size - size);
		mpz_export(pBufIdx, &size, 1, sizeof(pBufIdx[0]), 0, 0, to_export);
	}
}
示例#9
0
void generateMultipliers(uint32_t *primesCombined,
                         uint32_t *isNewMultiplier,
                         uint32_t *multipliers,
                         uint32_t *offsets,
                         uint64_t *multipliers64,
                         uint32_t *offsets64,
                         uint64_t *combinedMultipliers,
                         uint32_t *combinedOffsets,
                         uint32_t *primes,
                         unsigned primesNum,
                         unsigned multipliersNum)
{
  unsigned primeCombinedIdx = 0;
  mpz_class divisor;
  mpz_class inversedMultiplier;
  mpz_class inversedMultiplier64;
  mpz_class inversedCombinedMultiplier;
  unsigned offset;
  unsigned offset64;
  unsigned combinedOffset;
  unsigned primeCombined;
  for (unsigned i = 0; i < multipliersNum; i++) {
    findMultiplierForConstantDivision(31, primes[i], &inversedMultiplier, &offset);
    if (offset < 32)
      findMultiplierForConstantDivision(32, primes[i], &inversedMultiplier, &offset);
    
    findMultiplierForConstantDivision(63, primes[i], &inversedMultiplier64, &offset64);    
    if (offset64 < 64)
      findMultiplierForConstantDivision(64, primes[i], &inversedMultiplier64, &offset64);          
    if (primeCombinedIdx <= i) {
      primeCombined = 1;
      while (primeCombined < (1U << 31) / primes[primeCombinedIdx])
        primeCombined *= primes[primeCombinedIdx++];
      
      divisor = primeCombined;
      findMultiplierForConstantDivision(63, divisor, &inversedCombinedMultiplier, &combinedOffset);
      isNewMultiplier[i] = 1;
    } else {
      isNewMultiplier[i] = 0;
    }
    
    size_t size;
    primesCombined[i] = primeCombined;    
    mpz_export(&multipliers[i], &size, -1, 4, 0, 0, inversedMultiplier.get_mpz_t());
    mpz_export(&multipliers64[i], &size, -1, 4, 0, 0, inversedMultiplier64.get_mpz_t());    
    mpz_export(&combinedMultipliers[i], &size, -1, 4, 0, 0, inversedCombinedMultiplier.get_mpz_t());
    offsets[i] = offset;
    offsets64[i] = offset64;
    combinedOffsets[i] = combinedOffset;
  }
}
示例#10
0
// Input:  priv_key = buffer of 200 bytes
//         pub_key  = buffer of 200 bytes
// Output: priv_key = Your private key
//         pub_key  = Your public key
int DH1080_gen(char *priv_key, char *pub_key)
{
    unsigned char raw_buf[256]; //, iniHash[33];
    //unsigned long seed;
    int iRet, i;
    size_t len;

    mpz_t b_privkey, b_pubkey, b_base;
    unsigned char temp[DH1080_PRIME_BYTES];
    //FILE *hRnd;

    priv_key[0]='0';
    priv_key[1]='\0';
    pub_key[0]='0';
    pub_key[1]='\0';

    mpz_init(b_privkey);
    mpz_init(b_pubkey);
    mpz_init_set_ui(b_base, 2);

    do
    {
        for(i=0; i < DH1080_PRIME_BYTES; i++)
            temp[i] = (unsigned char)rand(&csprng);
        mpz_import(b_privkey, DH1080_PRIME_BYTES, 1, 1, 0, 0, temp);
        mpz_mod(b_privkey, b_privkey, b_prime1080); /* [2, prime1080-1] */
    } while( mpz_cmp_ui(b_privkey, 1) != 1); /* while smaller than 2 */

    mpz_powm(b_pubkey, b_base, b_privkey, b_prime1080);

    if(DH_verifyPubKey(b_pubkey))
    {
        mpz_export(raw_buf, &len, 1, 1, 0, 0, b_privkey);
        mpz_clear(b_privkey);
        htob64((char *)raw_buf, priv_key, len);

        mpz_export(raw_buf, &len, 1, 1, 0, 0, b_pubkey);
        htob64((char *)raw_buf, pub_key, len);

        iRet=1;
    }
    else iRet=0;

    ZeroMemory(raw_buf, sizeof(raw_buf));

    mpz_clear(b_pubkey);
    mpz_clear(b_base);

    return iRet;
}
示例#11
0
list_t *
entry (char *host, int sock, int flags)
{
  list_t *p = xmalloc (sizeof *p);
  p->host = xstrdup (host);

#if WITH_SSL
  p->ssl = flags & 1 ? SSL_new (client) : SSL_new (server);
  SSL_set_fd (p->ssl, sock);
#else
  p->sock = sock;
  gc_cipher_open (GC_AES256, GC_STREAM, &p->cipher);
  mpz_t my_num;
  mpz_init (my_num);

  char *key = xcalloc (len, sizeof *key);

  pthread_cleanup_push (free, key);
  gc_random (key, len);

  mpz_import (my_num, len, 1, 1, 1, 0, key);

  mpz_t sent;
  mpz_init_set (sent, base);
  mpz_powm (sent, sent, my_num, prime);

  char *buff = xcalloc (len, sizeof *buff);

  pthread_cleanup_push (free, buff);
  mpz_export (buff, NULL, 1, 1, 1, 0, sent);
  
  if (send (sock, buff, len, 0) < 0)
    error (1, errno, "Failed to perform handshake");

  if (recv (sock, buff, len, 0) < 0)
    error (1, errno, "Failed to perform handshake");

  mpz_import (sent, len, 1, 1, 1, 0, buff);
  pthread_cleanup_pop (1);
  
  mpz_powm (sent, sent, my_num, prime);
  mpz_export (key, NULL, 1, 1, 1, 0, sent); 
 
  gc_cipher_setkey (p->cipher, len, key);
  pthread_cleanup_pop (1);
#endif /* WITH_SSL */

  return p;
}
示例#12
0
	void BnetSRP3::getServerPasswordProof( byte * result, mpz_t& A, const byte * M, mpz_t& K )
	{
		SHA1Context sha;
		byte proofHash[20];
		byte A_[32], K_[40];

		SHA1Reset(&sha);
		mpz_export(A_, NULL, -1, 1, 0, 0, A);
		SHA1Input(&sha, (byte*) A_, 32);
		SHA1Input(&sha, M, 20);
		mpz_export(K_, NULL, -1, 1, 0, 0, K);
		SHA1Input(&sha, (byte*) K_, 40);
		SHA1Result(&sha, (byte*) proofHash);

		memcpy(result, proofHash, 20);
	}
示例#13
0
文件: bignum.c 项目: libbitc/libbitc
cstring *bn_getvch(const mpz_t v)
{
	/* get MPI format size */
	size_t sz;
	char *buf = mpz_export(NULL, &sz, -1, 1, 1, 0, v);

	if (sz == 0) {
		free(buf);
		return cstr_new(NULL);
	}

	cstring *s_le = cstr_new_buf(buf, sz);
	free(buf);

	/* check if sign bit is available */
	unsigned int msb = mpz_sizeinbase(v, 2);
	if ((!(msb & 0x07) && msb > 0)) {
		cstr_append_c(s_le, '\0');
		sz++;
	}
	cstr_resize(s_le, sz);

	/* set sign bit */
	if (mpz_sgn(v) == -1) {
		s_le->str[sz - 1] = (s_le->str[sz - 1] & 0xff) | 0x80;
	}

	return s_le;
}
示例#14
0
static void 
store_p_soa(uint64 p, uint32 num_roots, uint32 which_poly, 
		mpz_t *roots, void *extra)
{
	lattice_fb_t *L = (lattice_fb_t *)extra;
	p_soa_var_t *soa;
	uint32 num;
	uint128 tmp = {{0}};

	if (num_roots != 1) {
		printf("error: num_roots > 1\n");
		exit(-1);
	}

	if (L->fill_p)
		soa = (p_soa_var_t *)L->p_array;
	else
		soa = (p_soa_var_t *)L->q_array;

	num = soa->num_p;
	mpz_export(&tmp, NULL, -1, sizeof(uint32), 0, 0, roots[0]);

	if (p != soa->last_p) {
		soa->p[num] = p;
		soa->num_p++;
		soa->last_p = p;
		soa->roots[which_poly][num] = tmp;
	}
	else {
		soa->roots[which_poly][num - 1] = tmp;
	}
}
示例#15
0
void srp_get_A(srp_t *srp, gchar *out)
{
    mpz_t g;
    mpz_t A;
    size_t o;
    
    if (!srp)
        return;

    if (srp->A) {
        g_memmove(out, srp->A, 32);
        return;
    }
    
    mpz_init_set_ui(g, SRP_VAR_g);
    mpz_init2(A, 256);
    
    mpz_powm(A, g, srp->a, srp->n);
    mpz_export(out, &o, -1, 1, 0, 0, A);
    
    mpz_clear(A);
    mpz_clear(g);

    srp->A = (gchar *) g_malloc(32);
    if (srp->A)
        memcpy(srp->A, out, 32);
}
示例#16
0
文件: rsa.cpp 项目: Karthlan/server
bool RSA::encrypt(char* msg, int32_t size, const char* key)
{
    mpz_t plain, c;
    mpz_init2(plain, 1024);
    mpz_init2(c, 1024);

    mpz_t e;
    mpz_init(e);
    mpz_set_ui(e,65537);

    mpz_t mod;
    mpz_init2(mod, 1024);
    mpz_set_str(mod, key, 10);

    mpz_import(plain, 128, 1, 1, 0, 0, msg);
    mpz_powm(c, plain, e, mod);

    size_t count = (mpz_sizeinbase(c, 2) + 7)/8;
    memset(msg, 0, 128 - count);
    mpz_export(&msg[128 - count], NULL, 1, 1, 0, 0, c);

    mpz_clear(c);
    mpz_clear(plain);
    mpz_clear(e);
    mpz_clear(mod);
    return true;
}
示例#17
0
void*
paillier_plaintext_to_bytes( int len,
														 paillier_plaintext_t* pt )
{
	void* buf0;
	void* buf1;
	size_t written;

	buf0 = mpz_export(0, &written, 1, 1, 0, 0, pt->m);

 	if( written == len )
 		return buf0;

	buf1 = malloc(len);
	memset(buf1, 0, len);

	if( written == 0 )
		/* no need to copy anything, pt->m = 0 and buf0 was not allocated */
		return buf1;
	else if( written < len )
		/* pad with leading zeros */
		memcpy(buf1 + (len - written), buf0, written);
	else
		/* truncate leading garbage */
		memcpy(buf1, buf0 + (written - len), len);

	free(buf0);

	return buf1;
}
void BasicSizeHeaderSocket::send(const mpz_class& data) {
	unsigned long int words;
	void * toSend = mpz_export(NULL, (size_t*) &words, -1, MPZEXPORTWORDSIZE, -1, 0, data.get_mpz_t());
	this->RawSocket::sendInteger(words);
	this->RawSocket::sendData(toSend, words * MPZEXPORTWORDSIZE);
  free(toSend);
}
示例#19
0
static BIGNUM *
mpz2BN(mpz_t s)
{
    size_t size;
    BIGNUM *bn;
    void *p;

    mpz_export(NULL, &size, 1, 1, 1, 0, s);
    p = malloc(size);
    if (p == NULL && size != 0)
	return NULL;
    mpz_export(p, &size, 1, 1, 1, 0, s);
    bn = BN_bin2bn(p, size, NULL);
    free(p);
    return bn;
}
示例#20
0
/**
 *	Encrypt an unsigned int and return the encrypted bytes in char*
 *	Params :
 *		- unsigned int ui : the value to encrypt ;
 *		- unsigned int s  : the exponent (recursion lvl).
 *
 *	Return :
 *		- char* : an allocated pointer to the encrypted data.
 **/
  char* 
PaillierAdapter::encrypt(unsigned int ui, unsigned int s) 
{
  unsigned int ciph_size = publicParameters.getKeyBitsize()*(s+1)/8;
  char *tmp, *request = (char*) calloc((ciph_size + 1), sizeof(char));
  size_t n;
  mpz_t pt, ct;

  mpz_init(ct);
  mpz_init_set_ui( pt, ui); // convert the 0 or the 1 to an mpz_t

  enc( this->publicParameters.getPubKey(), pt, s, ct );
#ifdef CRYPTO_DEBUG
  gmp_printf("Created query element: %Zd with args %Zd and %d\n",ct, pt, s);
#endif
  tmp = (char*)mpz_export(NULL, &n, 1, sizeof(char), 0, 0, ct);
  //Padding
  memcpy(request+sizeof(char)*((ciph_size) - n), tmp, n);	

  //Free memory
  mpz_clears(ct, pt, NULL);

  free(tmp);

  return request;
}
示例#21
0
/* store */
static int unsigned_write(void *a, unsigned char *b)
{
   LTC_ARGCHK(a != NULL);
   LTC_ARGCHK(b != NULL);
   mpz_export(b, NULL, 1, 1, 1, 0, ((__mpz_struct*)a));
   return CRYPT_OK;
}
示例#22
0
文件: nls.c 项目: 0x6d48/bncsutil
MEXP(nls_t*) nls_account_change_proof(nls_t* nls, char* buf,
    const char* new_password, const char* B, const char* salt)
{
    nls_t* nouveau;
    mpz_t s; /* salt */
    
    if (!nls)
        return (nls_t*) 0;
        
    /* create new nls_t */
    nouveau = nls_init_l(nls->username, nls->username_len, new_password,
        (unsigned long) strlen(new_password));
    if (!nouveau)
        return (nls_t*) 0;
    
    /* fill buf */
    nls_get_M1(nls, buf, B, salt);
    
    mpz_init2(s, 256);
    mpz_urandomb(s, nouveau->rand, 256);
    mpz_export(buf + 20, (size_t*) 0, -1, 1, 0, 0, s);
    
	nls_get_v(nouveau, buf + 52, buf + 20);

    mpz_clear(s);
    
    return nouveau;
}
示例#23
0
static void 
store_p_soa(uint64 p, uint32 num_roots, uint32 which_poly, 
		mpz_t *roots, void *extra)
{
	uint32 i;
	lattice_fb_t *L = (lattice_fb_t *)extra;
	p_soa_var_t *soa;
	uint32 num;

	if (which_poly != 0) {
		printf("error: batched polynomials not allowed\n");
		exit(-1);
	}

	if (L->fill_p)
		soa = (p_soa_var_t *)L->p_array;
	else
		soa = (p_soa_var_t *)L->q_array;

	num = soa->num_p;
	soa->p[num] = p;
	soa->num_roots[num] = num_roots;
	for (i = 0; i < num_roots; i++) {
		uint128 tmp = {{0}};

		mpz_export(&tmp, NULL, -1, sizeof(uint32), 0, 0, roots[i]);
		soa->roots[i][num] = tmp;
	}

	soa->num_p++;
}
示例#24
0
void* damgard_jurik::export_prvkey(size_t *len) {
    void *buff;
    size_t written;
    buff = mpz_export(NULL, &written, 1, 1, 0, 0, prvkey->lambda);
    *len = written;
    return buff;
}
示例#25
0
文件: nls.c 项目: 0x6d48/bncsutil
MEXP(void) nls_get_A(nls_t* nls, char* out) {
    mpz_t g;
    mpz_t A;
    size_t o;
    
    if (!nls)
        return;

	if (nls->A) {
		memcpy(out, nls->A, 32);
		return;
	}
    
    mpz_init_set_ui(g, NLS_VAR_g);
    mpz_init2(A, 256);
    
    mpz_powm(A, g, nls->a, nls->n);
    mpz_export(out, &o, -1, 1, 0, 0, A);
    
    mpz_clear(A);
    mpz_clear(g);

	nls->A = (char*) malloc(32);
	if (nls->A)
		memcpy(nls->A, out, 32);
}
示例#26
0
signed long long vanilla::int_object_to_signed_longlong(object::ptr const& obj)
{
#if LLONG_MAX == LONG_MAX
    return int_object_to_signed_long(obj);
#endif
    
    if(obj->type_id() != OBJECT_ID_INT)
    {
        BOOST_THROW_EXCEPTION(error::bad_cast_error()
            << error::first_operand(obj)
            << error::cast_target_name("int"));
    }
    
    mpz_t& mpz = static_cast<int_object const*>(obj.get())->value().mpz();
    if(mpz_sizeinbase(mpz, 2) + 1 > sizeof(long long) * CHAR_BIT)
    {
        BOOST_THROW_EXCEPTION(error::integer_conversion_overflow_error()
            << error::first_operand(obj)
            << error::integer_conversion_target_type("signed long long"));
    }
    
    size_t count = 0;
    long long result = 0;
    mpz_export(&result, &count, -1, sizeof(result), 0, 0, mpz);
    assert(count == 1);
    return result;
}
示例#27
0
char* damgard_jurik_text_t::to_str() {
    char *buf;
    size_t len;
    buf = (char *)mpz_export(NULL, &len, 1, 1, 0, 0, text);
    buf[len] = 0;
    return buf;
}
示例#28
0
static inline void from_mpz(element_ptr e, mpz_ptr z) {
  fp_field_data_ptr p = e->field->data;
  size_t count;
  mpz_export(e->data, &count, -1, sizeof(mp_limb_t), 0, 0, z);
  memset((void *) (((unsigned char *) e->data) + count * sizeof(mp_limb_t)), 0,
         (p->limbs - count) * sizeof(mp_limb_t));
}
char* PaillierPublicParameters::getByteModulus() {
  char *key = new char[(getKeyBitsize() / 8 ) + sizeof(int)](); 
  mpz_export(key, NULL, 1, sizeof(char) , 0, 0, *pubkey.getnj(1));
  int init_s = pubkey.getinit_s();
  memcpy(key+(getKeyBitsize()/8), &init_s, sizeof(int));
	return key;
}
示例#30
0
void printPlaintext(mpz_t plaintext) {
   size_t count = 1024;
   char *buffer = (char *)calloc(count, sizeof(char));
   
   mpz_export((void*)buffer, &count, 1, sizeof( char), 1, 0, plaintext);
   printf("%s\n", buffer);
}