示例#1
1
文件: dh.c 项目: ozaki-r/netbsd-src
DH *
dh_new_group_asc(const char *gen, const char *modulus)
{
	DH *dh = NULL;
	BIGNUM *p=NULL, *g=NULL;

	if ((dh = DH_new()) == NULL ||
	    (p = BN_new()) == NULL ||
	    (g = BN_new()) == NULL)
		goto null;
	if (BN_hex2bn(&p, modulus) == 0 ||
	    BN_hex2bn(&g, gen) == 0) {
		goto null;
	}
	if (DH_set0_pqg(dh, p, NULL, g) == 0) {
		goto null;
	}
	p = g = NULL;
	return (dh);
null:
	BN_free(p);
	BN_free(g);
	DH_free(dh);
	return NULL;
}
示例#2
0
文件: srp.c 项目: Dan-McGee/lightwave
int _BN_rand(BIGNUM *rnd, int bits, int top,int bottom)
{
    static int i32 = 0;
    static int i256 = 0;
    int rsts = 0;

    switch(bits)
    {
      case 32:
        rsts = BN_hex2bn(&rnd, hex_bn32_rand[i32++]);
        if (i32 >= sizeof(hex_bn32_rand)/sizeof(char *))
        {
            i32 = 0;
        }

      break;

      case 256:
        rsts = BN_hex2bn(&rnd, hex_bn256_rand[i256++]);
        if (i256 >= sizeof(hex_bn256_rand)/sizeof(char *))
        {
            i256 = 0;
        }
      break;

      default:
      break;
    }

    return rsts;
}
示例#3
0
static DH *tr_msg_decode_dh(json_t *jdh)
{
  DH *dh = NULL;
  json_t *jp = NULL;
  json_t *jg = NULL;
  json_t *jpub_key = NULL;

  if (!(dh = malloc(sizeof(DH)))) {
    tr_crit("tr_msg_decode_dh(): Error allocating DH structure.");
    return NULL;
  }
 
  memset(dh, 0, sizeof(DH));

  /* store required fields from dh object */
  if ((NULL == (jp = json_object_get(jdh, "dh_p"))) ||
      (NULL == (jg = json_object_get(jdh, "dh_g"))) ||
      (NULL == (jpub_key = json_object_get(jdh, "dh_pub_key")))) {
    tr_debug("tr_msg_decode_dh(): Error parsing dh_info.");
    free(dh);
    return NULL;
  }

  BN_hex2bn(&(dh->p), json_string_value(jp));
  BN_hex2bn(&(dh->g), json_string_value(jg));
  BN_hex2bn(&(dh->pub_key), json_string_value(jpub_key));

  return dh;
}
示例#4
0
/*
 * Initialize everything necessary to check the signature of the given image.
 * Returns non-zero if successful, 0 otherwise.
 */
int
init_checksum(char *keyfile)
{
	char str[1024];
	FILE *file;

	if (keyfile == NULL || (file = fopen(keyfile, "r")) == NULL) {
		fprintf(stderr, "%s: cannot open keyfile\n", keyfile);
		return 0;
	}
	if ((signature_key = RSA_new()) == NULL) {
		fprintf(stderr, "%s: cannot allocate RSA struct\n", keyfile);
		return 0;
	}

	fscanf(file, "%1024s", str);
	BN_hex2bn(&signature_key->n, str);
	fscanf(file, "%1024s", str);
	BN_hex2bn(&signature_key->e, str);
	fscanf(file, "%1024s", str);
	BN_hex2bn(&signature_key->dmp1, str);
	fscanf(file, "%1024s", str);
	BN_hex2bn(&signature_key->dmq1, str);
	fscanf(file, "%1024s", str);
	BN_hex2bn(&signature_key->iqmp, str);
	fclose(file);

	return 1; 
}
示例#5
0
/**
* @brief Deserialize the supplied buffer into an RSA public key.
*
* Allocate a new RSA keypair and fill in the modulus and the exponent from
*	the public key stored in buf.
*
* @param buf Buffer containing the key to deserialize.
* @param len Length of the buffer.
*
* @return RSA *keypair on success, NULL on failure
*/
RSA *deserialize_rsa_pub_key(char *buf, size_t len) {
	(void)len; // TODO: use len to make sure we don't try to read past end of buffer

	/* get modulus */
	uint32_t hexformodsize = *(uint32_t*)buf;
	char *hexformod = (char*)malloc(hexformodsize + 1);
	memcpy(hexformod, &buf[sizeof(uint32_t)], hexformodsize);
	hexformod[hexformodsize] = '\0';
	DBGF("hexformod: %s", hexformod);

	/* get exponent */
	uint32_t hexforexpsize = *(uint32_t*)&buf[sizeof(uint32_t) + hexformodsize];
	char *hexforexp = (char*)malloc(hexforexpsize + 1);
	memcpy(hexforexp, &buf[2*sizeof(uint32_t) + hexformodsize], hexforexpsize);
	hexforexp[hexforexpsize] = '\0';
	DBGF("hexforexp: %s", hexforexp);

	/* make the keypair */
    RSA *keypair = RSA_new();
    BN_hex2bn(&keypair->n, hexformod); // TODO: need BN_new() first?
    BN_hex2bn(&keypair->e, hexforexp);
    keypair->d = NULL;
    keypair->p = NULL;
    keypair->q = NULL;
    keypair->dmp1 = NULL;
    keypair->dmq1 = NULL;
    keypair->iqmp = NULL;

	free(hexformod);
	free(hexforexp);

	return keypair;
}
示例#6
0
static EVP_PKEY *create_pkey(neverbleed_t *nb, size_t key_index, const char *ebuf, const char *nbuf)
{
    struct st_neverbleed_rsa_exdata_t *exdata;
    RSA *rsa;
    EVP_PKEY *pkey;

    if ((exdata = malloc(sizeof(*exdata))) == NULL) {
        fprintf(stderr, "no memory\n");
        abort();
    }
    exdata->nb = nb;
    exdata->key_index = key_index;

    rsa = RSA_new_method(nb->engine);
    RSA_set_ex_data(rsa, 0, exdata);
    if (BN_hex2bn(&rsa->e, ebuf) == 0) {
        fprintf(stderr, "failed to parse e:%s\n", ebuf);
        abort();
    }
    if (BN_hex2bn(&rsa->n, nbuf) == 0) {
        fprintf(stderr, "failed to parse n:%s\n", nbuf);
        abort();
    }
    rsa->flags |= RSA_FLAG_EXT_PKEY;

    pkey = EVP_PKEY_new();
    EVP_PKEY_set1_RSA(pkey, rsa);
    RSA_free(rsa);

    return pkey;
}
示例#7
0
Boolean APSetKey(CFStringRef key)
{
    hash = CFSTR("");
    blacklist = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
    
    // Create a new key
    rsaKey = RSA_new();
    
    // Public exponent is always 3
    BN_hex2bn(&rsaKey->e, "3");
    
    CFMutableStringRef mutableKey = CFStringCreateMutableCopy(kCFAllocatorDefault, 0, key);
    if (!mutableKey)
        return FALSE;
    
    CFIndex maximumCStringLength = CFStringGetMaximumSizeForEncoding(CFStringGetLength(mutableKey), kCFStringEncodingMacRoman) + 1;
    char *keyCStringBuffer = malloc(maximumCStringLength);
    
    // Determine if we have a hex or decimal key
    CFStringLowercase(mutableKey, NULL);
    if (CFStringHasPrefix(mutableKey, CFSTR("0x"))) {
        CFStringTrim(mutableKey, CFSTR("0x"));
        CFStringGetCString(mutableKey, keyCStringBuffer, maximumCStringLength, kCFStringEncodingMacRoman);
        BN_hex2bn(&rsaKey->n, keyCStringBuffer);
    }
    else {
        CFStringGetCString(mutableKey, keyCStringBuffer, maximumCStringLength, kCFStringEncodingMacRoman);
        BN_dec2bn(&rsaKey->n, keyCStringBuffer);
    }
    CFRelease(mutableKey);
    free(keyCStringBuffer);
    
    return TRUE;
}
polypseud_ctx *polypseud_ctx_new() {
    polypseud_ctx *ctx = (polypseud_ctx*)malloc(sizeof(polypseud_ctx));
    ctx->bn_ctx = BN_CTX_new();
    ctx->p = BN_new();
    ctx->a = BN_new();
    ctx->b = BN_new();
    BN_hex2bn(&ctx->p, "D35E472036BC4FB7E13C785ED201E065F98FCFA6F6F40DEF4F92B9EC7893EC28FCD412B1F1B32E27");
    BN_hex2bn(&ctx->a, "3EE30B568FBAB0F883CCEBD46D3F3BB8A2A73513F5EB79DA66190EB085FFA9F492F375A97D860EB4");
    BN_hex2bn(&ctx->b, "520883949DFDBC42D3AD198640688A6FE13F41349554B49ACC31DCCD884539816F5EB4AC8FB1F1A6");
    ctx->ec_group = EC_GROUP_new_curve_GFp(ctx->p, ctx->a, ctx->b, ctx->bn_ctx);
    if(ctx->ec_group == NULL) {
        BN_free(ctx->p);
        BN_free(ctx->a);
        BN_free(ctx->b);
        BN_CTX_free(ctx->bn_ctx);
        return NULL;
    }
    ctx->q = BN_new();
    BN_hex2bn(&ctx->q, "D35E472036BC4FB7E13C785ED201E065F98FCFA5B68F12A32D482EC7EE8658E98691555B44C59311");
    ctx->g = EC_POINT_new(ctx->ec_group);
    EC_POINT_hex2point(ctx->ec_group,
            "0443BD7E9AFB53D8B85289BCC48EE5BFE6F20137D10A087EB6E7871E2A10A599C710AF8D0D39E2061114FDD05545EC1CC8AB4093247F77275E0743FFED117182EAA9C77877AAAC6AC7D35245D1692E8EE1",
            ctx->g, ctx->bn_ctx);
    EC_GROUP_set_generator(ctx->ec_group, ctx->g, ctx->q, BN_value_one());
    return ctx;
}
示例#9
0
void test_Div_open_ssl()
{
    myInt64 cycles;
    myInt64 start;
    int num_runs = NUM_RUNS;
    
    BN_CTX *ctx;
    ctx = BN_CTX_new();
    BIGNUM *a = BN_new();
	BIGNUM *b = BN_new();
	BIGNUM *result = BN_new();
	BIGNUM *rem = BN_new();

    BN_hex2bn(&a, "7cd73b6fc007dfee34a23caf363ae67e8bb8782600000000032accceb");
    BN_hex2bn(&b, "c69d8b898f0e43b4643a018e7b0569de6f8cf328e0bf6d59ace4e3bc2ca28d10");


    start = start_tsc();
    for(int i = 0; i < num_runs; i++)
    {
		BN_div(result, rem, b, a, ctx);
	}
    cycles = stop_tsc(start);

    double r;  
    r = cycles / num_runs;
    printf("RDTSC instruction:\n %lf cycles measured => %lf seconds, assuming frequency is %lf MHz. (change in source file if different)\n", r, r/(FREQUENCY), (FREQUENCY)/1e6);
	
    BN_CTX_free(ctx);
    BN_free(a);
	BN_free(b);
    BN_free(result);
	BN_free(rem);
}
示例#10
0
文件: kex.c 项目: lifangbo/teraterm
static DH *dh_new_group_asc(const char *gen, const char *modulus)
{
	DH *dh = NULL;

	if ((dh = DH_new()) == NULL) {
		printf("dh_new_group_asc: DH_new");
		goto error;
	}

	// PとGは公開してもよい素数の組み合わせ
	if (BN_hex2bn(&dh->p, modulus) == 0) {
		printf("BN_hex2bn p");
		goto error;
	}

	if (BN_hex2bn(&dh->g, gen) == 0) {
		printf("BN_hex2bn g");
		goto error;
	}

	return (dh);

error:
	DH_free(dh);
	return (NULL);
}
示例#11
0
int main(int argc,char **argv)
    {
    ops_create_info_t *info;
    const unsigned char *id;
    const char *nstr;
    const char *estr;
    BIGNUM *n=NULL;
    BIGNUM *e=NULL;

    if(argc != 4)
	{
	fprintf(stderr,"%s <n> <e> <user id>\n",argv[0]);
	exit(1);
	}
    
    nstr=argv[1];
    estr=argv[2];
    id=(unsigned char *)argv[3];

    BN_hex2bn(&n,nstr);
    BN_hex2bn(&e,estr);

    info=ops_create_info_new();
    ops_writer_set_fd(info,1);

    ops_write_rsa_public_key(time(NULL),n,e,info);
    ops_write_user_id(id,info);

    ops_create_info_delete(info);

    return 0;
    }
示例#12
0
void Encode_RSA(unsigned char *in,int fd)
{
	RSA *r;
	BIGNUM *bne,*bnn,*bnd;
	int bits = 1024, ret, len, flen, padding, i;
	unsigned char *key, *p;
	BIO *b;
	unsigned  char *encData,*decData,*tmpData;//加密后的数据/解密后的数据/临时指针
       /* Key data */
	unsigned long e = 75011;  

	/* 构建RSA数据结构   */
	bne = BN_new();  
	bnd = BN_new();  
	bnn = BN_new();  
	ret = BN_set_word(bne, e);  
	BN_hex2bn(&bnd, PRIVATE);  
	BN_hex2bn(&bnn, MODULUS);  

	r = RSA_new();  
	r->e=bne;  
	r->d=bnd;  
	r->n=bnn;
	/* Debug output key */
	/*RSA_print_fp(stdout, r, 5);*/

	/*准备输出的加密数据结构   */
	flen =  RSA_size(r);// - 11;   
	encData =  (unsigned char *)malloc(flen);  
	bzero(encData, flen);//memset(encData, 0, flen);   

	ret =  RSA_private_encrypt(flen, in, encData, r,  RSA_NO_PADDING);  
	if(ret < 0){
		JCG("Encrypt failed!\n");  
		return;  
	}  

	write(fd,encData,flen);

	tmpData=encData;  
#if 0
	for  (i=0; i<ret; i++)
	{
		JDG("0x%02x, ", *tmpData);
		if(i%16 == 7)
			JDG("\t");
		else if(i%16 == 15)
			JDG("\n");
		tmpData++;  
	}
	JDG("\n");

	JCG("end private encrypt ");
#endif

	free(encData);  
	RSA_free(r);  
}
示例#13
0
文件: net_setup.c 项目: Rumko/tinc
bool read_rsa_private_key(void) {
    FILE *fp;
    char *fname, *key, *pubkey;
    struct stat s;

    if(get_config_string(lookup_config(config_tree, "PrivateKey"), &key)) {
        if(!get_config_string(lookup_config(config_tree, "PublicKey"), &pubkey)) {
            logger(LOG_ERR, "PrivateKey used but no PublicKey found!");
            return false;
        }
        myself->connection->rsa_key = RSA_new();
//		RSA_blinding_on(myself->connection->rsa_key, NULL);
        BN_hex2bn(&myself->connection->rsa_key->d, key);
        BN_hex2bn(&myself->connection->rsa_key->n, pubkey);
        BN_hex2bn(&myself->connection->rsa_key->e, "FFFF");
        free(key);
        free(pubkey);
        return true;
    }

    if(!get_config_string(lookup_config(config_tree, "PrivateKeyFile"), &fname))
        xasprintf(&fname, "%s/rsa_key.priv", confbase);

    fp = fopen(fname, "r");

    if(!fp) {
        logger(LOG_ERR, "Error reading RSA private key file `%s': %s",
               fname, strerror(errno));
        free(fname);
        return false;
    }

#if !defined(HAVE_MINGW) && !defined(HAVE_CYGWIN)
    if(fstat(fileno(fp), &s)) {
        logger(LOG_ERR, "Could not stat RSA private key file `%s': %s'",
               fname, strerror(errno));
        free(fname);
        return false;
    }

    if(s.st_mode & ~0100700)
        logger(LOG_WARNING, "Warning: insecure file permissions for RSA private key file `%s'!", fname);
#endif

    myself->connection->rsa_key = PEM_read_RSAPrivateKey(fp, NULL, NULL, NULL);
    fclose(fp);

    if(!myself->connection->rsa_key) {
        logger(LOG_ERR, "Reading RSA private key file `%s' failed: %s",
               fname, strerror(errno));
        free(fname);
        return false;
    }

    free(fname);
    return true;
}
示例#14
0
Person::Person(const char *p_str, const char *g_str) {
  p = NULL;
  g = NULL;
  B = NULL;
  hash = NULL;
  BN_hex2bn(&p, p_str);
  BN_hex2bn(&g, g_str);
  set_keys();
}
示例#15
0
void get_own_data(sqlite3* db, char** nickname, BIGNUM* e, BIGNUM* n, BIGNUM* d) {
	sqlite3_stmt *stmt;
	char* statement = "SELECT * FROM keys WHERE id = 0";
	sqlite3_prepare_v2(db, statement, strlen(statement) + 1 , &stmt, NULL);
	sqlite3_step(stmt);
	*nickname = (char*) sqlite3_column_text(stmt, 1);
	BN_hex2bn(&e, (const char*) sqlite3_column_text(stmt, 2));
	BN_hex2bn(&n, (const char*) sqlite3_column_text(stmt, 3));
	BN_hex2bn(&d, (const char*) sqlite3_column_text(stmt, 4));
}
示例#16
0
文件: test_bn.c 项目: Henauxg/minix
static int
test_BN_cmp(void)
{
    BIGNUM *a, *b;

    a = BN_new();
    b = BN_new();

    if (!BN_set_word(a, 1))
	return 1;
    if (!BN_set_word(b, 1))
	return 1;

    if (BN_cmp(a, b) != 0)
	return 1;
    if (BN_cmp(b, a) != 0)
	return 1;

    if (!BN_set_word(b, 2))
	return 1;

    if (BN_cmp(a, b) >= 0)
	return 1;
    if (BN_cmp(b, a) <= 0)
	return 1;

    BN_set_negative(b, 1);

    if (BN_cmp(a, b) <= 0)
	return 1;
    if (BN_cmp(b, a) >= 0)
	return 1;

    BN_free(a);
    BN_free(b);

    BN_hex2bn(&a, "50212A3B611D46642C825A16A354CE0FD4D85DD1");
    BN_hex2bn(&b, "50212A3B611D46642C825A16A354CE0FD4D85DD2");

    if (BN_cmp(a, b) >= 0)
	return 1;
    if (BN_cmp(b, a) <= 0)
	return 1;

    BN_set_negative(b, 1);

    if (BN_cmp(a, b) <= 0)
	return 1;
    if (BN_cmp(b, a) >= 0)
	return 1;

    BN_free(a);
    BN_free(b);
    return 0;
}
示例#17
0
int
main(int argc, char *argv[])
{
    BIGNUM *val;
    int ch;
    char *p, buf[LINE_MAX];		/* > max number of digits. */

    ctx = BN_CTX_new();
    val = BN_new();
    if (val == NULL)
        errx(1, "can't initialise bignum");

    while ((ch = getopt(argc, argv, "h")) != -1)
        switch (ch) {
        case 'h':
            hflag++;
            break;
        case '?':
        default:
            usage();
        }
    argc -= optind;
    argv += optind;

    /* No args supplied, read numbers from stdin. */
    if (argc == 0)
        for (;;) {
            if (fgets(buf, sizeof(buf), stdin) == NULL) {
                if (ferror(stdin))
                    err(1, "stdin");
                exit (0);
            }
            for (p = buf; isblank(*p); ++p);
            if (*p == '\n' || *p == '\0')
                continue;
            if (*p == '-')
                errx(1, "negative numbers aren't permitted.");
            if (BN_dec2bn(&val, buf) == 0 &&
                    BN_hex2bn(&val, buf) == 0)
                errx(1, "%s: illegal numeric format.", buf);
            pr_fact(val);
        }
    /* Factor the arguments. */
    else
        for (; *argv != NULL; ++argv) {
            if (argv[0][0] == '-')
                errx(1, "negative numbers aren't permitted.");
            if (BN_dec2bn(&val, argv[0]) == 0 &&
                    BN_hex2bn(&val, argv[0]) == 0)
                errx(1, "%s: illegal numeric format.", argv[0]);
            pr_fact(val);
        }
    exit(0);
}
示例#18
0
int next_pkey(RSA *pub, FILE *fp)
{
  static char nbuf[2048];
  static char ebuf[10];

  if (fscanf(fp, "%s\t%s", nbuf, ebuf) != 2)
    return 0;
  BN_hex2bn(&pub->n, nbuf);
  BN_hex2bn(&pub->e, ebuf);
  return 1;
}
示例#19
0
void openssl_bioBN_math()
{
	BIO *outs;
	BN_CTX *ctx;
	char num1[8], num2[8];
	BIGNUM *bg1, *bg2, *tmp, *stp;

	bg1 = BN_new();
	bg2 = BN_new();
	tmp = BN_new();
	ctx = BN_CTX_new();
	strcpy(num1, "84");
	strcpy(num2, "3");
	BN_hex2bn(&bg1, num1);
	BN_hex2bn(&bg2, num2);
	outs = BIO_new(BIO_s_file());
	BIO_set_fp(outs, stdout, BIO_NOCLOSE);

	printf("\nBIO_MATH as follow:\n");
	BN_add(tmp, bg1, bg2);
	BIO_puts(outs, "\tbn(0x84 + 0x3) = 0x");
	BN_print(outs, tmp);
	BIO_puts(outs, "\n");

	BN_sub(tmp, bg1, bg2);
	BIO_puts(outs, "\tbn(0x84 - 0x3) = 0x");
	BN_print(outs, tmp);
	BIO_puts(outs, "\n");

	BN_mul(tmp, bg1, bg2, ctx);
	BIO_puts(outs, "\tbn(0x84 * 0x3) = 0x");
	BN_print(outs, tmp);
	BIO_puts(outs, "\n");

	BN_sqr(tmp, bg1, ctx);
	BIO_puts(outs, "\tbn(sqr(0x84))  = 0x");
	BN_print(outs, tmp);
	BIO_puts(outs, "\n");

	BN_div(tmp, stp, bg1, bg2, ctx);
	BIO_puts(outs, "\tbn(0x84 / 0x3) = 0x");
	BN_print(outs, tmp);
	BIO_puts(outs, "\n");

	BN_exp(tmp, bg1, bg2, ctx);
	BIO_puts(outs, "\tbn(0x84 e 0x03)= 0x");
	BN_print(outs, tmp);
	BIO_puts(outs, "\n");

	BN_free(bg1);
	BN_free(bg2);
	BN_free(tmp);
	BIO_free(outs);
}
示例#20
0
rsa_prvkey_t *rsa_prvkey_new_from_str(const char *str)
{
	RSA *rsa = NULL;
	char n_buf[1024];
	char e_buf[1024];
	char d_buf[1024];

	OPENSSL_assert(str);

	if (strlen(str) > sizeof(n_buf)) {
		fprintf(stderr, "invalid data\n");
		return NULL;
	}

	if (sscanf(str, "%s %s %s", n_buf, e_buf, d_buf) != 3) {
		fprintf(stderr, "invalid data\n");
		return NULL;
	}
	
	if (!(rsa = RSA_new())) {
		ERR_print_errors_fp(stderr);
		return NULL;
	}

	if (!BN_hex2bn(&rsa->n, n_buf)) {
		ERR_print_errors_fp(stderr);
		RSA_free(rsa);
		return NULL;
	}
	
	if (!BN_hex2bn(&rsa->e, e_buf)) {
		ERR_print_errors_fp(stderr);
		RSA_free(rsa);
		return NULL;
	}

	if (!BN_hex2bn(&rsa->d, d_buf)) {
		ERR_print_errors_fp(stderr);
		RSA_free(rsa);
		return NULL;
	}
	
	if (!RSA_check_key(rsa)) {
		ERR_print_errors_fp(stderr);
		RSA_free(rsa);
		return NULL;
	}
		
	return rsa;	
}
示例#21
0
DH *
dh_new_group_asc(const char *gen, const char *modulus)
{
	DH *dh;

	if ((dh = DH_new()) == NULL)
		return NULL;
	if (BN_hex2bn(&dh->p, modulus) == 0 ||
	    BN_hex2bn(&dh->g, gen) == 0) {
		DH_free(dh);
		return NULL;
	}
	return (dh);
}
int do_hash_padding( __in char* sz_key, __in byte* hex_in, 
					 __in int n_in_len, __out char** sz_hash )
{
	
    char sz_module[FX_RSA_MODULE_LEN+1] = {0};
    char sz_exponent[FX_RSA_EXPNONT_LEN+1] = {0};
	
	int ret = 0, flen = 0;
    BIGNUM *bnn, *bne;
	byte* out;
	RSA *r = NULL;

	/*
	 *	get the value of module/exponent from sz_key
	 */
	
	memcpy( sz_module, sz_key, FX_RSA_MODULE_LEN );
	memcpy( sz_exponent, sz_key + FX_RSA_MODULE_LEN, FX_RSA_EXPNONT_LEN );
	
	/*
	 *	do hash 
	 */
	
	bnn = BN_new();
	bne = BN_new();
	
	BN_hex2bn(&bnn, sz_module);
	BN_hex2bn(&bne, sz_exponent);
	
	r = RSA_new();
	r->n = bnn;
	r->e = bne;
	r->d = NULL;
	
    flen = RSA_size(r);
	out = (byte*)malloc( flen );
	memset( out, 0, flen );

	ret = RSA_public_encrypt( n_in_len, hex_in, out, r, RSA_PKCS1_PADDING );
	if (ret < 0)
	{
		printf("Encrypt failed!\n");
		log_string( "Encrypt failed!" );
		return FX_ERROR_UNKOWN;
    }

	return byte_2_hex_str( out, sz_hash, ret );
		
}
示例#23
0
DH *
dh_new_group_asc(const char *gen, const char *modulus)
{
	DH *dh;

	if ((dh = DH_new()) == NULL)
		fatal("dh_new_group_asc: DH_new");

	if (BN_hex2bn(&dh->p, modulus) == 0)
		fatal("BN_hex2bn p");
	if (BN_hex2bn(&dh->g, gen) == 0)
		fatal("BN_hex2bn g");

	return (dh);
}
示例#24
0
bool CRsaEncDec::ReadPublickey(const std::string& keyfile, bool readfile)
{
    if (m_publicKey != NULL)
    {
        RSA_free(m_publicKey);
        m_publicKey = NULL;
    }

    if (NULL == (m_publicKey = RSA_new())) return false;

    if (readfile)
    {
        FILE* hPubKeyFile = fopen(keyfile.c_str(), "rb");
        if( hPubKeyFile == NULL )
        {
            LOG.err_log("打开公钥文件失败:%s, [%s:%d]", 
                keyfile.c_str(), __FILE__, __LINE__);
            return false; 
        }

        RSA* res = PEM_read_RSA_PUBKEY(hPubKeyFile, &m_publicKey, 0, 0);
        fclose(hPubKeyFile);
        hPubKeyFile = NULL;

        if (!res)
        {
            LOG.err_log("读取公钥失败![%s:%d]", __FILE__, __LINE__);
            return false;
        }
    }
    else
    {
        BIGNUM *bnn = BN_new(); 
        BIGNUM *bne = BN_new();
        BIGNUM *bnd = BN_new();

        BN_hex2bn(&bnn, MODULUS);
        BN_set_word(bne, PUBLIC_EXPONENT);
        BN_hex2bn(&bnd, PRIVATE_EXPONENT);

        m_publicKey->n = bnn;
        m_publicKey->e = bne;
        m_publicKey->d = bnd;
        return true;
    }
    
    return true;
}
示例#25
0
BIGNUM *BN_get(lua_State *L, int i)
{
  BIGNUM *x = BN_new();
  switch (lua_type(L, i))
  {
  case LUA_TNUMBER:
    BN_set_word(x, lua_tointeger(L, i));
    break;
  case LUA_TSTRING:
  {
    const char *s = lua_tostring(L, i);
    if (s[0] == 'X' || s[0] == 'x') BN_hex2bn(&x, s + 1);
    else BN_dec2bn(&x, s);
    break;
  }
  case LUA_TUSERDATA:
    BN_copy(x, CHECK_OBJECT(i, BIGNUM, "openssl.bn"));
    break;
  case LUA_TNIL:
    BN_free(x);
    x = NULL;
    break;
  }
  return x;
}
 int __openssl_initialize_dh(DH* pdh, int32_t bits_count){
     int ret = ERROR_SUCCESS;
 
     //2. Create his internal p and g
     if ((pdh->p = BN_new()) == NULL) {
         ret = ERROR_OpenSslCreateP; 
         return ret;
     }
     if ((pdh->g = BN_new()) == NULL) {
         ret = ERROR_OpenSslCreateG; 
         return ret;
     }
 
     //3. initialize p and g
     if (BN_hex2bn(&pdh->p, RFC2409_PRIME_1024) == 0) {
         ret = ERROR_OpenSslParseP1024; 
         return ret;
     }
     if (BN_set_word(pdh->g, 2) != 1) {
         ret = ERROR_OpenSslSetG;
         return ret;
     }
 
     //4. Set the key length
     pdh->length = bits_count;
 
     //5. Generate private and public key
     if (DH_generate_key(pdh) != 1) {
         ret = ERROR_OpenSslGenerateDHKeys;
         return ret;
     }
     
     return ret;
 }
示例#27
0
static LUA_FUNCTION(openssl_hex)
{
  size_t l = 0, pad = 0;
  const char* s = luaL_checklstring(L, 1, &l);
  int hl = 0;
  int encode = lua_isnoneornil(L, 2) ? 1 : lua_toboolean(L, 2);
  char* h = NULL;
  BIGNUM *B = NULL;

  if (encode)
  {
    h = OPENSSL_malloc(l * 2 + 1);
    to_hex(s, l, h);
    hl = strlen(h);
  }
  else
  {
    BN_hex2bn(&B, s);
    hl = l / 2;
    h = OPENSSL_malloc( hl + 1 );
    pad = hl - BN_num_bytes(B);
    memset(h, 0, pad);
    BN_bn2bin(B, (unsigned char *)h+pad);
    h[hl] = '\0';
  };
  lua_pushlstring(L, (const char*)h, hl);
  OPENSSL_free(h);
  BN_free(B);

  return 1;
}
示例#28
0
void meteor_user_generate_S_string( struct SRPUser *usr,
                                    BN_CTX * ctx,
                                    BIGNUM * kgx,
                                    BIGNUM * aux,
                                    const char * B_str,
                                    char ** S_str)
{
    BIGNUM *B         = BN_new();
    BIGNUM *bkgx      = BN_new();
    BIGNUM *S         = BN_new();

    BN_hex2bn( &B, B_str );

    if ( !B )
        goto cleanup_and_exit;

    BN_sub( bkgx, B, kgx );

    if ( !bkgx )
        goto cleanup_and_exit;

    BN_mod_exp(S, bkgx, aux, usr->ng->N, ctx);

    if ( !S )
        goto cleanup_and_exit;

    *S_str = convert_to_lower( BN_bn2hex(S) );

  cleanup_and_exit:

    BN_free(B);
    BN_free(bkgx);
    BN_free(S);
}
static int gmp2bn(mpz_t g, BIGNUM *bn)
	{
	if(((sizeof(bn->d[0]) * 8) == GMP_NUMB_BITS) &&
			(BN_BITS2 == GMP_NUMB_BITS))
		{
		/* The common case */
		int s = (g->_mp_size >= 0) ? g->_mp_size : -g->_mp_size;
		BN_zero(bn);
		if(bn_expand2 (bn, s) == NULL)
			return 0;
		bn->top = s;
		TINYCLR_SSL_MEMCPY(&bn->d[0], &g->_mp_d[0], s * sizeof(bn->d[0]));
		bn_correct_top(bn);
		bn->neg = g->_mp_size >= 0 ? 0 : 1;
		return 1;
		}
	else
		{
		int toret;
		char *tmpchar = OPENSSL_malloc(mpz_sizeinbase(g, 16) + 10);
		if(!tmpchar) return 0;
		mpz_get_str(tmpchar, 16, g);
		toret = BN_hex2bn(&bn, tmpchar);
		OPENSSL_free(tmpchar);
		return toret;
		}
	}
示例#30
0
文件: ecdhtest.c 项目: Voxer/openssl
static EC_KEY *mk_eckey(int nid, const char *str)
{
    int ok = 0;
    EC_KEY *k = NULL;
    BIGNUM *priv = NULL;
    EC_POINT *pub = NULL;
    const EC_GROUP *grp;
    k = EC_KEY_new_by_curve_name(nid);
    if (!k)
        goto err;
    if(!BN_hex2bn(&priv, str))
        goto err;
    if (!priv)
        goto err;
    if (!EC_KEY_set_private_key(k, priv))
        goto err;
    grp = EC_KEY_get0_group(k);
    pub = EC_POINT_new(grp);
    if (!pub)
        goto err;
    if (!EC_POINT_mul(grp, pub, priv, NULL, NULL, NULL))
        goto err;
    if (!EC_KEY_set_public_key(k, pub))
        goto err;
    ok = 1;
 err:
    BN_clear_free(priv);
    EC_POINT_free(pub);
    if (ok)
        return k;
    EC_KEY_free(k);
    return NULL;
}