fuzzer_base16_32_64.c

Go to the documentation of this file.

/*
 *   This program 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 of the License, or
 *   (at your option) any later version.
 *
 *   This program 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.
 */
 
/**
 * @file src/fuzzer/fuzzer_base16_32_64.c
 * @brief Fuzz the base conversion functions
 */
RCSID("$Id: d7a711582935deae35e0a2b2bd8cd757aa22cfa3 $")
 
#include <freeradius-devel/util/base16.h>
#include <freeradius-devel/util/base32.h>
#include <freeradius-devel/util/base64.h>
#include <freeradius-devel/util/dbuff.h>
#include <freeradius-devel/util/sbuff.h>
 
int LLVMFuzzerTestOneInput(const uint8_t *buf, size_t len);
 
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
    uint8_t decoded[4096];
    char encoded[8192];
 
    fr_dbuff_t decode_dbuff, input_dbuff;
    fr_sbuff_t encode_sbuff, input_sbuff;
    fr_sbuff_parse_error_t err;
 
    if (size == 0) return 0;
 
    /*
     * BASE64 TESTS (4 variants)
     */
 
    // Test 1: Decode with standard base64 alphabet
    fr_sbuff_init_in(&input_sbuff, (char const *)data, size);
    fr_dbuff_init(&decode_dbuff, decoded, sizeof(decoded));
    (void)fr_base64_decode_nstd(&err, &decode_dbuff, &input_sbuff, 
                                true, true, fr_base64_alphabet_decode);
 
    // Test 2: Decode with URL-safe base64 alphabet
    fr_sbuff_init_in(&input_sbuff, (char const *)data, size);
    fr_dbuff_init(&decode_dbuff, decoded, sizeof(decoded));
    (void)fr_base64_decode_nstd(&err, &decode_dbuff, &input_sbuff, 
                                false, false, fr_base64_url_alphabet_decode);
 
    // Test 3: Encode with standard base64 alphabet (limit input size)
    if (size <= 2048) {
        fr_dbuff_init(&input_dbuff, data, size);
        fr_sbuff_init_out(&encode_sbuff, encoded, sizeof(encoded));
        (void)fr_base64_encode_nstd(&encode_sbuff, &input_dbuff, 
                                    true, fr_base64_alphabet_encode);
    }
 
    // Test 4: Encode with URL-safe base64 alphabet (limit input size)
    if (size <= 2048) {
        fr_dbuff_init(&input_dbuff, data, size);
        fr_sbuff_init_out(&encode_sbuff, encoded, sizeof(encoded));
        (void)fr_base64_encode_nstd(&encode_sbuff, &input_dbuff, 
                                    false, fr_base64_url_alphabet_encode);
    }
 
    /*
     * BASE32 TESTS (4 variants)
     */
 
    // Test 5: Decode with standard base32 alphabet
    fr_sbuff_init_in(&input_sbuff, (char const *)data, size);
    fr_dbuff_init(&decode_dbuff, decoded, sizeof(decoded));
    (void)fr_base32_decode_nstd(&err, &decode_dbuff, &input_sbuff,
                                true, true, fr_base32_alphabet_decode);
 
    // Test 6: Decode with base32hex alphabet
    fr_sbuff_init_in(&input_sbuff, (char const *)data, size);
    fr_dbuff_init(&decode_dbuff, decoded, sizeof(decoded));
    (void)fr_base32_decode_nstd(&err, &decode_dbuff, &input_sbuff,
                                false, false, fr_base32_hex_alphabet_decode);
 
    // Test 7: Encode with standard base32 alphabet (limit input size)
    if (size <= 2048) {
        fr_dbuff_init(&input_dbuff, data, size);
        fr_sbuff_init_out(&encode_sbuff, encoded, sizeof(encoded));
        (void)fr_base32_encode_nstd(&encode_sbuff, &input_dbuff,
                                    true, fr_base32_alphabet_encode);
    }
 
    // Test 8: Encode with base32hex alphabet (limit input size)
    if (size <= 2048) {
        fr_dbuff_init(&input_dbuff, data, size);
        fr_sbuff_init_out(&encode_sbuff, encoded, sizeof(encoded));
        (void)fr_base32_encode_nstd(&encode_sbuff, &input_dbuff,
                                    false, fr_base32_hex_alphabet_encode);
    }
 
    /*
     * BASE16 TESTS (3 variants)
     */
 
    // Test 9: Decode with mixed-case base16 alphabet
    fr_sbuff_init_in(&input_sbuff, (char const *)data, size);
    fr_dbuff_init(&decode_dbuff, decoded, sizeof(decoded));
    (void)fr_base16_decode_nstd(&err, &decode_dbuff, &input_sbuff,
                                true, fr_base16_alphabet_decode_mc);
 
    // Test 10: Encode with lowercase base16 alphabet (limit input size)
    if (size <= 2048) {
        fr_dbuff_init(&input_dbuff, data, size);
        fr_sbuff_init_out(&encode_sbuff, encoded, sizeof(encoded));
        (void)fr_base16_encode_nstd(&encode_sbuff, &input_dbuff,
                                    fr_base16_alphabet_encode_lc);
    }
 
    // Test 11: Encode with uppercase base16 alphabet (limit input size)
    if (size <= 2048) {
        fr_dbuff_init(&input_dbuff, data, size);
        fr_sbuff_init_out(&encode_sbuff, encoded, sizeof(encoded));
        (void)fr_base16_encode_nstd(&encode_sbuff, &input_dbuff,
                                    fr_base16_alphabet_encode_uc);
    }
 
    return 0;
}