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; }