diff --git a/src/msgbuf.h b/src/msgbuf.h
index 691d9a6..f81eb13 100644
--- a/src/msgbuf.h
+++ b/src/msgbuf.h
@@ -52,9 +52,24 @@
 #include <string.h>
 #include <sys/types.h>
 
+/*
+ * We can't use static_assert() outside of some other C construct. Deal
+ * with high-level global assertions by burying them in an unused struct
+ * declaration, that has a sole member for compliance with the requirement that
+ * types must have a size.
+*/
+static struct {
+	static_assert(
+		INTMAX_MAX != SIZE_MAX,
+		"Extraction and insertion value comparisons may be broken");
+	static_assert(INTMAX_MIN + INTMAX_MAX <= 0,
+		      "Extraction and insertion arithmetic may be broken");
+	int compliance;
+} build_assertions __attribute__((unused));
+
 struct pldm_msgbuf {
 	uint8_t *cursor;
-	ssize_t remaining;
+	intmax_t remaining;
 };
 
 /**
@@ -76,16 +91,22 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	if ((minsize > len) || (len > SSIZE_MAX)) {
+	if ((minsize > len)) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
+#if INTMAX_MAX < SIZE_MAX
+	if (len > INTMAX_MAX) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+#endif
+
 	if ((uintptr_t)buf + len < len) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
 
 	ctx->cursor = (uint8_t *)buf;
-	ctx->remaining = (ssize_t)len;
+	ctx->remaining = (intmax_t)len;
 
 	return PLDM_SUCCESS;
 }
@@ -290,6 +311,10 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	if (ctx->remaining == INTMAX_MIN) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(uint8_t);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -312,6 +337,10 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	if (ctx->remaining == INTMAX_MIN) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(int8_t);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -336,6 +365,16 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	// Check for underflow while tracking the magnitude of the buffer overflow
+	static_assert(
+		// NOLINTNEXTLINE(bugprone-sizeof-expression)
+		sizeof(ldst) < INTMAX_MAX,
+		"The following addition may not uphold the runtime assertion");
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(ldst)) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+
 	// Check for buffer overflow. If we overflow, account for the request as
 	// negative values in ctx->remaining. This way we can debug how far
 	// we've overflowed.
@@ -376,6 +415,14 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	static_assert(
+		// NOLINTNEXTLINE(bugprone-sizeof-expression)
+		sizeof(ldst) < INTMAX_MAX,
+		"The following addition may not uphold the runtime assertion");
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(ldst)) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(ldst);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -404,6 +451,14 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	static_assert(
+		// NOLINTNEXTLINE(bugprone-sizeof-expression)
+		sizeof(ldst) < INTMAX_MAX,
+		"The following addition may not uphold the runtime assertion");
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(ldst)) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(ldst);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -431,6 +486,14 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	static_assert(
+		// NOLINTNEXTLINE(bugprone-sizeof-expression)
+		sizeof(ldst) < INTMAX_MAX,
+		"The following addition may not uphold the runtime assertion");
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(ldst)) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(ldst);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -462,6 +525,14 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	static_assert(
+		// NOLINTNEXTLINE(bugprone-sizeof-expression)
+		sizeof(ldst) < INTMAX_MAX,
+		"The following addition may not uphold the runtime assertion");
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(ldst)) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(ldst);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -525,11 +596,16 @@
 		return PLDM_SUCCESS;
 	}
 
-	if (count >= SSIZE_MAX) {
+#if INTMAX_MAX < SIZE_MAX
+	if (count > INTMAX_MAX) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
+#endif
 
-	ctx->remaining -= (ssize_t)count;
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)count) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+	ctx->remaining -= (intmax_t)count;
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
 		return PLDM_ERROR_INVALID_LENGTH;
@@ -554,6 +630,14 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	static_assert(
+		// NOLINTNEXTLINE(bugprone-sizeof-expression)
+		sizeof(src) < INTMAX_MAX,
+		"The following addition may not uphold the runtime assertion");
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -575,6 +659,14 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	static_assert(
+		// NOLINTNEXTLINE(bugprone-sizeof-expression)
+		sizeof(src) < INTMAX_MAX,
+		"The following addition may not uphold the runtime assertion");
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -594,6 +686,14 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	static_assert(
+		// NOLINTNEXTLINE(bugprone-sizeof-expression)
+		sizeof(src) < INTMAX_MAX,
+		"The following addition may not uphold the runtime assertion");
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -615,6 +715,14 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	static_assert(
+		// NOLINTNEXTLINE(bugprone-sizeof-expression)
+		sizeof(src) < INTMAX_MAX,
+		"The following addition may not uphold the runtime assertion");
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -636,6 +744,14 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	static_assert(
+		// NOLINTNEXTLINE(bugprone-sizeof-expression)
+		sizeof(src) < INTMAX_MAX,
+		"The following addition may not uphold the runtime assertion");
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -655,6 +771,14 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
+	static_assert(
+		// NOLINTNEXTLINE(bugprone-sizeof-expression)
+		sizeof(src) < INTMAX_MAX,
+		"The following addition may not uphold the runtime assertion");
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)sizeof(src)) {
+		assert(ctx->remaining < 0);
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
 	ctx->remaining -= sizeof(src);
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
@@ -688,11 +812,16 @@
 		return PLDM_SUCCESS;
 	}
 
-	if (count >= SSIZE_MAX) {
+#if INTMAX_MAX < SIZE_MAX
+	if (count > INTMAX_MAX) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
+#endif
 
-	ctx->remaining -= (ssize_t)count;
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)count) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+	ctx->remaining -= (intmax_t)count;
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
 		return PLDM_ERROR_INVALID_LENGTH;
@@ -715,11 +844,16 @@
 		return PLDM_ERROR_INVALID_DATA;
 	}
 
-	if (required > SSIZE_MAX) {
+#if INTMAX_MAX < SIZE_MAX
+	if (required > INTMAX_MAX) {
 		return PLDM_ERROR_INVALID_LENGTH;
 	}
+#endif
 
-	ctx->remaining -= (ssize_t)required;
+	if (ctx->remaining < INTMAX_MIN + (intmax_t)required) {
+		return PLDM_ERROR_INVALID_LENGTH;
+	}
+	ctx->remaining -= (intmax_t)required;
 	assert(ctx->remaining >= 0);
 	if (ctx->remaining < 0) {
 		return PLDM_ERROR_INVALID_LENGTH;