streamvalidator.c

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2025 Greenbone AG
 *
 * SPDX-License-Identifier: GPL-2.0-or-later
 */
 
#include "streamvalidator.h"
 
#include "authutils.h"
 
#include <assert.h>
#include <gcrypt.h>
#include <glib.h>
#include <stdint.h>
#include <string.h>


struct gvm_stream_validator
{
  gchar *expected_hash_str;  
  gchar *expected_hash_hex;  
  int algorithm;             
  size_t expected_size;      
  size_t current_size;       
  gboolean size_enforced;    
  gcry_md_hd_t gcrypt_md_hd; 
};

const char *
gvm_stream_validator_return_str (gvm_stream_validator_return_t value)
{
  switch (value)
    {
    case GVM_STREAM_VALIDATOR_INTERNAL_ERROR:
      return "internal error";
    case GVM_STREAM_VALIDATOR_OK:
      return NULL;
    case GVM_STREAM_VALIDATOR_DATA_TOO_SHORT:
      return "too short";
    case GVM_STREAM_VALIDATOR_DATA_TOO_LONG:
      return "too long";
    case GVM_STREAM_VALIDATOR_INVALID_HASH_SYNTAX:
      return "invalid hash syntax";
    case GVM_STREAM_VALIDATOR_INVALID_HASH_ALGORITHM:
      return "invalid or unsupported hash algorithm";
    case GVM_STREAM_VALIDATOR_INVALID_HASH_VALUE:
      return "invalid hash value";
    case GVM_STREAM_VALIDATOR_HASH_MISMATCH:
      return "hash does not match";
    default:
      return "unknown error";
    }
}

gvm_stream_validator_return_t
gvm_stream_validator_new (const char *expected_hash_str,
                          gvm_stream_validator_t *validator_out)
{
  return gvm_stream_validator_with_size_new (
    expected_hash_str, GVM_STREAM_VALIDATOR_NO_SIZE, validator_out);
}

gvm_stream_validator_return_t
gvm_stream_validator_with_size_new (const char *expected_hash_str,
                                    size_t expected_size,
                                    gvm_stream_validator_t *validator_out)
{
  assert (validator_out);
 
  static GRegex *hex_regex = NULL;
  gchar **parts = NULL;
  const char *algo_str = NULL;
  const char *hex_str = NULL;
  int algo;
  unsigned int expected_hex_len;
  gcry_md_hd_t gcrypt_md_hd;
  gboolean size_enforced = FALSE;
  size_t final_expected_size = 0;
 
  if (expected_hash_str == NULL)
    return GVM_STREAM_VALIDATOR_INVALID_HASH_SYNTAX;
 
  if (hex_regex == NULL)
    hex_regex = g_regex_new ("^(?:[0-9A-Fa-f][0-9A-Fa-f])+$", 0, 0, NULL);
 
  *validator_out = NULL;
 
  parts = g_strsplit (expected_hash_str, ":", 2);
  guint n = g_strv_length (parts);
  if (n != 2)
    {
      g_strfreev (parts);
      return GVM_STREAM_VALIDATOR_INVALID_HASH_SYNTAX;
    }
  algo_str = parts[0];
  hex_str = parts[1];
 
  if (expected_size != GVM_STREAM_VALIDATOR_NO_SIZE)
    {
      final_expected_size = expected_size;
      size_enforced = TRUE;
    }
  else
    {
      final_expected_size = 0;
      size_enforced = FALSE;
    }
 
  algo = gcry_md_map_name (algo_str);
  if (algo == GCRY_MD_NONE || gcry_md_test_algo (algo))
    {
      g_strfreev (parts);
      return GVM_STREAM_VALIDATOR_INVALID_HASH_ALGORITHM;
    }
 
  expected_hex_len = gcry_md_get_algo_dlen (algo) * 2;
  if (strlen (hex_str) != expected_hex_len
      || g_regex_match (hex_regex, hex_str, 0, NULL) == FALSE)
    {
      g_strfreev (parts);
      return GVM_STREAM_VALIDATOR_INVALID_HASH_VALUE;
    }
 
  gcrypt_md_hd = NULL;
  if (gcry_md_open (&gcrypt_md_hd, algo, 0))
    {
      g_strfreev (parts);
      return GVM_STREAM_VALIDATOR_INTERNAL_ERROR;
    }
 
  *validator_out = g_malloc0 (sizeof (struct gvm_stream_validator));
  (*validator_out)->algorithm = algo;
  (*validator_out)->expected_size = final_expected_size;
  (*validator_out)->size_enforced = size_enforced;
  (*validator_out)->expected_hash_str = g_strdup (expected_hash_str);
  (*validator_out)->expected_hash_hex = g_strdup (hex_str);
  (*validator_out)->gcrypt_md_hd = gcrypt_md_hd;
  (*validator_out)->current_size = 0;
 
  g_strfreev (parts);
  return GVM_STREAM_VALIDATOR_OK;
}

void
gvm_stream_validator_rewind (gvm_stream_validator_t validator)
{
  gcry_md_reset (validator->gcrypt_md_hd);
  validator->current_size = 0;
}

void
gvm_stream_validator_free (gvm_stream_validator_t validator)
{
  gcry_md_close (validator->gcrypt_md_hd);
  g_free (validator->expected_hash_str);
  g_free (validator->expected_hash_hex);
  g_free (validator);
}

gvm_stream_validator_return_t
gvm_stream_validator_write (gvm_stream_validator_t validator, const char *data,
                            size_t length)
{
  if (validator->size_enforced)
    {
      if (length > validator->expected_size - validator->current_size)
        return GVM_STREAM_VALIDATOR_DATA_TOO_LONG;
    }
 
  gcry_md_write (validator->gcrypt_md_hd, data, length);
  validator->current_size += length;
 
  return GVM_STREAM_VALIDATOR_OK;
}

gvm_stream_validator_return_t
gvm_stream_validator_end (gvm_stream_validator_t validator)
{
  unsigned char *actual_hash_bin;
  gchar *actual_hash_hex;
 
  if (validator->size_enforced)
    {
      if (validator->current_size < validator->expected_size)
        return GVM_STREAM_VALIDATOR_DATA_TOO_SHORT;
 
      if (validator->current_size > validator->expected_size)
        return GVM_STREAM_VALIDATOR_DATA_TOO_LONG;
    }
 
  actual_hash_bin =
    gcry_md_read (validator->gcrypt_md_hd, validator->algorithm);
  actual_hash_hex = digest_hex (validator->algorithm, actual_hash_bin);
  if (strcasecmp (validator->expected_hash_hex, actual_hash_hex))
    {
      g_free (actual_hash_hex);
      return GVM_STREAM_VALIDATOR_HASH_MISMATCH;
    }
  g_free (actual_hash_hex);
 
  return GVM_STREAM_VALIDATOR_OK;
}