feat: hold a real mutual-TLS session to the broker from bring-up

The other half. The device now opens a session to the broker at bring-up, over
lwIP's raw TCP and mbedTLS, with the credentials DeviceCertStore already holds —
and never closes it. Held rather than opened-and-closed on purpose: two sessions
that do not overlap measure max(), not sum(), and it is the sum that says what a
second session costs.

  flash_text    361,736 -> 362,968   (+1,232)
  static_bss    133,152 -> 157,280  (+24,128)
  mbedtls_peak   22,208 ->  37,224  (+15,016)
  heap_used       4,440 ->   4,440

The last line is the point of the exercise. mbedTLS's buffer used to peak at
22,208 bytes with SolidSyslog's session in it and nothing else; with the
device's own session open alongside it, 37,224. So a second concurrent session
costs about 15,000 bytes, not 22,208 — the difference is the parsed
certificates, the DRBG and the rest of the first session's one-off state, which
a device speaking mTLS has paid for already. Once the baseline is regenerated it
will hold that first session, and what SolidSyslog is charged for TLS memory
becomes the marginal figure, measured rather than argued.

"About", because mbedtls_peak is not byte-reproducible. Five runs of this image
gave 37,152 / 37,224 / 37,236 / 37,244 / 37,248 — a spread wider than the run's
64-byte drift tolerance, for the same reason heap_used moves: gen-certs.sh
builds a fresh PKI every run and DER lengths shift with the key material. The
figures above are the two committed run reports, so the arithmetic is checkable;
the marginal cost it yields is good to about a hundred bytes, not to the byte.
That has to be settled before the baseline is frozen with this key in it.
flash_text and static_bss are exact.

The static RAM growth is almost entirely the buffer: 32 KiB to 55 KiB, which is
the peak times 1.5 rounded up to the next KiB. The margin is not padding —
buffer_alloc hands out contiguous space, and 24 KiB against a 22.2 KiB peak
failed on fragmentation where 32 KiB worked. The remaining 576 bytes are the ssl
context, its config, and the TCP state.

The keep-alive list loses the mbedTLS client surface and most of the TCP entries,
because the session calls them for real now and naming a function there that the
device runs would say something untrue. Flash did not move for it: those call
closures were in the image either way, which is what the list was for. What stays
is what is still unexercised — UDP, the file API, and the teardown path a session
held for the life of the device never reaches.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: DavidCozens

CMakeLists.txt

@@ -141,6 +141,7 @@ endforeach()
 add_executable(baseline
     ${APP_DIR}/main.c
     ${APP_DIR}/sim/SimulatedExistingApp.c
+    ${APP_DIR}/sim/SimulatedBrokerSession.c
     ${APP_DIR}/tasks/LogTask.c
     ${APP_DIR}/tasks/ServiceTask.c
     ${APP_DIR}/measure/Measure.c
@@ -187,8 +188,8 @@ target_include_directories(baseline PRIVATE
     ${FATFS_STAGE_DIR}
 )
 
-# sim/SimulatedExistingApp.c includes <mbedtls/ssl.h> — it MUST see the same user
-# config as the library, or context struct sizes diverge between consumer and library.
+# app/sim includes <mbedtls/ssl.h> — it MUST see the same user config as the
+# library, or context struct sizes diverge between consumer and library.
 target_compile_definitions(baseline PRIVATE MBEDTLS_USER_CONFIG_FILE=${MBEDTLS_USER_CONFIG_HEADER})
 
 # SolidSyslog is the Core library (a real .a); the SolidSyslog::* packs are

app/AppConfig.h

@@ -42,9 +42,12 @@
  * the report prints absolutes for us to commit as the baseline. */
 #define BASELINE_FILE_PATH "measurements/Baseline.csv"
 
-/* The static buffer mbedTLS sub-allocates from. Sized from the high-water mark the
- * device reports, so a step that asks more of mbedTLS grows this and is charged for
- * it — the baseline holds no spare capacity on a later step's behalf. */
-#define SIMULATED_APP_MBEDTLS_HEAP_BYTES (32 * 1024)
+/* The static buffer mbedTLS sub-allocates from. Sized at the high-water mark the
+ * device reports times 1.5, rounded up to the next KiB — buffer_alloc hands out
+ * contiguous space, so a buffer only a little over the peak fails on
+ * fragmentation rather than on capacity. One rule, applied again at every step
+ * that asks more of mbedTLS, so the baseline holds no spare capacity on a later
+ * step's behalf and each step is charged what it actually added. */
+#define SIMULATED_APP_MBEDTLS_HEAP_BYTES (55 * 1024)
 
 #endif /* APP_CONFIG_H */

app/main.c

@@ -2,8 +2,8 @@
  * with ZERO SolidSyslog.
  *
  * This is the "simulated existing application": a device that already networks,
- * already uses storage, and has TLS on board — the frozen platform SolidSyslog's
- * footprint deltas are measured against. main() is deliberately thin: it starts
+ * already uses storage, and already holds a TLS session — the frozen platform
+ * SolidSyslog's footprint deltas are measured against. main() is deliberately thin: it starts
  * the console, creates the two idle application seams (a log source and a service
  * worker), and hands off to a harness task that brings up the simulated existing
  * application, measures the cost above the frozen baseline, and exits.
@@ -68,7 +68,7 @@ static void HarnessTask(void* parameters)
     (void) printf("[device] starting simulated existing application...\n");
     bool simReady = SimulatedExistingApp_Start();
     (void) printf(
-        "[device]   sim app (lwIP up, FatFs mounted, mTLS credentials loaded, mbedTLS linked): %s\n",
+        "[device]   sim app (lwIP up, FatFs mounted, broker session held over mTLS): %s\n",
         simReady ? "ready" : "FAILED"
     );