From: Nikos Mavrogiannopoulos <nmav@gnutls.org>
Date: Tue, 12 Feb 2013 19:09:20 +0000 (+0100)
Subject: gnutls_handshake_set_server_random -> gnutls_handshake_set_random
X-Git-Tag: gnutls_3_1_9~32
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=07605a8776d0e85bf451420a17203db0df7ea1cc;p=thirdparty%2Fgnutls.git

gnutls_handshake_set_server_random -> gnutls_handshake_set_random
---

diff --git a/NEWS b/NEWS
index a5e8f69fac..83e1fa29d0 100644
--- 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 83d7b3d699..5d216ccd19 100644
--- 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 7b5c2f331c..77d163d5a0 100644
--- 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 b321d6b1ac..e5ed413609 100644
--- 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 1145d6b4df..831b4d1fec 100644
--- 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 3d8bd85ebb..82855808e2 100644
--- 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 1747946cbd..c19fc5c08f 100644
--- 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);