gnutls_handshake_set_server_random -> gnutls_handshake_set_random

diff --git a/NEWS b/NEWS
index a5e8f69facd12e6c158181efdbe7fa09e6ff5336..83e1fa29d0409b2666b1b38255c9f1bca3742bc2 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -8,7 +8,7 @@ See the end for copying conditions.
 a PKCS #12 file from an encrypted key file. Reported by Yan Fiz.
 
 ** API and ABI modifications:
-No changes since last version.
+gnutls_handshake_set_random: Added
 
 
 * Version 3.1.8 (released 2013-02-10)

diff --git a/lib/gnutls_handshake.c b/lib/gnutls_handshake.c
index 83d7b3d69997ad02b65147867e86e4e064e814fe..5d216ccd19ba45029986f782dfa88f0b6e7c8bd0 100644 (file)
--- a/lib/gnutls_handshake.c
+++ b/lib/gnutls_handshake.c
@@ -168,18 +168,87 @@ resume_copy_required_values (gnutls_session_t session)
 
 }
 
-void
-_gnutls_set_server_random (gnutls_session_t session, uint8_t * rnd)
+
+/* this function will produce GNUTLS_RANDOM_SIZE==32 bytes of random data
+ * and put it to dst.
+ */
+static int
+_gnutls_tls_create_random (uint8_t * dst)
 {
-  memcpy (session->security_parameters.server_random, rnd,
-          GNUTLS_RANDOM_SIZE);
+  uint32_t tim;
+  int ret;
+
+  /* Use weak random numbers for the most of the
+   * buffer except for the first 4 that are the
+   * system's time.
+   */
+
+  tim = gnutls_time (NULL);
+  /* generate server random value */
+  _gnutls_write_uint32 (tim, dst);
+
+  ret = _gnutls_rnd (GNUTLS_RND_NONCE, &dst[4], GNUTLS_RANDOM_SIZE - 4);
+  if (ret < 0)
+    {
+      gnutls_assert ();
+      return ret;
+    }
+
+  return 0;
 }
 
-void
+int
 _gnutls_set_client_random (gnutls_session_t session, uint8_t * rnd)
 {
-  memcpy (session->security_parameters.client_random, rnd,
-          GNUTLS_RANDOM_SIZE);
+int ret;
+
+  if (rnd != NULL)
+    memcpy (session->security_parameters.client_random, rnd,
+            GNUTLS_RANDOM_SIZE);
+  else
+    {
+      /* no random given, we generate. */
+      if (session->internals.sc_random_set != 0)
+        {
+          memcpy (session->security_parameters.client_random, 
+                  session->internals.resumed_security_parameters.client_random,
+                  GNUTLS_RANDOM_SIZE);
+        }
+      else
+        {
+          ret = _gnutls_tls_create_random (session->security_parameters.client_random);
+          if (ret < 0)
+            return gnutls_assert_val(ret);
+         }
+    }
+  return 0;
+}
+
+int
+_gnutls_set_server_random (gnutls_session_t session, uint8_t * rnd)
+{
+int ret;
+
+  if (rnd != NULL)
+    memcpy (session->security_parameters.server_random, rnd,
+            GNUTLS_RANDOM_SIZE);
+  else
+    {
+      /* no random given, we generate. */
+      if (session->internals.sc_random_set != 0)
+        {
+          memcpy (session->security_parameters.server_random, 
+                  session->internals.resumed_security_parameters.server_random,
+                  GNUTLS_RANDOM_SIZE);
+        }
+      else
+        {
+          ret = _gnutls_tls_create_random (session->security_parameters.server_random);
+          if (ret < 0)
+            return gnutls_assert_val(ret);
+         }
+    }
+  return 0;
 }
 
 /* Calculate The SSL3 Finished message
@@ -301,33 +370,6 @@ _gnutls_finished (gnutls_session_t session, int type, void *ret, int sending)
                       GNUTLS_MASTER_SIZE, mesg, siz, concat, hash_len, 12, ret);
 }
 
-/* this function will produce GNUTLS_RANDOM_SIZE==32 bytes of random data
- * and put it to dst.
- */
-int
-_gnutls_tls_create_random (uint8_t * dst)
-{
-  uint32_t tim;
-  int ret;
-
-  /* Use weak random numbers for the most of the
-   * buffer except for the first 4 that are the
-   * system's time.
-   */
-
-  tim = gnutls_time (NULL);
-  /* generate server random value */
-  _gnutls_write_uint32 (tim, dst);
-
-  ret = _gnutls_rnd (GNUTLS_RND_NONCE, &dst[4], GNUTLS_RANDOM_SIZE - 4);
-  if (ret < 0)
-    {
-      gnutls_assert ();
-      return ret;
-    }
-
-  return 0;
-}
 
 /* returns the 0 on success or a negative error code.
  */
@@ -404,7 +446,7 @@ _gnutls_read_client_hello (gnutls_session_t session, uint8_t * data,
   gnutls_protocol_t adv_version;
   int neg_version;
   int len = datalen;
-  uint8_t rnd[GNUTLS_RANDOM_SIZE], *suite_ptr, *comp_ptr, *session_id;
+  uint8_t *suite_ptr, *comp_ptr, *session_id;
 
   DECR_LEN (len, 2);
 
@@ -425,20 +467,15 @@ _gnutls_read_client_hello (gnutls_session_t session, uint8_t * data,
   /* Read client random value.
    */
   DECR_LEN (len, GNUTLS_RANDOM_SIZE);
-  _gnutls_set_client_random (session, &data[pos]);
+  ret = _gnutls_set_client_random (session, &data[pos]);
+  if (ret < 0)
+    return gnutls_assert_val(ret);
+
   pos += GNUTLS_RANDOM_SIZE;
 
-  if (session->internals.server_random_set != 0) 
-    {
-      _gnutls_set_server_random (session, session->internals.resumed_security_parameters.server_random);
-      /* make sure it is used only once */
-      session->internals.server_random_set = 0;
-    }
-  else
-    {
-      _gnutls_tls_create_random (rnd);
-      _gnutls_set_server_random (session, rnd);
-    } 
+  ret = _gnutls_set_server_random (session, NULL);
+  if (ret < 0)
+    return gnutls_assert_val(ret);
 
   session->security_parameters.timestamp = gnutls_time (NULL);
 
@@ -1608,7 +1645,10 @@ _gnutls_read_server_hello (gnutls_session_t session,
   pos += 2;
 
   DECR_LEN (len, GNUTLS_RANDOM_SIZE);
-  _gnutls_set_server_random (session, &data[pos]);
+  ret = _gnutls_set_server_random (session, &data[pos]);
+  if (ret < 0)
+    return gnutls_assert_val(ret);
+
   pos += GNUTLS_RANDOM_SIZE;
 
 
@@ -1781,7 +1821,6 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
   uint8_t *data = NULL;
   int pos = 0, type;
   int datalen = 0, ret = 0;
-  uint8_t rnd[GNUTLS_RANDOM_SIZE];
   gnutls_protocol_t hver;
   gnutls_buffer_st extdata;
   int rehandshake = 0;
@@ -1876,10 +1915,11 @@ _gnutls_send_client_hello (gnutls_session_t session, int again)
       if (!IS_DTLS (session)
         || session->internals.dtls.hsk_hello_verify_requests == 0)
         {
-          _gnutls_tls_create_random (rnd);
-          _gnutls_set_client_random (session, rnd);
+          ret = _gnutls_set_client_random (session, NULL);
+          if (ret < 0)
+            return gnutls_assert_val(ret);
 
-          memcpy (&data[pos], rnd, GNUTLS_RANDOM_SIZE);
+          memcpy (&data[pos], session->security_parameters.client_random, GNUTLS_RANDOM_SIZE);
         }
       else
         memcpy (&data[pos], session->security_parameters.client_random, GNUTLS_RANDOM_SIZE);

diff --git a/lib/gnutls_handshake.h b/lib/gnutls_handshake.h
index 7b5c2f331cb51914249d246b2d1ce4e23686df83..77d163d5a0a15ca5a546df12d06791e6d17fece1 100644 (file)
--- a/lib/gnutls_handshake.h
+++ b/lib/gnutls_handshake.h
@@ -35,9 +35,8 @@ int _gnutls_recv_handshake (gnutls_session_t session,
                         gnutls_handshake_description_t type,
                         unsigned int optional, gnutls_buffer_st* buf);
 int _gnutls_generate_session_id (uint8_t * session_id, uint8_t * len);
-void _gnutls_set_server_random (gnutls_session_t session, uint8_t * rnd);
-void _gnutls_set_client_random (gnutls_session_t session, uint8_t * rnd);
-int _gnutls_tls_create_random (uint8_t * dst);
+int _gnutls_set_server_random (gnutls_session_t session, uint8_t * rnd);
+int _gnutls_set_client_random (gnutls_session_t session, uint8_t * rnd);
 
 int _gnutls_find_pk_algos_in_ciphersuites (uint8_t * data, int datalen);
 int _gnutls_server_select_suite (gnutls_session_t session, uint8_t * data,

diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index b321d6b1acf8af56a58a4096f583a94827e059bf..e5ed413609bf34a4a6af7ce9904c34f7a41cf63f 100644 (file)
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -951,7 +951,7 @@ typedef struct
   
   recv_state_t recv_state; /* state of the receive function */
   
-  unsigned int server_random_set:1;
+  unsigned int sc_random_set:1;
   
   /* If you add anything here, check _gnutls_handshake_internal_state_clear().
    */

diff --git a/lib/gnutls_state.c b/lib/gnutls_state.c
index 1145d6b4df0dfe832156c26be732c797e1b77354..831b4d1fec62d2f5536d05f7db4dfc0d1522b578 100644 (file)
--- a/lib/gnutls_state.c
+++ b/lib/gnutls_state.c
@@ -1428,13 +1428,13 @@ timespec_sub_ms (struct timespec *a, struct timespec *b)
 }
 
 /**
- * gnutls_handshake_set_server_random:
+ * gnutls_handshake_set_random:
  * @session: is a #gnutls_session_t structure.
  * @random: a random value of 32-bytes
  *
- * This function will explicitly set the server hello random value
- * in the subsequent TLS handshake. The random value should be
- * a 32-byte value.
+ * This function will explicitly set the server or client hello 
+ * random value in the subsequent TLS handshake. The random value 
+ * should be a 32-byte value.
  *
  * Note that this function should not normally be used as gnutls
  * will select automatically a random value for the handshake.
@@ -1446,13 +1446,16 @@ timespec_sub_ms (struct timespec *a, struct timespec *b)
  * Since 3.1.9
  **/
 int
-gnutls_handshake_set_server_random (gnutls_session_t session, gnutls_datum_t* random)
+gnutls_handshake_set_random (gnutls_session_t session, gnutls_datum_t* random)
 {
   if (random->size != GNUTLS_RANDOM_SIZE)
     return GNUTLS_E_INVALID_REQUEST;
   
-  session->internals.server_random_set = 1;
-  memcpy(session->internals.resumed_security_parameters.server_random, random->data, random->size);
+  session->internals.sc_random_set = 1;
+  if (session->security_parameters.entity == GNUTLS_CLIENT)
+    memcpy(session->internals.resumed_security_parameters.client_random, random->data, random->size);
+  else
+    memcpy(session->internals.resumed_security_parameters.server_random, random->data, random->size);
 
   return 0;
 }

diff --git a/lib/gnutls_v2_compat.c b/lib/gnutls_v2_compat.c
index 3d8bd85ebb3f031b4d7342954892505444b50205..82855808e2304a3a7acfb858f1d3c89c4c15d3c1 100644 (file)
--- a/lib/gnutls_v2_compat.c
+++ b/lib/gnutls_v2_compat.c
@@ -202,8 +202,6 @@ _gnutls_read_client_hello_v2 (gnutls_session_t session, uint8_t * data,
       return GNUTLS_E_INTERNAL_ERROR;
     }
 
-
-
   /* read random new values -skip session id for now */
   DECR_LEN (len, session_id_len);       /* skip session id for now */
   memcpy (session_id, &data[pos], session_id_len);
@@ -214,12 +212,14 @@ _gnutls_read_client_hello_v2 (gnutls_session_t session, uint8_t * data,
 
   memcpy (&rnd[GNUTLS_RANDOM_SIZE - challenge], &data[pos], challenge);
 
-  _gnutls_set_client_random (session, rnd);
+  ret = _gnutls_set_client_random (session, rnd);
+  if (ret < 0)
+    return gnutls_assert_val(ret);
 
   /* generate server random value */
-
-  _gnutls_tls_create_random (rnd);
-  _gnutls_set_server_random (session, rnd);
+  ret = _gnutls_set_server_random (session, NULL);
+  if (ret < 0)
+    return gnutls_assert_val(ret);
 
   session->security_parameters.timestamp = gnutls_time (NULL);
 

diff --git a/lib/includes/gnutls/gnutls.h.in b/lib/includes/gnutls/gnutls.h.in
index 1747946cbd6d59beedab6822d199e9a8d09fcb6a..c19fc5c08f262b32f31fa3db66888d7b40be7e8b 100644 (file)
--- a/lib/includes/gnutls/gnutls.h.in
+++ b/lib/includes/gnutls/gnutls.h.in
@@ -877,7 +877,7 @@ gnutls_ecc_curve_t gnutls_ecc_curve_get(gnutls_session_t session);
  */
   void gnutls_handshake_set_private_extensions (gnutls_session_t session,
                                                 int allow);
-  int gnutls_handshake_set_server_random (gnutls_session_t session, gnutls_datum_t* random);
+  int gnutls_handshake_set_random (gnutls_session_t session, gnutls_datum_t* random);
 
     gnutls_handshake_description_t
     gnutls_handshake_get_last_out (gnutls_session_t session);