gpg: Clear the symmetric passphrase cache for encrypted session keys.
[gnupg.git] / g10 / seskey.c
index 507eea1..1549017 100644 (file)
@@ -1,4 +1,4 @@
-/* seskey.c -  make sesssion keys etc.
+/* seskey.c -  make session keys etc.
  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
  *               2006, 2009, 2010 Free Software Foundation, Inc.
  *
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
 
 #include "gpg.h"
-#include "util.h"
+#include "../common/util.h"
 #include "options.h"
 #include "main.h"
-#include "i18n.h"
+#include "../common/i18n.h"
 
 
 /* Generate a new session key in *DEK that is appropriate for the
  algorithm DEK->ALGO (i.e., ensure that the key is not weak).
-
  This function overwrites DEK->KEYLEN, DEK->KEY.  The rest of the
  fields are left as is.  */
* algorithm DEK->ALGO (i.e., ensure that the key is not weak).
+ *
* This function overwrites DEK->KEYLEN, DEK->KEY.  The rest of the
* fields are left as is.  */
 void
 make_session_key( DEK *dek )
 {
@@ -70,11 +69,11 @@ make_session_key( DEK *dek )
 
 
 /* Encode the session key stored in DEK as an MPI in preparation to
  encrypt it with the public key algorithm OPENPGP_PK_ALGO with a key
  whose length (the size of the public key) is NBITS.
-
  On success, returns an MPI, which the caller must free using
  gcry_mpi_release().  */
* encrypt it with the public key algorithm OPENPGP_PK_ALGO with a key
* whose length (the size of the public key) is NBITS.
+ *
* On success, returns an MPI, which the caller must free using
* gcry_mpi_release().  */
 gcry_mpi_t
 encode_session_key (int openpgp_pk_algo, DEK *dek, unsigned int nbits)
 {
@@ -106,7 +105,7 @@ encode_session_key (int openpgp_pk_algo, DEK *dek, unsigned int nbits)
                   + 7 ) & (~7));
 
       /* alg+key+csum fit and the size is congruent to 8.  */
-      assert (!(nframe%8) && nframe > 1 + dek->keylen + 2 );
+      log_assert (!(nframe%8) && nframe > 1 + dek->keylen + 2 );
 
       frame = xmalloc_secure (nframe);
       n = 0;
@@ -117,7 +116,7 @@ encode_session_key (int openpgp_pk_algo, DEK *dek, unsigned int nbits)
       frame[n++] = csum;
       i = nframe - n;         /* Number of padded bytes.  */
       memset (frame+n, i, i); /* Use it as the value of each padded byte.  */
-      assert (n+i == nframe);
+      log_assert (n+i == nframe);
 
       if (DBG_CRYPTO)
         log_debug ("encode_session_key: "
@@ -161,7 +160,7 @@ encode_session_key (int openpgp_pk_algo, DEK *dek, unsigned int nbits)
   /* The number of random bytes are the number of otherwise unused
      bytes.  See diagram above.  */
   i = nframe - 6 - dek->keylen;
-  assert( i > 0 );
+  log_assert( i > 0 );
   p = gcry_random_bytes_secure (i, GCRY_STRONG_RANDOM);
   /* Replace zero bytes by new values.  */
   for (;;)
@@ -195,7 +194,7 @@ encode_session_key (int openpgp_pk_algo, DEK *dek, unsigned int nbits)
   n += dek->keylen;
   frame[n++] = csum >>8;
   frame[n++] = csum;
-  assert (n == nframe);
+  log_assert (n == nframe);
   if (gcry_mpi_scan( &a, GCRYMPI_FMT_USG, frame, n, &nframe))
     BUG();
   xfree (frame);
@@ -212,9 +211,12 @@ do_encode_md( gcry_md_hd_t md, int algo, size_t len, unsigned nbits,
     int i,n;
     gcry_mpi_t a;
 
-    if( len + asnlen + 4  > nframe )
-      log_bug ("can't encode a %d bit MD into a %d bits frame, algo=%d\n",
-               (int)(len*8), (int)nbits, algo);
+    if (len + asnlen + 4  > nframe)
+      {
+        log_error ("can't encode a %d bit MD into a %d bits frame, algo=%d\n",
+                   (int)(len*8), (int)nbits, algo);
+        return NULL;
+      }
 
     /* We encode the MD in this way:
      *
@@ -227,12 +229,12 @@ do_encode_md( gcry_md_hd_t md, int algo, size_t len, unsigned nbits,
     frame[n++] = 0;
     frame[n++] = 1; /* block type */
     i = nframe - len - asnlen -3 ;
-    assert( i > 1 );
+    log_assert( i > 1 );
     memset( frame+n, 0xff, i ); n += i;
     frame[n++] = 0;
     memcpy( frame+n, asn, asnlen ); n += asnlen;
     memcpy( frame+n, gcry_md_read (md, algo), len ); n += len;
-    assert( n == nframe );
+    log_assert( n == nframe );
 
     if (gcry_mpi_scan( &a, GCRYMPI_FMT_USG, frame, n, &nframe ))
        BUG();
@@ -263,8 +265,8 @@ encode_md_value (PKT_public_key *pk, gcry_md_hd_t md, int hash_algo)
   gcry_mpi_t frame;
   size_t mdlen;
 
-  assert (hash_algo);
-  assert (pk);
+  log_assert (hash_algo);
+  log_assert (pk);
 
   if (pk->pubkey_algo == PUBKEY_ALGO_EDDSA)
     {
@@ -309,7 +311,7 @@ encode_md_value (PKT_public_key *pk, gcry_md_hd_t md, int hash_algo)
 
 
       /* ECDSA 521 is special has it is larger than the largest hash
-         we have (SHA-512).  Thus we chnage the size for further
+         we have (SHA-512).  Thus we change the size for further
          processing to 512.  */
       if (pk->pubkey_algo == PUBKEY_ALGO_ECDSA && qbits > 512)
         qbits = 512;