wip

Author: julek-wolfssl

src/dtls13.c

@@ -2706,9 +2706,28 @@ int Dtls13DoScheduledWork(WOLFSSL* ssl)
     ret = wc_UnLockMutex(&ssl->dtls13Rtx.mutex);
 #endif
     if (sendAcks) {
-        ret = SendDtls13Ack(ssl);
-        if (ret != 0)
-            return ret;
+#ifdef HAVE_WRITE_DUP
+        /* The read side cannot encrypt.  Transfer the seenRecords list to the
+         * shared WriteDup struct so the write side sends the ACK instead. */
+        if (ssl->dupWrite && ssl->dupSide == READ_DUP_SIDE) {
+            if (wc_LockMutex(&ssl->dupWrite->dupMutex) == 0) {
+                struct Dtls13RecordNumber** tail =
+                    (struct Dtls13RecordNumber**)&ssl->dupWrite->sendAckList;
+                while (*tail != NULL)
+                    tail = &(*tail)->next;
+                *tail = ssl->dtls13Rtx.seenRecords;
+                ssl->dtls13Rtx.seenRecords = NULL;
+                ssl->dupWrite->sendAcks = 1;
+                wc_UnLockMutex(&ssl->dupWrite->dupMutex);
+            }
+        }
+        else
+#endif /* HAVE_WRITE_DUP */
+        {
+            ret = SendDtls13Ack(ssl);
+            if (ret != 0)
+                return ret;
+        }
     }
 
     if (ssl->dtls13Rtx.retransmit) {

src/ssl.c

@@ -748,6 +748,17 @@ void FreeWriteDup(WOLFSSL* ssl)
 
     if (doFree) {
         WOLFSSL_MSG("Doing WriteDup full free, count to zero");
+#ifdef WOLFSSL_DTLS13
+        /* Free any pending ACK list that was never consumed by the write side */
+        {
+            struct Dtls13RecordNumber* rn = ssl->dupWrite->sendAckList;
+            while (rn != NULL) {
+                struct Dtls13RecordNumber* next = rn->next;
+                XFREE(rn, ssl->heap, DYNAMIC_TYPE_DTLS_MSG);
+                rn = next;
+            }
+        }
+#endif
         wc_FreeMutex(&ssl->dupWrite->dupMutex);
         XFREE(ssl->dupWrite, ssl->heap, DYNAMIC_TYPE_WRITEDUP);
     }
@@ -2480,6 +2491,39 @@ static int wolfSSL_write_internal(WOLFSSL* ssl, const void* data, size_t sz)
             ssl->error = dupErr;
             return WOLFSSL_FATAL_ERROR;
         }
+
+#ifdef WOLFSSL_DTLS13
+        /* DTLS 1.3: the read side cannot encrypt, so it delegates ACK sending
+         * to the write side.  Check if an ACK was requested and send it. */
+        if (ssl->dupWrite && ssl->dupSide == WRITE_DUP_SIDE &&
+                ssl->options.dtls && IsAtLeastTLSv1_3(ssl->version)) {
+            byte ackNeeded = 0;
+
+            if (wc_LockMutex(&ssl->dupWrite->dupMutex) == 0) {
+                ackNeeded = ssl->dupWrite->sendAcks;
+                if (ackNeeded) {
+                    /* Claim the seenRecords list from the shared struct and
+                     * append to our own (write side always has an empty list). */
+                    struct Dtls13RecordNumber** tail =
+                        (struct Dtls13RecordNumber**)&ssl->dtls13Rtx.seenRecords;
+                    while (*tail != NULL)
+                        tail = &(*tail)->next;
+                    *tail = ssl->dupWrite->sendAckList;
+                    ssl->dupWrite->sendAckList = NULL;
+                    ssl->dupWrite->sendAcks = 0;
+                }
+                wc_UnLockMutex(&ssl->dupWrite->dupMutex);
+            }
+
+            if (ackNeeded) {
+                ret = SendDtls13Ack(ssl);
+                if (ret != 0) {
+                    ssl->error = ret;
+                    return WOLFSSL_FATAL_ERROR;
+                }
+            }
+        }
+#endif /* WOLFSSL_DTLS13 */
     }
 #endif
 

tests/api.c

@@ -32012,7 +32012,7 @@ static int test_write_dup(void)
 {
     EXPECT_DECLS;
 #if defined(HAVE_MANUAL_MEMIO_TESTS_DEPENDENCIES) && defined(HAVE_WRITE_DUP)
-    size_t i, j;
+    size_t i, j, k;
     char hiWorld[] = "dup message";
     char readData[sizeof(hiWorld) + 5];
     struct {
@@ -32132,6 +32132,35 @@ static int test_write_dup(void)
                     WC_NO_ERR_TRACE(WRITE_DUP_READ_E));
             ExpectIntEQ(wolfSSL_read(ssl_c, readData, sizeof(readData)),
                     sizeof(hiWorld));
+#ifdef WOLFSSL_DTLS13
+            /* After ssl_c (read side) processes the post-handshake
+             * NewSessionTicket it must have delegated the ACK to the
+             * write side via the shared WriteDup struct. */
+            if (ssl_c != NULL && ssl_c->options.dtls &&
+                    IsAtLeastTLSv1_3(ssl_c->version) &&
+                    ssl_c->dupWrite != NULL)
+                ExpectIntEQ(ssl_c->dupWrite->sendAcks, 1);
+#endif
+
+            for (k = 0; k < 10; k++) {
+                ExpectIntEQ(wolfSSL_write(ssl_c2, hiWorld, sizeof(hiWorld)),
+                        sizeof(hiWorld));
+                ExpectIntEQ(wolfSSL_read(ssl_s, readData, sizeof(readData)),
+                        sizeof(hiWorld));
+#ifdef WOLFSSL_DTLS13
+                /* On the first iteration the write side must have sent the
+                 * ACK for the NewSessionTicket.  Once the server reads it,
+                 * its retransmit list for the NST must be empty. */
+                if (k == 0 && ssl_s != NULL && ssl_c != NULL &&
+                        ssl_c->options.dtls &&
+                        IsAtLeastTLSv1_3(ssl_c->version))
+                    ExpectNull(ssl_s->dtls13Rtx.rtxRecords);
+#endif
+                ExpectIntEQ(wolfSSL_write(ssl_s, hiWorld, sizeof(hiWorld)),
+                        sizeof(hiWorld));
+                ExpectIntEQ(wolfSSL_read(ssl_c, readData, sizeof(readData)),
+                        sizeof(hiWorld));
+            }
 
             if (EXPECT_SUCCESS())
                 printf("ok\n");

wolfssl/internal.h

@@ -5759,6 +5759,12 @@ typedef struct BuildMsgArgs {
         wolfSSL_Mutex   dupMutex;       /* reference count mutex */
         int             dupCount;       /* reference count */
         int             dupErr;         /* under dupMutex, pass to other side */
+#ifdef WOLFSSL_DTLS13
+        /* DTLS 1.3: read side cannot encrypt, so it passes ACK work to the
+         * write side.  Protected by dupMutex. */
+        byte            sendAcks;
+        struct Dtls13RecordNumber* sendAckList; /* ownership transferred */
+#endif
     } WriteDup;
 
     WOLFSSL_LOCAL void FreeWriteDup(WOLFSSL* ssl);