 @@ -256,122 +256,36 @@ int BN_dec2bn(BIGNUM **bn, const char *a
     bn_correct_top(ret);
     *bn = ret;
     bn_check_top(ret);
     /* Don't set the negative flag if it's zero. */
     if (ret->top != 0)
         ret->neg = neg;
     return num;
  err:
     if (*bn == NULL)
         BN_free(ret);
     return 0;
+}
 int BN_oct2bn(BIGNUM **bn, const char *a)
     BIGNUM *ret = NULL;
     BN_ULONG l = 0;
     int neg = 0, h, m, i, j, b, k, c, r;
     int num;
     if (a == NULL || *a == '\0')
         return 0;
     if (*a == '-') {
         neg = 1;
         a++;
     for (i = 0; i <= INT_MAX / 4 && ossl_isdigit(a[i]) && a[i] < '8'; i++)
         continue;
     if (i == 0 || i > INT_MAX / 4)
         goto err;
     num = i + neg;
     if (bn == NULL)
         return num;
     /* a is the start of the hex digits, and it is 'i' long */
     if (*bn == NULL) {
         if ((ret = BN_new()) == NULL)
             return 0;
     } else {
         ret = *bn;
         BN_zero(ret);
     /* i is the number of hex digits */
     if (bn_expand(ret, i * 4) == NULL)
         goto err;
     j = i;                      /* least significant 'oct' */
     h = 0;
     b = 0;
 #define M (BN_BYTES * 8 / 3)
     while (j > 0) {
         m = (M <= j) ? M : j;
 	while (m > 0) {
 	    k = a[j - m] - '0';
 	    l = (l << 3) | k;
 	    b += 3;
 	    m--;
         j -= M;
 	if (j <= 0) {
 	    ret->d[h++] = l;
 	    break;
 	b = BN_BYTES * 8 - b;
 	r = 3 - b;
 	k = a[j--] - '0';
 	l = (l << r) | (k >> b);
 	ret->d[h++] = l;
 	l = k & ((2 << r) - 1);
 	if (j == 0) {
 	    ret->d[h++] = l;
 	    break;
     ret->top = h;
     bn_correct_top(ret);
     *bn = ret;
     bn_check_top(ret);
     /* Don't set the negative flag if it's zero. */
     if (ret->top != 0)
         ret->neg = neg;
     return num;
  err:
     if (*bn == NULL)
         BN_free(ret);
     return 0;
 int BN_asc2bn(BIGNUM **bn, const char *a)
+{
     const char *p = a;
     if (*p == '-')
         p++;
-    if (p[0] == '0') {
+    if (p[0] == '0' && (p[1] == 'X' || p[1] == 'x')) {
-	if (p[1] == 'X' || p[1] == 'x') {
+        if (!BN_hex2bn(bn, p + 2))
-	    if (!BN_hex2bn(bn, p + 2))
+            return 0;
 		return 0;
 	} else {
 	    if (!BN_oct2bn(bn, p + 1))
 		return 0;
     } else {
         if (!BN_dec2bn(bn, p))
             return 0;
+    }
     /* Don't set the negative flag if it's zero. */
     if (*a == '-' && (*bn)->top != 0)
         (*bn)->neg = 1;
     return 1;
+}
 # ifndef OPENSSL_NO_STDIO
 int BN_print_fp(FILE *fp, const BIGNUM *a)
+{

 @@ -300,27 +300,26 @@ int BN_print_fp(FILE *fp, const BIGNUM *
 int BN_print(BIO *bio, const BIGNUM *a);
 int BN_reciprocal(BIGNUM *r, const BIGNUM *m, int len, BN_CTX *ctx);
 int BN_rshift(BIGNUM *r, const BIGNUM *a, int n);
 int BN_rshift1(BIGNUM *r, const BIGNUM *a);
 void BN_clear(BIGNUM *a);
 BIGNUM *BN_dup(const BIGNUM *a);
 int BN_ucmp(const BIGNUM *a, const BIGNUM *b);
 int BN_set_bit(BIGNUM *a, int n);
 int BN_clear_bit(BIGNUM *a, int n);
 char *BN_bn2hex(const BIGNUM *a);
 char *BN_bn2dec(const BIGNUM *a);
 int BN_hex2bn(BIGNUM **a, const char *str);
 int BN_dec2bn(BIGNUM **a, const char *str);
 int BN_oct2bn(BIGNUM **a, const char *str);
 int BN_asc2bn(BIGNUM **a, const char *str);
 int BN_gcd(BIGNUM *r, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx);
 int BN_kronecker(const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx); /* returns
                                                                   * -2 for
                                                                   * error */
 BIGNUM *BN_mod_inverse(BIGNUM *ret,
                        const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
 BIGNUM *BN_mod_sqrt(BIGNUM *ret,
                     const BIGNUM *a, const BIGNUM *n, BN_CTX *ctx);
 void BN_consttime_swap(BN_ULONG swap, BIGNUM *a, BIGNUM *b, int nwords);
 /* Deprecated versions */

 @@ -542,27 +542,26 @@ OPENSSL_1_1_0 {
         BN_mpi2bn;
         BN_mul;
         BN_mul_word;
         BN_new;
         BN_nist_mod_192;
         BN_nist_mod_224;
         BN_nist_mod_256;
         BN_nist_mod_384;
         BN_nist_mod_521;
         BN_nist_mod_func;
         BN_nnmod;
         BN_num_bits;
         BN_num_bits_word;
         BN_oct2bn;
         BN_options;
         BN_print;
         BN_print_fp;
         BN_pseudo_rand;
         BN_pseudo_rand_range;
         BN_rand;
         BN_rand_range;
         BN_reciprocal;
         BN_rshift1;
         BN_rshift;
         BN_secure_new;
         BN_security_bits;
         BN_set_bit;