Remove redundant comments

Your code has a lot of comments, most of them are just explaining what the C language does. But a programmer should already know that. Limit what you put in comments to what would not be obvious to the average programmer. Too many useless comments will actually make the code harder to read, which is the opposite of what you try to achieve.

For example, don't explain what size_t and uint8_t are, and don't explain how out parameters work.

I can understand if you add these comments for yourself while you are learning C, but I would remove them in a final version of the program.

Use Doxygen format to document your API

It is good that do you document in comments what the parameter passed to gteMessage() is, and what the return value is. However, it would be even better if you do this in Doxygen's format. That way, Doxygen's tools can parse the comments and produce documentation in various formats such as HTML and PDF, they can verify that you documented all parameters and return values, and some code editors might even be able to use it to help with code completion and contextual help texts.

Use the right types

Since the message is always in JSON format, which is a textual format, I would use char* instead of uint8_t* to point to the message data. If you would turn on compiler warnings, you should have seen that passing a uint8_t* to strlen() is not correct.

Since the length of these messages will always be passed as 32-bits, use uint32_t consistently: inputLength should be uint32_t*.

Choose between NUL-termination or an explicit length

Your getMessage() returns both the actual message and its length, but sendMessage() only takes a pointer to the message. How does the latter know the length of the message? From reading the code, it turns out you always expect messages to be NUL-terminated. But then, why return the length from getMessage() at all?

I would choose one way to deal with the length, and use that consistently. So either:

char* getMessage(uint32_t *inputLength);
void sendMessage(char *reponse, uint32_t outputLength);

Or:

char* getMessage(void);
void sendMessage(char *reponse);

Missing error handling

Your code does not check if sending and receiving actually succeeded. Any number of things can go wrong, and if you ignore the return value of fread() and fwrite(), your application can incorrectly think it sent or received a complete message, which can have bad consequences.

It's not just fread() and fwrite(): calloc() can fail to allocate memory, and even fflush() can fail. Read the documentation of these functions to find out what can go wrong and what they return in that case.

When you do get an error, you have to deal with it appropriately. This probably means having the return value indicate success or failure somehow, like returning a NULL from getMessage() on failure, and a bool from sendMessage(). The caller is then responsible for checking the return value and deciding how to handle the problem.

Example code

This is how the code could look with all the comments above implemented. There's a lot of error checking, but that is just what you should do for input and output.

#include <stdint.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static const uint32_t max_message_size = 64 * 1024 * 1024;

/**
 * Get a message in Chrome's native messaging format
 *
 * @return A pointer to the message if succesful, `NULL` otherwise.
 *         The caller is responsible for freeing the message using
 *         free().
 */
char* getMessage(void) {
  // Read the size of the message
  uint32_t size;
  size_t result = fread(&size, sizeof size, 1, stdin);
  if (result != 1) {
    return NULL;
  }

  // Check if the size is valid
  if (size > max_message_size) {
    return NULL;
  }

  // Allocate memory for the message and the terminating NUL-byte
  char *message = malloc(size + 1);
  if (!message) {
    return NULL;
  }

  // Read the message itself
  result = fread(message, size, 1, stdin);
  if (result != 1) {
    free(message);
    return NULL;
  }

  // Ensure the message is NUL-terminated
  message[size] = '\0';
  return message;
}

/**
 * Send a message in Chrome's native messaging format
 *
 * @param message A pointer to the message.
                  It must be a NUL-terminated string.
 * @return        `true` if the message was sent succesfully,
                  `false` otherwise.
 */
bool sendMessage(const char* message) {
  // Write the size of the message
  const uint32_t size = strlen(message);
  if (fwrite(&size, sizeof size, 1, stdout) != 1) {
      return false;
  }

  // Write the message itself
  if (fwrite(message, size, 1, stdout) != 1) {
      return false;
  }

  // Flush the output to ensure the message is sent completely
  return fflush(stdout) == 0;
}

int main(void) {
  while (true) {
    char* message = getMessage();
    if (!message) {
      perror("Could not read message");
      return EXIT_FAILURE;
    }

    bool sent = sendMessage(message);
    free(message);

    if (!sent) {
      perror("Could not send message");
      return EXIT_FAILURE;
    }
  }
}