src/microhttpd/test_dauth_malformed.c - master - githubmirror/libmicrohttpd

src/microhttpd/test_dauth_malformed.c
1 248 строк40 KB
Christian Grothoff
expand test suite, add CI/CD logic as done in other GNUnet projects
28 июл 2026, 13:36
28 июл 2026, 13:36e34baa3
/*
     This file is part of libmicrohttpd
     Copyright (C) 2026 Christian Grothoff

     libmicrohttpd is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published
     by the Free Software Foundation; either version 2, or (at your
     option) any later version.

     libmicrohttpd is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with libmicrohttpd; see the file COPYING.  If not, write to the
     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
*/
/**
 * @file test_dauth_malformed.c
 * @brief  Testcase for malformed Digest "Authorization:" request headers
 * @author Christian Grothoff
 *
 * The malformed headers used by this test cannot be produced with libcurl,
 * therefore all the requests are sent over a raw socket.
 *
 * The test is a regression test for two remotely triggerable defects:
 *
 * - An unrecognised "algorithm=" token is parsed to
 *   #MHD_DIGEST_AUTH_ALGO3_INVALID, the numeric value of which is zero.  The
 *   "is the client's algorithm allowed by the application" bit-mask test is
 *   passed trivially by a zero value, so an invalid algorithm used to reach
 *   digest_init_one_time(), which aborts the process with MHD_PANIC().
 *
 * - The "response=" value was hex-decoded into a #MAX_DIGEST bytes long
 *   buffer on the stack, while the only length check allowed four times as
 *   many characters as the digest size, resulting in an out-of-bounds stack
 *   write of up to #MAX_DIGEST bytes.  Reaching the decoder requires an
 *   otherwise complete and valid Digest handshake, hence the two-step
 *   exchange performed by this test.
 *
 * A number of adjacent malformed, empty, over-long and duplicated parameters
 * is checked as well.  Every sub-case must leave the daemons alive and must
 * be answered with a regular HTTP error reply.
 *
 * Two daemons are used: one that issues SHA-256 challenges and one that
 * issues the challenges with the default "any non-session" algorithm.  This
 * keeps the length of the nonces recorded by a single daemon uniform, which
 * is what a real-world application does as well.
 *
 * The test honours the daemon option matrix of mhd_opt_matrix.h: when one of
 * the MHD_TEST_* environment variables selects a profile, its connection
 * memory limit, client discipline level, threading mode and polling backend
 * are applied to both daemons.  Without those variables nothing changes.  A
 * Digest handshake needs room for a 76 character nonce plus the realm, the
 * username and the response, so a profile asking for less than
 * #MIN_POOL_FOR_TEST bytes is raised to that value and the adjustment is
 * reported.
 */

#include "MHD_config.h"
#include "platform.h"
#include <microhttpd.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdint.h>
#include <errno.h>

#ifdef HAVE_STRINGS_H
#include <strings.h>
#endif /* HAVE_STRINGS_H */

#ifndef WINDOWS
#include <unistd.h>
#include <sys/socket.h>
#endif

#include "mhd_sockets.h" /* only macros used */
#include "mhd_opt_matrix.h"
/* Turn any MHD_PANIC() or failing mhd_assert() reached from this
   test into a marked, classifiable test error (TESTING.md, P5). */
#include "mhd_panic_tripwire.h"

/**
 * The smallest connection memory pool this test can work with: a complete
 * Digest "Authorization:" header plus the "WWW-Authenticate:" challenge of
 * the reply do not fit into a smaller pool.
 */
#define MIN_POOL_FOR_TEST 4096

#ifndef MHD_STATICSTR_LEN_
/**
 * Determine length of static string / macro strings at compile time.
 */
#define MHD_STATICSTR_LEN_(macro) (sizeof(macro) / sizeof(char) - 1)
#endif /* ! MHD_STATICSTR_LEN_ */

#if defined(DAUTH_SUPPORT) && defined(MHD_SHA256_SUPPORT)

/**
 * The realm used by the test daemons.
 */
#define TEST_REALM "TestRealm"

/**
 * The username known to the test daemons.
 */
#define TEST_USERNAME "testuser"

/**
 * The password known to the test daemons.
 */
#define TEST_PASSWORD "testpass"

/**
 * The URL used by all the requests.
 */
#define TEST_URL "/auth"

/**
 * The size of the buffer used to build a request.
 */
#define REQ_BUF_SIZE 32768

/**
 * The size of the buffer used to receive a reply.
 */
#define RPLY_BUF_SIZE 8192

/**
 * The length of the over-long parameter values.
 */
#define LONG_PARAM_LEN 4000

/**
 * Socket send/receive timeout in seconds.
 */
#define SOCK_TIMEOUT_SEC 5

/**
 * The number of the "nonce"/"nc" pairs recorded by a daemon.
 */
#define NONCE_NC_SIZE 100


/**
 * The port of the daemon issuing SHA-256 challenges.
 */
static uint16_t port_sha256;

/**
 * The port of the daemon issuing "any non-session" (MD5) challenges.
 */
static uint16_t port_any;

/**
 * The port used by the sub-case being executed.
 */
static uint16_t test_port;

/**
 * The number of the sub-case being executed.
 */
static unsigned int case_num;

/**
 * The number of the failed sub-cases.
 */
static unsigned int failures;

/**
 * The 'nc' value for the next request, incremented for every request so that
 * a "nonce"/"nc" combination is never re-used.
 */
static unsigned int nc_counter;

/**
 * Run only the sub-cases with a name containing this string, NULL for all.
 */
static const char *case_filter;

/**
 * Set to non-zero by the daemon if a malformed request was authenticated.
 */
static volatile int wrongly_authenticated;

/**
 * The profile selected by the environment, NULL if the built-in daemon
 * configuration is used (which is the case for a stock "make check").
 */
static const struct MHD_OptMatrixProfile *test_prof;

/**
 * The (possibly adjusted) copy of the profile @a test_prof points to.
 */
static struct MHD_OptMatrixProfile test_prof_copy;


_MHD_NORETURN static void
hard_error (const char *msg)
{
  fprintf (stderr,
           "Hard error: %s\n",
           msg);
  fflush (stderr);
  exit (99);
}


/**
 * Fill @a buf with @a len hexadecimal digits and zero-terminate it.
 *
 * @param[out] buf the buffer to fill, must be at least @a len + 1 bytes long
 * @param len the number of the hexadecimal digits to generate
 * @return the @a buf pointer
 */
static char *
fill_hex (char *buf,
          size_t len)
{
  static const char hex_chars[] = "0123456789abcdef";
  size_t i;

  for (i = 0; i < len; ++i)
    buf[i] = hex_chars[i % (MHD_STATICSTR_LEN_ (hex_chars))];
  buf[len] = 0;
  return buf;
}


/**
 * Fill @a buf with @a len copies of @a chr and zero-terminate it.
 *
 * @param[out] buf the buffer to fill, must be at least @a len + 1 bytes long
 * @param chr the character to repeat
 * @param len the number of the characters to generate
 * @return the @a buf pointer
 */
static char *
fill_chr (char *buf,
          char chr,
          size_t len)
{
  memset (buf, chr, len);
  buf[len] = 0;
  return buf;
}


/* * * * * * * * * * * *  The daemon side  * * * * * * * * * * * */

static enum MHD_Result
ahc_check (void *cls,
           struct MHD_Connection *connection,
           const char *url,
           const char *method,
           const char *version,
           const char *upload_data,
           size_t *upload_data_size,
           void **req_cls)
{
  static int marker;
  const enum MHD_DigestAuthMultiAlgo3 *const challenge_algo = cls;
  struct MHD_Response *response;
  enum MHD_DigestAuthResult check_res;
  enum MHD_Result ret;
  (void) url; (void) method; (void) version; (void) upload_data;
  (void) upload_data_size;

  if (&marker != *req_cls)
  { /* The first call for the request */
    *req_cls = &marker;
    return MHD_YES;
  }

  check_res =
    MHD_digest_auth_check3 (connection,
                            TEST_REALM,
                            TEST_USERNAME,
                            TEST_PASSWORD,
                            300,
                            0,
                            MHD_DIGEST_AUTH_MULT_QOP_ANY_NON_INT,
                            MHD_DIGEST_AUTH_MULT_ALGO3_ANY_NON_SESSION);
  if (MHD_DAUTH_OK == check_res)
  { /* None of the sub-cases must be authenticated */
    static const char page[] = "Authenticated";

    wrongly_authenticated = 1;
    response =
      MHD_create_response_from_buffer (MHD_STATICSTR_LEN_ (page),
                                       (void *) page,
                                       MHD_RESPMEM_PERSISTENT);
    if (NULL == response)
      return MHD_NO;
    ret = MHD_queue_response (connection,
                              MHD_HTTP_OK,
                              response);
    MHD_destroy_response (response);
    return ret;
  }

  if (1)
  {
    static const char page[] = "Access denied";

    response =
      MHD_create_response_from_buffer (MHD_STATICSTR_LEN_ (page),
                                       (void *) page,
                                       MHD_RESPMEM_PERSISTENT);
    if (NULL == response)
      return MHD_NO;
    ret =
      MHD_queue_auth_required_response3 (connection,
                                         TEST_REALM,
                                         "test-opaque",
                                         NULL,
                                         response,
                                         (MHD_DAUTH_NONCE_STALE == check_res) ?
                                         MHD_YES : MHD_NO,
                                         MHD_DIGEST_AUTH_MULT_QOP_ANY_NON_INT,
                                         *challenge_algo,
                                         MHD_YES,
                                         MHD_NO);
    MHD_destroy_response (response);
  }
  return ret;
}


/* * * * * * * * * * * *  The raw client side  * * * * * * * * * * * */

/**
 * Send @a req to the daemon at #test_port and receive the complete reply.
 *
 * @param req the request to send, zero-terminated
 * @param[out] rply the buffer for the reply
 * @param rply_size the size of the @a rply buffer
 * @return the number of the received bytes,
 *         -1 if no reply has been received
 */
static ssize_t
exchange (const char *req,
          char *rply,
          size_t rply_size)
{
  MHD_socket sckt;
  struct sockaddr_in sa;
  struct timeval tmo;
  size_t req_len;
  size_t sent;
  size_t received;

  sckt = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (MHD_INVALID_SOCKET == sckt)
    hard_error ("socket() failed");

  tmo.tv_sec = SOCK_TIMEOUT_SEC;
  tmo.tv_usec = 0;
  if ( (0 != setsockopt (sckt, SOL_SOCKET, SO_RCVTIMEO,
                         (const void *) &tmo, sizeof (tmo))) ||
       (0 != setsockopt (sckt, SOL_SOCKET, SO_SNDTIMEO,
                         (const void *) &tmo, sizeof (tmo))) )
    hard_error ("setsockopt() failed");

  memset (&sa, 0, sizeof (sa));
  sa.sin_family = AF_INET;
  sa.sin_port = htons (test_port);
  sa.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
  if (0 != connect (sckt, (const struct sockaddr *) &sa, sizeof (sa)))
  {
    MHD_socket_close_chk_ (sckt);
    return -1;
  }

  req_len = strlen (req);
  sent = 0;
  while (sent < req_len)
  {
    ssize_t res;

    res = send (sckt, req + sent, req_len - sent, 0);
    if (0 >= res)
      break;
    sent += (size_t) res;
  }
  if (sent != req_len)
  {
    MHD_socket_close_chk_ (sckt);
    return -1;
  }

  received = 0;
  while (received + 1 < rply_size)
  {
    ssize_t res;

    res = recv (sckt, rply + received, rply_size - received - 1, 0);
    if (0 >= res)
      break;
    received += (size_t) res;
  }
  rply[received] = 0;
  MHD_socket_close_chk_ (sckt);
  if (0 == received)
    return -1;
  return (ssize_t) received;
}


/**
 * Extract the HTTP status code from a raw reply.
 *
 * @param rply the reply, zero-terminated
 * @return the status code, zero if the reply is not a valid HTTP reply
 */
static unsigned int
get_status (const char *rply)
{
  unsigned int status;

  if (MHD_STATICSTR_LEN_ ("HTTP/1.1 000") > strlen (rply))
    return 0;
  if (0 != memcmp (rply, "HTTP/1.", MHD_STATICSTR_LEN_ ("HTTP/1.")))
    return 0;
  status = 0;
  if (1 != sscanf (rply + MHD_STATICSTR_LEN_ ("HTTP/1.1 "), "%3u", &status))
    return 0;
  return status;
}


/**
 * Request a challenge from the daemon at #test_port and extract the "nonce"
 * value from it.
 *
 * @param[out] nonce the buffer for the "nonce" value
 * @param nonce_size the size of the @a nonce buffer
 * @return non-zero on success, zero on failure
 */
static int
get_nonce (char *nonce,
           size_t nonce_size)
{
  static const char nonce_tk[] = "nonce=\"";
  static const char req[] =
    "GET " TEST_URL " HTTP/1.1\r\n"
    "Host: 127.0.0.1\r\n"
    "Connection: close\r\n"
    "\r\n";
  char rply[RPLY_BUF_SIZE];
  const char *start;
  const char *end;
  size_t len;

  if (0 >= exchange (req, rply, sizeof (rply)))
    return 0;
  if (MHD_HTTP_UNAUTHORIZED != get_status (rply))
    return 0;
  start = strstr (rply, nonce_tk);
  if (NULL == start)
    return 0;
  start += MHD_STATICSTR_LEN_ (nonce_tk);
  end = strchr (start, '"');
  if (NULL == end)
    return 0;
  len = (size_t) (end - start);
  if (len + 1 > nonce_size)
    return 0;
  memcpy (nonce, start, len);
  nonce[len] = 0;
  return 0 != len;
}


/**
 * Obtain a "nonce" or fail the whole test.
 *
 * @param[out] nonce the buffer for the "nonce" value
 * @param nonce_size the size of the @a nonce buffer
 */
static void
need_nonce (char *nonce,
            size_t nonce_size)
{
  if (! get_nonce (nonce, nonce_size))
    hard_error ("cannot obtain a 'nonce' from the daemon");
}


/**
 * Run a single sub-case: send a request with the given "Authorization:"
 * header value and check that the daemon replies with a regular HTTP error.
 *
 * @param name the name of the sub-case, used for reporting
 * @param auth_fmt the printf-style format of the "Authorization:" header
 *                 value, NULL to send no "Authorization:" header
 * @param ... the arguments for the @a auth_fmt
 */
static void
run_case (const char *name,
          const char *auth_fmt,
          ...)
{
  static char req[REQ_BUF_SIZE];
  static char auth[REQ_BUF_SIZE - 512];
  char rply[RPLY_BUF_SIZE];
  unsigned int status;

  ++case_num;
  if ( (NULL != case_filter) &&
       (NULL == strstr (name, case_filter)) )
    return;

  /* Report the sub-case before it is executed: if the daemon aborts the
     process, the last reported sub-case is the failing one. */
  fprintf (stderr,
           "[%02u] %s\n",
           case_num,
           name);
  fflush (stderr);

  if (NULL != auth_fmt)
  {
    va_list ap;

    va_start (ap, auth_fmt);
    vsnprintf (auth, sizeof (auth), auth_fmt, ap);
    va_end (ap);
    snprintf (req, sizeof (req),
              "GET " TEST_URL " HTTP/1.1\r\n"
              "Host: 127.0.0.1\r\n"
              "Connection: close\r\n"
              "Authorization: %s\r\n"
              "\r\n",
              auth);
  }
  else
    snprintf (req, sizeof (req),
              "GET " TEST_URL " HTTP/1.1\r\n"
              "Host: 127.0.0.1\r\n"
              "Connection: close\r\n"
              "\r\n");

  if (0 >= exchange (req, rply, sizeof (rply)))
  {
    fprintf (stderr,
             "FAILED sub-case '%s': no reply received.\n",
             name);
    fflush (stderr);
    ++failures;
    return;
  }
  status = get_status (rply);
  /* Any regular HTTP error reply is fine: the point of the test is that the
     daemon neither crashes nor accepts the malformed credentials. */
  if ( (MHD_HTTP_UNAUTHORIZED != status) &&
       (MHD_HTTP_BAD_REQUEST != status) &&
       (MHD_HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE != status) )
  {
    fprintf (stderr,
             "FAILED sub-case '%s': unexpected HTTP status %u.\n",
             name,
             status);
    fflush (stderr);
    ++failures;
    return;
  }
  if (0 != wrongly_authenticated)
  {
    fprintf (stderr,
             "FAILED sub-case '%s': the malformed request was "
             "authenticated.\n",
             name);
    fflush (stderr);
    wrongly_authenticated = 0;
    ++failures;
  }
}


/**
 * Build the common part of an otherwise valid Digest "Authorization:" header.
 *
 * @param[out] buf the buffer to fill
 * @param buf_size the size of the @a buf
 * @param nonce the "nonce" value received from the daemon
 */
static void
make_valid_params (char *buf,
                   size_t buf_size,
                   const char *nonce)
{
  snprintf (buf, buf_size,
            "username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"" TEST_URL "\", qop=auth, nc=%08x, "
            "cnonce=\"0123456789abcdef\"",
            nonce,
            ++nc_counter);
}


/* * * * * * * * * * * *  The sub-cases  * * * * * * * * * * * */

/**
 * Sub-cases for the missing #MHD_DIGEST_AUTH_ALGO3_INVALID check.
 *
 * An unknown "algorithm=" token is parsed to
 * #MHD_DIGEST_AUTH_ALGO3_INVALID, which has the numeric value of zero and
 * therefore satisfies the "allowed algorithms" bit-mask test.  Without the
 * explicit check for the invalid value the request reaches
 * digest_init_one_time() and aborts the process with MHD_PANIC().
 *
 * The algorithm is checked before anything else, so most of the sub-cases
 * need no other parameter at all.
 */
static void
test_invalid_algorithm (void)
{
  char nonce[256];
  char params[512];
  char resp[128];

  fill_hex (resp, 64);

  test_port = port_any;

  run_case ("bug-c/algo-bogus-alone",
            "Digest algorithm=BOGUS");
  run_case ("bug-c/algo-md5-x",
            "Digest algorithm=MD5-x");
  run_case ("bug-c/algo-sha512",
            "Digest algorithm=SHA-512");
  run_case ("bug-c/algo-sha1",
            "Digest algorithm=SHA1");
  run_case ("bug-c/algo-sha256-typo",
            "Digest algorithm=SHA256");
  run_case ("bug-c/algo-empty-quotes",
            "Digest algorithm=\"\"");
  run_case ("bug-c/algo-empty-token",
            "Digest algorithm=");
  run_case ("bug-c/algo-empty-token-comma",
            "Digest algorithm=, nonce=\"deadbeef\"");
  run_case ("bug-c/algo-quoted-bogus",
            "Digest algorithm=\"BOGUS\"");
  run_case ("bug-c/algo-space",
            "Digest algorithm = BOGUS");
  /* A backslash inside the value marks the parameter as "quoted", which
     selects the second, separate branch of the algorithm token parser. */
  run_case ("bug-c/algo-escaped-bogus",
            "Digest algorithm=\"\\BOGUS\"");
  run_case ("bug-c/algo-escaped-md5-x",
            "Digest algorithm=\"MD5\\-x\"");
  /* The "-sess" variants are valid tokens, but they are rejected by the
     bit-mask test as they are not allowed by the application. */
  run_case ("bug-c/algo-md5-sess",
            "Digest algorithm=MD5-sess");
  run_case ("bug-c/algo-sha256-sess",
            "Digest algorithm=SHA-256-sess");
  run_case ("bug-c/algo-sha512-256-sess",
            "Digest algorithm=SHA-512-256-sess");
  run_case ("bug-c/algo-escaped-md5-sess",
            "Digest algorithm=\"MD5\\-sess\"");
  run_case ("bug-c/algo-escaped-sha512-256",
            "Digest algorithm=\"SHA\\-512-256\"");
  /* The last occurrence of a duplicated parameter is the effective one. */
  run_case ("bug-c/algo-duplicated",
            "Digest algorithm=MD5, algorithm=BOGUS");
  run_case ("bug-c/algo-duplicated-rev",
            "Digest algorithm=BOGUS, algorithm=MD5");

  /* The same, but with all the other parameters present and valid, so that
     nothing else can short-circuit the check. */
  test_port = port_sha256;

  need_nonce (nonce, sizeof (nonce));
  make_valid_params (params, sizeof (params), nonce);
  run_case ("bug-c/algo-bogus-full",
            "Digest %s, algorithm=BOGUS, response=\"%s\"",
            params,
            resp);

  need_nonce (nonce, sizeof (nonce));
  make_valid_params (params, sizeof (params), nonce);
  run_case ("bug-c/algo-empty-full",
            "Digest %s, algorithm=\"\", response=\"%s\"",
            params,
            resp);

  need_nonce (nonce, sizeof (nonce));
  make_valid_params (params, sizeof (params), nonce);
  run_case ("bug-c/algo-escaped-bogus-full",
            "Digest %s, algorithm=\"\\BOGUS\", response=\"%s\"",
            params,
            resp);
}


/**
 * Sub-cases for the out-of-bounds stack write in the "response=" hex decoder.
 *
 * The decoder writes (len + 1) / 2 bytes into a #MAX_DIGEST (32) bytes long
 * stack buffer, while the length sanity check accepts up to digest_size * 4
 * (128) characters.  All the other parameters must be valid to reach the
 * decoder, therefore a fresh "nonce" is obtained for every sub-case.
 */
static void
test_overlong_response (void)
{
  /* 128 and 127 characters produce the maximum overflow of 32 bytes, 66 and
     65 characters produce the minimum overflow of a single byte, 64
     characters fit exactly and must not overflow. */
  static const size_t resp_lengths[] = { 128, 127, 100, 66, 65, 64 };
  char nonce[256];
  char params[512];
  char resp[512];
  char name[128];
  size_t i;

  test_port = port_sha256;

  for (i = 0; i < sizeof (resp_lengths) / sizeof (resp_lengths[0]); ++i)
  {
    const size_t len = resp_lengths[i];

    /* The value without the quotation marks */
    need_nonce (nonce, sizeof (nonce));
    make_valid_params (params, sizeof (params), nonce);
    snprintf (name, sizeof (name),
              "bug-d/sha256-response-%u-bare",
              (unsigned) len);
    run_case (name,
              "Digest %s, algorithm=SHA-256, response=%s",
              params,
              fill_hex (resp, len));

    /* The same value in the quotation marks */
    need_nonce (nonce, sizeof (nonce));
    make_valid_params (params, sizeof (params), nonce);
    snprintf (name, sizeof (name),
              "bug-d/sha256-response-%u-quoted",
              (unsigned) len);
    run_case (name,
              "Digest %s, algorithm=SHA-256, response=\"%s\"",
              params,
              fill_hex (resp, len));
  }

  /* A backslash marks the value as "quoted", so it is unquoted into the
     temporal buffer first and only then decoded. */
  need_nonce (nonce, sizeof (nonce));
  make_valid_params (params, sizeof (params), nonce);
  run_case ("bug-d/sha256-response-127-escaped",
            "Digest %s, algorithm=SHA-256, response=\"\\%s\"",
            params,
            fill_hex (resp, 127));

  /* The SHA-512/256 algorithm uses the same digest size as SHA-256 and the
     same nonce length, so it reaches the decoder as well. */
#ifdef MHD_SHA512_256_SUPPORT
  need_nonce (nonce, sizeof (nonce));
  make_valid_params (params, sizeof (params), nonce);
  run_case ("bug-d/sha512-256-response-128-bare",
            "Digest %s, algorithm=SHA-512-256, response=%s",
            params,
            fill_hex (resp, 128));
#endif /* MHD_SHA512_256_SUPPORT */

  /* The RFC2069 mode: no "qop", no "nc" and no "cnonce". */
  need_nonce (nonce, sizeof (nonce));
  run_case ("bug-d/sha256-response-128-rfc2069",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"" TEST_URL "\", algorithm=SHA-256, "
            "response=%s",
            nonce,
            fill_hex (resp, 128));

  /* The value is not a valid hexadecimal string, the decoder must bail out
     before writing anything. */
  need_nonce (nonce, sizeof (nonce));
  make_valid_params (params, sizeof (params), nonce);
  run_case ("bug-d/sha256-response-128-non-hex",
            "Digest %s, algorithm=SHA-256, response=%s",
            params,
            fill_chr (resp, 'z', 128));

  /* Only the last character is not a hexadecimal digit, so the decoder
     writes 63 bytes before it detects the error. */
  need_nonce (nonce, sizeof (nonce));
  make_valid_params (params, sizeof (params), nonce);
  fill_hex (resp, 128);
  resp[127] = 'z';
  run_case ("bug-d/sha256-response-128-tail-non-hex",
            "Digest %s, algorithm=SHA-256, response=%s",
            params,
            resp);

  /* Duplicated parameter: the last (over-long) value is the effective one. */
  need_nonce (nonce, sizeof (nonce));
  make_valid_params (params, sizeof (params), nonce);
  run_case ("bug-d/sha256-response-duplicated",
            "Digest %s, algorithm=SHA-256, response=\"00112233\", response=%s",
            params,
            fill_hex (resp, 128));

#ifdef MHD_MD5_SUPPORT
  /* The MD5 variant: the decoder writes 32 bytes, which overflows the buffer
     only in an MD5-only build, where MAX_DIGEST is 16. */
  test_port = port_any;

  need_nonce (nonce, sizeof (nonce));
  make_valid_params (params, sizeof (params), nonce);
  run_case ("bug-d/md5-response-64-bare",
            "Digest %s, algorithm=MD5, response=%s",
            params,
            fill_hex (resp, 64));

  need_nonce (nonce, sizeof (nonce));
  make_valid_params (params, sizeof (params), nonce);
  run_case ("bug-d/md5-response-63-bare",
            "Digest %s, algorithm=MD5, response=%s",
            params,
            fill_hex (resp, 63));

  need_nonce (nonce, sizeof (nonce));
  make_valid_params (params, sizeof (params), nonce);
  run_case ("bug-d/md5-response-34-quoted",
            "Digest %s, algorithm=MD5, response=\"%s\"",
            params,
            fill_hex (resp, 34));
#endif /* MHD_MD5_SUPPORT */
}


/**
 * Sub-cases for the adjacent malformed, empty, over-long and duplicated
 * parameters.
 */
static void
test_adjacent (void)
{
  static char big[LONG_PARAM_LEN + 1];
  char nonce[256];
  char resp[128];

  fill_hex (resp, 64);

  /* No or unusable "Authorization:" header.  These never reach the
     "nonce" handling, the daemon used does not matter. */
  test_port = port_any;

  run_case ("adj/no-auth-header", NULL);
  run_case ("adj/scheme-only", "Digest");
  run_case ("adj/scheme-and-space", "Digest ");
  run_case ("adj/only-commas", "Digest ,,,,");
  run_case ("adj/basic-scheme", "Basic dGVzdHVzZXI6dGVzdHBhc3M=");
  run_case ("adj/unknown-scheme", "Bogus xyz");
  run_case ("adj/unterminated-quote",
            "Digest username=\"" TEST_USERNAME);
  run_case ("adj/unterminated-quote-escape",
            "Digest username=\"" TEST_USERNAME "\\\"");
  run_case ("adj/no-equal-sign", "Digest username");
  run_case ("adj/leading-equal-sign", "Digest =value");
  run_case ("adj/semicolon-in-value", "Digest username=a;b");
  run_case ("adj/garbage-after-value", "Digest username=\"a\" garbage");
  run_case ("adj/unknown-parameter",
            "Digest bogus=\"x\", username=\"" TEST_USERNAME "\"");

  /* Over-long parameter values */
  run_case ("adj/username-too-long",
            "Digest username=\"%s\", realm=\"" TEST_REALM "\"",
            fill_chr (big, 'u', LONG_PARAM_LEN));
  run_case ("adj/realm-too-long",
            "Digest username=\"" TEST_USERNAME "\", realm=\"%s\"",
            fill_chr (big, 'r', LONG_PARAM_LEN));
  run_case ("adj/uri-too-long",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "uri=\"%s\"",
            fill_chr (big, 'p', LONG_PARAM_LEN));
  run_case ("adj/cnonce-too-long",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "qop=auth, nc=00000001, cnonce=\"%s\"",
            fill_chr (big, 'c', LONG_PARAM_LEN));
  run_case ("adj/nc-too-long",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "qop=auth, nc=%s, cnonce=\"abc\"",
            fill_hex (big, LONG_PARAM_LEN));
  run_case ("adj/opaque-too-long",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "opaque=\"%s\"",
            fill_chr (big, 'o', LONG_PARAM_LEN));
  run_case ("adj/nonce-too-long",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\"",
            fill_hex (big, LONG_PARAM_LEN));
  run_case ("adj/response-too-long",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "response=\"%s\"",
            fill_hex (big, LONG_PARAM_LEN));
  run_case ("adj/username-ext-too-long",
            "Digest username*=UTF-8''%s, realm=\"" TEST_REALM "\"",
            fill_chr (big, 'e', LONG_PARAM_LEN));

  /* The extended ("username*") notation */
  run_case ("adj/username-ext-truncated",
            "Digest username*=U, realm=\"" TEST_REALM "\"");
  run_case ("adj/username-ext-no-lang",
            "Digest username*=UTF-8', realm=\"" TEST_REALM "\"");
  run_case ("adj/username-ext-empty",
            "Digest username*=UTF-8'', realm=\"" TEST_REALM "\"");
  run_case ("adj/username-ext-broken-pct",
            "Digest username*=UTF-8''%%, realm=\"" TEST_REALM "\"");
  run_case ("adj/username-ext-broken-pct2",
            "Digest username*=UTF-8''%%z, realm=\"" TEST_REALM "\"");
  run_case ("adj/username-ext-broken-pct3",
            "Digest username*=UTF-8''%%zz, realm=\"" TEST_REALM "\"");
  run_case ("adj/username-ext-trailing-pct",
            "Digest username*=UTF-8''abc%%, realm=\"" TEST_REALM "\"");
  run_case ("adj/username-ext-bad-charset",
            "Digest username*=ISO-8859-1''abc, realm=\"" TEST_REALM "\"");
  run_case ("adj/username-ext-quoted",
            "Digest username*=\"UTF-8''\\abc\", realm=\"" TEST_REALM "\"");
  run_case ("adj/username-ext-and-plain",
            "Digest username=\"" TEST_USERNAME "\", "
            "username*=UTF-8''" TEST_USERNAME ", realm=\"" TEST_REALM "\"");

  /* The "userhash" handling */
  run_case ("adj/userhash-username-too-short",
            "Digest userhash=true, username=\"abcd\", "
            "realm=\"" TEST_REALM "\"");
  run_case ("adj/userhash-username-empty",
            "Digest userhash=true, username=\"\", "
            "realm=\"" TEST_REALM "\"");
  run_case ("adj/userhash-username-too-long",
            "Digest userhash=true, username=\"%s\", "
            "realm=\"" TEST_REALM "\"",
            fill_hex (big, 200));
  run_case ("adj/userhash-username-ext",
            "Digest userhash=true, username*=UTF-8''abc, "
            "realm=\"" TEST_REALM "\"");
  run_case ("adj/userhash-no-username",
            "Digest userhash=true, realm=\"" TEST_REALM "\"");

  /* The "nc" handling */
  run_case ("adj/nc-zero",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "qop=auth, nc=00000000, cnonce=\"abc\"");
  run_case ("adj/nc-non-hex",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "qop=auth, nc=zzzzzzzz, cnonce=\"abc\"");
  run_case ("adj/nc-empty",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "qop=auth, nc=, cnonce=\"abc\"");
  run_case ("adj/nc-overflow",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "qop=auth, nc=ffffffffffffffffffffffff, cnonce=\"abc\"");
  run_case ("adj/qop-auth-no-nc",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "qop=auth, cnonce=\"abc\"");
  run_case ("adj/qop-auth-no-cnonce",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "qop=auth, nc=00000001");
  run_case ("adj/cnonce-empty",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "qop=auth, nc=00000001, cnonce=\"\"");

  /* Malformed "nonce" values.  These are rejected by the length check
     before the "nonce"/"nc" map is consulted. */
  run_case ("adj/nonce-short",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"deadbeef\", uri=\"" TEST_URL "\", qop=auth, "
            "nc=00000001, cnonce=\"abc\", response=\"00112233\"");
  run_case ("adj/nonce-empty",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"\", uri=\"" TEST_URL "\", qop=auth, "
            "nc=00000001, cnonce=\"abc\", response=\"00112233\"");

  /* Duplicated parameters */
  run_case ("adj/duplicated-username",
            "Digest username=\"a\", username=\"" TEST_USERNAME "\", "
            "realm=\"" TEST_REALM "\"");
  run_case ("adj/duplicated-realm",
            "Digest username=\"" TEST_USERNAME "\", realm=\"x\", "
            "realm=\"" TEST_REALM "\"");
  run_case ("adj/duplicated-userhash",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "userhash=false, userhash=true");

  /* The sub-cases below use the SHA-256 algorithm and therefore need the
     daemon that issues the SHA-256 (76 characters long) nonces. */
  test_port = port_sha256;

  run_case ("adj/nonce-not-generated-by-mhd",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"" TEST_URL "\", algorithm=SHA-256, "
            "qop=auth, nc=00000001, cnonce=\"abc\", response=\"%s\"",
            fill_hex (big, 76),
            resp);

  need_nonce (nonce, sizeof (nonce));
  run_case ("adj/uri-mismatch",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"/other\", algorithm=SHA-256, qop=auth, "
            "nc=%08x, cnonce=\"abc\", response=\"%s\"",
            nonce,
            ++nc_counter,
            resp);

  need_nonce (nonce, sizeof (nonce));
  run_case ("adj/uri-empty",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"\", algorithm=SHA-256, qop=auth, "
            "nc=%08x, cnonce=\"abc\", response=\"%s\"",
            nonce,
            ++nc_counter,
            resp);

  need_nonce (nonce, sizeof (nonce));
  run_case ("adj/uri-with-args",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"" TEST_URL "?a=b\", algorithm=SHA-256, "
            "qop=auth, nc=%08x, cnonce=\"abc\", response=\"%s\"",
            nonce,
            ++nc_counter,
            resp);

  need_nonce (nonce, sizeof (nonce));
  run_case ("adj/duplicated-nonce",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"deadbeef\", nonce=\"%s\", uri=\"" TEST_URL "\", "
            "algorithm=SHA-256, qop=auth, nc=%08x, cnonce=\"abc\", "
            "response=\"%s\"",
            nonce,
            ++nc_counter,
            resp);

  need_nonce (nonce, sizeof (nonce));
  run_case ("adj/qop-auth-int",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"" TEST_URL "\", algorithm=SHA-256, "
            "qop=auth-int, nc=%08x, cnonce=\"abc\", response=\"%s\"",
            nonce,
            ++nc_counter,
            resp);

  need_nonce (nonce, sizeof (nonce));
  run_case ("adj/qop-bogus",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"" TEST_URL "\", algorithm=SHA-256, "
            "qop=BOGUS, nc=%08x, cnonce=\"abc\", response=\"%s\"",
            nonce,
            ++nc_counter,
            resp);

  need_nonce (nonce, sizeof (nonce));
  run_case ("adj/userhash-64-non-hex",
            "Digest userhash=true, username=\"%s\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"" TEST_URL "\", algorithm=SHA-256, qop=auth, "
            "nc=%08x, cnonce=\"abc\", response=\"%s\"",
            fill_chr (big, 'z', 64),
            nonce,
            ++nc_counter,
            resp);

  need_nonce (nonce, sizeof (nonce));
  run_case ("adj/userhash-128-hex",
            "Digest userhash=true, username=\"%s\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"" TEST_URL "\", algorithm=SHA-256, qop=auth, "
            "nc=%08x, cnonce=\"abc\", response=\"%s\"",
            fill_hex (big, 128),
            nonce,
            ++nc_counter,
            resp);

  /* An empty "qop" value ("qop=" or "qop=\"\"") is parsed to
     #MHD_DIGEST_AUTH_QOP_INVALID, whose numeric value is zero, so it used to
     pass the "allowed QOP" bit-mask test in exactly the same way an unknown
     "algorithm" token did before commit bd49ce93, and the empty value then
     reached get_unquoted_param(), which asserts that the value is not empty.
     Fixed in commit 3b898eae; these two sub-cases are its regression test. */
  need_nonce (nonce, sizeof (nonce));
  run_case ("adj/qop-empty",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"" TEST_URL "\", algorithm=SHA-256, qop=, "
            "nc=%08x, cnonce=\"abc\", response=\"%s\"",
            nonce,
            ++nc_counter,
            resp);

  need_nonce (nonce, sizeof (nonce));
  run_case ("adj/qop-empty-quotes",
            "Digest username=\"" TEST_USERNAME "\", realm=\"" TEST_REALM "\", "
            "nonce=\"%s\", uri=\"" TEST_URL "\", algorithm=SHA-256, qop=\"\", "
            "nc=%08x, cnonce=\"abc\", response=\"%s\"",
            nonce,
            ++nc_counter,
            resp);
}


/**
 * Start a test daemon.
 *
 * @param challenge_algo the pointer to the algorithm used for the challenges
 * @param[out] pport the pointer to store the port the daemon listens on
 * @return the daemon
 */
static struct MHD_Daemon *
start_test_daemon (const enum MHD_DigestAuthMultiAlgo3 *challenge_algo,
                   uint16_t *pport)
{
  struct MHD_Daemon *daemon;
  const union MHD_DaemonInfo *dinfo;
  struct MHD_OptMatrixProfile prof;
  struct MHD_OptionItem ops[8];
  unsigned int flags;

  if (NULL != test_prof)
    prof = *test_prof;
  else
  {
    memset (&prof, 0, sizeof (prof));
    prof.name = "built-in";
    prof.threading = MHD_OPT_MATRIX_THR_INTERNAL;
    prof.poll_backend = MHD_OPT_MATRIX_POLL_SELECT;
  }
  if (0 == mhd_opt_matrix_fill_options (&prof, ops,
                                        (unsigned int) (sizeof (ops)
                                                        / sizeof (ops[0]))))
    hard_error ("The daemon option array is too small");
  /* The client of this test is a plain blocking socket client, so external
     polling is served with an internal polling thread instead. */
  flags = mhd_opt_matrix_daemon_flags (&prof, MHD_USE_ERROR_LOG, 0);

  daemon = MHD_start_daemon (flags,
                             0,
                             NULL, NULL,
                             &ahc_check, (void *) challenge_algo,
                             MHD_OPTION_ARRAY, ops,
                             MHD_OPTION_CONNECTION_TIMEOUT,
                             (unsigned int) 10,
                             MHD_OPTION_NONCE_NC_SIZE,
                             (unsigned int) NONCE_NC_SIZE,
                             MHD_OPTION_END);
  if (NULL == daemon)
    hard_error ("MHD_start_daemon() failed");
  dinfo = MHD_get_daemon_info (daemon, MHD_DAEMON_INFO_BIND_PORT);
  if ( (NULL == dinfo) || (0 == dinfo->port) )
  {
    MHD_stop_daemon (daemon);
    hard_error ("MHD_get_daemon_info() failed");
  }
  *pport = dinfo->port;
  return daemon;
}


int
main (int argc, char *const *argv)
{
  static const enum MHD_DigestAuthMultiAlgo3 algo_sha256 =
    MHD_DIGEST_AUTH_MULT_ALGO3_SHA256;
  static const enum MHD_DigestAuthMultiAlgo3 algo_any =
    MHD_DIGEST_AUTH_MULT_ALGO3_ANY_NON_SESSION;
  struct MHD_Daemon *daemon_sha256;
  struct MHD_Daemon *daemon_any;
  char nonce[256];

  if (1 < argc)
    case_filter = argv[1];

  mhd_opt_matrix_print_notice ("test_dauth_malformed");
  test_prof = mhd_opt_matrix_from_env ();
  if (NULL != test_prof)
  {
    char desc[256];

    test_prof_copy = *test_prof;
    test_prof = &test_prof_copy;
    if (! mhd_opt_matrix_profile_supported (test_prof))
    {
      printf ("test_dauth_malformed: the selected profile %s is not "
              "supported by this build, the test is skipped.\n",
              mhd_opt_matrix_describe (test_prof, desc, sizeof (desc)));
      return 77;
    }
    if (mhd_opt_matrix_raise_mem_limit (&test_prof_copy, MIN_POOL_FOR_TEST))
      printf ("test_dauth_malformed: the connection memory limit of the "
              "profile was raised to %u, the smallest pool this test can "
              "work with.\n", (unsigned) MIN_POOL_FOR_TEST);
  }

  daemon_sha256 = start_test_daemon (&algo_sha256, &port_sha256);
  daemon_any = start_test_daemon (&algo_any, &port_any);

  test_invalid_algorithm ();
  test_overlong_response ();
  test_adjacent ();

  /* Both daemons must still be alive and functional. */
  test_port = port_sha256;
  if (! get_nonce (nonce, sizeof (nonce)))
  {
    fprintf (stderr,
             "FAILED: the SHA-256 daemon does not respond after the test.\n");
    ++failures;
  }
  test_port = port_any;
  if (! get_nonce (nonce, sizeof (nonce)))
  {
    fprintf (stderr,
             "FAILED: the default daemon does not respond after the test.\n");
    ++failures;
  }

  MHD_stop_daemon (daemon_any);
  MHD_stop_daemon (daemon_sha256);

  if (0 != failures)
  {
    fprintf (stderr,
             "Test FAILED: %u of %u sub-cases failed.\n",
             failures,
             case_num);
    return 1;
  }
  printf ("Test PASSED: %u sub-cases.\n",
          case_num);
  return 0;
}


#else  /* ! DAUTH_SUPPORT || ! MHD_SHA256_SUPPORT */


int
main (void)
{
  fprintf (stderr,
           "Digest Auth or SHA-256 support is not enabled in this MHD build, "
           "the test is skipped.\n");
  return 77;
}


#endif /* ! DAUTH_SUPPORT || ! MHD_SHA256_SUPPORT */