int serverAct1(Server * server) {
int bytes;
char buf[1024];
char * bufptr = buf;
char * tmpstr;
printf("\n==== Этап 1 ====\n\n");
server->k = BN_new();
server->m = BN_new();
bytes = BIO_read(server->conn, buf, 1024);
buf[bytes] = 0;
BN_dec2bn(&server->k, buf);
tmpstr = BN_bn2dec(server->k);
printf("k = %s\n", tmpstr);
OPENSSL_free(tmpstr);
BIO_puts(server->conn, "OK");
bytes = BIO_read(server->conn, buf, 1024);
buf[bytes] = 0;
BN_dec2bn(&server->m, buf);
tmpstr = BN_bn2dec(server->m);
printf("m = %s\n", tmpstr);
OPENSSL_free(tmpstr);
BIO_puts(server->conn, "OK");
return 0;
}
/*--------------------------------------------------*/
void compute_mod(Task * task)
{
BN_CTX *context;
BIGNUM *r,*a,*p,*m;
if(task->p==NULL){
fprintf(stderr,"Wrong Exponent\n");
exit(0);
}
/*Just printing out the client send numbers*/
printf("Printing the Exponent\n");
print_bignumber(task->p);
printf("Printing the Prime\n");
print_bignumber(task->m);
context = BN_CTX_new();
r = BN_new();
a = BN_new();
p = BN_new();
m = BN_new();
BN_dec2bn(&a,"2");
BN_dec2bn(&p,task->p);
BN_dec2bn(&m,task->m);
BN_mod_exp(r,a,p,m,context);
printf("Response ----\n");
strcpy(task->response,BN_bn2dec(r));
print_bignumber(task->response);
return;
}
/* retrieve basic constraints ingredients */
BOOL SSL_X509_getBC(X509 *cert, int *ca, int *pathlen)
{
X509_EXTENSION *ext;
BASIC_CONSTRAINTS *bc;
int idx;
BIGNUM *bn = NULL;
char *cp;
if ((idx = X509_get_ext_by_NID(cert, NID_basic_constraints, -1)) < 0)
return FALSE;
ext = X509_get_ext(cert, idx);
if (ext == NULL)
return FALSE;
if ((bc = (BASIC_CONSTRAINTS *)X509V3_EXT_d2i(ext)) == NULL)
return FALSE;
*ca = bc->ca;
*pathlen = -1 /* unlimited */;
if (bc->pathlen != NULL) {
if ((bn = ASN1_INTEGER_to_BN(bc->pathlen, NULL)) == NULL)
return FALSE;
if ((cp = BN_bn2dec(bn)) == NULL)
return FALSE;
*pathlen = atoi(cp);
OPENSSL_free(cp);
BN_free(bn);
}
BASIC_CONSTRAINTS_free(bc);
return TRUE;
}
/**
* Decode a two's complement varint (e.g. Java BigInteger) byte array into its
* numerical value
*
* @param byte_array Two's complement varint byte array
* @return Numerical value of the varint
*/
static std::string decode_varint(const char *byte_array) {
std::string result;
// Assuming positive numbers only
//TODO: Add check for bit to return negative values
BIGNUM *value = BN_bin2bn(reinterpret_cast<unsigned const char *>(byte_array), static_cast<int>(strlen(byte_array)), NULL);
if (value) {
char* decimal = BN_bn2dec(value);
result = std::string(decimal);
OPENSSL_free(decimal);
//Normalize - strip leading zeros
for (unsigned int n = 0; n < result.size(); ++n) {
if (result.at(n) == '0') {
result.replace(n, 1, "");
} else {
break;
}
}
if (result.size() == 0) {
result = "0";
}
}
BN_free(value);
return result;
}
/* Convert ASN1_INTEGER to decimal string string */
static int
tls_parse_bigint(struct tls *ctx, const ASN1_INTEGER *asn1int, const char **dst_p)
{
long small;
BIGNUM *big;
char *tmp, buf[64];
*dst_p = NULL;
small = ASN1_INTEGER_get(asn1int);
if (small < 0) {
big = ASN1_INTEGER_to_BN(asn1int, NULL);
if (big) {
tmp = BN_bn2dec(big);
if (tmp)
*dst_p = strdup(tmp);
OPENSSL_free(tmp);
}
BN_free(big);
} else {
snprintf(buf, sizeof buf, "%lu", small);
*dst_p = strdup(buf);
}
if (*dst_p)
return 0;
tls_set_errorx(ctx, "cannot parse serial");
return -1;
}
int main(int argc, char *argv[])
{
BIGNUM *fat; // declaração de uma variável Big
BN_ULONG a, f; // apenas um long int normal
char *resp;
int i;
/* Primeiro tem que alocar as variáveis BIGNUM */
fat = BN_new();
for (i = 1; i < argc; i++) {
printf("Calculando fatorial de %s\n", argv[i]);
/* convertendo string em long int */
f = atoll(argv[i]);
/* forma de atribuir 1 a uma variável BIGNUM */
BN_dec2bn(&fat, "1");
for (a = 2; a <= f; a++) {
BN_mul_word(fat, a);
}
/* gerando uma string imprimível do resultado */
resp = BN_bn2dec(fat);
/* impressão do resultado (agora é uma string) */
printf("Fatorial de %s = %s\n", argv[i], resp);
}
}
VALUE
asn1integer_to_num(ASN1_INTEGER *ai)
{
BIGNUM *bn;
#if DO_IT_VIA_RUBY
char *txt;
#endif
VALUE num;
if (!ai) {
ossl_raise(rb_eTypeError, "ASN1_INTEGER is NULL!");
}
if (!(bn = ASN1_INTEGER_to_BN(ai, NULL))) {
ossl_raise(eOSSLError, NULL);
}
#if DO_IT_VIA_RUBY
if (!(txt = BN_bn2dec(bn))) {
BN_free(bn);
ossl_raise(eOSSLError, NULL);
}
num = rb_cstr_to_inum(txt, 10, Qtrue);
OPENSSL_free(txt);
#else
num = ossl_bn_new(bn);
#endif
BN_free(bn);
return num;
}
/* retrieve basic constraints ingredients */
BOOL modssl_X509_getBC(X509 *cert, int *ca, int *pathlen)
{
BASIC_CONSTRAINTS *bc;
BIGNUM *bn = NULL;
char *cp;
bc = X509_get_ext_d2i(cert, NID_basic_constraints, NULL, NULL);
if (bc == NULL)
return FALSE;
*ca = bc->ca;
*pathlen = -1 /* unlimited */;
if (bc->pathlen != NULL) {
if ((bn = ASN1_INTEGER_to_BN(bc->pathlen, NULL)) == NULL) {
BASIC_CONSTRAINTS_free(bc);
return FALSE;
}
if ((cp = BN_bn2dec(bn)) == NULL) {
BN_free(bn);
BASIC_CONSTRAINTS_free(bc);
return FALSE;
}
*pathlen = atoi(cp);
OPENSSL_free(cp);
BN_free(bn);
}
BASIC_CONSTRAINTS_free(bc);
return TRUE;
}
jstring* BN_to_jstring(JNIEnv *env, BIGNUM *num) {
char *numString;
jstring res;
numString = BN_bn2dec(num);
res = (*env)->NewStringUTF(env, numString);
free(numString);
return res;
}
void
pn(const char *str, const struct number *n)
{
char *p = BN_bn2dec(n->number);
if (p == NULL)
err(1, "BN_bn2dec failed");
(void)fputs(str, stderr);
(void)fprintf(stderr, " %s (%u)\n" , p, n->scale);
OPENSSL_free(p);
}
void
pbn(const char *str, const BIGNUM *n)
{
char *p = BN_bn2dec(n);
if (p == NULL)
err(1, "BN_bn2dec failed");
(void)fputs(str, stderr);
(void)fprintf(stderr, " %s\n", p);
OPENSSL_free(p);
}
/*
* Sigh.. No _decimal_ output to file functions in BN.
*/
static void
BN_print_dec_fp(FILE *fp, const BIGNUM *num)
{
char *buf;
buf = BN_bn2dec(num);
if (buf == NULL)
return; /* XXX do anything here? */
fprintf(fp, buf);
free(buf);
}
extern "C" jstring Java_java_math_NativeBN_BN_1bn2dec(JNIEnv* env, jclass, jlong a) {
if (!oneValidHandle(env, a)) return NULL;
char* tmpStr = BN_bn2dec(toBigNum(a));
if (tmpStr == NULL) {
return NULL;
}
char* retStr = leadingZerosTrimmed(tmpStr);
jstring returnJString = env->NewStringUTF(retStr);
OPENSSL_free(tmpStr);
return returnJString;
}
/*
* pr_fact - print the factors of a number
*
* If the number is 0 or 1, then print the number and return.
* If the number is < 0, print -1, negate the number and continue
* processing.
*
* Print the factors of the number, from the lowest to the highest.
* A factor will be printed numtiple times if it divides the value
* multiple times.
*
* Factors are printed with leading tabs.
*/
static void
pr_fact(BIGNUM *val)
{
const ubig *fact; /* The factor found. */
/* Firewall - catch 0 and 1. */
if (BN_is_zero(val) || BN_is_one(val))
errx(1, "numbers <= 1 aren't permitted.");
/* Factor value. */
BN_print_dec_fp(stdout, val);
putchar(':');
for (fact = &prime[0]; !BN_is_one(val); ++fact) {
/* Look for the smallest factor. */
while (fact <= pr_limit) {
if (BN_mod_word(val, (BN_ULONG)*fact) == 0)
break;
fact++;
}
/* Watch for primes larger than the table. */
if (fact > pr_limit) {
#ifdef HAVE_OPENSSL
BIGNUM *bnfact;
bnfact = BN_new();
BN_set_word(bnfact, (BN_ULONG)*(fact - 1));
BN_sqr(bnfact, bnfact, ctx);
if (BN_cmp(bnfact, val) > 0
|| BN_is_prime(val, PRIME_CHECKS, NULL, NULL,
NULL) == 1) {
putchar(' ');
BN_print_dec_fp(stdout, val);
} else
pollard_rho(val);
#else
printf(" %s", BN_bn2dec(val));
#endif
break;
}
/* Divide factor out until none are left. */
do {
printf(" %lu", *fact);
BN_div_word(val, (BN_ULONG)*fact);
} while (BN_mod_word(val, (BN_ULONG)*fact) == 0);
/* Let the user know we're doing something. */
fflush(stdout);
}
putchar('\n');
}
/**
* public static native java.lang.String BN_bn2dec(int)
*/
static jstring NativeBN_BN_bn2dec(JNIEnv* env, jclass cls, BIGNUM* a) {
if (!oneValidHandle(env, a)) return NULL;
char* tmpStr;
char* retStr;
tmpStr = BN_bn2dec(a);
if (tmpStr != NULL) {
retStr = leadingZerosTrimmed(tmpStr);
jstring returnJString = ((*env)->NewStringUTF(env, (mcSignednessBull)retStr));
OPENSSL_free(tmpStr);
return returnJString;
}
else return NULL;
}
QString a1int::toDec() const
{
QString r;
if (in->length == 0) {
return r;
}
BIGNUM *bn = ASN1_INTEGER_to_BN(in, NULL);
char *res = BN_bn2dec(bn);
r = res;
BN_free(bn);
OPENSSL_free(res);
return r;
}
static char *
handle_serial (char * serial)
{
int hex = NULL != strchr (serial, ':');
/* Convert serial to a decimal serial when input is
a hexidecimal representation of the serial */
if (hex)
{
unsigned int i,ii;
char *tmp_serial = (char*) calloc (strlen (serial) + 1,1);
for (i=0,ii=0; '\0'!=serial[i];i++)
{
if (':'!=serial[i])
tmp_serial[ii++]=serial[i];
}
serial=tmp_serial;
}
else
{
unsigned int i;
for (i=0; ! hex && '\0' != serial[i]; i++)
hex = 'a'==serial[i]||'b'==serial[i]||'c'==serial[i]||'d'==serial[i]||'e'==serial[i]||'f'==serial[i];
}
if (hex)
{
ASN1_INTEGER* ai;
BIGNUM *ret;
BIO* in = BIO_new_mem_buf(serial, -1);
char buf[1025];
ai=ASN1_INTEGER_new();
if (ai == NULL) return NULL;
if (!a2i_ASN1_INTEGER(in,ai,buf,1024))
{
return NULL;
}
ret=ASN1_INTEGER_to_BN(ai,NULL);
if (ret == NULL)
{
return NULL;
}
else
{
serial = BN_bn2dec(ret);
}
}
return serial;
} /* handle_serial */
char *
x509_get_serial (x509_cert_t *cert)
{
ASN1_INTEGER *asn1_i;
BIGNUM *bignum;
char *serial;
asn1_i = X509_get_serialNumber(cert);
bignum = ASN1_INTEGER_to_BN(asn1_i, NULL);
serial = BN_bn2dec(bignum);
BN_free(bignum);
return serial;
}
int
main()
{
BIGNUM two, three, four, five;
BIGNUM answer;
BN_CTX *context;
size_t length;
char *string;
context = BN_CTX_new();
if (context == NULL)
fail("BN_CTX_new");
/* answer = 5 ** 4 ** 3 ** 2 */
BN_init(&two);
BN_init(&three);
BN_init(&four);
BN_init(&five);
if (BN_set_word(&two, 2) == 0 ||
BN_set_word(&three, 3) == 0 ||
BN_set_word(&four, 4) == 0 ||
BN_set_word(&five, 5) == 0)
fail("BN_set_word");
BN_init(&answer);
if (BN_exp(&answer, &three, &two, context) == 0 ||
BN_exp(&answer, &four, &answer, context) == 0 ||
BN_exp(&answer, &five, &answer, context) == 0)
fail("BN_exp");
/* string = decimal answer */
string = BN_bn2dec(&answer);
if (string == NULL)
fail("BN_bn2dec");
length = strlen(string);
printf(" First 20 digits: %.20s\n", string);
if (length >= 20)
printf(" Last 20 digits: %.20s\n", string + length - 20);
printf("Number of digits: %zd\n", length);
OPENSSL_free(string);
BN_free(&answer);
BN_free(&five);
BN_free(&four);
BN_free(&three);
BN_free(&two);
BN_CTX_free(context);
return 0;
}
int serverReadKey(Server * server, char * key) {
FILE * f;
if ((f = fopen(key, "r")) == NULL) {
fprintf(stderr, "Can't open file %s!\n", key);
return 1;
}
server->rsa = RSA_new();
if (server->rsa == NULL)
return 1;
if(PEM_read_RSA_PUBKEY(f, &server->rsa, (pem_password_cb *) password_callback, NULL) == 0) {
ERR_print_errors_fp(stderr);
return 1;
}
char * tmpstr;
tmpstr = BN_bn2dec(server->rsa->n);
printf("Модуль: %s\n", tmpstr);
OPENSSL_free(tmpstr);
tmpstr = BN_bn2dec(server->rsa->e);
printf("Публичная экспонента: %s\n", tmpstr);
OPENSSL_free(tmpstr);
printf("&p = %x\n", server->rsa->p);
if (server->rsa->p){
tmpstr = BN_bn2dec(server->rsa->p);
printf("p = %s\n", tmpstr);
OPENSSL_free(tmpstr);
}
return 0;
}
ostream& operator<<(ostream &os,Polynomial &PL)
{
char *num = NULL;
int count = 0;
bool flag = false;
vector<BIGNUM *>::iterator iter;
for (iter=PL.coefficients->begin();iter!=PL.coefficients->end();iter++)
{
num= BN_bn2dec (*iter);
if(flag)
{
if(strcmp(num,"0"))
{
os<<" + "<<endl;
os<<num<<"."<<"x^"<<count;
}
}
else
{
if(strcmp(num,"0"))
{
flag = true;
os<<num;
if(count)
os<<"x^"<<count;
}
}
count++;
}
if(!flag)
{
os<<"0";
}
os<<endl<<"% "<<BN_bn2dec(PL.p)<<endl;
return os;
}
int main(int argc, char ** argv) {
/* Generate 2 big random numbers (512 bits) */
primitive_p = initialize("1011011");
initialize_rand(SEED);
BIGNUM *p = get_long_prime_number(RSA_KEY_LENGTH);
printf("p=%s\n", BN_bn2hex(p));
BIGNUM *q = get_long_prime_number(RSA_KEY_LENGTH);
printf("q=%s\n", BN_bn2hex(q));
/* Compute phi = (p-1)*(q-1) and n = p*q */
BIGNUM *phi, *n;
BN_CTX *tmp;
tmp = BN_CTX_new();
n = BN_new();
phi = BN_new();
BN_copy(n, p);
BN_mul(n, n, q, tmp);
printf("n=%s\n", BN_bn2dec(n));
BN_sub_word(p, 1);
printf("p-1=%s\n", BN_bn2dec(p));
BN_sub_word(q, 1);
printf("q-1=%s\n", BN_bn2dec(q));
phi = BN_new();
BN_init(tmp);
BN_mul(phi, p, q, tmp);
printf("(p-1)(q-1)=%s\n", BN_bn2dec(phi));
/* Find the smallest integer coprime with phi */
BIGNUM * e = BN_new();
BIGNUM *gcd = BN_new();
BN_add_word(e, 3);
for ( ; ; BN_add_word(e, 2)) {
tmp = BN_CTX_new();
BN_gcd(gcd, e, phi, tmp);
if (BN_is_one(gcd))
break;
}
printf("e=%s\n", BN_bn2dec(e));
/* Find d, the inverse of e in Z_phi */
BIGNUM * d = BN_new();
BIGNUM * i = BN_new();
BIGNUM * rem = BN_new();
BIGNUM * prod = BN_new();
BN_add_word(i, 1);
for ( ; ; BN_add_word(i, 1)) {
BN_copy(prod, phi);
tmp = BN_CTX_new();
BN_mul(prod, prod, i, tmp);
BN_add_word(prod, 1);
BN_div(d, rem, prod, e, tmp);
if (BN_is_zero(rem)) {
break;
}
}
printf("d=%s\n", BN_bn2dec(d));
return 0;
}
/*
* call-seq:
* bn.to_i => integer
*/
static VALUE
ossl_bn_to_i(VALUE self)
{
BIGNUM *bn;
char *txt;
VALUE num;
GetBN(self, bn);
if (!(txt = BN_bn2dec(bn))) {
ossl_raise(eBNError, NULL);
}
num = rb_cstr_to_inum(txt, 10, Qtrue);
OPENSSL_free(txt);
return num;
}
/* Generate random moduli and check gcd */
int openSSLGenTest(mpz_t *n)
{
mpz_t myN, genN, tmp;
long counter = 0;
int status = FAIL;
printf("[INFO ] Trying OpenSSL generating\n");
mpz_init_set(myN, *n); mpz_init(genN); mpz_init(tmp);
BIGNUM *e = NULL;
RSA *rsa = NULL;
rsa = RSA_new();
e = BN_new();
BN_set_word(e, OPENSSLGENEXPONENT);
while (counter < OPENSSLGENMAX)
{
if (RSA_generate_key_ex(rsa, OPENSSLGENBITS, e, NULL) == 0)
break;
mpz_set_str(genN, BN_bn2dec(rsa->n), 10);
mpz_gcd(tmp, myN, genN);
if (mpz_cmp_ui(tmp, 1) != 0)
{
printWin(&tmp, "OpenSSL gen");
status = WIN;
break;
}
counter += 1;
}
BN_free(e);
RSA_free(rsa);
mpz_clear(myN); mpz_clear(genN);
return status;
}
char *
x509_get_serial (openvpn_x509_cert_t *cert, struct gc_arena *gc)
{
ASN1_INTEGER *asn1_i;
BIGNUM *bignum;
char *openssl_serial, *serial;
asn1_i = X509_get_serialNumber(cert);
bignum = ASN1_INTEGER_to_BN(asn1_i, NULL);
openssl_serial = BN_bn2dec(bignum);
serial = string_alloc(openssl_serial, gc);
BN_free(bignum);
OPENSSL_free(openssl_serial);
return serial;
}
std::string bdoc::X509Cert::getSerial() const
{
std::string serial;
ASN1_INTEGER* bs = NULL;
if (!(bs = X509_get_serialNumber(cert))) {
THROW_STACK_EXCEPTION("Failed to read certificate serial number from X.509 certificate: %s", ERR_reason_error_string(ERR_get_error()));
}
BIGNUM *bn = ASN1_INTEGER_to_BN(bs, NULL);
char *str = BN_bn2dec(bn);
serial = std::string(str);
BN_free(bn);
OPENSSL_free(str);
return serial;
}
// Generate a numbits-bit probable prime using the Random-Search algorithm
void rndsearch(int numbits, int maxitr, FILE* primesfile, FILE* rndfile) {
bool found_prime = false;
int count = 1;
int num_bytes = ceil(numbits/8.0);
BIGNUM* num_orig = BN_new();
char* num_trimmed = (char*)calloc(1, num_bytes);
// Iterate through potential numbers in RandomFile
while(!found_prime) {
printf("RANDOM-SEARCH: iteration %d\n", count);
// Generate random odd numbit-long integer
RndOddNum(numbits, num_orig, rndfile);
num_trimmed = BN_bn2dec(num_orig);
// Test with trial division
printf(" n = %s\n", num_trimmed);
printf(" ");
if(trialdiv(num_trimmed, primesfile)) {
// Passed trial division, check Miller-Rabin
if(millerrabin(num_trimmed, maxitr, primesfile, " ")) {
found_prime = true;
}
}
count++;
}
BN_free(num_orig);
free(num_trimmed);
// PSEUDO-CODE
// - Generate a random numbit-bit number
// - Read ceil(numbit/8) bytes from the random file
// - Set bits 0 and numbit-1 to 1
// - Set bits numbit to ceil(numbit/8)*8 to 0
// - Run the Trial Division test
// - If it passes, run the Miller-Rabin test
// - If it passes that too, return that prime number
// - If it fails either test, return to the beginning and try a new number
}
/**
* @return returns X.509 certificate serial number.
* @throws IOException exception is thrown if the serial is incorrect.
*/
std::string digidoc::X509Cert::getSerial() const throw(IOException)
{
std::string serial;
BIGNUM *bn = ASN1_INTEGER_to_BN(X509_get_serialNumber(cert), 0);
if(bn)
{
char *str = BN_bn2dec(bn);
if(str)
serial = str;
OPENSSL_free(str);
BN_free(bn);
}
if(serial.empty())
{
THROW_IOEXCEPTION("Failed to read certificate serial number from X.509 certificate: %s", ERR_reason_error_string(ERR_get_error()));
}
return serial;
}
int main(int argc, char *argv[])
{
char *prime;
BIGNUM *num_tmp;
long int num_bits = 0;
if(argc >= 2 && argv[1])
num_bits = atol(argv[1]);
else
num_bits = 1024;
printf("Prime generator by (c) 2004 Paolo Ardoino < *****@*****.** >\n usage: ./genprimes [num_bits]\nGenerating %ld bits primes.\nWait…\n",num_bits);
num_tmp = BN_new();
for (;;) {
BN_generate_prime(num_tmp,num_bits,1,NULL,NULL,status,NULL);
prime = (char *)malloc(BN_num_bytes(num_tmp));
prime = BN_bn2dec(num_tmp);
print_prime(prime);
free(prime);
}
BN_free(num_tmp);
}
double
vg_prefix_get_difficulty(int addrtype, const char *pattern)
{
BN_CTX *bnctx;
BIGNUM result, bntmp;
BIGNUM *ranges[4];
char *dbuf;
int ret;
double diffret = 0.0;
bnctx = BN_CTX_new();
BN_init(&result);
BN_init(&bntmp);
ret = get_prefix_ranges(addrtype,
pattern, ranges, bnctx);
if (ret == 0) {
BN_sub(&bntmp, ranges[1], ranges[0]);
BN_add(&result, &result, &bntmp);
if (ranges[2]) {
BN_sub(&bntmp, ranges[3], ranges[2]);
BN_add(&result, &result, &bntmp);
}
free_ranges(ranges);
BN_clear(&bntmp);
BN_set_bit(&bntmp, 192);
BN_div(&result, NULL, &bntmp, &result, bnctx);
dbuf = BN_bn2dec(&result);
diffret = strtod(dbuf, NULL);
OPENSSL_free(dbuf);
}
BN_clear_free(&result);
BN_clear_free(&bntmp);
BN_CTX_free(bnctx);
return diffret;
}
