Test results for the glibc-2.13 library on x86

Summary

Total tests	1943
Passed / Failed tests	1603 / 340
Warnings	106
Verdict	Test Failed

Problem Summary

Received signal	FPE	1
	ILL	8
	SEGV	328
Hanged execution		3

Failed Tests (340)

[+] Received signal FPE (1 problem)

search.h, libc-2.13.so
[+] hsearch ( ENTRY __item, ACTION __action )

received signal FPE

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

#include <stdlib.h>

#include <search.h>

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

{

char key [] = {

'A',

'B',

'C',

'D',

'\0'};

void* data = malloc(256);

ENTRY __item = {.key = key, .data = data};

hsearch(__item, FIND); //target call

return 0;

}

to the top

[+] Received signal ILL (8 problems)

netdb.h, libanl-2.13.so
[+] gai_error ( struct gaicb* __req )

received signal ILL

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

#include <stdlib.h>

#include <netdb.h>

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

{

socklen_t ai_addrlen = (socklen_t) malloc(sizeof(unsigned int)*256);

struct sockaddr ai_addr = {

.sa_family = AF_INET,

.sa_data = {

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N'}};

struct addrinfo ar_request = {

.ai_flags = 0,

.ai_family = 1,

.ai_socktype = 0,

.ai_protocol = 2,

.ai_addrlen = ai_addrlen,

.ai_addr = &ai_addr,

.ai_canonname = "ai_canonname",

.ai_next = 0};

struct gaicb __req = {

.ar_name = "ar_name",

.ar_service = "ar_service",

.ar_request = &ar_request,

.ar_result = &ar_request,

.__return = 3,

.__unused = {

4}};

gai_error(&__req); //target call

return 0;

}

dlfcn.h, libdl-2.13.so
[+] dladdr ( void const* __address, Dl_info* __info )

received signal ILL

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

#include <stdlib.h>

#include <dlfcn.h>

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

{

void* __address = malloc(256);

void* dli_fbase = malloc(256);

void* dli_saddr = malloc(256);

Dl_info __info = {

.dli_fname = "dli_fname",

.dli_fbase = dli_fbase,

.dli_sname = "dli_sname",

.dli_saddr = dli_saddr};

dladdr(__address, &__info); //target call

return 0;

}

pthread.h, libpthread-2.13.so
[+] pthread_attr_getaffinity_np ( pthread_attr_t const* __attr, size_t __cpusetsize, cpu_set_t* __cpuset )

received signal ILL

1
2
3
4
5
6
7
8
9
10

#include <pthread.h>

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

{

pthread_attr_t __attr;

pthread_attr_init(&__attr);

cpu_set_t* __cpuset = __sched_cpualloc(4);

pthread_attr_getaffinity_np(&__attr, 4, __cpuset); //target call

return 0;

}

[+] pthread_rwlock_unlock ( pthread_rwlock_t* __rwlock )

received signal ILL

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlock_t __rwlock;

pthread_rwlock_init(&__rwlock, &__attr);

pthread_rwlock_unlock(&__rwlock); //target call

return 0;

}

[+] pthread_rwlockattr_destroy ( pthread_rwlockattr_t* __attr )

received signal ILL

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlockattr_destroy(&__attr); //target call

return 0;

}

[+] pthread_spin_init ( int volatile* __lock, int __pshared )

received signal ILL

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <pthread.h>

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

{

int* __lock = (int volatile*) malloc(sizeof(int volatile)*256);

pthread_spin_init(__lock, 0); //target call

return 0;

}

aio.h, librt-2.13.so
[+] aio_write64 ( struct aiocb64* __aiocbp )

received signal ILL

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __next_prio = {

.aio_fildes = 5,

.aio_lio_opcode = 6,

.aio_reqprio = 7,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 8,

.__policy = 9,

.__error_code = 10,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

FILE* __stream_1 = fopen("testdata/sample.txt", "r+");

__off64_t aio_offset_1 = ftello64(__stream_1);

struct aiocb64 __aiocbp = {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 1,

.__policy = 2,

.__error_code = 3,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P'}};

aio_write64(&__aiocbp); //target call

//finalization

fclose(__stream_1);

fclose(__stream);

return 0;

}

mqueue.h, librt-2.13.so
[+] mq_notify ( mqd_t __mqdes, struct sigevent const* __notification )

received signal ILL

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

#include <stdlib.h>

#include <signal.h>

#include <mqueue.h>

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

{

mqd_t __mqdes = mq_open("__name", 0, 0);

timer_t __timerid [] = {

malloc(256),

0};

struct sigevent __notification;

timer_create(1, &__notification, __timerid);

mq_notify(__mqdes, &__notification); //target call

return 0;

}

to the top

[+] Received signal SEGV (328 problems)

netdb.h, libanl-2.13.so
[+] gai_cancel ( struct gaicb* __gaicbp )

received signal SEGV

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

#include <stdlib.h>

#include <netdb.h>

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

{

socklen_t ai_addrlen = (socklen_t) malloc(sizeof(unsigned int)*256);

struct sockaddr ai_addr = {

.sa_family = AF_INET,

.sa_data = {

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N'}};

struct addrinfo ar_request = {

.ai_flags = 0,

.ai_family = 1,

.ai_socktype = 0,

.ai_protocol = 2,

.ai_addrlen = ai_addrlen,

.ai_addr = &ai_addr,

.ai_canonname = "ai_canonname",

.ai_next = 0};

struct gaicb __gaicbp = {

.ar_name = "ar_name",

.ar_service = "ar_service",

.ar_request = &ar_request,

.ar_result = &ar_request,

.__return = 3,

.__unused = {

4}};

gai_cancel(&__gaicbp); //target call

return 0;

}

[+] gai_suspend ( struct gaicb const*const* __list, int __ent, struct timespec const* __timeout )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

#include <stdlib.h>

#include <netdb.h>

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

{

socklen_t ai_addrlen = (socklen_t) malloc(sizeof(unsigned int)*256);

struct sockaddr ai_addr = {

.sa_family = AF_INET,

.sa_data = {

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N'}};

struct addrinfo ar_request = {

.ai_flags = 0,

.ai_family = 1,

.ai_socktype = 0,

.ai_protocol = 2,

.ai_addrlen = ai_addrlen,

.ai_addr = &ai_addr,

.ai_canonname = "ai_canonname",

.ai_next = 0};

struct gaicb __list_elem [] = {

(struct gaicb) {

.ar_name = "ar_name",

.ar_service = "ar_service",

.ar_request = &ar_request,

.ar_result = &ar_request,

.__return = 3,

.__unused = {

4}},

(struct gaicb) {

.ar_name = "ar_name",

.ar_service = "ar_service",

.ar_request = &ar_request,

.ar_result = &ar_request,

.__return = 4,

.__unused = {

4}},

(struct gaicb) {

.ar_name = "ar_name",

.ar_service = "ar_service",

.ar_request = &ar_request,

.ar_result = &ar_request,

.__return = 5,

.__unused = {

4}},

(struct gaicb) {

.ar_name = "ar_name",

.ar_service = "ar_service",

.ar_request = &ar_request,

.ar_result = &ar_request,

.__return = 6,

.__unused = {

4}},

(struct gaicb) {0}};

struct gaicb* __list [] = {

__list_elem,

0};

struct timespec __timeout;

clock_getres(8, &__timeout);

gai_suspend((struct gaicb const*const*)__list, 7, &__timeout); //target call

return 0;

}

[+] getaddrinfo_a ( int __mode, struct gaicb** __list, int __ent, struct sigevent* __sig )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

#include <signal.h>

#include <stdlib.h>

#include <netdb.h>

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

{

socklen_t ai_addrlen = (socklen_t) malloc(sizeof(unsigned int)*256);

struct sockaddr ai_addr = {

.sa_family = AF_INET,

.sa_data = {

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N'}};

struct addrinfo ar_request = {

.ai_flags = 0,

.ai_family = 1,

.ai_socktype = 0,

.ai_protocol = 2,

.ai_addrlen = ai_addrlen,

.ai_addr = &ai_addr,

.ai_canonname = "ai_canonname",

.ai_next = 0};

struct gaicb __list_elem [] = {

(struct gaicb) {

.ar_name = "ar_name",

.ar_service = "ar_service",

.ar_request = &ar_request,

.ar_result = &ar_request,

.__return = 3,

.__unused = {

4}},

(struct gaicb) {

.ar_name = "ar_name",

.ar_service = "ar_service",

.ar_request = &ar_request,

.ar_result = &ar_request,

.__return = 4,

.__unused = {

4}},

(struct gaicb) {

.ar_name = "ar_name",

.ar_service = "ar_service",

.ar_request = &ar_request,

.ar_result = &ar_request,

.__return = 5,

.__unused = {

4}},

(struct gaicb) {

.ar_name = "ar_name",

.ar_service = "ar_service",

.ar_request = &ar_request,

.ar_result = &ar_request,

.__return = 6,

.__unused = {

4}},

(struct gaicb) {0}};

struct gaicb* __list [] = {

__list_elem,

0};

timer_t __timerid [] = {

malloc(256),

0};

struct sigevent __sig;

timer_create(8, &__sig, __timerid);

getaddrinfo_a(

__list,

&__sig); //target call

return 0;

}

argz.h, libc-2.13.so
[+] argz_delete ( char** __argz, size_t* __argz_len, char* __entry )

received signal SEGV

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

#include <argz.h>

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

{

char* __argz = 0;

unsigned int __argz_len = 0;

char __entry [] = {

'A',

'B',

'C',

'D',

'\0'};

argz_delete((char**)&__argz, &__argz_len, __entry); //target call

return 0;

}

[+] argz_extract ( char const* __argz, size_t __len, char** __argv )

received signal SEGV

#include <argz.h>

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

{

argz_extract("__argz", 6, argv); //target call

return 0;

}

auth.h, libc-2.13.so
[+] authdes_create ( char const* __servername, u_int __window, struct sockaddr* __syncaddr, des_block* __ckey )

received signal SEGV

509: U��$�]�衄��&H 509: U�� }��}�]��+��ðG

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

#include <rpc/rpc.h>

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

{

struct sockaddr __syncaddr = {

.sa_family = AF_INET,

.sa_data = {

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N'}};

union des_block __ckey = {.key = {.high = 2, .low = 3}};

authdes_create(

"__servername",

&__syncaddr,

&__ckey); //target call

return 0;

}

[+] netname2user ( char const* p1, uid_t* p2, gid_t* p3, int* p4, gid_t* p5 )

received signal SEGV

3981: U��$�]�衄��&H 3981: U�� }��}�]��+��ðG

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

#include <rpc/rpc.h>

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

{

uid_t* p2 = (uid_t*) malloc(sizeof(uid_t)*256);

gid_t* p3 = (gid_t*) malloc(sizeof(gid_t)*256);

int* p4 = (int*) malloc(sizeof(int)*256);

gid_t* p5 = (gid_t*) malloc(sizeof(gid_t)*256);

netname2user(

"str",

p2,

p3,

p4,

p5); //target call

return 0;

}

auth_des.h, libc-2.13.so
[+] authdes_getucred ( struct authdes_cred const* __adc, uid_t* __uid, gid_t* __gid, short* __grouplen, gid_t* __groups )

received signal SEGV

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

#include <rpc/rpc.h>

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

{

struct authdes_cred __adc = {

.adc_namekind = ADN_FULLNAME,

.adc_fullname = (struct authdes_fullname) {

.name = "name",

.key = (des_block) {.key = {.high = 1, .low = 2}},

.window = 3},

.adc_nickname = 4};

uid_t* __uid = (uid_t*) malloc(sizeof(uid_t)*256);

gid_t* __gid = (gid_t*) malloc(sizeof(gid_t)*256);

short __grouplen = 0;

gid_t __groups [] = {

3};

authdes_getucred(

&__adc,

__uid,

__gid,

&__grouplen,

__groups); //target call

return 0;

}

[+] getpublickey ( char const* __name, char* __key )

received signal SEGV

2400: U��$�]�衄��&H 2400: U�� }��}�]��+��ðG

1
2
3
4
5
6
7
8
9
10
11
12

#include <rpc/rpc.h>

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

{

char __key [] = {

'A',

'B',

'C',

'D',

'\0'};

getpublickey("__name", __key); //target call

return 0;

}

[+] getsecretkey ( char const* __name, char* __key, char const* __passwd )

received signal SEGV

2486: U��$�]�衄��&H 2486: U�� }��}�]��+��ðG

1
2
3
4
5
6
7
8
9
10
11
12

#include <rpc/rpc.h>

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

{

char __key [] = {

'A',

'B',

'C',

'D',

'\0'};

getsecretkey("__name", __key, "__passwd"); //target call

return 0;

}

clnt.h, libc-2.13.so
[+] clnt_perror ( CLIENT* __clnt, char const* __msg )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <rpc/clnt.h>

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

{

CLIENT* __clnt = clnt_create(

"__host",

"__prot");

clnt_perror(__clnt, "__msg"); //target call

return 0;

}

[+] clnt_sperror ( CLIENT* __clnt, char const* __msg )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <rpc/clnt.h>

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

{

CLIENT* __clnt = clnt_create(

"__host",

"__prot");

clnt_sperror(__clnt, "__msg"); //target call

return 0;

}

ctype.h, libc-2.13.so
[+] __tolower_l ( int __c, __locale_t __l )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <ctype.h>

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

{

__locale_t __l = duplocale(0);

__tolower_l(1, __l); //target call

return 0;

}

[+] __toupper_l ( int __c, __locale_t __l )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <ctype.h>

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

{

__locale_t __l = duplocale(0);

__toupper_l(1, __l); //target call

return 0;

}

[+] isalnum_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

isalnum_l(1, duplocale(0)); //target call

return 0;

}

[+] isalpha_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

isalpha_l(1, duplocale(0)); //target call

return 0;

}

[+] isblank_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

isblank_l(1, duplocale(0)); //target call

return 0;

}

[+] iscntrl_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

iscntrl_l(1, duplocale(0)); //target call

return 0;

}

[+] isdigit_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

isdigit_l(1, duplocale(0)); //target call

return 0;

}

[+] isgraph_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

isgraph_l(1, duplocale(0)); //target call

return 0;

}

[+] islower_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

islower_l(1, duplocale(0)); //target call

return 0;

}

[+] isprint_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

isprint_l(1, duplocale(0)); //target call

return 0;

}

[+] ispunct_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

ispunct_l(1, duplocale(0)); //target call

return 0;

}

[+] isspace_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

isspace_l(1, duplocale(0)); //target call

return 0;

}

[+] isupper_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

isupper_l(1, duplocale(0)); //target call

return 0;

}

[+] isxdigit_l ( int p1, __locale_t p2 )

received signal SEGV

#include <locale.h>

#include <ctype.h>

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

{

isxdigit_l(1, duplocale(0)); //target call

return 0;

}

[+] tolower_l ( int __c, __locale_t __l )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <ctype.h>

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

{

__locale_t __l = duplocale(0);

tolower_l(1, __l); //target call

return 0;

}

[+] toupper_l ( int __c, __locale_t __l )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <ctype.h>

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

{

__locale_t __l = duplocale(0);

toupper_l(1, __l); //target call

return 0;

}

dirent.h, libc-2.13.so
[+] alphasort ( struct dirent const** __e1, struct dirent const** __e2 )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

struct dirent* __e1 = readdir(__dirp);

struct dirent* __e2 = readdir(__dirp);

alphasort((struct dirent const**)&__e1, (struct dirent const**)&__e2); //target call

return 0;

}

[+] alphasort64 ( struct dirent64 const** __e1, struct dirent64 const** __e2 )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

struct dirent64* __e1 = readdir64(__dirp);

struct dirent64* __e2 = readdir64(__dirp);

alphasort64((struct dirent64 const**)&__e1, (struct dirent64 const**)&__e2); //target call

return 0;

}

[+] dirfd ( DIR* __dirp )

received signal SEGV

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

dirfd(__dirp); //target call

return 0;

}

[+] readdir ( DIR* __dirp )

received signal SEGV

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

readdir(__dirp); //target call

return 0;

}

[+] readdir64 ( DIR* __dirp )

received signal SEGV

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

readdir64(__dirp); //target call

return 0;

}

[+] readdir64_r ( DIR* __dirp, struct dirent64* __entry, struct dirent64** __result )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

struct dirent64* __entry = readdir64(__dirp);

struct dirent64* __result = 0;

readdir64_r(__dirp, __entry, (struct dirent64**)&__result); //target call

return 0;

}

[+] readdir_r ( DIR* __dirp, struct dirent* __entry, struct dirent** __result )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

struct dirent* __entry = readdir(__dirp);

struct dirent* __result = 0;

readdir_r(__dirp, __entry, (struct dirent**)&__result); //target call

return 0;

}

[+] rewinddir ( DIR* __dirp )

received signal SEGV

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

rewinddir(__dirp); //target call

return 0;

}

[+] scandir ( char const* __dir, struct dirent*** __namelist, int(*__selector)(struct dirent const*), int(*__cmp)(struct dirent const**, struct dirent const**) )

received signal SEGV

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

#include <dirent.h>

//auxiliary function

int

__selector(struct dirent const* p1){

return 1;

}

//auxiliary function

int

__cmp(struct dirent const** p1, struct dirent const** p2){

return 2;

}

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

{

DIR* __dirp = opendir("__name");

struct dirent* __namelist = readdir(__dirp);

struct dirent* *__namelist_p = (struct dirent* *)&__namelist;

struct dirent* **__namelist_pp = &__namelist_p;

scandir(

"testdata/",

(struct dirent***)__namelist_pp,

&__selector,

&__cmp); //target call

return 0;

}

[+] scandir64 ( char const* __dir, struct dirent64*** __namelist, int(*__selector)(struct dirent64 const*), int(*__cmp)(struct dirent64 const**, struct dirent64 const**) )

received signal SEGV

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

#include <dirent.h>

//auxiliary function

int

__selector(struct dirent64 const* p1){

return 1;

}

//auxiliary function

int

__cmp(struct dirent64 const** p1, struct dirent64 const** p2){

return 2;

}

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

{

DIR* __dirp = opendir("__name");

struct dirent64* __namelist = readdir64(__dirp);

struct dirent64* *__namelist_p = (struct dirent64* *)&__namelist;

struct dirent64* **__namelist_pp = &__namelist_p;

scandir64(

"testdata/",

(struct dirent64***)__namelist_pp,

&__selector,

&__cmp); //target call

return 0;

}

[+] seekdir ( DIR* __dirp, long __pos )

received signal SEGV

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

seekdir(__dirp, 1L); //target call

return 0;

}

[+] telldir ( DIR* __dirp )

received signal SEGV

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

telldir(__dirp); //target call

return 0;

}

[+] versionsort ( struct dirent const** __e1, struct dirent const** __e2 )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

struct dirent* __e1 = readdir(__dirp);

struct dirent* __e2 = readdir(__dirp);

versionsort((struct dirent const**)&__e1, (struct dirent const**)&__e2); //target call

return 0;

}

[+] versionsort64 ( struct dirent64 const** __e1, struct dirent64 const** __e2 )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <dirent.h>

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

{

DIR* __dirp = opendir("__name");

struct dirent64* __e1 = readdir64(__dirp);

struct dirent64* __e2 = readdir64(__dirp);

versionsort64((struct dirent64 const**)&__e1, (struct dirent64 const**)&__e2); //target call

return 0;

}

envz.h, libc-2.13.so
[+] envz_merge ( char** __envz, size_t* __envz_len, char const* __envz2, size_t __envz2_len, int __override )

received signal SEGV

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

#include <envz.h>

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

{

char* __envz = 0;

unsigned int __envz_len = 0;

envz_merge(

(char**)&__envz,

&__envz_len,

"__envz2",

1); //target call

return 0;

}

ether.h, libc-2.13.so
[+] ether_hostton ( char const* __hostname, struct ether_addr* __addr )

received signal SEGV

1191: U��$�]�衄��&H 1191: U�� }��}�]��+��ðG

#include <netinet/ether.h>

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

{

struct ether_addr* __addr = ether_aton("__asc");

ether_hostton("__hostname", __addr); //target call

return 0;

}

[+] ether_ntoa ( struct ether_addr const* __addr )

received signal SEGV

#include <netinet/ether.h>

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

{

struct ether_addr* __addr = ether_aton("__asc");

ether_ntoa(__addr); //target call

return 0;

}

[+] ether_ntoa_r ( struct ether_addr const* __addr, char* __buf )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <stdlib.h>

#include <netinet/ether.h>

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

{

struct ether_addr* __addr = ether_aton("__asc");

char* __buf = (char*) malloc(sizeof(char)*256);

ether_ntoa_r(__addr, __buf); //target call

return 0;

}

[+] ether_ntohost ( char* __hostname, struct ether_addr const* __addr )

received signal SEGV

1207: U��$�]�衄��&H 1207: U�� }��}�]��+��ðG

#include <netinet/ether.h>

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

{

struct ether_addr* __addr = ether_aton("__asc");

ether_ntohost("__hostname", __addr); //target call

return 0;

}

execinfo.h, libc-2.13.so
[+] backtrace ( void** __array, int __size )

received signal SEGV

535: U��$�]�衄��&H 535: U�� }��}�]��+��ðG

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

#include <stdlib.h>

#include <execinfo.h>

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

{

void* __array [] = {

malloc(256),

0};

backtrace(__array, 4); //target call

return 0;

}

[+] backtrace_symbols ( void*const* __array, int __size )

received signal SEGV

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

#include <stdlib.h>

#include <execinfo.h>

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

{

void* __array [] = {

malloc(256),

0};

backtrace_symbols((void*const*)__array, 4); //target call

return 0;

}

[+] backtrace_symbols_fd ( void*const* __array, int __size, int __fd )

received signal SEGV

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

#include <sys/stat.h>

#include <fcntl.h>

#include <stdlib.h>

#include <execinfo.h>

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

{

void* __array [] = {

malloc(256),

0};

int __fd = open("testdata/sample.txt", O_RDWR);

backtrace_symbols_fd((void*const*)__array, 4, __fd); //target call

return 0;

}

grp.h, libc-2.13.so
[+] setgrent ( )

received signal SEGV

5623: U��$�]�衄��&H 5623: U�� }��}�]��+��ðG

#include <grp.h>

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

{

setgrent(); //target call

return 0;

}

gshadow.h, libc-2.13.so
[+] setsgent ( )

received signal SEGV

5742: U��$�]�衄��&H 5742: U�� }��}�]��+��ðG

#include <gshadow.h>

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

{

setsgent(); //target call

return 0;

}

in.h, libc-2.13.so
[+] getsourcefilter ( int __s, uint32_t __interface_addr, struct sockaddr const* __group, socklen_t __grouplen, uint32_t* __fmode, uint32_t* __numsrc, struct sockaddr_storage* __slist )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

#include <stdlib.h>

#include <netinet/in.h>

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

{

uint32_t __interface_addr = (uint32_t) malloc(sizeof(unsigned int)*256);

struct sockaddr __group = {

.sa_family = AF_INET,

.sa_data = {

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N'}};

uint32_t* __fmode = (uint32_t*) malloc(sizeof(uint32_t)*256);

uint32_t* __numsrc = (uint32_t*) malloc(sizeof(uint32_t)*256);

struct sockaddr_storage __slist [] = {

(struct sockaddr_storage) {

.ss_family = 2,

.__ss_align = 3,

.__ss_padding = {

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D'}},

(struct sockaddr_storage) {

.ss_family = 4,

.__ss_align = 5,

.__ss_padding = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T'}},

(struct sockaddr_storage) {

.ss_family = 6,

.__ss_align = 7,

.__ss_padding = {

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}},

(struct sockaddr_storage) {

.ss_family = 8,

.__ss_align = 9,

.__ss_padding = {

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z'}},

(struct sockaddr_storage) {0}};

getsourcefilter(

__interface_addr,

&__group,

256,

__fmode,

__numsrc,

__slist); //target call

return 0;

}

[+] inet6_option_init ( void* __bp, struct cmsghdr** __cmsgp, int __type )

received signal SEGV

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

#include <stdlib.h>

#include <netinet/in.h>

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

{

void* __bp = malloc(256);

void* msg_name = malloc(256);

void* iov_base = malloc(256);

struct iovec msg_iov = {.iov_base = iov_base, .iov_len = 4};

void* msg_control = malloc(256);

struct msghdr __mhdr = {

.msg_name = msg_name,

.msg_namelen = 4,

.msg_iov = &msg_iov,

.msg_iovlen = 4,

.msg_control = msg_control,

.msg_controllen = 4,

.msg_flags = 0};

struct cmsghdr* __cmsgp = __cmsg_nxthdr(&__mhdr, 0);

inet6_option_init(__bp, (struct cmsghdr**)&__cmsgp, 0); //target call

return 0;

}

langinfo.h, libc-2.13.so
[+] nl_langinfo_l ( nl_item __item, __locale_t __l )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <langinfo.h>

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

{

__locale_t __l = duplocale(0);

nl_langinfo_l(1, __l); //target call

return 0;

}

link.h, libc-2.13.so
[+] dl_iterate_phdr ( int(*__callback)(struct dl_phdr_info*, size_t, void*), void* __data )

received signal SEGV

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

#include <stdlib.h>

#include <link.h>

//auxiliary function

int

__callback(struct dl_phdr_info* p1, size_t p2, void* p3){

return 1;

}

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

{

void* __data = malloc(256);

dl_iterate_phdr(&__callback, __data); //target call

return 0;

}

locale.h, libc-2.13.so
[+] freelocale ( __locale_t __dataset )

received signal SEGV

#include <locale.h>

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

{

__locale_t __dataset = duplocale(0);

freelocale(__dataset); //target call

return 0;

}

[+] newlocale ( int __category_mask, char const* __locale, __locale_t __base )

received signal SEGV

#include <locale.h>

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

{

__locale_t __base = duplocale(0);

newlocale(0, "__locale", __base); //target call

return 0;

}

[+] uselocale ( __locale_t __dataset )

received signal SEGV

#include <locale.h>

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

{

__locale_t __dataset = duplocale(0);

uselocale(__dataset); //target call

return 0;

}

malloc.h, libc-2.13.so
[+] mallinfo ( )

received signal SEGV

#include <malloc.h>

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

{

mallinfo(); //target call

return 0;

}

[+] malloc_get_state ( )

received signal SEGV

#include <malloc.h>

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

{

malloc_get_state(); //target call

return 0;

}

[+] malloc_info ( int __options, FILE* __fp )

received signal SEGV

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

#include <wchar.h>

#include <stdio.h>

#include <malloc.h>

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

{

FILE* __fp = fopen("testdata/sample.txt", "r+");

malloc_info(0, __fp); //target call

//finalization

fclose(__fp);

return 0;

}

[+] malloc_set_state ( void* __ptr )

received signal SEGV

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <malloc.h>

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

{

void* __ptr = malloc(256);

malloc_set_state(__ptr); //target call

return 0;

}

[+] malloc_stats ( )

received signal SEGV

#include <malloc.h>

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

{

malloc_stats(); //target call

return 0;

}

[+] malloc_trim ( size_t __pad )

received signal SEGV

#include <malloc.h>

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

{

malloc_trim(4); //target call

return 0;

}

[+] mallopt ( int __param, int __val )

received signal SEGV

#include <malloc.h>

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

{

mallopt(1, 2); //target call

return 0;

}

[+] memalign ( size_t __alignment, size_t __size )

received signal SEGV

#include <malloc.h>

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

{

memalign(4, 4); //target call

return 0;

}

[+] pvalloc ( size_t __size )

received signal SEGV

#include <malloc.h>

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

{

pvalloc(4); //target call

return 0;

}

mntent.h, libc-2.13.so
[+] endmntent ( FILE* __stream )

received signal SEGV

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

#include <wchar.h>

#include <stdio.h>

#include <mntent.h>

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

{

FILE* __stream = fopen("testdata/sample.txt", "r+");

endmntent(__stream); //target call

//finalization

fclose(__stream);

return 0;

}

monetary.h, libc-2.13.so
[+] strfmon_l ( char* __s, size_t __maxsize, __locale_t __loc, char const* __format, ... )

received signal SEGV

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

#include <locale.h>

#include <rpc/types.h>

#include <monetary.h>

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

{

char __s [] = {

'A',

'B',

'C',

'D',

'\0'};

__locale_t __loc = duplocale(0);

strfmon_l(

__s,

__loc,

"%d",

(char*)0); //target call

return 0;

}

netdb.h, libc-2.13.so
[+] innetgr ( char const* __netgroup, char const* __host, char const* __user, char const* __domain )

received signal SEGV

2907: U��$�]�衄��&H 2907: U�� }��}�]��+��ðG

1
2
3
4
5
6
7
8
9
10

#include <netdb.h>

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

{

innetgr(

"__netgroup",

"__host",

"__user",

"__domain"); //target call

return 0;

}

[+] setnetent ( int __stay_open )

received signal SEGV

5679: U��$�]�衄��&H 5679: U�� }��}�]��+��ðG

#include <netdb.h>

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

{

setnetent(1); //target call

return 0;

}

[+] setnetgrent ( char const* __netgroup )

received signal SEGV

5683: U��$�]�衄��&H 5683: U�� }��}�]��+��ðG

#include <netdb.h>

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

{

setnetgrent("__netgroup"); //target call

return 0;

}

[+] setrpcent ( int __stayopen )

received signal SEGV

5734: U��$�]�衄��&H 5734: U�� }��}�]��+��ðG

#include <netdb.h>

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

{

setrpcent(1); //target call

return 0;

}

poll.h, libc-2.13.so
[+] ppoll ( struct pollfd* __fds, nfds_t __nfds, struct timespec const* __timeout, __sigset_t const* __ss )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57

#include <rpc/rpc.h>
#include <poll.h>
int main(int argc, char *argv[])
{
struct pollfd** __fds = __rpc_thread_svc_pollfd();
struct timespec __timeout;
clock_getres(2, &__timeout);

__sigset_t __ss [] = {
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {0}};
ppoll(
*__fds,
1,
&__timeout,
__ss); //target call
return 0;
}

pthread.h, libc-2.13.so
[+] pthread_cond_timedwait ( pthread_cond_t* __cond, pthread_mutex_t* __mutex, struct timespec const* __abstime )

received signal SEGV

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

#include <pthread.h>

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

{

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t __cond;

pthread_cond_init(&__cond, &__cond_attr);

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t __mutex;

pthread_mutex_init(&__mutex, &__mutexattr);

struct timespec __abstime;

clock_getres(1, &__abstime);

pthread_cond_timedwait(&__cond, &__mutex, &__abstime); //target call

return 0;

}

[+] pthread_cond_wait ( pthread_cond_t* __cond, pthread_mutex_t* __mutex )

received signal SEGV

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

#include <pthread.h>

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

{

pthread_condattr_t __cond_attr;

pthread_condattr_init(&__cond_attr);

pthread_cond_t __cond;

pthread_cond_init(&__cond, &__cond_attr);

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t __mutex;

pthread_mutex_init(&__mutex, &__mutexattr);

pthread_cond_wait(&__cond, &__mutex); //target call

return 0;

}

[+] pthread_mutex_destroy ( pthread_mutex_t* __mutex )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t __mutex;

pthread_mutex_init(&__mutex, &__mutexattr);

pthread_mutex_destroy(&__mutex); //target call

return 0;

}

[+] pthread_mutex_init ( pthread_mutex_t* __mutex, pthread_mutexattr_t const* __mutexattr )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <pthread.h>

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

{

pthread_mutex_t __mutex;

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_init(&__mutex, &__mutexattr); //target call

return 0;

}

[+] pthread_mutex_lock ( pthread_mutex_t* __mutex )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t __mutex;

pthread_mutex_init(&__mutex, &__mutexattr);

pthread_mutex_lock(&__mutex); //target call

return 0;

}

[+] pthread_mutex_unlock ( pthread_mutex_t* __mutex )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t __mutex;

pthread_mutex_init(&__mutex, &__mutexattr);

pthread_mutex_unlock(&__mutex); //target call

return 0;

}

pwd.h, libc-2.13.so
[+] setpwent ( )

received signal SEGV

5706: U��$�]�衄��&H 5706: U�� }��}�]��+��ðG

#include <pwd.h>

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

{

setpwent(); //target call

return 0;

}

regex.h, libc-2.13.so
[+] re_compile_fastmap ( struct re_pattern_buffer* __buffer )

received signal SEGV

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <regex.h>

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

{

struct re_pattern_buffer* __buffer = (struct re_pattern_buffer*) malloc(sizeof(struct re_pattern_buffer)*256);

re_compile_fastmap(__buffer); //target call

return 0;

}

[+] re_match ( struct re_pattern_buffer* __buffer, char const* __string, int __length, int __start, struct re_registers* __regs )

received signal SEGV

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

#include <stdlib.h>

#include <regex.h>

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

{

struct re_pattern_buffer* __buffer = (struct re_pattern_buffer*) malloc(sizeof(struct re_pattern_buffer)*256);

regoff_t* start = (regoff_t*) malloc(sizeof(regoff_t)*256);

struct re_registers __regs [] = {

(struct re_registers) {.num_regs = 1, .start = start, .end = start},

(struct re_registers) {.num_regs = 2, .start = start, .end = start},

(struct re_registers) {.num_regs = 3, .start = start, .end = start},

(struct re_registers) {.num_regs = 4, .start = start, .end = start},

(struct re_registers) {0}};

re_match(

__buffer,

"__string",

__regs); //target call

return 0;

}

[+] re_match_2 ( struct re_pattern_buffer* __buffer, char const* __string1, int __length1, char const* __string2, int __length2, int __start, struct re_registers* __regs, int __stop )

received signal SEGV

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

#include <stdlib.h>

#include <regex.h>

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

{

struct re_pattern_buffer* __buffer = (struct re_pattern_buffer*) malloc(sizeof(struct re_pattern_buffer)*256);

regoff_t* start = (regoff_t*) malloc(sizeof(regoff_t)*256);

struct re_registers __regs [] = {

(struct re_registers) {.num_regs = 1, .start = start, .end = start},

(struct re_registers) {.num_regs = 2, .start = start, .end = start},

(struct re_registers) {.num_regs = 3, .start = start, .end = start},

(struct re_registers) {.num_regs = 4, .start = start, .end = start},

(struct re_registers) {0}};

re_match_2(

__buffer,

"__string1",

"__string2",

__regs,

5); //target call

return 0;

}

[+] re_search ( struct re_pattern_buffer* __buffer, char const* __string, int __length, int __start, int __range, struct re_registers* __regs )

received signal SEGV

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

#include <stdlib.h>

#include <regex.h>

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

{

struct re_pattern_buffer* __buffer = (struct re_pattern_buffer*) malloc(sizeof(struct re_pattern_buffer)*256);

regoff_t* start = (regoff_t*) malloc(sizeof(regoff_t)*256);

struct re_registers __regs [] = {

(struct re_registers) {.num_regs = 2, .start = start, .end = start},

(struct re_registers) {.num_regs = 3, .start = start, .end = start},

(struct re_registers) {.num_regs = 4, .start = start, .end = start},

(struct re_registers) {.num_regs = 5, .start = start, .end = start},

(struct re_registers) {0}};

re_search(

__buffer,

"__string",

256,

__regs); //target call

return 0;

}

[+] re_search_2 ( struct re_pattern_buffer* __buffer, char const* __string1, int __length1, char const* __string2, int __length2, int __start, int __range, struct re_registers* __regs, int __stop )

received signal SEGV

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

#include <stdlib.h>

#include <regex.h>

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

{

struct re_pattern_buffer* __buffer = (struct re_pattern_buffer*) malloc(sizeof(struct re_pattern_buffer)*256);

regoff_t* start = (regoff_t*) malloc(sizeof(regoff_t)*256);

struct re_registers __regs [] = {

(struct re_registers) {.num_regs = 2, .start = start, .end = start},

(struct re_registers) {.num_regs = 3, .start = start, .end = start},

(struct re_registers) {.num_regs = 4, .start = start, .end = start},

(struct re_registers) {.num_regs = 5, .start = start, .end = start},

(struct re_registers) {0}};

re_search_2(

__buffer,

"__string1",

"__string2",

__regs,

6); //target call

return 0;

}

sched.h, libc-2.13.so
[+] sched_rr_get_interval ( __pid_t __pid, struct timespec* __t )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <rpc/types.h>

#include <unistd.h>

#include <sched.h>

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

{

__pid_t __pid = fork();

struct timespec __t;

clock_getres(1, &__t);

sched_rr_get_interval(__pid, &__t); //target call

return 0;

}

search.h, libc-2.13.so
[+] hsearch_r ( ENTRY __item, ACTION __action, ENTRY** __retval, struct hsearch_data* __htab )

received signal SEGV

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

#include <stdlib.h>

#include <search.h>

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

{

char key [] = {

'A',

'B',

'C',

'D',

'\0'};

void* data = malloc(256);

ENTRY __item = {.key = key, .data = data};

ENTRY* __retval [] = {

&__item,

0};

struct hsearch_data __htab;

hcreate_r(4, &__htab);

hsearch_r(

__item,

FIND,

__retval,

&__htab); //target call

return 0;

}

select.h, libc-2.13.so
[+] pselect ( int __nfds, fd_set* __readfds, fd_set* __writefds, fd_set* __exceptfds, struct timespec const* __timeout, __sigset_t const* __sigmask )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#include <rpc/rpc.h>
int main(int argc, char *argv[])
{
fd_set* __readfds = __rpc_thread_svc_fdset();
fd_set* __writefds = __rpc_thread_svc_fdset();
fd_set* __exceptfds = __rpc_thread_svc_fdset();
struct timespec __timeout;
clock_getres(2, &__timeout);

__sigset_t __sigmask [] = {
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {0}};
pselect(
1,
__readfds,
__writefds,
__exceptfds,
&__timeout,
__sigmask); //target call
return 0;
}

sem.h, libc-2.13.so
[+] semtimedop ( int __semid, struct sembuf* __sops, size_t __nsops, struct timespec const* __timeout )

received signal SEGV

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

#include <sys/sem.h>

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

{

struct sembuf __sops [] = {

(struct sembuf) {.sem_num = 2, .sem_op = 3, .sem_flg = 4},

(struct sembuf) {.sem_num = 5, .sem_op = 6, .sem_flg = 7},

(struct sembuf) {.sem_num = 8, .sem_op = 9, .sem_flg = 10},

(struct sembuf) {.sem_num = 1, .sem_op = 2, .sem_flg = 3},

(struct sembuf) {0}};

struct timespec __timeout;

clock_getres(4, &__timeout);

semtimedop(

__sops,

&__timeout); //target call

return 0;

}

setjmp.h, libc-2.13.so
[+] _longjmp ( struct __jmp_buf_tag* __env, int __val )

received signal SEGV

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

#include <setjmp.h>
int main(int argc, char *argv[])
{
struct __jmp_buf_tag __env = {
.__jmpbuf = {
0,
1,
2,
3,
4,
5},
.__mask_was_saved = 0,
.__saved_mask = (__sigset_t) {
.__val = {
0, 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}}};
_longjmp(&__env, 1); //target call
return 0;
}

[+] longjmp ( struct __jmp_buf_tag* __env, int __val )

received signal SEGV

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

#include <setjmp.h>
int main(int argc, char *argv[])
{
struct __jmp_buf_tag __env = {
.__jmpbuf = {
0,
1,
2,
3,
4,
5},
.__mask_was_saved = 0,
.__saved_mask = (__sigset_t) {
.__val = {
0, 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}}};
longjmp(&__env, 1); //target call
return 0;
}

[+] siglongjmp ( struct __jmp_buf_tag* __env, int __val )

received signal SEGV

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

#include <setjmp.h>
int main(int argc, char *argv[])
{
struct __jmp_buf_tag __env = {
.__jmpbuf = {
0,
1,
2,
3,
4,
5},
.__mask_was_saved = 0,
.__saved_mask = (__sigset_t) {
.__val = {
0, 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}}};
siglongjmp(&__env, 1); //target call
return 0;
}

shadow.h, libc-2.13.so
[+] setspent ( )

received signal SEGV

5758: U��$�]�衄��&H 5758: U�� }��}�]��+��ðG

#include <shadow.h>

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

{

setspent(); //target call

return 0;

}

signal.h, libc-2.13.so
[+] sigtimedwait ( sigset_t const* __set, siginfo_t* __info, struct timespec const* __timeout )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <signal.h>
int main(int argc, char *argv[])
{
sigset_t __set [] = {
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {0}};
siginfo_t __info = {
.si_signo = 1,
.si_errno = 1,
.si_code = 2,
._sifields = {._pad = {
0, 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}}};
struct timespec __timeout;
clock_getres(3, &__timeout);

sigtimedwait(__set, &__info, &__timeout); //target call
return 0;
}

socket.h, libc-2.13.so
[+] recvmmsg ( int __fd, struct mmsghdr* __vmessages, unsigned int __vlen, int __flags, struct timespec const* __tmo )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include <stdlib.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <sys/socket.h>

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

{

int __fd = open("testdata/sample.txt", O_RDWR);

void* msg_name = malloc(256);

void* iov_base = malloc(256);

struct iovec msg_iov = {.iov_base = iov_base, .iov_len = 4};

void* msg_control = malloc(256);

void* msg_name_1 = malloc(256);

void* msg_control_1 = malloc(256);

void* msg_name_2 = malloc(256);

void* msg_control_2 = malloc(256);

void* msg_name_3 = malloc(256);

void* msg_control_3 = malloc(256);

struct mmsghdr __vmessages [] = {

(struct mmsghdr) {

.msg_hdr = (struct msghdr) {

.msg_name = msg_name,

.msg_namelen = 4,

.msg_iov = &msg_iov,

.msg_iovlen = 4,

.msg_control = msg_control,

.msg_controllen = 4,

.msg_flags = 0},

.msg_len = 4},

(struct mmsghdr) {

.msg_hdr = (struct msghdr) {

.msg_name = msg_name_1,

.msg_namelen = 4,

.msg_iov = &msg_iov,

.msg_iovlen = 4,

.msg_control = msg_control_1,

.msg_controllen = 4,

.msg_flags = 0},

.msg_len = 4},

(struct mmsghdr) {

.msg_hdr = (struct msghdr) {

.msg_name = msg_name_2,

.msg_namelen = 4,

.msg_iov = &msg_iov,

.msg_iovlen = 4,

.msg_control = msg_control_2,

.msg_controllen = 4,

.msg_flags = 0},

.msg_len = 4},

(struct mmsghdr) {

.msg_hdr = (struct msghdr) {

.msg_name = msg_name_3,

.msg_namelen = 4,

.msg_iov = &msg_iov,

.msg_iovlen = 4,

.msg_control = msg_control_3,

.msg_controllen = 4,

.msg_flags = 0},

.msg_len = 4},

(struct mmsghdr) {0}};

struct timespec __tmo;

clock_getres(1, &__tmo);

recvmmsg(

__fd,

__vmessages,

&__tmo); //target call

return 0;

}

spawn.h, libc-2.13.so
[+] posix_spawn_file_actions_addopen ( posix_spawn_file_actions_t* __file_actions, int __fd, char const* __path, int __oflag, mode_t __mode )

received signal SEGV

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

#include <rpc/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <spawn.h>

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

{

posix_spawn_file_actions_t __file_actions;

int __fd = open("testdata/sample.txt", O_RDWR);

posix_spawn_file_actions_addopen(

&__file_actions,

__fd,

"testdata/sample.txt",

0); //target call

return 0;

}

stat.h, libc-2.13.so
[+] futimens ( int __fd, struct timespec const* __times )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <sys/stat.h>

#include <fcntl.h>

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

{

int __fd = open("testdata/sample.txt", O_RDWR);

struct timespec __times;

clock_getres(1, &__times);

futimens(__fd, &__times); //target call

return 0;

}

[+] utimensat ( int __fd, char const* __path, struct timespec const* __times, int __flags )

received signal SEGV

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

#include <sys/stat.h>

#include <fcntl.h>

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

{

int __fd = open("testdata/sample.txt", O_RDWR);

struct timespec __times;

clock_getres(1, &__times);

utimensat(

__fd,

"testdata/sample.txt",

&__times,

0); //target call

return 0;

}

stdio.h, libc-2.13.so
[+] fclose ( FILE* __stream )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <wchar.h>

#include <stdio.h>

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

{

FILE* __stream = fopen("testdata/sample.txt", "r+");

fclose(__stream); //target call

//finalization

fclose(__stream);

return 0;

}

[+] gets ( char* __s )

received signal SEGV

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

#include <wchar.h>

#include <stdio.h>

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

{

char __s [] = {

'A',

'B',

'C',

'D',

'\0'};

gets(__s); //target call

return 0;

}

[+] pclose ( FILE* __stream )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <wchar.h>

#include <stdio.h>

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

{

FILE* __stream = fopen("testdata/sample.txt", "r+");

pclose(__stream); //target call

//finalization

fclose(__stream);

return 0;

}

stdlib.h, libc-2.13.so
[+] cfree ( void* __ptr )

received signal SEGV

*** glibc detected *** ./test: free(): invalid pointer: 0xb7624bd8 ***
662: U��$�]�衄��&H 662: U�� }��}�]��+��ðG

#include <stdlib.h>

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

{

void* __ptr = malloc(256);

cfree(__ptr); //target call

return 0;

}

[+] getsubopt ( char** __optionp, char*const* __tokens, char** __valuep )

received signal SEGV

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

#include <stdlib.h>

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

{

char* __optionp = 0;

char* __tokens [] = {

(char*const)__optionp,

0};

char* __valuep = 0;

getsubopt((char**)&__optionp, (char*const*)__tokens, (char**)&__valuep); //target call

return 0;

}

[+] posix_memalign ( void** __memptr, size_t __alignment, size_t __size )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdlib.h>

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

{

void* __memptr [] = {

malloc(256),

0};

posix_memalign(__memptr, 4, 4); //target call

return 0;

}

[+] random_r ( struct random_data* __buf, int32_t* __result )

received signal SEGV

1
2
3
4
5
6
7
8

#include <rpc/types.h>

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

{

struct random_data __buf;

int32_t __result = 0;

random_r(&__buf, &__result); //target call

return 0;

}

[+] realpath ( char const* __name, char* __resolved )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdlib.h>

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

{

char __resolved [] = {

'A',

'B',

'C',

'D',

'\0'};

realpath("__name", __resolved); //target call

return 0;

}

[+] strtod_l ( char const* __nptr, char** __endptr, __locale_t __loc )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <locale.h>

#include <stdlib.h>

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

{

char __nptr = 'A';

char* __endptr = 0;

__locale_t __loc = duplocale(0);

strtod_l(&__nptr, (char**)&__endptr, __loc); //target call

return 0;

}

[+] strtof_l ( char const* __nptr, char** __endptr, __locale_t __loc )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <locale.h>

#include <stdlib.h>

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

{

char __nptr = 'A';

char* __endptr = 0;

__locale_t __loc = duplocale(0);

strtof_l(&__nptr, (char**)&__endptr, __loc); //target call

return 0;

}

[+] strtol_l ( char const* __nptr, char** __endptr, int __base, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <stdlib.h>

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

{

char __nptr = 'A';

char* __endptr = 0;

__locale_t __loc = duplocale(0);

strtol_l(

&__nptr,

(char**)&__endptr,

__loc); //target call

return 0;

}

[+] strtold_l ( char const* __nptr, char** __endptr, __locale_t __loc )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <locale.h>

#include <stdlib.h>

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

{

char __nptr = 'A';

char* __endptr = 0;

__locale_t __loc = duplocale(0);

strtold_l(&__nptr, (char**)&__endptr, __loc); //target call

return 0;

}

[+] strtoll_l ( char const* __nptr, char** __endptr, int __base, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <stdlib.h>

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

{

char __nptr = 'A';

char* __endptr = 0;

__locale_t __loc = duplocale(0);

strtoll_l(

&__nptr,

(char**)&__endptr,

__loc); //target call

return 0;

}

[+] strtoul_l ( char const* __nptr, char** __endptr, int __base, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <stdlib.h>

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

{

char __nptr = 'A';

char* __endptr = 0;

__locale_t __loc = duplocale(0);

strtoul_l(

&__nptr,

(char**)&__endptr,

__loc); //target call

return 0;

}

[+] strtoull_l ( char const* __nptr, char** __endptr, int __base, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <stdlib.h>

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

{

char __nptr = 'A';

char* __endptr = 0;

__locale_t __loc = duplocale(0);

strtoull_l(

&__nptr,

(char**)&__endptr,

__loc); //target call

return 0;

}

[+] valloc ( size_t __size )

received signal SEGV

#include <stdlib.h>

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

{

valloc(4); //target call

return 0;

}

[+] wcstombs ( char* __s, wchar_t const* __pwcs, size_t __n )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdlib.h>

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

{

char __s [] = {

'A',

'B',

'C',

'D',

'\0'};

wcstombs(__s, L"__pwcs", 4); //target call

return 0;

}

string.h, libc-2.13.so
[+] strcasecmp_l ( char const* __s1, char const* __s2, __locale_t __loc )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <string.h>

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

{

__locale_t __loc = duplocale(0);

strcasecmp_l("__s1", "__s2", __loc); //target call

return 0;

}

[+] strcoll_l ( char const* __s1, char const* __s2, __locale_t __l )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <string.h>

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

{

__locale_t __l = duplocale(0);

strcoll_l("__s1", "__s2", __l); //target call

return 0;

}

[+] strerror_l ( int __errnum, __locale_t __l )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <string.h>

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

{

__locale_t __l = duplocale(0);

strerror_l(1, __l); //target call

return 0;

}

[+] strncasecmp_l ( char const* __s1, char const* __s2, size_t __n, __locale_t __loc )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <locale.h>

#include <string.h>

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

{

__locale_t __loc = duplocale(0);

strncasecmp_l(

"__s1",

"__s2",

__loc); //target call

return 0;

}

[+] strxfrm_l ( char* __dest, char const* __src, size_t __n, __locale_t __l )

received signal SEGV

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

#include <locale.h>

#include <string.h>

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

{

char __dest [] = {

'A',

'B',

'C',

'D',

'\0'};

__locale_t __l = duplocale(0);

strxfrm_l(

__dest,

"__src",

__l); //target call

return 0;

}

svc.h, libc-2.13.so
[+] svc_getreq ( int __rdfds )

received signal SEGV

#include <rpc/rpc.h>

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

{

svc_getreq(1); //target call

return 0;

}

[+] svc_getreq_common ( int const __fd )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <sys/stat.h>

#include <fcntl.h>

#include <rpc/rpc.h>

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

{

int __fd = open("testdata/sample.txt", O_RDWR);

svc_getreq_common(__fd); //target call

return 0;

}

[+] xprt_unregister ( SVCXPRT* __xprt )

received signal SEGV

#include <rpc/rpc.h>

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

{

SVCXPRT* __xprt = svcraw_create();

xprt_unregister(__xprt); //target call

return 0;

}

termios.h, libc-2.13.so
[+] cfgetispeed ( struct termios const* __termios_p )

received signal SEGV

#include <termios.h>

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

{

struct termios* __termios_p = 0; //can't initialize

cfgetispeed(__termios_p); //target call

return 0;

}

[+] cfgetospeed ( struct termios const* __termios_p )

received signal SEGV

#include <termios.h>

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

{

struct termios* __termios_p = 0; //can't initialize

cfgetospeed(__termios_p); //target call

return 0;

}

[+] cfmakeraw ( struct termios* __termios_p )

received signal SEGV

#include <termios.h>

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

{

struct termios* __termios_p = 0; //can't initialize

cfmakeraw(__termios_p); //target call

return 0;

}

[+] cfsetispeed ( struct termios* __termios_p, speed_t __speed )

received signal SEGV

1
2
3
4
5
6
7
8

#include <termios.h>

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

{

struct termios* __termios_p = 0; //can't initialize

speed_t __speed = cfgetispeed(__termios_p);

cfsetispeed(__termios_p, __speed); //target call

return 0;

}

[+] cfsetospeed ( struct termios* __termios_p, speed_t __speed )

received signal SEGV

1
2
3
4
5
6
7
8

#include <termios.h>

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

{

struct termios* __termios_p = 0; //can't initialize

speed_t __speed = cfgetispeed(__termios_p);

cfsetospeed(__termios_p, __speed); //target call

return 0;

}

[+] cfsetspeed ( struct termios* __termios_p, speed_t __speed )

received signal SEGV

1
2
3
4
5
6
7
8

#include <termios.h>

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

{

struct termios* __termios_p = 0; //can't initialize

speed_t __speed = cfgetispeed(__termios_p);

cfsetspeed(__termios_p, __speed); //target call

return 0;

}

[+] tcsetattr ( int __fd, int __optional_actions, struct termios const* __termios_p )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <sys/stat.h>

#include <fcntl.h>

#include <termios.h>

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

{

int __fd = open("testdata/sample.txt", O_RDWR);

struct termios* __termios_p = 0; //can't initialize

tcsetattr(__fd, 0, __termios_p); //target call

return 0;

}

time.h, libc-2.13.so
[+] mktime ( struct tm* __tp )

received signal SEGV

#include <time.h>

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

{

struct tm* __tp = getdate("__string");

mktime(__tp); //target call

return 0;

}

[+] nanosleep ( struct timespec const* __requested_time, struct timespec* __remaining )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <time.h>

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

{

struct timespec __requested_time;

clock_getres(1, &__requested_time);

struct timespec __remaining;

clock_getres(2, &__remaining);

nanosleep(&__requested_time, &__remaining); //target call

return 0;

}

[+] strftime ( char* __s, size_t __maxsize, char const* __format, struct tm const* __tp )

received signal SEGV

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

#include <time.h>

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

{

char __s [] = {

'A',

'B',

'C',

'D',

'\0'};

struct tm* __tp = getdate("__string");

strftime(

__s,

"__format",

__tp); //target call

return 0;

}

[+] strftime_l ( char* __s, size_t __maxsize, char const* __format, struct tm const* __tp, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <time.h>

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

{

char __s [] = {

'A',

'B',

'C',

'D',

'\0'};

struct tm* __tp = getdate("__string");

__locale_t __loc = duplocale(0);

strftime_l(

__s,

"__format",

__tp,

__loc); //target call

return 0;

}

[+] strptime_l ( char const* __s, char const* __fmt, struct tm* __tp, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <time.h>

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

{

struct tm* __tp = getdate("__string");

__locale_t __loc = duplocale(0);

strptime_l(

"__s",

"__fmt",

__tp,

__loc); //target call

return 0;

}

[+] time ( time_t* __timer )

received signal SEGV

1
2
3
4
5
6
7
8

#include <time.h>

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

{

struct tm* __tp = getdate("__string");

time_t __timer = mktime(__tp);

time(&__timer); //target call

return 0;

}

[+] timegm ( struct tm* __tp )

received signal SEGV

#include <time.h>

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

{

struct tm* __tp = getdate("__string");

timegm(__tp); //target call

return 0;

}

[+] timelocal ( struct tm* __tp )

received signal SEGV

#include <time.h>

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

{

struct tm* __tp = getdate("__string");

timelocal(__tp); //target call

return 0;

}

timerfd.h, libc-2.13.so
[+] timerfd_gettime ( int __ufd, struct itimerspec* __otmr )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <sys/timerfd.h>

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

{

timer_t __timerid = malloc(256);

struct itimerspec __otmr;

timer_gettime(__timerid, &__otmr);

timerfd_gettime(1, &__otmr); //target call

return 0;

}

[+] timerfd_settime ( int __ufd, int __flags, struct itimerspec const* __utmr, struct itimerspec* __otmr )

received signal SEGV

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

#include <stdlib.h>

#include <sys/timerfd.h>

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

{

timer_t __timerid = malloc(256);

struct itimerspec __utmr;

timer_gettime(__timerid, &__utmr);

timer_t __timerid_1 = malloc(256);

struct itimerspec __otmr;

timer_gettime(__timerid_1, &__otmr);

timerfd_settime(

&__utmr,

&__otmr); //target call

return 0;

}

ucontext.h, libc-2.13.so
[+] setcontext ( ucontext_t const* __ucp )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

#include <stdlib.h>

#include <ucontext.h>

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

{

void* ss_sp = malloc(256);

struct _libc_fpstate fpregs = {

.cw = 1,

.sw = 2,

.tag = 3,

.ipoff = 4,

.cssel = 5,

.dataoff = 6,

.datasel = 7,

._st = {

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 8},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 9},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 10},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 1},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 2},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 3},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 4},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 5}},

.status = 6};

ucontext_t __ucp = {

.uc_flags = 0,

.uc_link = 0,

.uc_stack = (stack_t) {.ss_sp = ss_sp, .ss_flags = 0, .ss_size = 4},

.uc_mcontext = (mcontext_t) {

.gregs = {

0, 1, 2, 3,

4, 5, 6, 7,

8, 9, 10, 11,

12, 13, 14, 15,

16, 17, 18},

.fpregs = &fpregs,

.oldmask = 0,

.cr2 = 7},

.uc_sigmask = (__sigset_t) {

.__val = {

0, 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}},

.__fpregs_mem = fpregs};

setcontext(&__ucp); //target call

return 0;

}

[+] swapcontext ( ucontext_t* __oucp, ucontext_t const* __ucp )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

#include <stdlib.h>

#include <ucontext.h>

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

{

void* ss_sp = malloc(256);

struct _libc_fpstate fpregs = {

.cw = 1,

.sw = 2,

.tag = 3,

.ipoff = 4,

.cssel = 5,

.dataoff = 6,

.datasel = 7,

._st = {

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 8},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 9},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 10},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 1},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 2},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 3},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 4},

(struct _libc_fpreg) {

.significand = {

3},

.exponent = 5}},

.status = 6};

ucontext_t __oucp = {

.uc_flags = 0,

.uc_link = 0,

.uc_stack = (stack_t) {.ss_sp = ss_sp, .ss_flags = 0, .ss_size = 4},

.uc_mcontext = (mcontext_t) {

.gregs = {

0, 1, 2, 3,

4, 5, 6, 7,

8, 9, 10, 11,

12, 13, 14, 15,

16, 17, 18},

.fpregs = &fpregs,

.oldmask = 0,

.cr2 = 7},

.uc_sigmask = (__sigset_t) {

.__val = {

0, 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}},

.__fpregs_mem = fpregs};

void* ss_sp_1 = malloc(256);

ucontext_t __ucp = {

.uc_flags = 0,

.uc_link = 0,

.uc_stack = (stack_t) {.ss_sp = ss_sp_1, .ss_flags = 0, .ss_size = 4},

.uc_mcontext = (mcontext_t) {

.gregs = {

0, 1, 2, 3,

4, 5, 6, 7,

8, 9, 10, 11,

12, 13, 14, 15,

16, 17, 18},

.fpregs = &fpregs,

.oldmask = 0,

.cr2 = 8},

.uc_sigmask = (__sigset_t) {

.__val = {

0, 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}},

.__fpregs_mem = fpregs};

swapcontext(&__oucp, &__ucp); //target call

return 0;

}

vm86.h, libc-2.13.so
[+] vm86 ( unsigned long __subfunction, struct vm86plus_struct* __info )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#include <sys/vm86.h>

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

{

struct vm86plus_struct __info = {

.regs = (struct vm86_regs) {

.ebx = 2L,

.ecx = 3L,

.edx = 4L,

.esi = 5L,

.edi = 6L,

.ebp = 7L,

.eax = 8L,

.__null_ds = 9L,

.__null_es = 10L,

.__null_fs = 1L,

.__null_gs = 2L,

.orig_eax = 3L,

.eip = 4L,

.cs = 5,

.__csh = 6,

.eflags = 0,

.esp = 7L,

.ss = 8,

.__ssh = 9,

.es = 10,

.__esh = 1,

.ds = 2,

.__dsh = 3,

.fs = 4,

.__fsh = 5,

.gs = 6,

.__gsh = 7},

.flags = 0,

.screen_bitmap = 1,

.cpu_type = 0,

.int_revectored = (struct revectored_struct) {

.__map = {

0, 1, 2, 3,

4, 5, 6, 7}},

.int21_revectored = (struct revectored_struct) {

.__map = {

0, 1, 2, 3,

4, 5, 6, 7}},

.vm86plus = (struct vm86plus_info_struct) {

.force_return_for_pic = 8,

.vm86dbg_active = 9,

.vm86dbg_TFpendig = 10,

.unused = 0,

.is_vm86pus = 1,

.vm86dbg_intxxtab = {

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F'}}};

vm86(1, &__info); //target call

return 0;

}

wchar.h, libc-2.13.so
[+] wcscasecmp_l ( wchar_t const* __s1, wchar_t const* __s2, __locale_t __loc )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wchar.h>

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

{

__locale_t __loc = duplocale(0);

wcscasecmp_l(L"__s1", L"__s2", __loc); //target call

return 0;

}

[+] wcscat ( wchar_t* __dest, wchar_t const* __src )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <wchar.h>

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

{

wchar_t __dest [] = {

L'A',

L'B',

L'C',

L'D',

L'\0'};

wcscat(__dest, L"__src"); //target call

return 0;

}

[+] wcscoll_l ( wchar_t const* __s1, wchar_t const* __s2, __locale_t __loc )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wchar.h>

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

{

__locale_t __loc = duplocale(0);

wcscoll_l(L"__s1", L"__s2", __loc); //target call

return 0;

}

[+] wcsftime ( wchar_t* __s, size_t __maxsize, wchar_t const* __format, struct tm const* __tp )

received signal SEGV

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

#include <time.h>

#include <wchar.h>

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

{

wchar_t __s [] = {

L'A',

L'B',

L'C',

L'D',

L'\0'};

struct tm* __tp = getdate("__string");

wcsftime(

__s,

L"__format",

__tp); //target call

return 0;

}

[+] wcsftime_l ( wchar_t* __s, size_t __maxsize, wchar_t const* __format, struct tm const* __tp, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <time.h>

#include <wchar.h>

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

{

wchar_t __s [] = {

L'A',

L'B',

L'C',

L'D',

L'\0'};

struct tm* __tp = getdate("__string");

__locale_t __loc = duplocale(0);

wcsftime_l(

__s,

L"__format",

__tp,

__loc); //target call

return 0;

}

[+] wcsncasecmp_l ( wchar_t const* __s1, wchar_t const* __s2, size_t __n, __locale_t __loc )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <locale.h>

#include <wchar.h>

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

{

__locale_t __loc = duplocale(0);

wcsncasecmp_l(

L"__s1",

L"__s2",

__loc); //target call

return 0;

}

[+] wcsrtombs ( char* __dst, wchar_t const** __src, size_t __len, mbstate_t* __ps )

received signal SEGV

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

#include <wchar.h>

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

{

char __dst [] = {

'A',

'B',

'C',

'D',

'\0'};

wchar_t* __src [] = {

"testdata/sample.txt",

0};

mbstate_t __ps = {.__count = 4, .__value = {.__wch = 1}};

wcsrtombs(

__dst,

(wchar_t const**)__src,

&__ps); //target call

return 0;

}

[+] wcstod_l ( wchar_t const* __nptr, wchar_t** __endptr, __locale_t __loc )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <locale.h>

#include <wchar.h>

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

{

wchar_t __nptr = L'A';

wchar_t* __endptr = 0;

__locale_t __loc = duplocale(0);

wcstod_l(&__nptr, (wchar_t**)&__endptr, __loc); //target call

return 0;

}

[+] wcstof_l ( wchar_t const* __nptr, wchar_t** __endptr, __locale_t __loc )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <locale.h>

#include <wchar.h>

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

{

wchar_t __nptr = L'A';

wchar_t* __endptr = 0;

__locale_t __loc = duplocale(0);

wcstof_l(&__nptr, (wchar_t**)&__endptr, __loc); //target call

return 0;

}

[+] wcstol_l ( wchar_t const* __nptr, wchar_t** __endptr, int __base, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <wchar.h>

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

{

wchar_t __nptr = L'A';

wchar_t* __endptr = 0;

__locale_t __loc = duplocale(0);

wcstol_l(

&__nptr,

(wchar_t**)&__endptr,

__loc); //target call

return 0;

}

[+] wcstold_l ( wchar_t const* __nptr, wchar_t** __endptr, __locale_t __loc )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <locale.h>

#include <wchar.h>

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

{

wchar_t __nptr = L'A';

wchar_t* __endptr = 0;

__locale_t __loc = duplocale(0);

wcstold_l(&__nptr, (wchar_t**)&__endptr, __loc); //target call

return 0;

}

[+] wcstoll_l ( wchar_t const* __nptr, wchar_t** __endptr, int __base, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <wchar.h>

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

{

wchar_t __nptr = L'A';

wchar_t* __endptr = 0;

__locale_t __loc = duplocale(0);

wcstoll_l(

&__nptr,

(wchar_t**)&__endptr,

__loc); //target call

return 0;

}

[+] wcstoul_l ( wchar_t const* __nptr, wchar_t** __endptr, int __base, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <wchar.h>

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

{

wchar_t __nptr = L'A';

wchar_t* __endptr = 0;

__locale_t __loc = duplocale(0);

wcstoul_l(

&__nptr,

(wchar_t**)&__endptr,

__loc); //target call

return 0;

}

[+] wcstoull_l ( wchar_t const* __nptr, wchar_t** __endptr, int __base, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <wchar.h>

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

{

wchar_t __nptr = L'A';

wchar_t* __endptr = 0;

__locale_t __loc = duplocale(0);

wcstoull_l(

&__nptr,

(wchar_t**)&__endptr,

__loc); //target call

return 0;

}

[+] wcsxfrm_l ( wchar_t* __s1, wchar_t const* __s2, size_t __n, __locale_t __loc )

received signal SEGV

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

#include <locale.h>

#include <wchar.h>

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

{

wchar_t __s1 [] = {

L'A',

L'B',

L'C',

L'D',

L'\0'};

__locale_t __loc = duplocale(0);

wcsxfrm_l(

__s1,

L"__s2",

__loc); //target call

return 0;

}

wctype.h, libc-2.13.so
[+] iswalnum_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswalnum_l(1, __locale); //target call

return 0;

}

[+] iswalpha_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswalpha_l(1, __locale); //target call

return 0;

}

[+] iswblank_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswblank_l(1, __locale); //target call

return 0;

}

[+] iswcntrl_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswcntrl_l(1, __locale); //target call

return 0;

}

[+] iswctype_l ( wint_t __wc, wctype_t __desc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

wctype_t __desc = wctype_l("__property", __locale);

iswctype_l(1, __desc, __locale); //target call

return 0;

}

[+] iswdigit_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswdigit_l(1, __locale); //target call

return 0;

}

[+] iswgraph_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswgraph_l(1, __locale); //target call

return 0;

}

[+] iswlower_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswlower_l(1, __locale); //target call

return 0;

}

[+] iswprint_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswprint_l(1, __locale); //target call

return 0;

}

[+] iswpunct_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswpunct_l(1, __locale); //target call

return 0;

}

[+] iswspace_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswspace_l(1, __locale); //target call

return 0;

}

[+] iswupper_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswupper_l(1, __locale); //target call

return 0;

}

[+] iswxdigit_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

iswxdigit_l(1, __locale); //target call

return 0;

}

[+] towctrans_l ( wint_t __wc, wctrans_t __desc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

wctrans_t __desc = wctrans_l("__property", __locale);

towctrans_l(1, __desc, __locale); //target call

return 0;

}

[+] towlower_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

towlower_l(1, __locale); //target call

return 0;

}

[+] towupper_l ( wint_t __wc, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

towupper_l(1, __locale); //target call

return 0;

}

[+] wctrans_l ( char const* __property, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

wctrans_l("__property", __locale); //target call

return 0;

}

[+] wctype_l ( char const* __property, __locale_t __locale )

received signal SEGV

1
2
3
4
5
6
7
8

#include <locale.h>

#include <wctype.h>

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

{

__locale_t __locale = duplocale(0);

wctype_l("__property", __locale); //target call

return 0;

}

xdr.h, libc-2.13.so
[+] xdr_bytes ( XDR* __xdrs, char** __cpp, u_int* __sizep, u_int __maxsize )

received signal SEGV

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

#include <wchar.h>

#include <stdio.h>

#include <rpc/xdr.h>

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

{

FILE* __file = fopen("testdata/sample.txt", "r+");

XDR __xdrs;

xdrstdio_create(&__xdrs, __file, XDR_ENCODE);

char* __cpp = 0;

u_int __sizep [] = {

4};

xdr_bytes(

&__xdrs,

(char**)&__cpp,

__sizep,

4); //target call

//finalization

fclose(__file);

return 0;

}

[+] xdr_opaque ( XDR* __xdrs, caddr_t __cp, u_int __cnt )

received signal SEGV

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

#include <wchar.h>

#include <stdio.h>

#include <rpc/xdr.h>

//auxiliary function

bool_t

__proc(XDR* p1, void* p2){

return 1;

}

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

{

FILE* __file = fopen("testdata/sample.txt", "r+");

XDR __xdrs;

xdrstdio_create(&__xdrs, __file, XDR_ENCODE);

caddr_t __cp = 0;

xdr_reference(

&__xdrs,

&__cp,

&__proc);

xdr_opaque(&__xdrs, __cp, 1); //target call

//finalization

fclose(__file);

return 0;

}

[+] xdrrec_endofrecord ( XDR* __xdrs, bool_t __sendnow )

received signal SEGV

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

#include <wchar.h>

#include <stdio.h>

#include <rpc/xdr.h>

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

{

FILE* __file = fopen("testdata/sample.txt", "r+");

XDR __xdrs;

xdrstdio_create(&__xdrs, __file, XDR_ENCODE);

xdrrec_endofrecord(&__xdrs, 1); //target call

//finalization

fclose(__file);

return 0;

}

crypt.h, libcrypt-2.13.so
[+] crypt_r ( char const* __key, char const* __salt, struct crypt_data* __data )

received signal SEGV

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
46
47
48
49

#include <crypt.h>

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

{

struct crypt_data __data = {

.keysched = {

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X'},

.crypt_3_buf = {

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L'},

.current_salt = {'M', 'N'},

.current_saltbits = 1L,

.direction = 2,

.initialized = 0};

crypt_r("__key", "__salt", &__data); //target call

return 0;

}

[+] encrypt_r ( char* __block, int __edflag, struct crypt_data* __data )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55

#include <crypt.h>

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

{

char __block [] = {

'A',

'B',

'C',

'D',

'\0'};

struct crypt_data __data = {

.keysched = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B'},

.crypt_3_buf = {

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P'},

.current_salt = {'Q', 'R'},

.current_saltbits = 1L,

.direction = 2,

.initialized = 0};

encrypt_r(__block, 0, &__data); //target call

return 0;

}

[+] setkey_r ( char const* __key, struct crypt_data* __data )

received signal SEGV

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
46
47
48
49

#include <crypt.h>

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

{

struct crypt_data __data = {

.keysched = {

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X'},

.crypt_3_buf = {

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L'},

.current_salt = {'M', 'N'},

.current_saltbits = 1L,

.direction = 2,

.initialized = 0};

setkey_r("__key", &__data); //target call

return 0;

}

stdlib.h, libcrypt-2.13.so
[+] setkey ( char const* __key )

received signal SEGV

#include <stdlib.h>

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

{

setkey("__key"); //target call

return 0;

}

unistd.h, libcrypt-2.13.so
[+] crypt ( char const* __key, char const* __salt )

received signal SEGV

#include <unistd.h>

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

{

crypt("__key", "__salt"); //target call

return 0;

}

[+] encrypt ( char* __block, int __edflag )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <unistd.h>

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

{

char __block [] = {

'A',

'B',

'C',

'D',

'\0'};

encrypt(__block, 0); //target call

return 0;

}

dlfcn.h, libdl-2.13.so
[+] dladdr1 ( void const* __address, Dl_info* __info, void** __extra_info, int __flags )

received signal SEGV

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

#include <stdlib.h>

#include <dlfcn.h>

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

{

void* __address = malloc(256);

void* dli_fbase = malloc(256);

void* dli_saddr = malloc(256);

Dl_info __info = {

.dli_fname = "dli_fname",

.dli_fbase = dli_fbase,

.dli_sname = "dli_sname",

.dli_saddr = dli_saddr};

void* __extra_info [] = {

malloc(256),

0};

dladdr1(

__address,

&__info,

__extra_info,

0); //target call

return 0;

}

[+] dlclose ( void* __handle )

received signal SEGV

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <dlfcn.h>

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

{

void* __handle = malloc(256);

dlclose(__handle); //target call

return 0;

}

[+] dlerror ( )

received signal SEGV

#include <dlfcn.h>

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

{

dlerror(); //target call

return 0;

}

[+] dlinfo ( void* __handle, int __request, void* __arg )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <stdlib.h>

#include <dlfcn.h>

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

{

void* __handle = malloc(256);

void* __arg = malloc(256);

dlinfo(__handle, 1, __arg); //target call

return 0;

}

[+] dlmopen ( Lmid_t __nsid, char const* __file, int __mode )

received signal SEGV

#include <dlfcn.h>

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

{

dlmopen(1L, "testdata/sample.txt", 0); //target call

return 0;

}

[+] dlopen ( char const* __file, int __mode )

received signal SEGV

#include <dlfcn.h>

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

{

dlopen("testdata/sample.txt", 0); //target call

return 0;

}

[+] dlsym ( void* __handle, char const* __name )

received signal SEGV

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <dlfcn.h>

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

{

void* __handle = malloc(256);

dlsym(__handle, "__name"); //target call

return 0;

}

[+] dlvsym ( void* __handle, char const* __name, char const* __version )

received signal SEGV

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <dlfcn.h>

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

{

void* __handle = malloc(256);

dlvsym(__handle, "__name", "1.0"); //target call

return 0;

}

pthread.h, libpthread-2.13.so
[+] pthread_attr_getguardsize ( pthread_attr_t const* __attr, size_t* __guardsize )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <pthread.h>

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

{

pthread_attr_t __attr;

pthread_attr_init(&__attr);

unsigned int __guardsize = 0;

pthread_attr_getguardsize(&__attr, &__guardsize); //target call

return 0;

}

[+] pthread_attr_getstack ( pthread_attr_t const* __attr, void** __stackaddr, size_t* __stacksize )

received signal SEGV

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

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_attr_t __attr;

pthread_attr_init(&__attr);

void* __stackaddr [] = {

malloc(256),

0};

unsigned int __stacksize = 0;

pthread_attr_getstack(&__attr, __stackaddr, &__stacksize); //target call

return 0;

}

[+] pthread_attr_getstackaddr ( pthread_attr_t const* __attr, void** __stackaddr )

received signal SEGV

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

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_attr_t __attr;

pthread_attr_init(&__attr);

void* __stackaddr [] = {

malloc(256),

0};

pthread_attr_getstackaddr(&__attr, __stackaddr); //target call

return 0;

}

[+] pthread_attr_getstacksize ( pthread_attr_t const* __attr, size_t* __stacksize )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <pthread.h>

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

{

pthread_attr_t __attr;

pthread_attr_init(&__attr);

unsigned int __stacksize = 0;

pthread_attr_getstacksize(&__attr, &__stacksize); //target call

return 0;

}

[+] pthread_attr_setaffinity_np ( pthread_attr_t* __attr, size_t __cpusetsize, cpu_set_t const* __cpuset )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <pthread.h>

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

{

pthread_attr_t __attr;

pthread_attr_init(&__attr);

cpu_set_t* __cpuset = __sched_cpualloc(4);

pthread_attr_setaffinity_np(&__attr, 4, __cpuset); //target call

return 0;

}

[+] pthread_attr_setguardsize ( pthread_attr_t* __attr, size_t __guardsize )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_attr_t __attr;

pthread_attr_init(&__attr);

pthread_attr_setguardsize(&__attr, 4); //target call

return 0;

}

[+] pthread_attr_setstack ( pthread_attr_t* __attr, void* __stackaddr, size_t __stacksize )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_attr_t __attr;

pthread_attr_init(&__attr);

void* __stackaddr = malloc(256);

pthread_attr_setstack(&__attr, __stackaddr, 256); //target call

return 0;

}

[+] pthread_attr_setstackaddr ( pthread_attr_t* __attr, void* __stackaddr )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_attr_t __attr;

pthread_attr_init(&__attr);

void* __stackaddr = malloc(256);

pthread_attr_setstackaddr(&__attr, __stackaddr); //target call

return 0;

}

[+] pthread_attr_setstacksize ( pthread_attr_t* __attr, size_t __stacksize )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_attr_t __attr;

pthread_attr_init(&__attr);

pthread_attr_setstacksize(&__attr, 4); //target call

return 0;

}

[+] pthread_barrier_destroy ( pthread_barrier_t* __barrier )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_barrierattr_t __attr;

pthread_barrierattr_init(&__attr);

pthread_barrier_t __barrier;

pthread_barrier_init(&__barrier, &__attr, 4);

pthread_barrier_destroy(&__barrier); //target call

return 0;

}

[+] pthread_barrier_init ( pthread_barrier_t* __barrier, pthread_barrierattr_t const* __attr, unsigned int __count )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <pthread.h>

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

{

pthread_barrier_t __barrier;

pthread_barrierattr_t __attr;

pthread_barrierattr_init(&__attr);

pthread_barrier_init(&__barrier, &__attr, 4); //target call

return 0;

}

[+] pthread_barrier_wait ( pthread_barrier_t* __barrier )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_barrierattr_t __attr;

pthread_barrierattr_init(&__attr);

pthread_barrier_t __barrier;

pthread_barrier_init(&__barrier, &__attr, 4);

pthread_barrier_wait(&__barrier); //target call

return 0;

}

[+] pthread_barrierattr_destroy ( pthread_barrierattr_t* __attr )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_barrierattr_t __attr;

pthread_barrierattr_init(&__attr);

pthread_barrierattr_destroy(&__attr); //target call

return 0;

}

[+] pthread_barrierattr_getpshared ( pthread_barrierattr_t const* __attr, int* __pshared )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_barrierattr_t __attr;

pthread_barrierattr_init(&__attr);

int* __pshared = (int*) malloc(sizeof(int)*256);

pthread_barrierattr_getpshared(&__attr, __pshared); //target call

return 0;

}

[+] pthread_barrierattr_init ( pthread_barrierattr_t* __attr )

received signal SEGV

#include <pthread.h>

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

{

pthread_barrierattr_t __attr;

pthread_barrierattr_init(&__attr); //target call

return 0;

}

[+] pthread_barrierattr_setpshared ( pthread_barrierattr_t* __attr, int __pshared )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_barrierattr_t __attr;

pthread_barrierattr_init(&__attr);

pthread_barrierattr_setpshared(&__attr, 0); //target call

return 0;

}

[+] pthread_cancel ( pthread_t __th )

received signal SEGV

#include <pthread.h>

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

{

pthread_t __th = pthread_self();

pthread_cancel(__th); //target call

return 0;

}

[+] pthread_condattr_getclock ( pthread_condattr_t const* __attr, __clockid_t* __clock_id )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <rpc/types.h>

#include <pthread.h>

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

{

pthread_condattr_t __attr;

pthread_condattr_init(&__attr);

__clockid_t* __clock_id = (__clockid_t*) malloc(sizeof(__clockid_t)*256);

pthread_condattr_getclock(&__attr, __clock_id); //target call

return 0;

}

[+] pthread_condattr_getpshared ( pthread_condattr_t const* __attr, int* __pshared )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_condattr_t __attr;

pthread_condattr_init(&__attr);

int* __pshared = (int*) malloc(sizeof(int)*256);

pthread_condattr_getpshared(&__attr, __pshared); //target call

return 0;

}

[+] pthread_condattr_setclock ( pthread_condattr_t* __attr, __clockid_t __clock_id )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <rpc/types.h>

#include <pthread.h>

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

{

pthread_condattr_t __attr;

pthread_condattr_init(&__attr);

pthread_condattr_setclock(&__attr, 1); //target call

return 0;

}

[+] pthread_condattr_setpshared ( pthread_condattr_t* __attr, int __pshared )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_condattr_t __attr;

pthread_condattr_init(&__attr);

pthread_condattr_setpshared(&__attr, 0); //target call

return 0;

}

[+] pthread_create ( pthread_t* __newthread, pthread_attr_t const* __attr, void*(*__start_routine)(void*), void* __arg )

received signal SEGV

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

#include <stdlib.h>

#include <link.h>

#include <pthread.h>

//auxiliary function

void*

__start_routine(void* p1){

La_i86_retval retval = {

.lrv_eax = 1,

.lrv_edx = 2,

.lrv_st0 = 1.5L,

.lrv_st1 = 2.5L};

return (void*)&retval;

}

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

{

pthread_t __newthread = pthread_self();

pthread_attr_t __attr;

pthread_attr_init(&__attr);

void* __arg = malloc(256);

pthread_create(

&__newthread,

&__attr,

&__start_routine,

__arg); //target call

return 0;

}

[+] pthread_detach ( pthread_t __th )

received signal SEGV

#include <pthread.h>

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

{

pthread_t __th = pthread_self();

pthread_detach(__th); //target call

return 0;

}

[+] pthread_getaffinity_np ( pthread_t __th, size_t __cpusetsize, cpu_set_t* __cpuset )

received signal SEGV

1
2
3
4
5
6
7
8

#include <pthread.h>

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

{

pthread_t __th = pthread_self();

cpu_set_t* __cpuset = __sched_cpualloc(4);

pthread_getaffinity_np(__th, 4, __cpuset); //target call

return 0;

}

[+] pthread_getattr_np ( pthread_t __th, pthread_attr_t* __attr )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <pthread.h>

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

{

pthread_t __th = pthread_self();

pthread_attr_t __attr;

pthread_attr_init(&__attr);

pthread_getattr_np(__th, &__attr); //target call

return 0;

}

[+] pthread_getconcurrency ( )

received signal SEGV

#include <pthread.h>

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

{

pthread_getconcurrency(); //target call

return 0;

}

[+] pthread_getcpuclockid ( pthread_t __thread_id, __clockid_t* __clock_id )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <rpc/types.h>

#include <pthread.h>

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

{

pthread_t __thread_id = pthread_self();

__clockid_t* __clock_id = (__clockid_t*) malloc(sizeof(__clockid_t)*256);

pthread_getcpuclockid(__thread_id, __clock_id); //target call

return 0;

}

[+] pthread_getname_np ( pthread_t __target_thread, char* __buf, size_t __buflen )

received signal SEGV

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

#include <pthread.h>

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

{

pthread_t __target_thread = pthread_self();

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

pthread_getname_np(__target_thread, __buf, 4); //target call

return 0;

}

[+] pthread_getspecific ( pthread_key_t __key )

received signal SEGV

#include <pthread.h>

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

{

pthread_getspecific(1); //target call

return 0;

}

[+] pthread_join ( pthread_t __th, void** __thread_return )

received signal SEGV

1
2
3
4
5
6
7
8

#include <pthread.h>

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

{

pthread_t __th = pthread_self();

void* __thread_return = 0;

pthread_join(__th, (void**)&__thread_return); //target call

return 0;

}

[+] pthread_key_create ( pthread_key_t* __key, void(*__destr_function)(void*) )

received signal SEGV

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

#include <stdlib.h>

#include <pthread.h>

//auxiliary function

void

__destr_function(void* p1){}

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

{

pthread_key_t* __key = (pthread_key_t*) malloc(sizeof(pthread_key_t)*256);

pthread_key_create(__key, &__destr_function); //target call

return 0;

}

[+] pthread_key_delete ( pthread_key_t __key )

received signal SEGV

#include <pthread.h>

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

{

pthread_key_delete(1); //target call

return 0;

}

[+] pthread_mutex_consistent ( pthread_mutex_t* __mutex )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t __mutex;

pthread_mutex_init(&__mutex, &__mutexattr);

pthread_mutex_consistent(&__mutex); //target call

return 0;

}

[+] pthread_mutex_consistent_np ( pthread_mutex_t* __mutex )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t __mutex;

pthread_mutex_init(&__mutex, &__mutexattr);

pthread_mutex_consistent_np(&__mutex); //target call

return 0;

}

[+] pthread_mutex_getprioceiling ( pthread_mutex_t const* __mutex, int* __prioceiling )

received signal SEGV

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

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t __mutex;

pthread_mutex_init(&__mutex, &__mutexattr);

int* __prioceiling = (int*) malloc(sizeof(int)*256);

pthread_mutex_getprioceiling(&__mutex, __prioceiling); //target call

return 0;

}

[+] pthread_mutex_setprioceiling ( pthread_mutex_t* __mutex, int __prioceiling, int* __old_ceiling )

received signal SEGV

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

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t __mutex;

pthread_mutex_init(&__mutex, &__mutexattr);

int* __old_ceiling = (int*) malloc(sizeof(int)*256);

pthread_mutex_setprioceiling(&__mutex, 1, __old_ceiling); //target call

return 0;

}

[+] pthread_mutex_timedlock ( pthread_mutex_t* __mutex, struct timespec const* __abstime )

received signal SEGV

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

#include <pthread.h>

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

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t __mutex;

pthread_mutex_init(&__mutex, &__mutexattr);

struct timespec __abstime;

clock_getres(1, &__abstime);

pthread_mutex_timedlock(&__mutex, &__abstime); //target call

return 0;

}

[+] pthread_mutex_trylock ( pthread_mutex_t* __mutex )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_mutexattr_t __mutexattr;

pthread_mutexattr_init(&__mutexattr);

pthread_mutex_t __mutex;

pthread_mutex_init(&__mutex, &__mutexattr);

pthread_mutex_trylock(&__mutex); //target call

return 0;

}

[+] pthread_mutexattr_destroy ( pthread_mutexattr_t* __attr )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

pthread_mutexattr_destroy(&__attr); //target call

return 0;

}

[+] pthread_mutexattr_getprioceiling ( pthread_mutexattr_t const* __attr, int* __prioceiling )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

int* __prioceiling = (int*) malloc(sizeof(int)*256);

pthread_mutexattr_getprioceiling(&__attr, __prioceiling); //target call

return 0;

}

[+] pthread_mutexattr_getprotocol ( pthread_mutexattr_t const* __attr, int* __protocol )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

int* __protocol = (int*) malloc(sizeof(int)*256);

pthread_mutexattr_getprotocol(&__attr, __protocol); //target call

return 0;

}

[+] pthread_mutexattr_getpshared ( pthread_mutexattr_t const* __attr, int* __pshared )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

int* __pshared = (int*) malloc(sizeof(int)*256);

pthread_mutexattr_getpshared(&__attr, __pshared); //target call

return 0;

}

[+] pthread_mutexattr_getrobust ( pthread_mutexattr_t const* __attr, int* __robustness )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

int* __robustness = (int*) malloc(sizeof(int)*256);

pthread_mutexattr_getrobust(&__attr, __robustness); //target call

return 0;

}

[+] pthread_mutexattr_getrobust_np ( pthread_mutexattr_t const* __attr, int* __robustness )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

int* __robustness = (int*) malloc(sizeof(int)*256);

pthread_mutexattr_getrobust_np(&__attr, __robustness); //target call

return 0;

}

[+] pthread_mutexattr_gettype ( pthread_mutexattr_t const* __attr, int* __kind )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

int* __kind = (int*) malloc(sizeof(int)*256);

pthread_mutexattr_gettype(&__attr, __kind); //target call

return 0;

}

[+] pthread_mutexattr_init ( pthread_mutexattr_t* __attr )

received signal SEGV

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr); //target call

return 0;

}

[+] pthread_mutexattr_setprioceiling ( pthread_mutexattr_t* __attr, int __prioceiling )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

pthread_mutexattr_setprioceiling(&__attr, 1); //target call

return 0;

}

[+] pthread_mutexattr_setprotocol ( pthread_mutexattr_t* __attr, int __protocol )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

pthread_mutexattr_setprotocol(&__attr, 1); //target call

return 0;

}

[+] pthread_mutexattr_setpshared ( pthread_mutexattr_t* __attr, int __pshared )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

pthread_mutexattr_setpshared(&__attr, 0); //target call

return 0;

}

[+] pthread_mutexattr_setrobust ( pthread_mutexattr_t* __attr, int __robustness )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

pthread_mutexattr_setrobust(&__attr, 1); //target call

return 0;

}

[+] pthread_mutexattr_setrobust_np ( pthread_mutexattr_t* __attr, int __robustness )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

pthread_mutexattr_setrobust_np(&__attr, 1); //target call

return 0;

}

[+] pthread_mutexattr_settype ( pthread_mutexattr_t* __attr, int __kind )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_mutexattr_t __attr;

pthread_mutexattr_init(&__attr);

pthread_mutexattr_settype(&__attr, 1); //target call

return 0;

}

[+] pthread_once ( pthread_once_t* __once_control, __init_routine_type __init_routine )

received signal SEGV

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

#include <obstack.h>

#include <stdlib.h>

#include <pthread.h>

typedef void (*__init_routine_type) ();

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

{

pthread_once_t* __once_control = (pthread_once_t*) malloc(sizeof(pthread_once_t)*256);

__init_routine_type __init_routine = obstack_alloc_failed_handler;

pthread_once(__once_control, __init_routine); //target call

return 0;

}

[+] pthread_rwlock_destroy ( pthread_rwlock_t* __rwlock )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlock_t __rwlock;

pthread_rwlock_init(&__rwlock, &__attr);

pthread_rwlock_destroy(&__rwlock); //target call

return 0;

}

[+] pthread_rwlock_init ( pthread_rwlock_t* __rwlock, pthread_rwlockattr_t const* __attr )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <pthread.h>

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

{

pthread_rwlock_t __rwlock;

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlock_init(&__rwlock, &__attr); //target call

return 0;

}

[+] pthread_rwlock_rdlock ( pthread_rwlock_t* __rwlock )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlock_t __rwlock;

pthread_rwlock_init(&__rwlock, &__attr);

pthread_rwlock_rdlock(&__rwlock); //target call

return 0;

}

[+] pthread_rwlock_timedrdlock ( pthread_rwlock_t* __rwlock, struct timespec const* __abstime )

received signal SEGV

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

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlock_t __rwlock;

pthread_rwlock_init(&__rwlock, &__attr);

struct timespec __abstime;

clock_getres(1, &__abstime);

pthread_rwlock_timedrdlock(&__rwlock, &__abstime); //target call

return 0;

}

[+] pthread_rwlock_timedwrlock ( pthread_rwlock_t* __rwlock, struct timespec const* __abstime )

received signal SEGV

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

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlock_t __rwlock;

pthread_rwlock_init(&__rwlock, &__attr);

struct timespec __abstime;

clock_getres(1, &__abstime);

pthread_rwlock_timedwrlock(&__rwlock, &__abstime); //target call

return 0;

}

[+] pthread_rwlock_tryrdlock ( pthread_rwlock_t* __rwlock )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlock_t __rwlock;

pthread_rwlock_init(&__rwlock, &__attr);

pthread_rwlock_tryrdlock(&__rwlock); //target call

return 0;

}

[+] pthread_rwlock_trywrlock ( pthread_rwlock_t* __rwlock )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlock_t __rwlock;

pthread_rwlock_init(&__rwlock, &__attr);

pthread_rwlock_trywrlock(&__rwlock); //target call

return 0;

}

[+] pthread_rwlock_wrlock ( pthread_rwlock_t* __rwlock )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlock_t __rwlock;

pthread_rwlock_init(&__rwlock, &__attr);

pthread_rwlock_wrlock(&__rwlock); //target call

return 0;

}

[+] pthread_rwlockattr_getkind_np ( pthread_rwlockattr_t const* __attr, int* __pref )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

int* __pref = (int*) malloc(sizeof(int)*256);

pthread_rwlockattr_getkind_np(&__attr, __pref); //target call

return 0;

}

[+] pthread_rwlockattr_getpshared ( pthread_rwlockattr_t const* __attr, int* __pshared )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <stdlib.h>

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

int* __pshared = (int*) malloc(sizeof(int)*256);

pthread_rwlockattr_getpshared(&__attr, __pshared); //target call

return 0;

}

[+] pthread_rwlockattr_init ( pthread_rwlockattr_t* __attr )

received signal SEGV

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr); //target call

return 0;

}

[+] pthread_rwlockattr_setkind_np ( pthread_rwlockattr_t* __attr, int __pref )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlockattr_setkind_np(&__attr, 1); //target call

return 0;

}

[+] pthread_rwlockattr_setpshared ( pthread_rwlockattr_t* __attr, int __pshared )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <pthread.h>

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

{

pthread_rwlockattr_t __attr;

pthread_rwlockattr_init(&__attr);

pthread_rwlockattr_setpshared(&__attr, 0); //target call

return 0;

}

[+] pthread_setaffinity_np ( pthread_t __th, size_t __cpusetsize, cpu_set_t const* __cpuset )

received signal SEGV

1
2
3
4
5
6
7
8

#include <pthread.h>

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

{

pthread_t __th = pthread_self();

cpu_set_t* __cpuset = __sched_cpualloc(4);

pthread_setaffinity_np(__th, 4, __cpuset); //target call

return 0;

}

[+] pthread_setconcurrency ( int __level )

received signal SEGV

#include <pthread.h>

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

{

pthread_setconcurrency(1); //target call

return 0;

}

[+] pthread_setname_np ( pthread_t __target_thread, char const* __name )

received signal SEGV

#include <pthread.h>

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

{

pthread_t __target_thread = pthread_self();

pthread_setname_np(__target_thread, "__name"); //target call

return 0;

}

[+] pthread_setschedprio ( pthread_t __target_thread, int __prio )

received signal SEGV

#include <pthread.h>

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

{

pthread_t __target_thread = pthread_self();

pthread_setschedprio(__target_thread, 1); //target call

return 0;

}

[+] pthread_setspecific ( pthread_key_t __key, void const* __pointer )

received signal SEGV

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <pthread.h>

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

{

void* __pointer = malloc(256);

pthread_setspecific(1, __pointer); //target call

return 0;

}

[+] pthread_spin_destroy ( int volatile* __lock )

received signal SEGV

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <pthread.h>

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

{

int* __lock = (int volatile*) malloc(sizeof(int volatile)*256);

pthread_spin_destroy(__lock); //target call

return 0;

}

[+] pthread_spin_lock ( int volatile* __lock )

received signal SEGV

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <pthread.h>

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

{

int* __lock = (int volatile*) malloc(sizeof(int volatile)*256);

pthread_spin_lock(__lock); //target call

return 0;

}

[+] pthread_spin_trylock ( int volatile* __lock )

received signal SEGV

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <pthread.h>

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

{

int* __lock = (int volatile*) malloc(sizeof(int volatile)*256);

pthread_spin_trylock(__lock); //target call

return 0;

}

[+] pthread_spin_unlock ( int volatile* __lock )

received signal SEGV

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <pthread.h>

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

{

int* __lock = (int volatile*) malloc(sizeof(int volatile)*256);

pthread_spin_unlock(__lock); //target call

return 0;

}

[+] pthread_testcancel ( )

received signal SEGV

#include <pthread.h>

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

{

pthread_testcancel(); //target call

return 0;

}

[+] pthread_timedjoin_np ( pthread_t __th, void** __thread_return, struct timespec const* __abstime )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <pthread.h>

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

{

pthread_t __th = pthread_self();

void* __thread_return = 0;

struct timespec __abstime;

clock_getres(1, &__abstime);

pthread_timedjoin_np(__th, (void**)&__thread_return, &__abstime); //target call

return 0;

}

[+] pthread_tryjoin_np ( pthread_t __th, void** __thread_return )

received signal SEGV

1
2
3
4
5
6
7
8

#include <pthread.h>

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

{

pthread_t __th = pthread_self();

void* __thread_return = 0;

pthread_tryjoin_np(__th, (void**)&__thread_return); //target call

return 0;

}

[+] pthread_yield ( )

received signal SEGV

#include <pthread.h>

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

{

pthread_yield(); //target call

return 0;

}

semaphore.h, libpthread-2.13.so
[+] sem_close ( sem_t* __sem )

received signal SEGV

#include <semaphore.h>

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

{

sem_t* __sem = sem_open("__name", 0, 0);

sem_close(__sem); //target call

return 0;

}

[+] sem_destroy ( sem_t* __sem )

received signal SEGV

#include <semaphore.h>

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

{

sem_t* __sem = sem_open("__name", 0, 0);

sem_destroy(__sem); //target call

return 0;

}

[+] sem_getvalue ( sem_t* __sem, int* __sval )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <stdlib.h>

#include <semaphore.h>

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

{

sem_t* __sem = sem_open("__name", 0, 0);

int* __sval = (int*) malloc(sizeof(int)*256);

sem_getvalue(__sem, __sval); //target call

return 0;

}

[+] sem_init ( sem_t* __sem, int __pshared, unsigned int __value )

received signal SEGV

#include <semaphore.h>

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

{

sem_t* __sem = sem_open("__name", 0, 0);

sem_init(__sem, 0, 1); //target call

return 0;

}

[+] sem_open ( char const* __name, int __oflag, ... )

received signal SEGV

#include <semaphore.h>

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

{

sem_open("__name", 0, 0); //target call

return 0;

}

[+] sem_post ( sem_t* __sem )

received signal SEGV

#include <semaphore.h>

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

{

sem_t* __sem = sem_open("__name", 0, 0);

sem_post(__sem); //target call

return 0;

}

[+] sem_timedwait ( sem_t* __sem, struct timespec const* __abstime )

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <semaphore.h>

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

{

sem_t* __sem = sem_open("__name", 0, 0);

struct timespec __abstime;

clock_getres(1, &__abstime);

sem_timedwait(__sem, &__abstime); //target call

return 0;

}

[+] sem_trywait ( sem_t* __sem )

received signal SEGV

#include <semaphore.h>

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

{

sem_t* __sem = sem_open("__name", 0, 0);

sem_trywait(__sem); //target call

return 0;

}

[+] sem_unlink ( char const* __name )

received signal SEGV

#include <semaphore.h>

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

{

sem_unlink("__name"); //target call

return 0;

}

[+] sem_wait ( sem_t* __sem )

received signal SEGV

#include <semaphore.h>

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

{

sem_t* __sem = sem_open("__name", 0, 0);

sem_wait(__sem); //target call

return 0;

}

sigthread.h, libpthread-2.13.so
[+] pthread_kill ( pthread_t __threadid, int __signo )

received signal SEGV

#include <pthread.h>

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

{

pthread_t __threadid = pthread_self();

pthread_kill(__threadid, 1); //target call

return 0;

}

[+] pthread_sigmask ( int __how, __sigset_t const* __newmask, __sigset_t* __oldmask )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

#include <signal.h>
#include <pthread.h>
int main(int argc, char *argv[])
{
__sigset_t __newmask [] = {
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {0}};
__sigset_t __oldmask [] = {
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {
.__val = {
0, 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}},
(__sigset_t) {0}};
pthread_sigmask(1, __newmask, __oldmask); //target call
return 0;
}

[+] pthread_sigqueue ( pthread_t __threadid, int __signo, union sigval const __value )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <signal.h>

#include <pthread.h>

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

{

pthread_t __threadid = pthread_self();

union sigval __value = {.sival_int = 1};

pthread_sigqueue(__threadid, 1, __value); //target call

return 0;

}

nameser.h, libresolv-2.13.so
[+] ns_initparse ( u_char const* p1, int p2, ns_msg* p3 )

received signal SEGV

1
2
3
4
5
6
7
8

#include <rpc/types.h>

#include <arpa/nameser.h>

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

{

ns_msg* msg = 0; //can't initialize

ns_initparse((u_char const*) "str", 1, msg); //target call

return 0;

}

[+] ns_parserr ( ns_msg* p1, ns_sect p2, int p3, ns_rr* p4 )

received signal SEGV

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

#include <rpc/types.h>

#include <arpa/nameser.h>

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

{

ns_msg* msg = 0; //can't initialize

ns_rr rr = {

.type = 0,

.rr_class = 2,

.ttl = 3,

.rdlength = 4,

.rdata = (u_char const*) "rdata"};

ns_parserr(

msg,

ns_s_qd,

&rr); //target call

return 0;

}

[+] ns_sprintrr ( ns_msg const* p1, ns_rr const* p2, char const* p3, char const* p4, char* p5, size_t p6 )

received signal SEGV

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

#include <rpc/types.h>

#include <arpa/nameser.h>

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

{

ns_msg* msg = 0; //can't initialize

ns_rr rr = {

.type = 0,

.rr_class = 1,

.ttl = 2,

.rdlength = 4,

.rdata = (u_char const*) "rdata"};

char p5 [] = {

'A',

'B',

'C',

'D',

'\0'};

ns_sprintrr(

msg,

&rr,

"str",

"str2",

p5,

4); //target call

return 0;

}

resolv.h, libresolv-2.13.so
[+] __loc_ntoa ( u_char const* __binary, char* __ascii )

received signal SEGV

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

#include <rpc/types.h>

#include <resolv.h>

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

{

char __ascii [] = {

'A',

'B',

'C',

'D',

'\0'};

__loc_ntoa((u_char const*) "__binary", __ascii); //target call

return 0;

}

aio.h, librt-2.13.so
[+] aio_cancel ( int __fildes, struct aiocb* __aiocbp )

received signal SEGV

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
46

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(5, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __aiocbp = {

.aio_fildes = 2,

.aio_lio_opcode = 3,

.aio_reqprio = 4,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 6,

.__policy = 7,

.__error_code = 8,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

aio_cancel(1, &__aiocbp); //target call

//finalization

fclose(__stream);

return 0;

}

[+] aio_cancel64 ( int __fildes, struct aiocb64* __aiocbp )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(5, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __next_prio = {

.aio_fildes = 6,

.aio_lio_opcode = 7,

.aio_reqprio = 8,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 9,

.__policy = 10,

.__error_code = 1,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

FILE* __stream_1 = fopen("testdata/sample.txt", "r+");

__off64_t aio_offset_1 = ftello64(__stream_1);

struct aiocb64 __aiocbp = {

.aio_fildes = 2,

.aio_lio_opcode = 3,

.aio_reqprio = 4,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 2,

.__policy = 3,

.__error_code = 4,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P'}};

aio_cancel64(1, &__aiocbp); //target call

//finalization

fclose(__stream_1);

fclose(__stream);

return 0;

}

[+] aio_error ( struct aiocb const* __aiocbp )

received signal SEGV

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
46

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __aiocbp = {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 5,

.__policy = 6,

.__error_code = 7,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

aio_error(&__aiocbp); //target call

//finalization

fclose(__stream);

return 0;

}

[+] aio_error64 ( struct aiocb64 const* __aiocbp )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __next_prio = {

.aio_fildes = 5,

.aio_lio_opcode = 6,

.aio_reqprio = 7,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 8,

.__policy = 9,

.__error_code = 10,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

FILE* __stream_1 = fopen("testdata/sample.txt", "r+");

__off64_t aio_offset_1 = ftello64(__stream_1);

struct aiocb64 __aiocbp = {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 1,

.__policy = 2,

.__error_code = 3,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P'}};

aio_error64(&__aiocbp); //target call

//finalization

fclose(__stream_1);

fclose(__stream);

return 0;

}

[+] aio_fsync ( int __operation, struct aiocb* __aiocbp )

received signal SEGV

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
46

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(5, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __aiocbp = {

.aio_fildes = 2,

.aio_lio_opcode = 3,

.aio_reqprio = 4,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 6,

.__policy = 7,

.__error_code = 8,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

aio_fsync(1, &__aiocbp); //target call

//finalization

fclose(__stream);

return 0;

}

[+] aio_fsync64 ( int __operation, struct aiocb64* __aiocbp )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(5, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __next_prio = {

.aio_fildes = 6,

.aio_lio_opcode = 7,

.aio_reqprio = 8,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 9,

.__policy = 10,

.__error_code = 1,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

FILE* __stream_1 = fopen("testdata/sample.txt", "r+");

__off64_t aio_offset_1 = ftello64(__stream_1);

struct aiocb64 __aiocbp = {

.aio_fildes = 2,

.aio_lio_opcode = 3,

.aio_reqprio = 4,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 2,

.__policy = 3,

.__error_code = 4,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P'}};

aio_fsync64(1, &__aiocbp); //target call

//finalization

fclose(__stream_1);

fclose(__stream);

return 0;

}

[+] aio_init ( struct aioinit const* __init )

received signal SEGV

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

#include <aio.h>

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

{

struct aioinit __init = {

.aio_threads = 1,

.aio_num = 2,

.aio_locks = 3,

.aio_usedba = 4,

.aio_debug = 0,

.aio_numusers = 5,

.aio_idle_time = 1,

.aio_reserved = 0};

aio_init(&__init); //target call

return 0;

}

[+] aio_read ( struct aiocb* __aiocbp )

received signal SEGV

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
46

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __aiocbp = {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 5,

.__policy = 6,

.__error_code = 7,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

aio_read(&__aiocbp); //target call

//finalization

fclose(__stream);

return 0;

}

[+] aio_read64 ( struct aiocb64* __aiocbp )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __next_prio = {

.aio_fildes = 5,

.aio_lio_opcode = 6,

.aio_reqprio = 7,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 8,

.__policy = 9,

.__error_code = 10,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

FILE* __stream_1 = fopen("testdata/sample.txt", "r+");

__off64_t aio_offset_1 = ftello64(__stream_1);

struct aiocb64 __aiocbp = {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 1,

.__policy = 2,

.__error_code = 3,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P'}};

aio_read64(&__aiocbp); //target call

//finalization

fclose(__stream_1);

fclose(__stream);

return 0;

}

[+] aio_return ( struct aiocb* __aiocbp )

received signal SEGV

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
46

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __aiocbp = {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 5,

.__policy = 6,

.__error_code = 7,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

aio_return(&__aiocbp); //target call

//finalization

fclose(__stream);

return 0;

}

[+] aio_return64 ( struct aiocb64* __aiocbp )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __next_prio = {

.aio_fildes = 5,

.aio_lio_opcode = 6,

.aio_reqprio = 7,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 8,

.__policy = 9,

.__error_code = 10,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

FILE* __stream_1 = fopen("testdata/sample.txt", "r+");

__off64_t aio_offset_1 = ftello64(__stream_1);

struct aiocb64 __aiocbp = {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 1,

.__policy = 2,

.__error_code = 3,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P'}};

aio_return64(&__aiocbp); //target call

//finalization

fclose(__stream_1);

fclose(__stream);

return 0;

}

[+] aio_suspend ( struct aiocb const*const* __list, int __nent, struct timespec const* __timeout )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __list_elem [] = {

(struct aiocb) {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 5,

.__policy = 6,

.__error_code = 7,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}},

(struct aiocb) {

.aio_fildes = 8,

.aio_lio_opcode = 9,

.aio_reqprio = 10,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 1,

.__policy = 2,

.__error_code = 3,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'K',

'L',

'M',

'N'},

.__unused = {

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T'}},

(struct aiocb) {

.aio_fildes = 4,

.aio_lio_opcode = 5,

.aio_reqprio = 6,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 7,

.__policy = 8,

.__error_code = 9,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'U',

'V',

'W',

'X'},

.__unused = {

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D'}},

(struct aiocb) {

.aio_fildes = 10,

.aio_lio_opcode = 1,

.aio_reqprio = 2,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 3,

.__policy = 4,

.__error_code = 5,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'E',

'F',

'G',

'H'},

.__unused = {

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N'}},

(struct aiocb) {0}};

struct aiocb* __list [] = {

__list_elem,

0};

struct timespec __timeout;

clock_getres(7, &__timeout);

aio_suspend((struct aiocb const*const*)__list, 6, &__timeout); //target call

//finalization

fclose(__stream);

return 0;

}

[+] aio_suspend64 ( struct aiocb64 const*const* __list, int __nent, struct timespec const* __timeout )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __next_prio = {

.aio_fildes = 5,

.aio_lio_opcode = 6,

.aio_reqprio = 7,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 8,

.__policy = 9,

.__error_code = 10,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

FILE* __stream_1 = fopen("testdata/sample.txt", "r+");

__off64_t aio_offset_1 = ftello64(__stream_1);

struct aiocb64 __list_elem [] = {

(struct aiocb64) {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 1,

.__policy = 2,

.__error_code = 3,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P'}},

(struct aiocb64) {

.aio_fildes = 4,

.aio_lio_opcode = 5,

.aio_reqprio = 6,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 7,

.__policy = 8,

.__error_code = 9,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V'}},

(struct aiocb64) {

.aio_fildes = 10,

.aio_lio_opcode = 1,

.aio_reqprio = 2,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 3,

.__policy = 4,

.__error_code = 5,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B'}},

(struct aiocb64) {

.aio_fildes = 6,

.aio_lio_opcode = 7,

.aio_reqprio = 8,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 9,

.__policy = 10,

.__error_code = 1,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H'}},

(struct aiocb64) {0}};

struct aiocb64* __list [] = {

__list_elem,

0};

struct timespec __timeout;

clock_getres(3, &__timeout);

aio_suspend64((struct aiocb64 const*const*)__list, 2, &__timeout); //target call

//finalization

fclose(__stream_1);

fclose(__stream);

return 0;

}

[+] aio_write ( struct aiocb* __aiocbp )

received signal SEGV

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
46

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __aiocbp = {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 5,

.__policy = 6,

.__error_code = 7,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

aio_write(&__aiocbp); //target call

//finalization

fclose(__stream);

return 0;

}

[+] lio_listio ( int __mode, struct aiocb*const* __list, int __nent, struct sigevent* __sig )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __list_elem [] = {

(struct aiocb) {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 5,

.__policy = 6,

.__error_code = 7,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}},

(struct aiocb) {

.aio_fildes = 8,

.aio_lio_opcode = 9,

.aio_reqprio = 10,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 1,

.__policy = 2,

.__error_code = 3,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'K',

'L',

'M',

'N'},

.__unused = {

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T'}},

(struct aiocb) {

.aio_fildes = 4,

.aio_lio_opcode = 5,

.aio_reqprio = 6,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 7,

.__policy = 8,

.__error_code = 9,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'U',

'V',

'W',

'X'},

.__unused = {

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D'}},

(struct aiocb) {

.aio_fildes = 10,

.aio_lio_opcode = 1,

.aio_reqprio = 2,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 3,

.__policy = 4,

.__error_code = 5,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'E',

'F',

'G',

'H'},

.__unused = {

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N'}},

(struct aiocb) {0}};

struct aiocb* __list [] = {

__list_elem,

0};

struct sigevent __sig;

timer_create(7, &__sig, (timer_t*)&aio_buf);

lio_listio(

(struct aiocb*const*)__list,

&__sig); //target call

//finalization

fclose(__stream);

return 0;

}

[+] lio_listio64 ( int __mode, struct aiocb64*const* __list, int __nent, struct sigevent* __sig )

received signal SEGV

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

#include <wchar.h>

#include <stdio.h>

#include <rpc/types.h>

#include <aio.h>

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

{

void* aio_buf = malloc(256);

struct sigevent aio_sigevent;

timer_create(4, &aio_sigevent, (timer_t*)&aio_buf);

FILE* __stream = fopen("testdata/sample.txt", "r+");

__off_t aio_offset = ftello(__stream);

struct aiocb __next_prio = {

.aio_fildes = 5,

.aio_lio_opcode = 6,

.aio_reqprio = 7,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = 0,

.__abs_prio = 8,

.__policy = 9,

.__error_code = 10,

.__return_value = 4,

.aio_offset = aio_offset,

.__pad = {

'A',

'B',

'C',

'D'},

.__unused = {

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J'}};

FILE* __stream_1 = fopen("testdata/sample.txt", "r+");

__off64_t aio_offset_1 = ftello64(__stream_1);

struct aiocb64 __list_elem [] = {

(struct aiocb64) {

.aio_fildes = 1,

.aio_lio_opcode = 2,

.aio_reqprio = 3,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 1,

.__policy = 2,

.__error_code = 3,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P'}},

(struct aiocb64) {

.aio_fildes = 4,

.aio_lio_opcode = 5,

.aio_reqprio = 6,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 7,

.__policy = 8,

.__error_code = 9,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B',

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V'}},

(struct aiocb64) {

.aio_fildes = 10,

.aio_lio_opcode = 1,

.aio_reqprio = 2,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 3,

.__policy = 4,

.__error_code = 5,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H',

'I', 'J', 'K', 'L',

'M', 'N', 'O', 'P',

'Q', 'R', 'S', 'T',

'U', 'V', 'W', 'X',

'Y', 'Z', 'A', 'B'}},

(struct aiocb64) {

.aio_fildes = 6,

.aio_lio_opcode = 7,

.aio_reqprio = 8,

.aio_buf = aio_buf,

.aio_nbytes = 4,

.aio_sigevent = aio_sigevent,

.__next_prio = &__next_prio,

.__abs_prio = 9,

.__policy = 10,

.__error_code = 1,

.__return_value = 4,

.aio_offset = aio_offset_1,

.__unused = {

'C', 'D', 'E', 'F',

'G', 'H', 'I', 'J',

'K', 'L', 'M', 'N',

'O', 'P', 'Q', 'R',

'S', 'T', 'U', 'V',

'W', 'X', 'Y', 'Z',

'A', 'B', 'C', 'D',

'E', 'F', 'G', 'H'}},

(struct aiocb64) {0}};

struct aiocb64* __list [] = {

__list_elem,

0};

struct sigevent __sig;

timer_create(3, &__sig, (timer_t*)&aio_buf);

lio_listio64(

(struct aiocb64*const*)__list,

&__sig); //target call

//finalization

fclose(__stream_1);

fclose(__stream);

return 0;

}

mman.h, librt-2.13.so
[+] shm_open ( char const* __name, int __oflag, mode_t __mode )

received signal SEGV

#include <rpc/types.h>

#include <sys/mman.h>

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

{

shm_open("__name", 0, 0); //target call

return 0;

}

[+] shm_unlink ( char const* __name )

received signal SEGV

#include <sys/mman.h>

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

{

shm_unlink("__name"); //target call

return 0;

}

mqueue.h, librt-2.13.so
[+] mq_close ( mqd_t __mqdes )

received signal SEGV

#include <mqueue.h>

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

{

mqd_t __mqdes = mq_open("__name", 0, 0);

mq_close(__mqdes); //target call

return 0;

}

[+] mq_getattr ( mqd_t __mqdes, struct mq_attr* __mqstat )

received signal SEGV

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

#include <mqueue.h>

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

{

mqd_t __mqdes = mq_open("__name", 0, 0);

struct mq_attr __mqstat = {

.mq_flags = 0,

.mq_maxmsg = 4,

.mq_msgsize = 4,

.mq_curmsgs = 1L,

.__pad = {

3}};

mq_getattr(__mqdes, &__mqstat); //target call

return 0;

}

[+] mq_open ( char const* __name, int __oflag, ... )

received signal SEGV

#include <mqueue.h>

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

{

mq_open("__name", 0, 0); //target call

return 0;

}

[+] mq_receive ( mqd_t __mqdes, char* __msg_ptr, size_t __msg_len, unsigned int* __msg_prio )

received signal SEGV

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

#include <rpc/types.h>

#include <mqueue.h>

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

{

mqd_t __mqdes = mq_open("__name", 0, 0);

char __msg_ptr [] = {

'A',

'B',

'C',

'D',

'\0'};

unsigned int* __msg_prio = (unsigned int*) malloc(sizeof(unsigned int)*256);

mq_receive(

__mqdes,

__msg_ptr,

256,

__msg_prio); //target call

return 0;

}

[+] mq_send ( mqd_t __mqdes, char const* __msg_ptr, size_t __msg_len, unsigned int __msg_prio )

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12

#include <mqueue.h>

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

{

mqd_t __mqdes = mq_open("__name", 0, 0);

char __msg_ptr = 'A';

mq_send(

__mqdes,

&__msg_ptr,

1); //target call

return 0;

}

[+] mq_setattr ( mqd_t __mqdes, struct mq_attr const* __mqstat, struct mq_attr* __omqstat )

received signal SEGV

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

#include <mqueue.h>

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

{

mqd_t __mqdes = mq_open("__name", 0, 0);

struct mq_attr __mqstat = {

.mq_flags = 0,

.mq_maxmsg = 4,

.mq_msgsize = 4,

.mq_curmsgs = 1L,

.__pad = {

3}};

struct mq_attr __omqstat = {

.mq_flags = 0,

.mq_maxmsg = 4,

.mq_msgsize = 4,

.mq_curmsgs = 2L,

.__pad = {

3}};

mq_setattr(__mqdes, &__mqstat, &__omqstat); //target call

return 0;

}

[+] mq_timedreceive ( mqd_t __mqdes, char* __msg_ptr, size_t __msg_len, unsigned int* __msg_prio, struct timespec const* __abs_timeout )

received signal SEGV

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

#include <rpc/types.h>

#include <mqueue.h>

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

{

mqd_t __mqdes = mq_open("__name", 0, 0);

char __msg_ptr [] = {

'A',

'B',

'C',

'D',

'\0'};

unsigned int* __msg_prio = (unsigned int*) malloc(sizeof(unsigned int)*256);

struct timespec __abs_timeout;

clock_getres(1, &__abs_timeout);

mq_timedreceive(

__mqdes,

__msg_ptr,

256,

__msg_prio,

&__abs_timeout); //target call

return 0;

}

[+] mq_timedsend ( mqd_t __mqdes, char const* __msg_ptr, size_t __msg_len, unsigned int __msg_prio, struct timespec const* __abs_timeout )

received signal SEGV

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

#include <mqueue.h>

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

{

mqd_t __mqdes = mq_open("__name", 0, 0);

char __msg_ptr = 'A';

struct timespec __abs_timeout;

clock_getres(2, &__abs_timeout);

mq_timedsend(

__mqdes,

&__msg_ptr,

&__abs_timeout); //target call

return 0;

}

[+] mq_unlink ( char const* __name )

received signal SEGV

#include <mqueue.h>

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

{

mq_unlink("__name"); //target call

return 0;

}

time.h, librt-2.13.so
[+] clock_getcpuclockid ( pid_t __pid, clockid_t* __clock_id )

received signal SEGV

#include <rpc/types.h>

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

{

clockid_t* __clock_id = (clockid_t*) malloc(sizeof(clockid_t)*256);

clock_getcpuclockid(1, __clock_id); //target call

return 0;

}

[+] clock_getres ( clockid_t __clock_id, struct timespec* __res )

received signal SEGV

#include <time.h>

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

{

struct timespec __res;

clock_getres(1, &__res); //target call

return 0;

}

[+] clock_gettime ( clockid_t __clock_id, struct timespec* __tp )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <time.h>

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

{

struct timespec __tp;

clock_getres(2, &__tp);

clock_gettime(1, &__tp); //target call

return 0;

}

[+] clock_nanosleep ( clockid_t __clock_id, int __flags, struct timespec const* __req, struct timespec* __rem )

received signal SEGV

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

#include <time.h>

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

{

struct timespec __req;

clock_getres(2, &__req);

struct timespec __rem;

clock_getres(3, &__rem);

clock_nanosleep(

&__req,

&__rem); //target call

return 0;

}

[+] clock_settime ( clockid_t __clock_id, struct timespec const* __tp )

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <time.h>

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

{

struct timespec __tp;

clock_getres(2, &__tp);

clock_settime(1, &__tp); //target call

return 0;

}

[+] timer_create ( clockid_t __clock_id, struct sigevent* __evp, timer_t* __timerid )

received signal SEGV

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

#include <stdlib.h>

#include <signal.h>

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

{

struct sigevent __evp;

timer_t __timerid [] = {

malloc(256),

0};

timer_create(1, &__evp, __timerid); //target call

return 0;

}

[+] timer_delete ( timer_t __timerid )

received signal SEGV

#include <stdlib.h>

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

{

timer_t __timerid = malloc(256);

timer_delete(__timerid); //target call

return 0;

}

[+] timer_getoverrun ( timer_t __timerid )

received signal SEGV

#include <stdlib.h>

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

{

timer_t __timerid = malloc(256);

timer_getoverrun(__timerid); //target call

return 0;

}

pty.h, libutil-2.13.so
[+] forkpty ( int* __amaster, char* __name, struct termios const* __termp, struct winsize const* __winp )

received signal SEGV

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

#include <stdlib.h>

#include <pty.h>

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

{

int* __amaster = (int*) malloc(sizeof(int)*256);

struct termios* __termp = 0; //can't initialize

struct winsize __winp = {

.ws_row = 0,

.ws_col = 1,

.ws_xpixel = 2,

.ws_ypixel = 3};

forkpty(

__amaster,

"__name",

__termp,

&__winp); //target call

return 0;

}

[+] openpty ( int* __amaster, int* __aslave, char* __name, struct termios const* __termp, struct winsize const* __winp )

received signal SEGV

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

#include <stdlib.h>

#include <pty.h>

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

{

int* __amaster = (int*) malloc(sizeof(int)*256);

int* __aslave = (int*) malloc(sizeof(int)*256);

struct termios* __termp = 0; //can't initialize

struct winsize __winp = {

.ws_row = 0,

.ws_col = 1,

.ws_xpixel = 2,

.ws_ypixel = 3};

openpty(

__amaster,

__aslave,

"__name",

__termp,

&__winp); //target call

return 0;

}

to the top

[+] Hanged execution (3 problems)

pmap_clnt.h, libc-2.13.so
[+] clnt_broadcast ( u_long const __prog, u_long const __vers, u_long const __proc, xdrproc_t __xargs, caddr_t __argsp, xdrproc_t __xresults, caddr_t __resultsp, resultproc_t __eachresult )

hanged execution (more than 7 seconds)

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
46
47
48
49
50
51

#include <wchar.h>

#include <stdio.h>

#include <rpc/pmap_clnt.h>

//auxiliary function

bool_t

__xargs(XDR* p1, void* p2){

return 1;

}

//auxiliary function

bool_t

__eachresult(caddr_t p1, struct sockaddr_in* p2){

return 1;

}

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

{

FILE* __file = fopen("testdata/sample.txt", "r+");

XDR __xdrs;

xdrstdio_create(&__xdrs, __file, XDR_ENCODE);

caddr_t __argsp = 0;

xdr_reference(

&__xdrs,

&__argsp,

&__xargs);

caddr_t __resultsp = 0;

xdr_reference(

&__xdrs,

&__resultsp,

&__xargs);

clnt_broadcast(

&__xargs,

__argsp,

&__xargs,

__resultsp,

&__eachresult); //target call

//finalization

fclose(__file);

return 0;

}

signal.h, libc-2.13.so
[+] sigsuspend ( sigset_t const* __set )

hanged execution (more than 7 seconds)

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
46
47
48

#include <signal.h>
int main(int argc, char *argv[])
{
sigset_t __set [] = {
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {0}};
sigsuspend(__set); //target call
return 0;
}

unistd.h, libc-2.13.so
[+] pause ( )

hanged execution (more than 7 seconds)

#include <unistd.h>

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

{

pause(); //target call

return 0;

}

to the top

Warnings (106)

[+] Received signal ABRT (2 warnings)

obstack.h, libc-2.13.so
[+] obstack_free ( struct obstack* __obstack, void* __block )

received signal ABRT

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

#include <stdlib.h>

#include <obstack.h>

//auxiliary function

struct _obstack_chunk*

chunkfun(void* p1, long p2){

char limit [] = {

'I',

'J',

'K',

'L',

'\0'};

struct _obstack_chunk retval = {

.limit = limit,

.prev = 0,

.contents = {

'M',

'N',

'O',

'P'}};

return &retval;

}

//auxiliary function

void

freefun(void* p1, struct _obstack_chunk* p2){

free(p1);

}

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

{

char limit [] = {

'A',

'B',

'C',

'D',

'\0'};

struct _obstack_chunk chunk = {

.limit = limit,

.prev = 0,

.contents = {

'E',

'F',

'G',

'H'}};

void* extra_arg = malloc(256);

struct obstack __obstack = {

.chunk_size = 4,

.chunk = &chunk,

.object_base = limit,

.next_free = limit,

.chunk_limit = limit,

.temp = {.tempint = 1},

.alignment_mask = 0,

.chunkfun = &chunkfun,

.freefun = &freefun,

.extra_arg = extra_arg,

.use_extra_arg = 2,

.maybe_empty_object = 3,

.alloc_failed = 0};

void* __block = malloc(256);

obstack_free(&__obstack, __block); //target call

return 0;

}

stdlib.h, libc-2.13.so
[+] abort ( )

received signal ABRT

#include <stdlib.h>

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

{

abort(); //target call

return 0;

}

to the top

[+] Received signal ALRM (2 warnings)

unistd.h, libc-2.13.so
[+] ualarm ( __useconds_t __value, __useconds_t __interval )

received signal ALRM

#include <rpc/types.h>

#include <unistd.h>

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

{

ualarm(1, 1); //target call

return 0;

}

[+] usleep ( __useconds_t __useconds )

received signal ALRM

1
2
3
4
5
6
7
8

#include <rpc/types.h>

#include <unistd.h>

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

{

__useconds_t __useconds = ualarm(1, 1);

usleep(__useconds); //target call

return 0;

}

to the top

[+] Received signal HUP (2 warnings)

signal.h, libc-2.13.so
[+] gsignal ( int __sig )

received signal HUP

#include <signal.h>

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

{

gsignal(1); //target call

return 0;

}

[+] raise ( int __sig )

received signal HUP

#include <signal.h>

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

{

raise(1); //target call

return 0;

}

to the top

[+] Exited with value "1" (4 warnings)

err.h, libc-2.13.so
[+] err ( int __status, char const* __format, ... )

exited with value 1

test: 1: Success

1
2
3
4
5
6
7
8
9
10

#include <err.h>

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

{

err(

"%d",

(char*)0); //target call

return 0;

}

[+] errx ( int __status, char const* __format, ... )

exited with value 1

test: 1

1
2
3
4
5
6
7
8
9
10

#include <err.h>

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

{

errx(

"%d",

(char*)0); //target call

return 0;

}

[+] verr ( int __status, char const* __format, __gnuc_va_list p3 )

exited with value 1

test: __format: Success

1
2
3
4
5
6
7
8
9
10
11
12

#include <err.h>

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

{

char p3 [] = {

'A',

'B',

'C',

'D',

'\0'};

verr(1, "__format", p3); //target call

return 0;

}

[+] verrx ( int __status, char const* p2, __gnuc_va_list p3 )

exited with value 1

test: str

1
2
3
4
5
6
7
8
9
10
11
12

#include <err.h>

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

{

char p3 [] = {

'A',

'B',

'C',

'D',

'\0'};

verrx(1, "str", p3); //target call

return 0;

}

to the top

[+] Exited with value "127" (75 warnings)

aliases.h, libc-2.13.so
[+] getaliasbyname ( char const* __name )

exited with value 127

2069: U��$�]�衄��&H 2069: U�� }��}�]��+��ðG./test: : �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072493679312

#include <aliases.h>

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

{

getaliasbyname("__name"); //target call

return 0;

}

[+] getaliasbyname_r ( char const* __name, struct aliasent* __result_buf, char* __buffer, size_t __buflen, struct aliasent** __result )

exited with value 127

2073: U��$�]�衄��&H 2073: U�� }��}�]��+��ðG./test: : �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072493032144

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

#include <aliases.h>

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

{

struct aliasent __result_buf;

char __buffer [] = {

'A',

'B',

'C',

'D',

'\0'};

struct aliasent* __result = 0;

getaliasbyname_r(

"__name",

&__result_buf,

__buffer,

(struct aliasent**)&__result); //target call

return 0;

}

[+] getaliasent ( )

exited with value 127

2077: U��$�]�衄��&H 2077: U�� }��}�]��+��ðG./test: �?p�na�Q��m��!n��g��k�Ϯk��Pf��!n��!n��!n�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492098256

#include <aliases.h>

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

{

getaliasent(); //target call

return 0;

}

[+] getaliasent_r ( struct aliasent* __result_buf, char* __buffer, size_t __buflen, struct aliasent** __result )

exited with value 127

2081: U��$�]�衄��&H 2081: U�� }��}�]��+��ðG./test: ��dn�_�_��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072494093008

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

#include <aliases.h>

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

{

struct aliasent __result_buf;

char __buffer [] = {

'A',

'B',

'C',

'D',

'\0'};

struct aliasent* __result = 0;

getaliasent_r(

&__result_buf,

__buffer,

(struct aliasent**)&__result); //target call

return 0;

}

[+] setaliasent ( )

exited with value 127

5575: U��$�]�衄��&H 5575: U�� }��}�]��+��ðG./test: �AX�: �$: �$: Error 18446744072492143312

#include <aliases.h>

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

{

setaliasent(); //target call

return 0;

}

dlfcn.h, libc-2.13.so
[+] _dl_mcount_wrapper_check ( void* __selfpc )

exited with value 127

./test: : �: �: Error 18446744072493212368

1
2
3
4
5
6
7
8

#include <stdlib.h>

#include <dlfcn.h>

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

{

void* __selfpc = malloc(256);

_dl_mcount_wrapper_check(__selfpc); //target call

return 0;

}

grp.h, libc-2.13.so
[+] getgrent ( )

exited with value 127

2167: U��$�]�衄��&H 2167: U�� }��}�]��+��ðG./test: �_��we�`��|+��\�� bv�&��1��`l{��+��+��+��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072493482704

#include <grp.h>

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

{

getgrent(); //target call

return 0;

}

[+] getgrent_r ( struct group* __resultbuf, char* __buffer, size_t __buflen, struct group** __result )

exited with value 127

2171: U��$�]�衄��&H 2171: U�� }��}�]��+��ðG./test: 􏈷we�`�?��|[��l��0��y�&ꃷ1ꃷ`�~��[��[��[��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072493691600

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

#include <grp.h>

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

{

struct group* __resultbuf = getgrent();

char __buffer [] = {

'A',

'B',

'C',

'D',

'\0'};

struct group* __result = 0;

getgrent_r(

__resultbuf,

__buffer,

(struct group**)&__result); //target call

return 0;

}

[+] putgrent ( struct group const* __p, FILE* __f )

exited with value 127

4991: U��$�]�衄��&H 4991: U�� }��}�]��+��ðG./test: �?y�we�`��v�|w�lI��0I��Bj�&�t�1�t�`Lo��w��w��w�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492688080

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

#include <wchar.h>

#include <stdio.h>

#include <grp.h>

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

{

struct group* __p = getgrent();

FILE* __f = fopen("testdata/sample.txt", "r+");

putgrent(__p, __f); //target call

//finalization

fclose(__f);

return 0;

}

gshadow.h, libc-2.13.so
[+] getsgent ( )

exited with value 127

2514: U��$�]�衄��&H 2514: U�� }��}�]��+��ðG./test: �ot�le�`�r�<Cr�,��i��o��o�`�j��Cr��Cr��Cr�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492372688

#include <gshadow.h>

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

{

getsgent(); //target call

return 0;

}

[+] getsgent_r ( struct sgrp* __result_buf, char* __buffer, size_t __buflen, struct sgrp** __result )

exited with value 127

2518: U��$�]�衄��&H 2518: U�� }��}�]��+��ðG./test: ��}�dn�_�{�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492987088

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

#include <gshadow.h>

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

{

struct sgrp __result_buf;

char __buffer [] = {

'A',

'B',

'C',

'D',

'\0'};

struct sgrp* __result = 0;

getsgent_r(

&__result_buf,

__buffer,

(struct sgrp**)&__result); //target call

return 0;

}

[+] getsgnam ( char const* __name )

exited with value 127

2522: U��$�]�衄��&H 2522: U�� }��}�]��+��ðG./test: dn�_(�X��o�: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072492176080

#include <gshadow.h>

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

{

getsgnam("__name"); //target call

return 0;

}

[+] getsgnam_r ( char const* __name, struct sgrp* __result_buf, char* __buffer, size_t __buflen, struct sgrp** __result )

exited with value 127

2526: U��$�]�衄��&H 2526: U�� }��}�]��+��ðG./test: dn�_: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072492688080

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

#include <gshadow.h>

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

{

struct sgrp __result_buf;

char __buffer [] = {

'A',

'B',

'C',

'D',

'\0'};

struct sgrp* __result = 0;

getsgnam_r(

"__name",

&__result_buf,

__buffer,

(struct sgrp**)&__result); //target call

return 0;

}

[+] putsgent ( struct sgrp const* __g, FILE* __stream )

exited with value 127

5011: U��$�]�衄��&H 5011: U�� }��}�]��+��ðG./test: �r�le�`�/p�<Sp�,��g��m��m�`�h��Sp��Sp��Sp�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492245712

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

#include <wchar.h>

#include <stdio.h>

#include <gshadow.h>

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

{

struct sgrp* __g = getsgent();

FILE* __stream = fopen("testdata/sample.txt", "r+");

putsgent(__g, __stream); //target call

//finalization

fclose(__stream);

return 0;

}

netdb.h, libc-2.13.so
[+] gethostbyaddr ( void const* __addr, __socklen_t __len, int __type )

exited with value 127

2201: U��$�]�衄��&H 2201: U�� }��}�]��+��ðG./test: : �M�E�U�|$�L$�M�D$�E�T$�U�L$�M�D$�T$�$�U��u��?��y��U؋Eԃ<"�i��E �: �M�E�U�|$�L$�M�D$�E�T$�U�L$�M�D$�T$�$�U��u��?��y��U؋Eԃ<"�i��E �: Error 18446744072493236944

1
2
3
4
5
6
7
8

#include <rpc/types.h>

#include <netdb.h>

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

{

void* __addr = malloc(256);

gethostbyaddr(__addr, 256, 0); //target call

return 0;

}

[+] gethostbyaddr_r ( void const* __addr, __socklen_t __len, int __type, struct hostent* __result_buf, char* __buf, size_t __buflen, struct hostent** __result, int* __h_errnop )

exited with value 127

2205: U��$�]�衄��&H 2205: U�� }��}�]��+��ðG./test: : �M�E�U�|$�L$�M�D$�E�T$�U�L$�M�D$�T$�$�U��u��?��y��U؋Eԃ<"�i��E �: �M�E�U�|$�L$�M�D$�E�T$�U�L$�M�D$�T$�$�U��u��?��y��U؋Eԃ<"�i��E �: Error 18446744072493171408

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

#include <rpc/types.h>

#include <netdb.h>

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

{

void* __addr = malloc(256);

struct hostent __result_buf;

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

struct hostent* __result = 0;

int* __h_errnop = (int*) malloc(sizeof(int)*256);

gethostbyaddr_r(

__addr,

256,

&__result_buf,

__buf,

256,

(struct hostent**)&__result,

__h_errnop); //target call

return 0;

}

[+] gethostent ( )

exited with value 127

2229: U��$�]�衄��&H 2229: U�� }��}�]��+��ðG./test: �?z�xt�Z��w��a��-̿�-̿Z�p�_�u�I�u� Kp��x��x��x��x�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492753616

#include <netdb.h>

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

{

gethostent(); //target call

return 0;

}

[+] gethostent_r ( struct hostent* __result_buf, char* __buf, size_t __buflen, struct hostent** __result, int* __h_errnop )

exited with value 127

2233: U��$�]�衄��&H 2233: U�� }��}�]��+��ðG./test: ��~�dn�_�O|��f�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072493040336

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

#include <stdlib.h>

#include <netdb.h>

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

{

struct hostent __result_buf;

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

struct hostent* __result = 0;

int* __h_errnop = (int*) malloc(sizeof(int)*256);

gethostent_r(

&__result_buf,

__buf,

256,

(struct hostent**)&__result,

__h_errnop); //target call

return 0;

}

[+] getnetbyaddr ( uint32_t __net, int __type )

exited with value 127

2287: U��$�]�衄��&H 2287: U�� }��}�]��+��ðG./test: : �M�E�U�t$�L$�M�D$�E�T$�U�L$�D$�$�U��u��>�u��E؋Mԃ<"�x��M�": �M�E�U�t$�L$�M�D$�E�T$�U�L$�D$�$�U��u��>�u��E؋Mԃ<"�x��M�": Error 18446744072493753040

#include <netdb.h>

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

{

getnetbyaddr(1, 0); //target call

return 0;

}

[+] getnetbyaddr_r ( uint32_t __net, int __type, struct netent* __result_buf, char* __buf, size_t __buflen, struct netent** __result, int* __h_errnop )

exited with value 127

2291: U��$�]�衄��&H 2291: U�� }��}�]��+��ðG./test: : �M�E�U�t$�L$�M�D$�E�T$�U�L$�D$�$�U��u��>�u��E؋Mԃ<"�x��M�": �M�E�U�t$�L$�M�D$�E�T$�U�L$�D$�$�U��u��>�u��E؋Mԃ<"�x��M�": Error 18446744072493077200

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

#include <stdlib.h>

#include <netdb.h>

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

{

struct netent __result_buf;

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

struct netent* __result = 0;

int* __h_errnop = (int*) malloc(sizeof(int)*256);

getnetbyaddr_r(

&__result_buf,

__buf,

256,

(struct netent**)&__result,

__h_errnop); //target call

return 0;

}

[+] getnetbyname ( char const* __name )

exited with value 127

2295: U��$�]�衄��&H 2295: U�� }��}�]��+��ðG./test: : �M�E�U�t$�L$�M�D$�E�T$�L$�$�U��u��>�u��M؋Uԃ<"u��M�": �M�E�U�t$�L$�M�D$�E�T$�L$�$�U��u��>�u��M؋Uԃ<"u��M�": Error 18446744072493490896

#include <netdb.h>

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

{

getnetbyname("__name"); //target call

return 0;

}

[+] getnetbyname_r ( char const* __name, struct netent* __result_buf, char* __buf, size_t __buflen, struct netent** __result, int* __h_errnop )

exited with value 127

2299: U��$�]�衄��&H 2299: U�� }��}�]��+��ðG./test: : �M�E�U�t$�L$�M�D$�E�T$�L$�$�U��u��>�u��M؋Uԃ<"u��M�": �M�E�U�t$�L$�M�D$�E�T$�L$�$�U��u��>�u��M؋Uԃ<"u��M�": Error 18446744072492507856

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

#include <stdlib.h>

#include <netdb.h>

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

{

struct netent __result_buf;

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

struct netent* __result = 0;

int* __h_errnop = (int*) malloc(sizeof(int)*256);

getnetbyname_r(

"__name",

&__result_buf,

__buf,

256,

(struct netent**)&__result,

__h_errnop); //target call

return 0;

}

[+] getnetent ( )

exited with value 127

2303: U��$�]�衄��&H 2303: U�� }��}�]��+��ðG./test: �Ox�ye�`��u��_�|��@��n��s�{�s��[n�/v� /v�$/v�(/v�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492626640

#include <netdb.h>

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

{

getnetent(); //target call

return 0;

}

[+] getnetent_r ( struct netent* __result_buf, char* __buf, size_t __buflen, struct netent** __result, int* __h_errnop )

exited with value 127

2307: U��$�]�衄��&H 2307: U�� }��}�]��+��ðG./test: �/q�dn�_��n��X�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492159696

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

#include <stdlib.h>

#include <netdb.h>

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

{

struct netent __result_buf;

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

struct netent* __result = 0;

int* __h_errnop = (int*) malloc(sizeof(int)*256);

getnetent_r(

&__result_buf,

__buf,

256,

(struct netent**)&__result,

__h_errnop); //target call

return 0;

}

[+] getprotobyname ( char const* __name )

exited with value 127

2372: U��$�]�衄��&H 2372: U�� }��}�]��+��ðG./test: : �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072493040336

#include <netdb.h>

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

{

getprotobyname("__name"); //target call

return 0;

}

[+] getprotobyname_r ( char const* __name, struct protoent* __result_buf, char* __buf, size_t __buflen, struct protoent** __result )

exited with value 127

2376: U��$�]�衄��&H 2376: U�� }��}�]��+��ðG./test: : �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072492585680

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

#include <netdb.h>

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

{

struct protoent __result_buf;

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

struct protoent* __result = 0;

getprotobyname_r(

"__name",

&__result_buf,

__buf,

(struct protoent**)&__result); //target call

return 0;

}

[+] getprotobynumber ( int __proto )

exited with value 127

2380: U��$�]�衄��&H 2380: U�� }��}�]��+��ðG./test: �-��Z��Op�: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072492253904

#include <netdb.h>

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

{

getprotobynumber(1); //target call

return 0;

}

[+] getprotobynumber_r ( int __proto, struct protoent* __result_buf, char* __buf, size_t __buflen, struct protoent** __result )

exited with value 127

2384: U��$�]�衄��&H 2384: U�� }��}�]��+��ðG./test: �-��x/l��_��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072493437648

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

#include <netdb.h>

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

{

struct protoent __result_buf;

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

struct protoent* __result = 0;

getprotobynumber_r(

&__result_buf,

__buf,

(struct protoent**)&__result); //target call

return 0;

}

[+] getprotoent ( )

exited with value 127

2388: U��$�]�衄��&H 2388: U�� }��}�]��+��ðG./test: ��x�tt�Q�ov�h�v�L>��>��/6o��+t��+t��n�p�v�t�v�x�v�|�v�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492655312

#include <netdb.h>

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

{

getprotoent(); //target call

return 0;

}

[+] getprotoent_r ( struct protoent* __result_buf, char* __buf, size_t __buflen, struct protoent** __result )

exited with value 127

2392: U��$�]�衄��&H 2392: U�� }��}�]��+��ðG./test: �y�dn�_�?w�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492708560

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

#include <netdb.h>

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

{

struct protoent __result_buf;

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

struct protoent* __result = 0;

getprotoent_r(

&__result_buf,

__buf,

(struct protoent**)&__result); //target call

return 0;

}

[+] getrpcbyname ( char const* __name )

exited with value 127

2449: U��$�]�衄��&H 2449: U�� }��}�]��+��ðG./test: : �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072493871824

#include <netdb.h>

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

{

getrpcbyname("__name"); //target call

return 0;

}

[+] getrpcbyname_r ( char const* __name, struct rpcent* __result_buf, char* __buffer, size_t __buflen, struct rpcent** __result )

exited with value 127

2453: U��$�]�衄��&H 2453: U�� }��}�]��+��ðG./test: : �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072493253328

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

#include <netdb.h>

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

{

struct rpcent __result_buf;

char __buffer [] = {

'A',

'B',

'C',

'D',

'\0'};

struct rpcent* __result = 0;

getrpcbyname_r(

"__name",

&__result_buf,

__buffer,

(struct rpcent**)&__result); //target call

return 0;

}

[+] getrpcbynumber ( int __number )

exited with value 127

2457: U��$�]�衄��&H 2457: U�� }��}�]��+��ðG./test: : �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072493728464

#include <netdb.h>

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

{

getrpcbynumber(1); //target call

return 0;

}

[+] getrpcbynumber_r ( int __number, struct rpcent* __result_buf, char* __buffer, size_t __buflen, struct rpcent** __result )

exited with value 127

2461: U��$�]�衄��&H 2461: U�� }��}�]��+��ðG./test: : �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072493195984

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

#include <netdb.h>

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

{

struct rpcent __result_buf;

char __buffer [] = {

'A',

'B',

'C',

'D',

'\0'};

struct rpcent* __result = 0;

getrpcbynumber_r(

&__result_buf,

__buffer,

(struct rpcent**)&__result); //target call

return 0;

}

[+] getrpcent ( )

exited with value 127

2465: U��$�]�衄��&H 2465: U�� }��}�]��+��ðG./test: 􏉷he�`�?��$p��Ͽ�Ͽ��K��7��Tp��Xp��\p��`p��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072493757136

#include <netdb.h>

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

{

getrpcent(); //target call

return 0;

}

[+] getrpcent_r ( struct rpcent* __result_buf, char* __buffer, size_t __buflen, struct rpcent** __result )

exited with value 127

2469: U��$�]�衄��&H 2469: U�� }��}�]��+��ðG./test: �_��dn�_��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072493941456

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

#include <netdb.h>

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

{

struct rpcent __result_buf;

char __buffer [] = {

'A',

'B',

'C',

'D',

'\0'};

struct rpcent* __result = 0;

getrpcent_r(

&__result_buf,

__buffer,

(struct rpcent**)&__result); //target call

return 0;

}

[+] getservbyname ( char const* __name, char const* __proto )

exited with value 127

2490: U��$�]�衄��&H 2490: U�� }��}�]��+��ðG./test: getservbyname_r: �U�M�E�|$�T$�U�L$�M�D$�T$�$�U��u�UԋE؃<"��: �U�M�E�|$�T$�U�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072492319440

#include <netdb.h>

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

{

getservbyname("__name", "__proto"); //target call

return 0;

}

[+] getservbyname_r ( char const* __name, char const* __proto, struct servent* __result_buf, char* __buf, size_t __buflen, struct servent** __result )

exited with value 127

2494: U��$�]�衄��&H 2494: U�� }��}�]��+��ðG./test: getservbyname_r: �U�M�E�|$�T$�U�L$�M�D$�T$�$�U��u�UԋE؃<"��: �U�M�E�|$�T$�U�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072493720272

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

#include <netdb.h>

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

{

struct servent __result_buf;

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

struct servent* __result = 0;

getservbyname_r(

"__name",

"__proto",

&__result_buf,

__buf,

(struct servent**)&__result); //target call

return 0;

}

[+] getservbyport ( int __port, char const* __proto )

exited with value 127

2498: U��$�]�衄��&H 2498: U�� }��}�]��+��ðG./test: getservbyport_r: �U�M�E�|$�T$�U�L$�M�D$�T$�$�U��u�UԋE؃<"��: �U�M�E�|$�T$�U�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072494121680

#include <netdb.h>

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

{

getservbyport(1, "__proto"); //target call

return 0;

}

[+] getservbyport_r ( int __port, char const* __proto, struct servent* __result_buf, char* __buf, size_t __buflen, struct servent** __result )

exited with value 127

2502: U��$�]�衄��&H 2502: U�� }��}�]��+��ðG./test: getservbyport_r: �U�M�E�|$�T$�U�L$�M�D$�T$�$�U��u�UԋE؃<"��: �U�M�E�|$�T$�U�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072492118736

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

#include <netdb.h>

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

{

struct servent __result_buf;

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

struct servent* __result = 0;

getservbyport_r(

"__proto",

&__result_buf,

__buf,

(struct servent**)&__result); //target call

return 0;

}

[+] getservent ( )

exited with value 127

2506: U��$�]�衄��&H 2506: U�� }��}�]��+��ðG./test: ��wv�Z�O��̶��%��*��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072494154448

#include <netdb.h>

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

{

getservent(); //target call

return 0;

}

[+] getservent_r ( struct servent* __result_buf, char* __buf, size_t __buflen, struct servent** __result )

exited with value 127

2510: U��$�]�衄��&H 2510: U�� }��}�]��+��ðG./test: �_p�dn�_�n�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492106448

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

#include <netdb.h>

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

{

struct servent __result_buf;

char __buf [] = {

'A',

'B',

'C',

'D',

'\0'};

struct servent* __result = 0;

getservent_r(

&__result_buf,

__buf,

(struct servent**)&__result); //target call

return 0;

}

[+] sethostent ( int __stay_open )

exited with value 127

5631: U��$�]�衄��&H 5631: U�� }��}�]��+��ðG./test: 8~g�: �M��$�U��D$�U�E��D$: �M��$�U��D$�U�E��D$: Error 18446744072493130448

#include <netdb.h>

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

{

sethostent(1); //target call

return 0;

}

[+] setprotoent ( int __stay_open )

exited with value 127

5702: U��$�]�衄��&H 5702: U�� }��}�]��+��ðG./test: xOb�: �M��$�U��D$�U�E��D$: �M��$�U��D$�U�E��D$: Error 18446744072492790480

#include <netdb.h>

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

{

setprotoent(1); //target call

return 0;

}

[+] setservent ( int __stay_open )

exited with value 127

5738: U��$�]�衄��&H 5738: U�� }��}�]��+��ðG./test: 8ov�: �M��$�U��D$�U�E��D$: �M��$�U��D$�U�E��D$: Error 18446744072494109392

#include <netdb.h>

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

{

setservent(1); //target call

return 0;

}

pwd.h, libc-2.13.so
[+] getpwent ( )

exited with value 127

2408: U��$�]�衄��&H 2408: U�� }��}�]��+��ðG./test: ��|�|e�`�z��z��,��,��M�m��:x��:x�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492925648

#include <pwd.h>

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

{

getpwent(); //target call

return 0;

}

[+] getpwent_r ( struct passwd* __resultbuf, char* __buffer, size_t __buflen, struct passwd** __result )

exited with value 127

2412: U��$�]�衄��&H 2412: U�� }��}�]��+��ðG./test: ��r�|e�`�Op�lp�,I��H��M�c��m��m�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492253904

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

#include <pwd.h>

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

{

struct passwd* __resultbuf = getpwent();

char __buffer [] = {

'A',

'B',

'C',

'D',

'\0'};

struct passwd* __result = 0;

getpwent_r(

__resultbuf,

__buffer,

(struct passwd**)&__result); //target call

return 0;

}

[+] putpwent ( struct passwd const* __p, FILE* __f )

exited with value 127

5003: U��$�]�衄��&H 5003: U�� }��}�]��+��ðG./test: ��|�|e�`�z��z��E��E��M�m��*x��*x�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072492921552

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

#include <wchar.h>

#include <stdio.h>

#include <pwd.h>

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

{

struct passwd* __p = getpwent();

FILE* __f = fopen("testdata/sample.txt", "r+");

putpwent(__p, __f); //target call

//finalization

fclose(__f);

return 0;

}

shadow.h, libc-2.13.so
[+] getspent ( )

exited with value 127

2547: U��$�]�衄��&H 2547: U�� }��}�]��+��ðG./test: ��ue�`�/~��Q~��\ƿ�\ƿ��u�l�{�Z�{��v�S~�S~�S~�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072493163216

#include <shadow.h>

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

{

getspent(); //target call

return 0;

}

[+] getspent_r ( struct spwd* __result_buf, char* __buffer, size_t __buflen, struct spwd** __result )

exited with value 127

2551: U��$�]�衄��&H 2551: U�� }��}�]��+��ðG./test: ��dn�_�ω�: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072493925072

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

#include <shadow.h>

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

{

struct spwd __result_buf;

char __buffer [] = {

'A',

'B',

'C',

'D',

'\0'};

struct spwd* __result = 0;

getspent_r(

&__result_buf,

__buffer,

(struct spwd**)&__result); //target call

return 0;

}

[+] getspnam ( char const* __name )

exited with value 127

2555: U��$�]�衄��&H 2555: U�� }��}�]��+��ðG./test: dn�_�t��ߊ�� ُ��]�� ثt�: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072493994704

#include <shadow.h>

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

{

getspnam("__name"); //target call

return 0;

}

[+] getspnam_r ( char const* __name, struct spwd* __result_buf, char* __buffer, size_t __buflen, struct spwd** __result )

exited with value 127

2559: U��$�]�衄��&H 2559: U�� }��}�]��+��ðG./test: dn�_�M`��v�: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: �M�E�U�|$�L$�M�D$�T$�$�U��u�UԋE؃<"��: Error 18446744072492659408

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

#include <shadow.h>

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

{

struct spwd __result_buf;

char __buffer [] = {

'A',

'B',

'C',

'D',

'\0'};

struct spwd* __result = 0;

getspnam_r(

"__name",

&__result_buf,

__buffer,

(struct spwd**)&__result); //target call

return 0;

}

[+] putspent ( struct spwd const* __p, FILE* __stream )

exited with value 127

5015: U��$�]�衄��&H 5015: U�� }��}�]��+��ðG./test: ��ue�`�ω��,��X��l��Z��.��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: �M܋E؋U0�L$�M,�D$�E(�T$�L$�$�U��: Error 18446744072493925072

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

#include <wchar.h>

#include <stdio.h>

#include <shadow.h>

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

{

struct spwd* __p = getspent();

FILE* __stream = fopen("testdata/sample.txt", "r+");

putspent(__p, __stream); //target call

//finalization

fclose(__stream);

return 0;

}

stdlib.h, libc-2.13.so
[+] mblen ( char const* __s, size_t __n )

exited with value 127

./test: �Ko�: �U��M��D$: �U��M��D$: Error 18446744072492188368

#include <stdlib.h>

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

{

mblen("__s", 3); //target call

return 0;

}

[+] mbstowcs ( wchar_t* __pwcs, char const* __s, size_t __n )

exited with value 127

./test: U��WVS��P�E��sx: ��$�D$: ��$�D$: Error 18446744072494101200

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdlib.h>

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

{

wchar_t __pwcs [] = {

L'A',

L'B',

L'C',

L'D',

L'\0'};

mbstowcs(__pwcs, "__s", 4); //target call

return 0;

}

[+] mbtowc ( wchar_t* __pwc, char const* __s, size_t __n )

exited with value 127

./test: �kr�: �U��M��D$: �U��M��D$: Error 18446744072492393168

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdlib.h>

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

{

wchar_t __pwc [] = {

L'A',

L'B',

L'C',

L'D',

L'\0'};

mbtowc(__pwc, "__s", 4); //target call

return 0;

}

[+] wctomb ( char* __s, wchar_t __wchar )

exited with value 127

./test: E: �M��E��L$�M��D$: �M��E��L$�M��D$: Error 18446744072492344016

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdlib.h>

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

{

char __s [] = {

'A',

'B',

'C',

'D',

'\0'};

wctomb(__s, L'E'); //target call

return 0;

}

syslog.h, libc-2.13.so
[+] syslog ( int __pri, char const* __fmt, ... )

exited with value 127

Inconsistency detected by ld.so: dl-minimal.c: 138: realloc: Assertion `ptr == alloc_last_block' failed!

1
2
3
4
5
6
7
8
9
10

#include <syslog.h>

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

{

syslog(

"%d",

(char*)0); //target call

return 0;

}

[+] vsyslog ( int __pri, char const* __fmt, __gnuc_va_list __ap )

exited with value 127

Inconsistency detected by ld.so: dl-minimal.c: 138: realloc: Assertion `ptr == alloc_last_block' failed!

1
2
3
4
5
6
7
8
9
10
11
12

#include <syslog.h>

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

{

char __ap [] = {

'A',

'B',

'C',

'D',

'\0'};

vsyslog(1, "__fmt", __ap); //target call

return 0;

}

wchar.h, libc-2.13.so
[+] __mbrlen ( char const* __s, size_t __n, mbstate_t* __ps )

exited with value 127

./test: ��: �U��M��D$: �U��M��D$: Error 18446744072493396688

#include <wchar.h>

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

{

mbstate_t __ps = {.__count = 4, .__value = {.__wch = 1}};

__mbrlen("__s", 3, &__ps); //target call

return 0;

}

[+] getwchar ( )

exited with value 127

./test: gcc -Wall -D_GNU_SOURCE -I/home/andrey/glibc-fuzzing/testing/glibc-2.13/include test.c -o test /home/andrey/glibc-fuzzing/testing/glibc-2.13/lib/ld-2.13.so -L/home/andrey/glibc-fuzzing/testing/glibc-2.13/lib -lc-2.13 -lm
: �U��E�T$�U�D$: �U��E�T$�U�D$: Error 18446744072492618448

#include <wchar.h>

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

{

getwchar(); //target call

return 0;

}

[+] getwchar_unlocked ( )

#include <wchar.h>

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

{

getwchar_unlocked(); //target call

return 0;

}

[+] mbrlen ( char const* __s, size_t __n, mbstate_t* __ps )

exited with value 127

./test: �Ku�: �U��M��D$: �U��M��D$: Error 18446744072492581584

#include <wchar.h>

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

{

mbstate_t __ps = {.__count = 4, .__value = {.__wch = 1}};

mbrlen("__s", 3, &__ps); //target call

return 0;

}

[+] mbrtowc ( wchar_t* __pwc, char const* __s, size_t __n, mbstate_t* __p )

exited with value 127

./test: �{u�: �U��M��D$: �U��M��D$: Error 18446744072492593872

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

#include <wchar.h>

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

{

wchar_t __pwc [] = {

L'A',

L'B',

L'C',

L'D',

L'\0'};

mbstate_t __p = {.__count = 4, .__value = {.__wch = 1}};

mbrtowc(

__pwc,

"__s",

&__p); //target call

return 0;

}

[+] mbsnrtowcs ( wchar_t* __dst, char const** __src, size_t __nmc, size_t __len, mbstate_t* __ps )

exited with value 127

./test: tdata/sample.txt: �E��D$�E��D$: �E��D$�E��D$: Error 18446744072493585104

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

#include <wchar.h>

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

{

wchar_t __dst [] = {

L'A',

L'B',

L'C',

L'D',

L'\0'};

char* __src [] = {

"testdata/sample.txt",

0};

mbstate_t __ps = {.__count = 4, .__value = {.__wch = 1}};

mbsnrtowcs(

__dst,

(char const**)__src,

&__ps); //target call

return 0;

}

[+] mbsrtowcs ( wchar_t* __dst, char const** __src, size_t __len, mbstate_t* __ps )

exited with value 127

./test: U��WVS��P�E��sx: ��$�D$: ��$�D$: Error 18446744072493966032

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

#include <wchar.h>

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

{

wchar_t __dst [] = {

L'A',

L'B',

L'C',

L'D',

L'\0'};

char* __src [] = {

"testdata/sample.txt",

0};

mbstate_t __ps = {.__count = 4, .__value = {.__wch = 1}};

mbsrtowcs(

__dst,

(char const**)__src,

&__ps); //target call

return 0;

}

[+] putwchar ( wchar_t __wc )

exited with value 127

./test: : �U��E�T$�U�D$: �U��E�T$�U�D$: Error 18446744072493044432

#include <wchar.h>

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

{

putwchar(L'A'); //target call

return 0;

}

[+] putwchar_unlocked ( wchar_t __wc )

exited with value 127

./test: : �U��E�T$�U�D$: �U��E�T$�U�D$: Error 18446744072492634832

#include <wchar.h>

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

{

putwchar_unlocked(L'A'); //target call

return 0;

}

[+] vwprintf ( wchar_t const* __format, __gnuc_va_list __arg )

exited with value 127

./test: : �U��E�T$�U�D$: �U��E�T$�U�D$: Error 18446744072492438224

1
2
3
4
5
6
7
8
9
10
11
12

#include <wchar.h>

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

{

char __arg [] = {

'A',

'B',

'C',

'D',

'\0'};

vwprintf(L"__format", __arg); //target call

return 0;

}

[+] vwscanf ( wchar_t const* __format, __gnuc_va_list __arg )

1
2
3
4
5
6
7
8
9
10
11
12

#include <wchar.h>

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

{

char __arg [] = {

'A',

'B',

'C',

'D',

'\0'};

vwscanf(L"__format", __arg); //target call

return 0;

}

[+] wcrtomb ( char* __s, wchar_t __wc, mbstate_t* __ps )

exited with value 127

./test: E: �M��E��L$�M��D$: �M��E��L$�M��D$: Error 18446744072493892304

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

#include <wchar.h>

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

{

char __s [] = {

'A',

'B',

'C',

'D',

'\0'};

mbstate_t __ps = {.__count = 4, .__value = {.__wch = 1}};

wcrtomb(__s, L'E', &__ps); //target call

return 0;

}

[+] wcsnrtombs ( char* __dst, wchar_t const** __src, size_t __nwc, size_t __len, mbstate_t* __ps )

exited with value 127

./test: ABCD: ��E�D$�E�D$: ��E�D$�E�D$: Error 18446744072493945552

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

#include <wchar.h>

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

{

char __dst [] = {

'A',

'B',

'C',

'D',

'\0'};

wchar_t* __src [] = {

"testdata/sample.txt",

0};

mbstate_t __ps = {.__count = 4, .__value = {.__wch = 1}};

wcsnrtombs(

__dst,

(wchar_t const**)__src,

&__ps); //target call

return 0;

}

[+] wprintf ( wchar_t const* __format, ... )

exited with value 127

./test: : �U��E�T$�U�D$: �U��E�T$�U�D$: Error 18446744072493634256

#include <wchar.h>

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

{

wprintf("%d", 1, (char*)0); //target call

return 0;

}

[+] wscanf ( wchar_t const* __format, ... )

#include <wchar.h>

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

{

wscanf("%d", 1, (char*)0); //target call

return 0;

}

wordexp.h, libc-2.13.so
[+] wordexp ( char const* __words, wordexp_t* __pwordexp, int __flags )

exited with value 127

Inconsistency detected by ld.so: dl-minimal.c: 138: realloc: Assertion `ptr == alloc_last_block' failed!

1
2
3
4
5
6
7
8
9
10
11

#include <wordexp.h>

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

{

char we_wordv = 'A';

char *we_wordv_p = (char *)&we_wordv;

char **we_wordv_pp = &we_wordv_p;

wordexp_t __pwordexp = {.we_wordc = 4, .we_wordv = (char**)we_wordv_pp, .we_offs = 4};

wordexp("__words", &__pwordexp, 0); //target call

return 0;

}

to the top

[+] Exited with value "64" (2 warnings)

argp.h, libc-2.13.so
[+] argp_error ( struct argp_state const* __state, char const* __fmt, ... )

exited with value 64

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289

#include <signal.h>

#include <wchar.h>

#include <stdio.h>

#include <stdlib.h>

#include <argp.h>

//auxiliary function

error_t

parser(int p1, char* p2, struct argp_state* p3){

return 1;

}

//auxiliary function

char*

help_filter(int p1, char const* p2, void* p3){

return (char*)p2;

}

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

{

struct argp_option options [] = {

(struct argp_option) {

.name = "name",

.key = 1,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 2},

(struct argp_option) {

.name = "name",

.key = 3,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 4},

(struct argp_option) {

.name = "name",

.key = 5,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 6},

(struct argp_option) {

.name = "name",

.key = 7,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 8},

(struct argp_option) {0}};

struct argp_child children = {

.argp = 0,

.flags = 0,

.header = "header",

.group = 9};

struct argp root_argp = {

.options = options,

.parser = &parser,

.args_doc = "args_doc",

.doc = "doc",

.children = &children,

.help_filter = &help_filter,

.argp_domain = "argp_domain"};

void* input = malloc(256);

void* hook = malloc(256);

struct _fpstate pstate = {

.cw = 2,

.sw = 3,

.tag = 4,

.ipoff = 5,

.cssel = 6,

.dataoff = 7,

.datasel = 8,

._st = {

(struct _fpreg) {

.significand = {

3},

.exponent = 9},

(struct _fpreg) {

.significand = {

3},

.exponent = 10},

(struct _fpreg) {

.significand = {

3},

.exponent = 1},

(struct _fpreg) {

.significand = {

3},

.exponent = 2},

(struct _fpreg) {

.significand = {

3},

.exponent = 3},

(struct _fpreg) {

.significand = {

3},

.exponent = 4},

(struct _fpreg) {

.significand = {

3},

.exponent = 5},

(struct _fpreg) {

.significand = {

3},

.exponent = 6}},

.status = 7,

.magic = 8,

._fxsr_env = {

5},

.mxcsr = 9,

.reserved = 0,

._fxsr_st = {

(struct _fpxreg) {

.significand = {

3},

.exponent = 10,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 1,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 2,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 3,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 4,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 5,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 6,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 7,

.padding = {0, 1, 2}}},

._xmm = {

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}}},

.padding1 = {

0, 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}};

struct argp_state __state = {

.root_argp = &root_argp,

.argc = argc,

.argv = argv,

.next = 10,

.flags = 0,

.arg_num = 1,

.quoted = 0,

.input = input,

.child_inputs = (void**)&input,

.hook = hook,

.name = "name",

.err_stream = fopen("testdata/sample.txt", "r+"),

.out_stream = fopen("testdata/sample.txt", "r+"),

.pstate = (void*)&pstate};

argp_error(

&__state,

"%d",

(char*)0); //target call

return 0;

}

[+] argp_usage ( struct argp_state const* __state )

exited with value 64

Usage: name [OPTION...] args_doc
Try `name --help' or `name --usage' for more information.

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285

#include <signal.h>

#include <wchar.h>

#include <stdio.h>

#include <stdlib.h>

#include <argp.h>

//auxiliary function

error_t

parser(int p1, char* p2, struct argp_state* p3){

return 1;

}

//auxiliary function

char*

help_filter(int p1, char const* p2, void* p3){

return (char*)p2;

}

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

{

struct argp_option options [] = {

(struct argp_option) {

.name = "name",

.key = 1,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 2},

(struct argp_option) {

.name = "name",

.key = 3,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 4},

(struct argp_option) {

.name = "name",

.key = 5,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 6},

(struct argp_option) {

.name = "name",

.key = 7,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 8},

(struct argp_option) {0}};

struct argp_child children = {

.argp = 0,

.flags = 0,

.header = "header",

.group = 9};

struct argp root_argp = {

.options = options,

.parser = &parser,

.args_doc = "args_doc",

.doc = "doc",

.children = &children,

.help_filter = &help_filter,

.argp_domain = "argp_domain"};

void* input = malloc(256);

void* hook = malloc(256);

struct _fpstate pstate = {

.cw = 2,

.sw = 3,

.tag = 4,

.ipoff = 5,

.cssel = 6,

.dataoff = 7,

.datasel = 8,

._st = {

(struct _fpreg) {

.significand = {

3},

.exponent = 9},

(struct _fpreg) {

.significand = {

3},

.exponent = 10},

(struct _fpreg) {

.significand = {

3},

.exponent = 1},

(struct _fpreg) {

.significand = {

3},

.exponent = 2},

(struct _fpreg) {

.significand = {

3},

.exponent = 3},

(struct _fpreg) {

.significand = {

3},

.exponent = 4},

(struct _fpreg) {

.significand = {

3},

.exponent = 5},

(struct _fpreg) {

.significand = {

3},

.exponent = 6}},

.status = 7,

.magic = 8,

._fxsr_env = {

5},

.mxcsr = 9,

.reserved = 0,

._fxsr_st = {

(struct _fpxreg) {

.significand = {

3},

.exponent = 10,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 1,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 2,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 3,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 4,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 5,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 6,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 7,

.padding = {0, 1, 2}}},

._xmm = {

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}}},

.padding1 = {

0, 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}};

struct argp_state __state = {

.root_argp = &root_argp,

.argc = argc,

.argv = argv,

.next = 10,

.flags = 0,

.arg_num = 1,

.quoted = 0,

.input = input,

.child_inputs = (void**)&input,

.hook = hook,

.name = "name",

.err_stream = fopen("testdata/sample.txt", "r+"),

.out_stream = fopen("testdata/sample.txt", "r+"),

.pstate = (void*)&pstate};

argp_usage(&__state); //target call

return 0;

}

to the top

[+] Exited with value "8" (1 warning)

argp.h, libc-2.13.so
[+] argp_failure ( struct argp_state const* __state, int __status, int __errnum, char const* __fmt, ... )

exited with value 8

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291

#include <signal.h>

#include <wchar.h>

#include <stdio.h>

#include <stdlib.h>

#include <argp.h>

//auxiliary function

error_t

parser(int p1, char* p2, struct argp_state* p3){

return 1;

}

//auxiliary function

char*

help_filter(int p1, char const* p2, void* p3){

return (char*)p2;

}

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

{

struct argp_option options [] = {

(struct argp_option) {

.name = "name",

.key = 1,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 2},

(struct argp_option) {

.name = "name",

.key = 3,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 4},

(struct argp_option) {

.name = "name",

.key = 5,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 6},

(struct argp_option) {

.name = "name",

.key = 7,

.arg = "arg",

.flags = 0,

.doc = "doc",

.group = 8},

(struct argp_option) {0}};

struct argp_child children = {

.argp = 0,

.flags = 0,

.header = "header",

.group = 9};

struct argp root_argp = {

.options = options,

.parser = &parser,

.args_doc = "args_doc",

.doc = "doc",

.children = &children,

.help_filter = &help_filter,

.argp_domain = "argp_domain"};

void* input = malloc(256);

void* hook = malloc(256);

struct _fpstate pstate = {

.cw = 2,

.sw = 3,

.tag = 4,

.ipoff = 5,

.cssel = 6,

.dataoff = 7,

.datasel = 8,

._st = {

(struct _fpreg) {

.significand = {

3},

.exponent = 9},

(struct _fpreg) {

.significand = {

3},

.exponent = 10},

(struct _fpreg) {

.significand = {

3},

.exponent = 1},

(struct _fpreg) {

.significand = {

3},

.exponent = 2},

(struct _fpreg) {

.significand = {

3},

.exponent = 3},

(struct _fpreg) {

.significand = {

3},

.exponent = 4},

(struct _fpreg) {

.significand = {

3},

.exponent = 5},

(struct _fpreg) {

.significand = {

3},

.exponent = 6}},

.status = 7,

.magic = 8,

._fxsr_env = {

5},

.mxcsr = 9,

.reserved = 0,

._fxsr_st = {

(struct _fpxreg) {

.significand = {

3},

.exponent = 10,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 1,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 2,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 3,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 4,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 5,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 6,

.padding = {0, 1, 2}},

(struct _fpxreg) {

.significand = {

3},

.exponent = 7,

.padding = {0, 1, 2}}},

._xmm = {

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}},

(struct _xmmreg) {

.element = {

3}}},

.padding1 = {

0, 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}};

struct argp_state __state = {

.root_argp = &root_argp,

.argc = argc,

.argv = argv,

.next = 10,

.flags = 0,

.arg_num = 1,

.quoted = 0,

.input = input,

.child_inputs = (void**)&input,

.hook = hook,

.name = "name",

.err_stream = fopen("testdata/sample.txt", "r+"),

.out_stream = fopen("testdata/sample.txt", "r+"),

.pstate = (void*)&pstate};

argp_failure(

&__state,

"%d",

(char*)0); //target call

return 0;

}

to the top

[+] Hanged execution (2 warnings)

signal.h, libc-2.13.so
[+] sigwait ( sigset_t const* __set, int* __sig )

hanged execution (more than 7 seconds)

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
46
47
48
49
50

#include <stdlib.h>
#include <signal.h>
int main(int argc, char *argv[])
{
sigset_t __set [] = {
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {0}};
int* __sig = (int) malloc(sizeof(int)256);
sigwait(__set, __sig); //target call
return 0;
}

[+] sigwaitinfo ( sigset_t const* __set, siginfo_t* __info )

hanged execution (more than 7 seconds)

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

#include <signal.h>
int main(int argc, char *argv[])
{
sigset_t __set [] = {
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {
.__val = {
0, 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}},
(sigset_t) {0}};
siginfo_t __info = {
.si_signo = 1,
.si_errno = 1,
.si_code = 2,
._sifields = {._pad = {
0, 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}}};
sigwaitinfo(__set, &__info); //target call
return 0;
}

to the top

[+] Unexpected Output (16 warnings)

clnt.h, libc-2.13.so
[+] clnt_perrno ( enum clnt_stat __num )

RPC: Success

#include <rpc/clnt.h>

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

{

clnt_perrno(RPC_SUCCESS); //target call

return 0;

}

netdb.h, libc-2.13.so
[+] rcmd ( char** __ahost, unsigned short __rport, char const* __locuser, char const* __remuser, char const* __cmd, int* __fd2p )

rcmd: getaddrinfo: Bad value for ai_flags

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

#include <stdlib.h>

#include <netdb.h>

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

{

char* __ahost = 0;

int* __fd2p = (int*) malloc(sizeof(int)*256);

rcmd(

(char**)&__ahost,

"__locuser",

"__remuser",

"__cmd",

__fd2p); //target call

return 0;

}

[+] rcmd_af ( char** __ahost, unsigned short __rport, char const* __locuser, char const* __remuser, char const* __cmd, int* __fd2p, sa_family_t __af )

rcmd: getaddrinfo: Bad value for ai_flags

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

#include <stdlib.h>

#include <netdb.h>

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

{

char* __ahost = 0;

int* __fd2p = (int*) malloc(sizeof(int)*256);

rcmd_af(

(char**)&__ahost,

"__locuser",

"__remuser",

"__cmd",

__fd2p,

2); //target call

return 0;

}

pmap_clnt.h, libc-2.13.so
[+] pmap_set ( u_long const __program, u_long const __vers, int __protocol, u_short __port )

Cannot register service: RPC: Authentication error; why = Client credential too weak

1
2
3
4
5
6
7
8
9
10

#include <rpc/pmap_clnt.h>

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

{

pmap_set(

4); //target call

return 0;

}

signal.h, libc-2.13.so
[+] psiginfo ( siginfo_t const* __pinfo, char const* __s )

__s: Hangup (2 0 1)

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

#include <signal.h>

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

{

siginfo_t __pinfo = {

.si_signo = 1,

.si_errno = 1,

.si_code = 2,

._sifields = {._pad = {

0, 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}}};

psiginfo(&__pinfo, "__s"); //target call

return 0;

}

[+] psignal ( int __sig, char const* __s )

__s: Hangup

#include <signal.h>

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

{

psignal(1, "__s"); //target call

return 0;

}

stdio.h, libc-2.13.so
[+] putchar ( int __c )

#include <wchar.h>

#include <stdio.h>

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

{

putchar(1); //target call

return 0;

}

[+] putchar_unlocked ( int __c )

#include <wchar.h>

#include <stdio.h>

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

{

putchar_unlocked(1); //target call

return 0;

}

[+] puts ( char const* __s )

__s

#include <wchar.h>

#include <stdio.h>

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

{

puts("__s"); //target call

return 0;

}

svc.h, libc-2.13.so
[+] svc_register ( SVCXPRT* __xprt, rpcprog_t __prog, rpcvers_t __vers, __dispatch_fn_t __dispatch, rpcprot_t __protocol )

Cannot register service: RPC: Authentication error; why = Client credential too weak

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

#include <rpc/rpc.h>

//auxiliary function

void

__dispatch(struct svc_req* p1, SVCXPRT* p2){}

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

{

SVCXPRT* __xprt = svcraw_create();

svc_register(

__xprt,

&__dispatch,

3); //target call

return 0;

}

[+] svctcp_create ( int __sock, u_int __sendsize, u_int __recvsize )

svc_tcp.c - cannot getsockname or listen: Socket operation on non-socket

#include <rpc/rpc.h>

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

{

svctcp_create(1, 4, 4); //target call

return 0;

}

[+] svcudp_bufcreate ( int __sock, u_int __sendsz, u_int __recvsz )

svcudp_create - cannot getsockname: Socket operation on non-socket

#include <rpc/rpc.h>

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

{

svcudp_bufcreate(1, 2, 3); //target call

return 0;

}

[+] svcudp_create ( int __sock )

svcudp_create - cannot getsockname: Socket operation on non-socket

#include <rpc/rpc.h>

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

{

svcudp_create(1); //target call

return 0;

}

[+] svcunix_create ( int __sock, u_int __sendsize, u_int __recvsize, char* __path )

svc_unix.c - cannot getsockname or listen: Socket operation on non-socket

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

#include <rpc/rpc.h>

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

{

char __path [] = {

'A',

'B',

'C',

'D',

'\0'};

svcunix_create(

__path); //target call

return 0;

}

unistd.h, libc-2.13.so
[+] getpass ( char const* __prompt )

__prompt

#include <unistd.h>

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

{

getpass("__prompt"); //target call

return 0;

}

resolv.h, libresolv-2.13.so
[+] __p_query ( u_char const* p1 )

;; ns_initparse: Message too long

#include <rpc/types.h>

#include <resolv.h>

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

{

__p_query((u_char const*) "str"); //target call

return 0;

}

to the top