[Perl-openssl-checkins] Crypt/OpenSSL/RSA RSA.xs,1.52,1.53

[<iro...@us...>]

Update of /cvsroot/perl-openssl/Crypt/OpenSSL/RSA
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv14500

Modified Files:
	RSA.xs 
Log Message:
memory leaks considered harmful

Index: RSA.xs
===================================================================
RCS file: /cvsroot/perl-openssl/Crypt/OpenSSL/RSA/RSA.xs,v
retrieving revision 1.52
retrieving revision 1.53
diff -C2 -d -r1.52 -r1.53
*** RSA.xs	19 Feb 2004 02:24:41 -0000	1.52
--- RSA.xs	19 Feb 2004 02:57:16 -0000	1.53
***************
*** 38,41 ****
--- 38,43 ----
      { PACKAGE_CROAK("unable to alloc buffer"); }
  
+ #define THROW(p_result) if (!(p_result)) { error = 1; goto err; }
+ 
  char is_private(rsaData* p_rsa)
  {
***************
*** 303,352 ****
      BIGNUM* p_minus_1;
      BIGNUM* q_minus_1;
    CODE:
  {
-     //FIXME - do a better job of cleaning up in the event of errors
- 
      if (!(n && e))
      {
          croak("At least a modulous and public key must be provided");
      }
!     rsa = RSA_new();
      rsa->n = n;
      rsa->e = e;
      if (p || q)
      {
!         ctx = BN_CTX_new();
          if (!p)
          {
!             p = BN_new();
!             CHECK_OPEN_SSL(BN_div(p, NULL, n, q, ctx))
          }
          else if (! q)
          {
              q = BN_new();
!             CHECK_OPEN_SSL(BN_div(q, NULL, n, p, ctx))
          }
          rsa->p = p;
          rsa->q = q;
!         p_minus_1 = BN_new();
!         CHECK_OPEN_SSL(BN_sub(p_minus_1, p, BN_value_one()))
!         q_minus_1 = BN_new();
!         CHECK_OPEN_SSL(BN_sub(q_minus_1, q, BN_value_one()))
          if (!d)
          {
!             d = BN_new();
!             CHECK_OPEN_SSL(BN_mul(d, p_minus_1, q_minus_1, ctx))
!             CHECK_OPEN_SSL(BN_mod_inverse(d, e, d, ctx))
          }
          rsa->d = d;
!         rsa->dmp1 = BN_new();
!         CHECK_OPEN_SSL(BN_mod(rsa->dmp1, d, p_minus_1, ctx))
!         rsa->dmq1 = BN_new();
!         CHECK_OPEN_SSL(BN_mod(rsa->dmq1, d, q_minus_1, ctx))
!         rsa->iqmp = BN_new();
!         CHECK_OPEN_SSL(BN_mod_inverse(rsa->iqmp, q, p, ctx))
!         BN_clear_free(p_minus_1);
!         BN_clear_free(q_minus_1);
!         if (RSA_check_key(rsa) != 1)
          {
              RSA_free(rsa);
--- 305,357 ----
      BIGNUM* p_minus_1;
      BIGNUM* q_minus_1;
+     int error;
    CODE:
  {
      if (!(n && e))
      {
          croak("At least a modulous and public key must be provided");
      }
!     CHECK_OPEN_SSL(rsa = RSA_new())
      rsa->n = n;
      rsa->e = e;
      if (p || q)
      {
!         error = 0;
!         THROW(ctx = BN_CTX_new());
          if (!p)
          {
!             THROW(p = BN_new());
!             THROW(BN_div(p, NULL, n, q, ctx));
          }
          else if (! q)
          {
              q = BN_new();
!             THROW(BN_div(q, NULL, n, p, ctx));
          }
          rsa->p = p;
          rsa->q = q;
!         THROW(p_minus_1 = BN_new());
!         THROW(BN_sub(p_minus_1, p, BN_value_one()));
!         THROW(q_minus_1 = BN_new());
!         THROW(BN_sub(q_minus_1, q, BN_value_one()));
          if (!d)
          {
!             THROW(d = BN_new());
!             THROW(BN_mul(d, p_minus_1, q_minus_1, ctx))
!             THROW(BN_mod_inverse(d, e, d, ctx))
          }
          rsa->d = d;
!         THROW(rsa->dmp1 = BN_new());
!         THROW(BN_mod(rsa->dmp1, d, p_minus_1, ctx))
!         THROW(rsa->dmq1 = BN_new());
!         THROW(BN_mod(rsa->dmq1, d, q_minus_1, ctx))
!         THROW(rsa->iqmp = BN_new());
!         THROW(BN_mod_inverse(rsa->iqmp, q, p, ctx))
!         THROW(RSA_check_key(rsa) == 1)
!      err:
!         if(p_minus_1) BN_clear_free(p_minus_1);
!         if(q_minus_1) BN_clear_free(q_minus_1);
!         if(ctx) BN_CTX_free(ctx);
!         if(error)
          {
              RSA_free(rsa);