Hugging Face's logo

Datasets:
meddyrat
/
dis-bench

Modalities:
Tabular
Text
Formats:
parquet
Size:
1K - 10K
Libraries:
Datasets
pandas
Polars
Dataset card Data Studio Files
xet
 Community
1
dis-bench / src /php /php-src /sapi /fuzzer /fuzzer-mbstring.c
meddyrat's picture
meddyrat
Replace repository contents with the original corrected artifact
1e94262
Raw History Blame Contribute Delete
5.5 kB
/*
+----------------------------------------------------------------------+
| Copyright (c) The PHP Group |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| https://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Stanislav Malyshev <stas@php.net> |
+----------------------------------------------------------------------+
*/
#include "zend.h"
#include "fuzzer.h"
#include "fuzzer-sapi.h"
#include "ext/mbstring/mbstring.h"
zend_string* convert_encoding(const uint8_t *Data, size_t Size, const mbfl_encoding *FromEncoding, const mbfl_encoding *ToEncoding, size_t BufSize, unsigned int *NumErrors)
{
uint32_t *wchar_buf = ecalloc(BufSize, sizeof(uint32_t));
unsigned int state = 0;
mb_convert_buf buf;
mb_convert_buf_init(&buf, Size, '?', MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR);
while (Size) {
size_t out_len = FromEncoding->to_wchar((unsigned char**)&Data, &Size, wchar_buf, BufSize, &state);
ZEND_ASSERT(out_len <= BufSize);
ToEncoding->from_wchar(wchar_buf, out_len, &buf, !Size);
}
*NumErrors = buf.errors;
zend_string *result = mb_convert_buf_result(&buf, ToEncoding);
efree(wchar_buf);
return result;
}
void assert_zend_string_eql(zend_string *str1, zend_string *str2)
{
ZEND_ASSERT(ZSTR_LEN(str1) == ZSTR_LEN(str2));
for (int i = 0; i < ZSTR_LEN(str1); i++) {
ZEND_ASSERT(ZSTR_VAL(str1)[i] == ZSTR_VAL(str2)[i]);
}
}
int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
const uint8_t *Comma1 = memchr(Data, ',', Size);
if (!Comma1) {
return 0;
}
size_t ToEncodingNameLen = Comma1 - Data;
char *ToEncodingName = estrndup((char *) Data, ToEncodingNameLen);
Data = Comma1 + 1;
Size -= ToEncodingNameLen + 1;
const uint8_t *Comma2 = memchr(Data, ',', Size);
if (!Comma2) {
efree(ToEncodingName);
return 0;
}
size_t FromEncodingNameLen = Comma2 - Data;
char *FromEncodingName = estrndup((char *) Data, FromEncodingNameLen);
Data = Comma2 + 1;
Size -= FromEncodingNameLen + 1;
const mbfl_encoding *ToEncoding = mbfl_name2encoding(ToEncodingName);
const mbfl_encoding *FromEncoding = mbfl_name2encoding(FromEncodingName);
if (!ToEncoding || !FromEncoding || Size < 2 || fuzzer_request_startup() == FAILURE) {
efree(ToEncodingName);
efree(FromEncodingName);
return 0;
}
/* Rather than converting an entire (possibly very long) string at once, mbstring converts
* strings 'chunk by chunk'; the decoder will run until it fills up its output buffer with
* wchars, then the encoder will process those wchars, then the decoder runs again until it
* again fills up its output buffer, and so on
*
* The most error-prone part of the decoder/encoder code is where we exit a decoder/encoder
* function and save its state to allow later resumption
* To stress-test that aspect of the decoders/encoders, try performing an encoding conversion
* operation with different, random buffer sizes
* If the code is correct, the result should always be the same either way */
size_t bufsize1 = *Data++;
size_t bufsize2 = *Data++;
bufsize1 = MAX(bufsize1, MBSTRING_MIN_WCHAR_BUFSIZE);
bufsize2 = MAX(bufsize2, MBSTRING_MIN_WCHAR_BUFSIZE);
Size -= 2;
unsigned int errors1 = 0, errors2 = 0;
zend_string *Result1 = convert_encoding(Data, Size, FromEncoding, ToEncoding, bufsize1, &errors1);
zend_string *Result2 = convert_encoding(Data, Size, FromEncoding, ToEncoding, bufsize2, &errors2);
assert_zend_string_eql(Result1, Result2);
ZEND_ASSERT(errors1 == errors2);
/* For some text encodings, we have specialized validation functions. These should always be
* stricter than the conversion functions; if the conversion function receives invalid input
* and emits an error marker (MBFL_BAD_INPUT), then the validation function should always
* return false. However, if the conversion function does not emit any error marker, it may
* still happen in some cases that the validation function returns false. */
if (FromEncoding->check != NULL) {
bool good = FromEncoding->check((unsigned char*)Data, Size);
if (errors1 > 0) {
/* If the conversion function emits an error marker, that may or may not mean the input
* was invalid; it could also be that the input was valid, but it contains codepoints
* which cannot be represented in the output encoding.
* To confirm if that is the case, try converting to UTF-8, which can represent any
* Unicode codepoint. */
unsigned int errors3 = 0;
zend_string *Temp = convert_encoding(Data, Size, FromEncoding, &mbfl_encoding_utf8, 128, &errors3);
if (errors3 > 0) {
ZEND_ASSERT(!good);
}
zend_string_release(Temp);
}
}
zend_string_release(Result1);
zend_string_release(Result2);
efree(ToEncodingName);
efree(FromEncodingName);
fuzzer_request_shutdown();
return 0;
}
int LLVMFuzzerInitialize(int *argc, char ***argv) {
fuzzer_init_php(NULL);
return 0;
}