Test results for the library libtheora-1.0 on x86

Summary

Total tests	54
Passed / Failed tests	45 / 9
Verdict	Test Failed

Problem Summary

Received signal SEGV

Failed Tests (9)

[+] Received signal SEGV (9 problems)

theora.h, libtheora.so.0.3.4
[+] theora_clear ( theora_state* t ):void

received signal SEGV (11)

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

#include <stdlib.h>

#include <theora/theora.h>

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

{

theora_info i;

theora_info_init(&i);

void* internal_encode = malloc(256);

void* internal_decode = malloc(256);

theora_state t = {

.i = &i,

.granulepos = 1LL,

.internal_encode = internal_encode,

.internal_decode = internal_decode};

theora_clear(&t); //target call

return 0;

}

[+] theora_control ( theora_state* th, int req, void* buf, size_t buf_sz ):int

received signal SEGV (11)

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

#include <stdlib.h>

#include <theora/theora.h>

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

{

theora_info i;

theora_info_init(&i);

void* internal_encode = malloc(256);

void* internal_decode = malloc(256);

theora_state th = {

.i = &i,

.granulepos = 1LL,

.internal_encode = internal_encode,

.internal_decode = internal_decode};

yuv_buffer* buf = (yuv_buffer*) malloc(sizeof(yuv_buffer)*256);

theora_control(

&th,

(void*)buf,

4); //target call

return 0;

}

[+] theora_decode_init ( theora_state* th, theora_info* c ):int

received signal SEGV (11)

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

#include <stdlib.h>

#include <theora/theora.h>

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

{

theora_info i;

theora_info_init(&i);

void* internal_encode = malloc(256);

void* internal_decode = malloc(256);

theora_state th = {

.i = &i,

.granulepos = 1LL,

.internal_encode = internal_encode,

.internal_decode = internal_decode};

theora_info c;

theora_info_init(&c);

theora_decode_init(&th, &c); //target call

return 0;

}

[+] theora_encode_header ( theora_state* t, ogg_packet* op ):int

received signal SEGV (11)

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

#include <stdlib.h>

#include <theora/theora.h>

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

{

theora_info i;

theora_info_init(&i);

void* internal_encode = malloc(256);

void* internal_decode = malloc(256);

theora_state t = {

.i = &i,

.granulepos = 1LL,

.internal_encode = internal_encode,

.internal_decode = internal_decode};

unsigned char packet [] = {

'A',

'B',

'C',

'D',

'\0'};

ogg_packet op = {

.packet = packet,

.bytes = 2L,

.b_o_s = 3L,

.e_o_s = 4L,

.granulepos = 5LL,

.packetno = 6LL};

theora_encode_header(&t, &op); //target call

return 0;

}

[+] theora_encode_packetout ( theora_state* t, int last_p, ogg_packet* op ):int

received signal SEGV (11)

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

#include <stdlib.h>

#include <theora/theora.h>

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

{

theora_info i;

theora_info_init(&i);

void* internal_encode = malloc(256);

void* internal_decode = malloc(256);

theora_state t = {

.i = &i,

.granulepos = 1LL,

.internal_encode = internal_encode,

.internal_decode = internal_decode};

unsigned char packet [] = {

'A',

'B',

'C',

'D',

'\0'};

ogg_packet op = {

.packet = packet,

.bytes = 3L,

.b_o_s = 4L,

.e_o_s = 5L,

.granulepos = 6LL,

.packetno = 7LL};

theora_encode_packetout(&t, 2, &op); //target call

return 0;

}

[+] theora_encode_tables ( theora_state* t, ogg_packet* op ):int

received signal SEGV (11)

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

#include <stdlib.h>

#include <theora/theora.h>

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

{

theora_info i;

theora_info_init(&i);

void* internal_encode = malloc(256);

void* internal_decode = malloc(256);

theora_state t = {

.i = &i,

.granulepos = 1LL,

.internal_encode = internal_encode,

.internal_decode = internal_decode};

unsigned char packet [] = {

'A',

'B',

'C',

'D',

'\0'};

ogg_packet op = {

.packet = packet,

.bytes = 2L,

.b_o_s = 3L,

.e_o_s = 4L,

.granulepos = 5LL,

.packetno = 6LL};

theora_encode_tables(&t, &op); //target call

return 0;

}

[+] theora_granule_frame ( theora_state* th, ogg_int64_t granulepos ):ogg_int64_t

received signal SEGV (11)

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

#include <stdlib.h>

#include <theora/theora.h>

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

{

theora_info i;

theora_info_init(&i);

void* internal_encode = malloc(256);

void* internal_decode = malloc(256);

theora_state th = {

.i = &i,

.granulepos = 1LL,

.internal_encode = internal_encode,

.internal_decode = internal_decode};

theora_granule_frame(&th, 2LL); //target call

return 0;

}

[+] theora_granule_time ( theora_state* th, ogg_int64_t granulepos ):double

received signal SEGV (11)

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

#include <stdlib.h>

#include <theora/theora.h>

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

{

theora_info i;

theora_info_init(&i);

void* internal_encode = malloc(256);

void* internal_decode = malloc(256);

theora_state th = {

.i = &i,

.granulepos = 1LL,

.internal_encode = internal_encode,

.internal_decode = internal_decode};

theora_granule_time(&th, 2LL); //target call

return 0;

}

theoradec.h, libtheoradec.so.1.0.1
[+] th_decode_ycbcr_out ( th_dec_ctx* _dec, th_img_plane* _ycbcr ):int

received signal SEGV (11)

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

#include <theora/theoradec.h>

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

{

th_info _info;

th_info_init(&_info);

th_setup_info* _setup = 0; //can't initialize

th_dec_ctx* _dec = th_decode_alloc(&_info, _setup);

unsigned char data [] = {

'A',

'B',

'C',

'D',

'\0'};

th_img_plane _ycbcr = {

.width = 8,

.height = 16,

.stride = 1,

.data = data};

th_decode_ycbcr_out(_dec, &_ycbcr); //target call

return 0;

}

to the top