openssl 3.3.2 → 4.0.0

data/ext/openssl/ossl_bn.c

@@ -11,19 +11,19 @@
 #include "ossl.h"
 
 #define NewBN(klass) \
-  TypedData_Wrap_Struct((klass), &ossl_bn_type, 0)
+    TypedData_Wrap_Struct((klass), &ossl_bn_type, 0)
 #define SetBN(obj, bn) do { \
-  if (!(bn)) { \
-    ossl_raise(rb_eRuntimeError, "BN wasn't initialized!"); \
-  } \
-  RTYPEDDATA_DATA(obj) = (bn); \
+    if (!(bn)) { \
+        ossl_raise(rb_eRuntimeError, "BN wasn't initialized!"); \
+    } \
+    RTYPEDDATA_DATA(obj) = (bn); \
 } while (0)
 
 #define GetBN(obj, bn) do { \
-  TypedData_Get_Struct((obj), BIGNUM, &ossl_bn_type, (bn)); \
-  if (!(bn)) { \
-    ossl_raise(rb_eRuntimeError, "BN wasn't initialized!"); \
-  } \
+    TypedData_Get_Struct((obj), BIGNUM, &ossl_bn_type, (bn)); \
+    if (!(bn)) { \
+        ossl_raise(rb_eRuntimeError, "BN wasn't initialized!"); \
+    } \
 } while (0)
 
 static void
@@ -35,7 +35,7 @@ ossl_bn_free(void *ptr)
 static const rb_data_type_t ossl_bn_type = {
     "OpenSSL/BN",
     {
-	0, ossl_bn_free,
+        0, ossl_bn_free,
     },
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FROZEN_SHAREABLE,
 };
@@ -61,10 +61,9 @@ ossl_bn_new(const BIGNUM *bn)
     VALUE obj;
 
     obj = NewBN(cBN);
-    newbn = bn ? BN_dup(bn) : BN_new();
-    if (!newbn) {
-	ossl_raise(eBNError, NULL);
-    }
+    newbn = BN_dup(bn);
+    if (!newbn)
+        ossl_raise(eBNError, "BN_dup");
     SetBN(obj, newbn);
 
     return obj;
@@ -76,40 +75,40 @@ integer_to_bnptr(VALUE obj, BIGNUM *orig)
     BIGNUM *bn;
 
     if (FIXNUM_P(obj)) {
-	long i;
-	unsigned char bin[sizeof(long)];
-	long n = FIX2LONG(obj);
-	unsigned long un = labs(n);
-
-	for (i = sizeof(long) - 1; 0 <= i; i--) {
-	    bin[i] = un & 0xff;
-	    un >>= 8;
-	}
-
-	bn = BN_bin2bn(bin, sizeof(bin), orig);
-	if (!bn)
-	    ossl_raise(eBNError, "BN_bin2bn");
-	if (n < 0)
-	    BN_set_negative(bn, 1);
+        long i;
+        unsigned char bin[sizeof(long)];
+        long n = FIX2LONG(obj);
+        unsigned long un = labs(n);
+
+        for (i = sizeof(long) - 1; 0 <= i; i--) {
+            bin[i] = un & 0xff;
+            un >>= 8;
+        }
+
+        bn = BN_bin2bn(bin, sizeof(bin), orig);
+        if (!bn)
+            ossl_raise(eBNError, "BN_bin2bn");
+        if (n < 0)
+            BN_set_negative(bn, 1);
     }
     else { /* assuming Bignum */
-	size_t len = rb_absint_size(obj, NULL);
-	unsigned char *bin;
-	VALUE buf;
-	int sign;
-
-	if (INT_MAX < len) {
-	    rb_raise(eBNError, "bignum too long");
-	}
-	bin = (unsigned char*)ALLOCV_N(unsigned char, buf, len);
-	sign = rb_integer_pack(obj, bin, len, 1, 0, INTEGER_PACK_BIG_ENDIAN);
-
-	bn = BN_bin2bn(bin, (int)len, orig);
-	ALLOCV_END(buf);
-	if (!bn)
-	    ossl_raise(eBNError, "BN_bin2bn");
-	if (sign < 0)
-	    BN_set_negative(bn, 1);
+        size_t len = rb_absint_size(obj, NULL);
+        unsigned char *bin;
+        VALUE buf;
+        int sign;
+
+        if (INT_MAX < len) {
+            rb_raise(eBNError, "bignum too long");
+        }
+        bin = (unsigned char*)ALLOCV_N(unsigned char, buf, len);
+        sign = rb_integer_pack(obj, bin, len, 1, 0, INTEGER_PACK_BIG_ENDIAN);
+
+        bn = BN_bin2bn(bin, (int)len, orig);
+        ALLOCV_END(buf);
+        if (!bn)
+            ossl_raise(eBNError, "BN_bin2bn");
+        if (sign < 0)
+            BN_set_negative(bn, 1);
     }
 
     return bn;
@@ -122,11 +121,11 @@ try_convert_to_bn(VALUE obj)
     VALUE newobj = Qnil;
 
     if (rb_obj_is_kind_of(obj, cBN))
-	return obj;
+        return obj;
     if (RB_INTEGER_TYPE_P(obj)) {
-	newobj = NewBN(cBN); /* Handle potential mem leaks */
-	bn = integer_to_bnptr(obj, NULL);
-	SetBN(newobj, bn);
+        newobj = NewBN(cBN); /* Handle potential mem leaks */
+        bn = integer_to_bnptr(obj, NULL);
+        SetBN(newobj, bn);
     }
 
     return newobj;
@@ -140,7 +139,7 @@ ossl_bn_value_ptr(volatile VALUE *ptr)
 
     tmp = try_convert_to_bn(*ptr);
     if (NIL_P(tmp))
-	ossl_raise(rb_eTypeError, "Cannot convert into OpenSSL::BN");
+        ossl_raise(rb_eTypeError, "Cannot convert into OpenSSL::BN");
     GetBN(tmp, bn);
     *ptr = tmp;
 
@@ -210,7 +209,7 @@ ossl_bn_alloc(VALUE klass)
     VALUE obj = NewBN(klass);
 
     if (!(bn = BN_new())) {
-	ossl_raise(eBNError, NULL);
+        ossl_raise(eBNError, NULL);
     }
     SetBN(obj, bn);
 
@@ -252,7 +251,7 @@ ossl_bn_initialize(int argc, VALUE *argv, VALUE self)
     char *ptr;
 
     if (rb_scan_args(argc, argv, "11", &str, &bs) == 2) {
-	base = NUM2INT(bs);
+        base = NUM2INT(bs);
     }
 
     if (NIL_P(str)) {
@@ -261,49 +260,49 @@ ossl_bn_initialize(int argc, VALUE *argv, VALUE self)
 
     rb_check_frozen(self);
     if (RB_INTEGER_TYPE_P(str)) {
-	GetBN(self, bn);
-	integer_to_bnptr(str, bn);
+        GetBN(self, bn);
+        integer_to_bnptr(str, bn);
 
-	return self;
+        return self;
     }
 
     if (RTEST(rb_obj_is_kind_of(str, cBN))) {
-	BIGNUM *other;
-
-	GetBN(self, bn);
-	GetBN(str, other); /* Safe - we checked kind_of? above */
-	if (!BN_copy(bn, other)) {
-	    ossl_raise(eBNError, NULL);
-	}
-	return self;
+        BIGNUM *other;
+
+        GetBN(self, bn);
+        GetBN(str, other); /* Safe - we checked kind_of? above */
+        if (!BN_copy(bn, other)) {
+            ossl_raise(eBNError, NULL);
+        }
+        return self;
     }
 
     GetBN(self, bn);
     switch (base) {
-    case 0:
+      case 0:
         ptr = StringValuePtr(str);
         if (!BN_mpi2bn((unsigned char *)ptr, RSTRING_LENINT(str), bn)) {
-	    ossl_raise(eBNError, NULL);
-	}
-	break;
-    case 2:
+            ossl_raise(eBNError, NULL);
+        }
+        break;
+      case 2:
         ptr = StringValuePtr(str);
         if (!BN_bin2bn((unsigned char *)ptr, RSTRING_LENINT(str), bn)) {
-	    ossl_raise(eBNError, NULL);
-	}
-	break;
-    case 10:
-	if (!BN_dec2bn(&bn, StringValueCStr(str))) {
-	    ossl_raise(eBNError, NULL);
-	}
-	break;
-    case 16:
-	if (!BN_hex2bn(&bn, StringValueCStr(str))) {
-	    ossl_raise(eBNError, NULL);
-	}
-	break;
-    default:
-	ossl_raise(rb_eArgError, "invalid radix %d", base);
+            ossl_raise(eBNError, NULL);
+        }
+        break;
+      case 10:
+        if (!BN_dec2bn(&bn, StringValueCStr(str))) {
+            ossl_raise(eBNError, NULL);
+        }
+        break;
+      case 16:
+        if (!BN_hex2bn(&bn, StringValueCStr(str))) {
+            ossl_raise(eBNError, NULL);
+        }
+        break;
+      default:
+        ossl_raise(rb_eArgError, "invalid radix %d", base);
     }
     return self;
 }
@@ -335,32 +334,32 @@ ossl_bn_to_s(int argc, VALUE *argv, VALUE self)
     char *buf;
 
     if (rb_scan_args(argc, argv, "01", &bs) == 1) {
-	base = NUM2INT(bs);
+        base = NUM2INT(bs);
     }
     GetBN(self, bn);
     switch (base) {
-    case 0:
-	len = BN_bn2mpi(bn, NULL);
+      case 0:
+        len = BN_bn2mpi(bn, NULL);
         str = rb_str_new(0, len);
-	if (BN_bn2mpi(bn, (unsigned char *)RSTRING_PTR(str)) != len)
-	    ossl_raise(eBNError, NULL);
-	break;
-    case 2:
-	len = BN_num_bytes(bn);
+        if (BN_bn2mpi(bn, (unsigned char *)RSTRING_PTR(str)) != len)
+            ossl_raise(eBNError, NULL);
+        break;
+      case 2:
+        len = BN_num_bytes(bn);
         str = rb_str_new(0, len);
-	if (BN_bn2bin(bn, (unsigned char *)RSTRING_PTR(str)) != len)
-	    ossl_raise(eBNError, NULL);
-	break;
-    case 10:
-	if (!(buf = BN_bn2dec(bn))) ossl_raise(eBNError, NULL);
-	str = ossl_buf2str(buf, rb_long2int(strlen(buf)));
-	break;
-    case 16:
-	if (!(buf = BN_bn2hex(bn))) ossl_raise(eBNError, NULL);
-	str = ossl_buf2str(buf, rb_long2int(strlen(buf)));
-	break;
-    default:
-	ossl_raise(rb_eArgError, "invalid radix %d", base);
+        if (BN_bn2bin(bn, (unsigned char *)RSTRING_PTR(str)) != len)
+            ossl_raise(eBNError, NULL);
+        break;
+      case 10:
+        if (!(buf = BN_bn2dec(bn))) ossl_raise(eBNError, NULL);
+        str = ossl_buf2str(buf, rb_long2int(strlen(buf)));
+        break;
+      case 16:
+        if (!(buf = BN_bn2hex(bn))) ossl_raise(eBNError, NULL);
+        str = ossl_buf2str(buf, rb_long2int(strlen(buf)));
+        break;
+      default:
+        ossl_raise(rb_eArgError, "invalid radix %d", base);
     }
 
     return str;
@@ -380,7 +379,7 @@ ossl_bn_to_i(VALUE self)
     GetBN(self, bn);
 
     if (!(txt = BN_bn2hex(bn))) {
-	ossl_raise(eBNError, NULL);
+        ossl_raise(eBNError, NULL);
     }
     num = rb_cstr_to_inum(txt, 16, Qtrue);
     OPENSSL_free(txt);
@@ -398,31 +397,31 @@ static VALUE
 ossl_bn_coerce(VALUE self, VALUE other)
 {
     switch(TYPE(other)) {
-    case T_STRING:
-	self = ossl_bn_to_s(0, NULL, self);
-	break;
-    case T_FIXNUM:
-    case T_BIGNUM:
-	self = ossl_bn_to_i(self);
-	break;
-    default:
-	if (!RTEST(rb_obj_is_kind_of(other, cBN))) {
-	    ossl_raise(rb_eTypeError, "Don't know how to coerce");
-	}
+      case T_STRING:
+        self = ossl_bn_to_s(0, NULL, self);
+        break;
+      case T_FIXNUM:
+      case T_BIGNUM:
+        self = ossl_bn_to_i(self);
+        break;
+      default:
+        if (!RTEST(rb_obj_is_kind_of(other, cBN))) {
+            ossl_raise(rb_eTypeError, "Don't know how to coerce");
+        }
     }
     return rb_assoc_new(other, self);
 }
 
-#define BIGNUM_BOOL1(func)				\
-    static VALUE					\
-    ossl_bn_##func(VALUE self)				\
-    {							\
-	BIGNUM *bn;					\
-	GetBN(self, bn);				\
-	if (BN_##func(bn)) {				\
-	    return Qtrue;				\
-	}						\
-	return Qfalse;					\
+#define BIGNUM_BOOL1(func)                              \
+    static VALUE                                        \
+    ossl_bn_##func(VALUE self)                          \
+    {                                                   \
+        BIGNUM *bn;                                     \
+        GetBN(self, bn);                                \
+        if (BN_##func(bn)) {                            \
+            return Qtrue;                               \
+        }                                               \
+        return Qfalse;                                  \
     }
 
 /*
@@ -457,27 +456,27 @@ ossl_bn_is_negative(VALUE self)
 
     GetBN(self, bn);
     if (BN_is_zero(bn))
-	return Qfalse;
+        return Qfalse;
     return BN_is_negative(bn) ? Qtrue : Qfalse;
 }
 
-#define BIGNUM_1c(func)					\
-    static VALUE					\
-    ossl_bn_##func(VALUE self)				\
-    {							\
-	BIGNUM *bn, *result;				\
-	VALUE obj;					\
-	GetBN(self, bn);				\
-	obj = NewBN(rb_obj_class(self));		\
-	if (!(result = BN_new())) {			\
-	    ossl_raise(eBNError, NULL);			\
-	}						\
-	if (BN_##func(result, bn, ossl_bn_ctx) <= 0) {	\
-	    BN_free(result);				\
-	    ossl_raise(eBNError, NULL);			\
-	}						\
-	SetBN(obj, result);				\
-	return obj;					\
+#define BIGNUM_1c(func)                                 \
+    static VALUE                                        \
+    ossl_bn_##func(VALUE self)                          \
+    {                                                   \
+        BIGNUM *bn, *result;                            \
+        VALUE obj;                                      \
+        GetBN(self, bn);                                \
+        obj = NewBN(rb_obj_class(self));                \
+        if (!(result = BN_new())) {                     \
+            ossl_raise(eBNError, NULL);                 \
+        }                                               \
+        if (BN_##func(result, bn, ossl_bn_ctx) <= 0) {  \
+            BN_free(result);                            \
+            ossl_raise(eBNError, NULL);                 \
+        }                                               \
+        SetBN(obj, result);                             \
+        return obj;                                     \
     }
 
 /*
@@ -487,23 +486,23 @@ ossl_bn_is_negative(VALUE self)
  */
 BIGNUM_1c(sqr)
 
-#define BIGNUM_2(func)					\
-    static VALUE					\
-    ossl_bn_##func(VALUE self, VALUE other)		\
-    {							\
-	BIGNUM *bn1, *bn2 = GetBNPtr(other), *result;	\
-	VALUE obj;					\
-	GetBN(self, bn1);				\
-	obj = NewBN(rb_obj_class(self));		\
-	if (!(result = BN_new())) {			\
-	    ossl_raise(eBNError, NULL);			\
-	}						\
-	if (BN_##func(result, bn1, bn2) <= 0) {		\
-	    BN_free(result);				\
-	    ossl_raise(eBNError, NULL);			\
-	}						\
-	SetBN(obj, result);				\
-	return obj;					\
+#define BIGNUM_2(func)                                  \
+    static VALUE                                        \
+    ossl_bn_##func(VALUE self, VALUE other)             \
+    {                                                   \
+        BIGNUM *bn1, *bn2 = GetBNPtr(other), *result;   \
+        VALUE obj;                                      \
+        GetBN(self, bn1);                               \
+        obj = NewBN(rb_obj_class(self));                \
+        if (!(result = BN_new())) {                     \
+            ossl_raise(eBNError, NULL);                 \
+        }                                               \
+        if (BN_##func(result, bn1, bn2) <= 0) {         \
+            BN_free(result);                            \
+            ossl_raise(eBNError, NULL);                 \
+        }                                               \
+        SetBN(obj, result);                             \
+        return obj;                                     \
     }
 
 /*
@@ -520,23 +519,23 @@ BIGNUM_2(add)
  */
 BIGNUM_2(sub)
 
-#define BIGNUM_2c(func)						\
-    static VALUE						\
-    ossl_bn_##func(VALUE self, VALUE other)			\
-    {								\
-	BIGNUM *bn1, *bn2 = GetBNPtr(other), *result;		\
-	VALUE obj;						\
-	GetBN(self, bn1);					\
-	obj = NewBN(rb_obj_class(self));			\
-	if (!(result = BN_new())) {				\
-	    ossl_raise(eBNError, NULL);				\
-	}							\
-	if (BN_##func(result, bn1, bn2, ossl_bn_ctx) <= 0) {	\
-	    BN_free(result);					\
-	    ossl_raise(eBNError, NULL);				\
-	}							\
-	SetBN(obj, result);					\
-	return obj;						\
+#define BIGNUM_2c(func)                                         \
+    static VALUE                                                \
+    ossl_bn_##func(VALUE self, VALUE other)                     \
+    {                                                           \
+        BIGNUM *bn1, *bn2 = GetBNPtr(other), *result;           \
+        VALUE obj;                                              \
+        GetBN(self, bn1);                                       \
+        obj = NewBN(rb_obj_class(self));                        \
+        if (!(result = BN_new())) {                             \
+            ossl_raise(eBNError, NULL);                         \
+        }                                                       \
+        if (BN_##func(result, bn1, bn2, ossl_bn_ctx) <= 0) {    \
+            BN_free(result);                                    \
+            ossl_raise(eBNError, NULL);                         \
+        }                                                       \
+        SetBN(obj, result);                                     \
+        return obj;                                             \
     }
 
 /*
@@ -574,18 +573,18 @@ BIGNUM_2c(gcd)
  */
 BIGNUM_2c(mod_sqr)
 
-#define BIGNUM_2cr(func)					\
-    static VALUE						\
-    ossl_bn_##func(VALUE self, VALUE other)			\
-    {								\
-	BIGNUM *bn1, *bn2 = GetBNPtr(other), *result;		\
-	VALUE obj;						\
-	GetBN(self, bn1);					\
-	obj = NewBN(rb_obj_class(self));			\
-	if (!(result = BN_##func(NULL, bn1, bn2, ossl_bn_ctx)))	\
-	    ossl_raise(eBNError, NULL);				\
-	SetBN(obj, result);					\
-	return obj;						\
+#define BIGNUM_2cr(func)                                        \
+    static VALUE                                                \
+    ossl_bn_##func(VALUE self, VALUE other)                     \
+    {                                                           \
+        BIGNUM *bn1, *bn2 = GetBNPtr(other), *result;           \
+        VALUE obj;                                              \
+        GetBN(self, bn1);                                       \
+        obj = NewBN(rb_obj_class(self));                        \
+        if (!(result = BN_##func(NULL, bn1, bn2, ossl_bn_ctx))) \
+            ossl_raise(eBNError, NULL);                         \
+        SetBN(obj, result);                                     \
+        return obj;                                             \
     }
 
 /*
@@ -620,16 +619,16 @@ ossl_bn_div(VALUE self, VALUE other)
     obj1 = NewBN(klass);
     obj2 = NewBN(klass);
     if (!(r1 = BN_new())) {
-	ossl_raise(eBNError, NULL);
+        ossl_raise(eBNError, NULL);
     }
     if (!(r2 = BN_new())) {
-	BN_free(r1);
-	ossl_raise(eBNError, NULL);
+        BN_free(r1);
+        ossl_raise(eBNError, NULL);
     }
     if (!BN_div(r1, r2, bn1, bn2, ossl_bn_ctx)) {
-	BN_free(r1);
-	BN_free(r2);
-	ossl_raise(eBNError, NULL);
+        BN_free(r1);
+        BN_free(r2);
+        ossl_raise(eBNError, NULL);
     }
     SetBN(obj1, r1);
     SetBN(obj2, r2);
@@ -637,24 +636,24 @@ ossl_bn_div(VALUE self, VALUE other)
     return rb_ary_new3(2, obj1, obj2);
 }
 
-#define BIGNUM_3c(func)						\
-    static VALUE						\
-    ossl_bn_##func(VALUE self, VALUE other1, VALUE other2)	\
-    {								\
-	BIGNUM *bn1, *bn2 = GetBNPtr(other1);			\
-	BIGNUM *bn3 = GetBNPtr(other2), *result;		\
-	VALUE obj;						\
-	GetBN(self, bn1);					\
-	obj = NewBN(rb_obj_class(self));			\
-	if (!(result = BN_new())) {				\
-	    ossl_raise(eBNError, NULL);				\
-	}							\
-	if (BN_##func(result, bn1, bn2, bn3, ossl_bn_ctx) <= 0) { \
-	    BN_free(result);					\
-	    ossl_raise(eBNError, NULL);				\
-	}							\
-	SetBN(obj, result);					\
-	return obj;						\
+#define BIGNUM_3c(func)                                         \
+    static VALUE                                                \
+    ossl_bn_##func(VALUE self, VALUE other1, VALUE other2)      \
+    {                                                           \
+        BIGNUM *bn1, *bn2 = GetBNPtr(other1);                   \
+        BIGNUM *bn3 = GetBNPtr(other2), *result;                \
+        VALUE obj;                                              \
+        GetBN(self, bn1);                                       \
+        obj = NewBN(rb_obj_class(self));                        \
+        if (!(result = BN_new())) {                             \
+            ossl_raise(eBNError, NULL);                         \
+        }                                                       \
+        if (BN_##func(result, bn1, bn2, bn3, ossl_bn_ctx) <= 0) { \
+            BN_free(result);                                    \
+            ossl_raise(eBNError, NULL);                         \
+        }                                                       \
+        SetBN(obj, result);                                     \
+        return obj;                                             \
     }
 
 /*
@@ -685,17 +684,17 @@ BIGNUM_3c(mod_mul)
  */
 BIGNUM_3c(mod_exp)
 
-#define BIGNUM_BIT(func)				\
-    static VALUE					\
-    ossl_bn_##func(VALUE self, VALUE bit)		\
-    {							\
-	BIGNUM *bn;					\
-	rb_check_frozen(self);				\
-	GetBN(self, bn);				\
-	if (BN_##func(bn, NUM2INT(bit)) <= 0) {		\
-	    ossl_raise(eBNError, NULL);			\
-	}						\
-	return self;					\
+#define BIGNUM_BIT(func)                                \
+    static VALUE                                        \
+    ossl_bn_##func(VALUE self, VALUE bit)               \
+    {                                                   \
+        BIGNUM *bn;                                     \
+        rb_check_frozen(self);                          \
+        GetBN(self, bn);                                \
+        if (BN_##func(bn, NUM2INT(bit)) <= 0) {         \
+            ossl_raise(eBNError, NULL);                 \
+        }                                               \
+        return self;                                    \
     }
 
 /*
@@ -734,30 +733,30 @@ ossl_bn_is_bit_set(VALUE self, VALUE bit)
     b = NUM2INT(bit);
     GetBN(self, bn);
     if (BN_is_bit_set(bn, b)) {
-	return Qtrue;
+        return Qtrue;
     }
     return Qfalse;
 }
 
-#define BIGNUM_SHIFT(func)				\
-    static VALUE					\
-    ossl_bn_##func(VALUE self, VALUE bits)		\
-    {							\
-	BIGNUM *bn, *result;				\
-	int b;						\
-	VALUE obj;					\
-	b = NUM2INT(bits);				\
-	GetBN(self, bn);				\
-	obj = NewBN(rb_obj_class(self));		\
-	if (!(result = BN_new())) {			\
-		ossl_raise(eBNError, NULL);		\
-	}						\
-	if (BN_##func(result, bn, b) <= 0) {		\
-		BN_free(result);			\
-		ossl_raise(eBNError, NULL);		\
-	}						\
-	SetBN(obj, result);				\
-	return obj;					\
+#define BIGNUM_SHIFT(func)                              \
+    static VALUE                                        \
+    ossl_bn_##func(VALUE self, VALUE bits)              \
+    {                                                   \
+        BIGNUM *bn, *result;                            \
+        int b;                                          \
+        VALUE obj;                                      \
+        b = NUM2INT(bits);                              \
+        GetBN(self, bn);                                \
+        obj = NewBN(rb_obj_class(self));                \
+        if (!(result = BN_new())) {                     \
+                ossl_raise(eBNError, NULL);             \
+        }                                               \
+        if (BN_##func(result, bn, b) <= 0) {            \
+                BN_free(result);                        \
+                ossl_raise(eBNError, NULL);             \
+        }                                               \
+        SetBN(obj, result);                             \
+        return obj;                                     \
     }
 
 /*
@@ -774,18 +773,18 @@ BIGNUM_SHIFT(lshift)
  */
 BIGNUM_SHIFT(rshift)
 
-#define BIGNUM_SELF_SHIFT(func)				\
-    static VALUE					\
-    ossl_bn_self_##func(VALUE self, VALUE bits)		\
-    {							\
-	BIGNUM *bn;					\
-	int b;						\
-	rb_check_frozen(self);				\
-	b = NUM2INT(bits);				\
-	GetBN(self, bn);				\
-	if (BN_##func(bn, bn, b) <= 0)			\
-		ossl_raise(eBNError, NULL);		\
-	return self;					\
+#define BIGNUM_SELF_SHIFT(func)                         \
+    static VALUE                                        \
+    ossl_bn_self_##func(VALUE self, VALUE bits)         \
+    {                                                   \
+        BIGNUM *bn;                                     \
+        int b;                                          \
+        rb_check_frozen(self);                          \
+        b = NUM2INT(bits);                              \
+        GetBN(self, bn);                                \
+        if (BN_##func(bn, bn, b) <= 0)                  \
+                ossl_raise(eBNError, NULL);             \
+        return self;                                    \
     }
 
 /*
@@ -887,32 +886,32 @@ ossl_bn_s_generate_prime(int argc, VALUE *argv, VALUE klass)
     num = NUM2INT(vnum);
 
     if (vsafe == Qfalse) {
-	safe = 0;
+        safe = 0;
     }
     if (!NIL_P(vadd)) {
-	add = GetBNPtr(vadd);
-	rem = NIL_P(vrem) ? NULL : GetBNPtr(vrem);
+        add = GetBNPtr(vadd);
+        rem = NIL_P(vrem) ? NULL : GetBNPtr(vrem);
     }
     obj = NewBN(klass);
     if (!(result = BN_new())) {
-	ossl_raise(eBNError, NULL);
+        ossl_raise(eBNError, NULL);
     }
     if (!BN_generate_prime_ex(result, num, safe, add, rem, NULL)) {
-	BN_free(result);
-	ossl_raise(eBNError, NULL);
+        BN_free(result);
+        ossl_raise(eBNError, NULL);
     }
     SetBN(obj, result);
 
     return obj;
 }
 
-#define BIGNUM_NUM(func)			\
-    static VALUE 				\
-    ossl_bn_##func(VALUE self)			\
-    {						\
-	BIGNUM *bn;				\
-	GetBN(self, bn);			\
-	return INT2NUM(BN_##func(bn));		\
+#define BIGNUM_NUM(func)                        \
+    static VALUE                                \
+    ossl_bn_##func(VALUE self)                  \
+    {                                           \
+        BIGNUM *bn;                             \
+        GetBN(self, bn);                        \
+        return INT2NUM(BN_##func(bn));          \
     }
 
 /*
@@ -929,6 +928,7 @@ BIGNUM_NUM(num_bytes)
  */
 BIGNUM_NUM(num_bits)
 
+/* :nodoc: */
 static VALUE
 ossl_bn_copy(VALUE self, VALUE other)
 {
@@ -942,7 +942,7 @@ ossl_bn_copy(VALUE self, VALUE other)
     bn2 = GetBNPtr(other);
 
     if (!BN_copy(bn1, bn2)) {
-	ossl_raise(eBNError, NULL);
+        ossl_raise(eBNError, NULL);
     }
     return self;
 }
@@ -961,7 +961,7 @@ ossl_bn_uplus(VALUE self)
     obj = NewBN(cBN);
     bn2 = BN_dup(bn1);
     if (!bn2)
-	ossl_raise(eBNError, "BN_dup");
+        ossl_raise(eBNError, "BN_dup");
     SetBN(obj, bn2);
 
     return obj;
@@ -981,7 +981,7 @@ ossl_bn_uminus(VALUE self)
     obj = NewBN(cBN);
     bn2 = BN_dup(bn1);
     if (!bn2)
-	ossl_raise(eBNError, "BN_dup");
+        ossl_raise(eBNError, "BN_dup");
     SetBN(obj, bn2);
     BN_set_negative(bn2, !BN_is_negative(bn2));
 
@@ -1006,13 +1006,13 @@ ossl_bn_abs(VALUE self)
     }
 }
 
-#define BIGNUM_CMP(func)				\
-    static VALUE					\
-    ossl_bn_##func(VALUE self, VALUE other)		\
-    {							\
-	BIGNUM *bn1, *bn2 = GetBNPtr(other);		\
-	GetBN(self, bn1);				\
-	return INT2NUM(BN_##func(bn1, bn2));		\
+#define BIGNUM_CMP(func)                                \
+    static VALUE                                        \
+    ossl_bn_##func(VALUE self, VALUE other)             \
+    {                                                   \
+        BIGNUM *bn1, *bn2 = GetBNPtr(other);            \
+        GetBN(self, bn1);                               \
+        return INT2NUM(BN_##func(bn1, bn2));            \
     }
 
 /*
@@ -1049,11 +1049,11 @@ ossl_bn_eq(VALUE self, VALUE other)
     GetBN(self, bn1);
     other = try_convert_to_bn(other);
     if (NIL_P(other))
-	return Qfalse;
+        return Qfalse;
     GetBN(other, bn2);
 
     if (!BN_cmp(bn1, bn2)) {
-	return Qtrue;
+        return Qtrue;
     }
     return Qfalse;
 }
@@ -1072,7 +1072,7 @@ ossl_bn_eql(VALUE self, VALUE other)
     BIGNUM *bn1, *bn2;
 
     if (!rb_obj_is_kind_of(other, cBN))
-	return Qfalse;
+        return Qfalse;
     GetBN(self, bn1);
     GetBN(other, bn2);
 
@@ -1099,8 +1099,8 @@ ossl_bn_hash(VALUE self)
     len = BN_num_bytes(bn);
     buf = ALLOCV(tmp, len);
     if (BN_bn2bin(bn, buf) != len) {
-	ALLOCV_END(tmp);
-	ossl_raise(eBNError, "BN_bn2bin");
+        ALLOCV_END(tmp);
+        ossl_raise(eBNError, "BN_bn2bin");
     }
 
     hash = ST2FIX(rb_memhash(buf, len));
@@ -1202,11 +1202,6 @@ ossl_bn_set_flags(VALUE self, VALUE arg)
 void
 Init_ossl_bn(void)
 {
-#if 0
-    mOSSL = rb_define_module("OpenSSL");
-    eOSSLError = rb_define_class_under(mOSSL, "OpenSSLError", rb_eStandardError);
-#endif
-
 #ifdef HAVE_RB_EXT_RACTOR_SAFE
     ossl_bn_ctx_key = rb_ractor_local_storage_ptr_newkey(&ossl_bn_ctx_key_type);
 #else