Test results for the library libtre-0.7.1 on x86

Summary

Total tests	20
Passed / Failed tests	12 / 8
Verdict	Test Failed

Problem Summary

Received signal SEGV

Failed Tests (8)

[+] Received signal SEGV (8 problems)

regex.h, libtre.so.4.2.1
[+] regaexec ( regex_t const* preg, char const* string, regamatch_t* match, regaparams_t params, int eflags )

received signal SEGV (11)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stddef.h>

#include <regex.h>

#include <tre-config.h>

int main(int argc, char *argv[])

{

void* value = malloc(256);

regex_t preg = {.re_nsub = 4, .value = value};

regmatch_t pmatch = {.rm_so = 1, .rm_eo = 2};

regamatch_t match = {

.nmatch = 4,

.pmatch = &pmatch,

.cost = 3,

.num_ins = 4,

.num_del = 5,

.num_subst = 6};

regaparams_t params = {

.cost_ins = 7,

.cost_del = 8,

.cost_subst = 9,

.max_cost = 10,

.max_ins = 11,

.max_del = 1,

.max_subst = 2,

.max_err = 3};

regaexec(

&preg,

"string",

&match,

params,

0); //target call

return 0;

}

[+] reganexec ( regex_t const* preg, char const* string, size_t len, regamatch_t* match, regaparams_t params, int eflags )

received signal SEGV (11)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include <stddef.h>

#include <regex.h>

#include <tre-config.h>

int main(int argc, char *argv[])

{

void* value = malloc(256);

regex_t preg = {.re_nsub = 4, .value = value};

char const string [] = {

'A',

'B',

'C',

'D',

'\0'};

regmatch_t pmatch = {.rm_so = 1, .rm_eo = 2};

regamatch_t match = {

.nmatch = 4,

.pmatch = &pmatch,

.cost = 3,

.num_ins = 4,

.num_del = 5,

.num_subst = 6};

regaparams_t params = {

.cost_ins = 7,

.cost_del = 8,

.cost_subst = 9,

.max_cost = 10,

.max_ins = 11,

.max_del = 1,

.max_subst = 2,

.max_err = 3};

reganexec(

&preg,

string,

&match,

params,

0); //target call

return 0;

}

[+] regawexec ( regex_t const* preg, wchar_t const* string, regamatch_t* match, regaparams_t params, int eflags )

received signal SEGV (11)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stddef.h>

#include <regex.h>

#include <tre-config.h>

int main(int argc, char *argv[])

{

void* value = malloc(256);

regex_t preg = {.re_nsub = 4, .value = value};

regmatch_t pmatch = {.rm_so = 1, .rm_eo = 2};

regamatch_t match = {

.nmatch = 4,

.pmatch = &pmatch,

.cost = 3,

.num_ins = 4,

.num_del = 5,

.num_subst = 6};

regaparams_t params = {

.cost_ins = 7,

.cost_del = 8,

.cost_subst = 9,

.max_cost = 10,

.max_ins = 11,

.max_del = 1,

.max_subst = 2,

.max_err = 3};

regawexec(

&preg,

L"string",

&match,

params,

0); //target call

return 0;

}

[+] regawnexec ( regex_t const* preg, wchar_t const* string, size_t len, regamatch_t* match, regaparams_t params, int eflags )

received signal SEGV (11)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#include <stddef.h>

#include <regex.h>

#include <tre-config.h>

int main(int argc, char *argv[])

{

void* value = malloc(256);

regex_t preg = {.re_nsub = 4, .value = value};

wchar_t const string [] = {

L'A',

L'B',

L'C',

L'D',

L'\0'};

regmatch_t pmatch = {.rm_so = 1, .rm_eo = 2};

regamatch_t match = {

.nmatch = 4,

.pmatch = &pmatch,

.cost = 3,

.num_ins = 4,

.num_del = 5,

.num_subst = 6};

regaparams_t params = {

.cost_ins = 7,

.cost_del = 8,

.cost_subst = 9,

.max_cost = 10,

.max_ins = 11,

.max_del = 1,

.max_subst = 2,

.max_err = 3};

regawnexec(

&preg,

string,

&match,

params,

0); //target call

return 0;

}

[+] regexec ( regex_t const* preg, char const* string, size_t nmatch, regmatch_t* pmatch, int eflags )

received signal SEGV (11)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <stddef.h>

#include <regex.h>

#include <tre-config.h>

int main(int argc, char *argv[])

{

void* value = malloc(256);

regex_t preg = {.re_nsub = 4, .value = value};

regmatch_t pmatch = {.rm_so = 1, .rm_eo = 2};

regexec(

&preg,

"string",

&pmatch,

0); //target call

return 0;

}

[+] reguexec ( regex_t const* preg, tre_str_source const* string, size_t nmatch, regmatch_t* pmatch, int eflags )

received signal SEGV (11)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

#include <stddef.h>

#include <regex.h>

#include <tre-config.h>

//auxiliary function

int

get_next_char(tre_char_t* p1, unsigned int* p2, void* p3)

{

return 1;

}

//auxiliary function

void

rewind(size_t p1, void* p2){}

//auxiliary function

int

compare(

size_t p1,

size_t p2,

size_t p3,

void* p4)

{

return 2;

}

int main(int argc, char *argv[])

{

void* value = malloc(256);

regex_t preg = {.re_nsub = 4, .value = value};

void* context = malloc(256);

tre_str_source string = {

.get_next_char = &get_next_char,

.rewind = &rewind,

.compare = &compare,

.context = context};

regmatch_t pmatch = {.rm_so = 3, .rm_eo = 4};

reguexec(

&preg,

&string,

&pmatch,

0); //target call

return 0;

}

[+] regwexec ( regex_t const* preg, wchar_t const* string, size_t nmatch, regmatch_t* pmatch, int eflags )

received signal SEGV (11)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <stddef.h>

#include <regex.h>

#include <tre-config.h>

int main(int argc, char *argv[])

{

void* value = malloc(256);

regex_t preg = {.re_nsub = 4, .value = value};

regmatch_t pmatch = {.rm_so = 1, .rm_eo = 2};

regwexec(

&preg,

L"string",

&pmatch,

0); //target call

return 0;

}

[+] regwnexec ( regex_t const* preg, wchar_t const* string, size_t len, size_t nmatch, regmatch_t* pmatch, int eflags )

received signal SEGV (11)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <stddef.h>

#include <regex.h>

#include <tre-config.h>

int main(int argc, char *argv[])

{

void* value = malloc(256);

regex_t preg = {.re_nsub = 4, .value = value};

wchar_t const string [] = {

L'A',

L'B',

L'C',

L'D',

L'\0'};

regmatch_t pmatch = {.rm_so = 1, .rm_eo = 2};

regwnexec(

&preg,

string,

&pmatch,

0); //target call

return 0;

}

to the top