Test results for the library libtheora-1.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.9
[+] 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_YUVin ( theora_state* t, yuv_buffer* yuv ):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
31
32
33

#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 y [] = {

'A',

'B',

'C',

'D',

'\0'};

yuv_buffer yuv = {

.y_width = 16,

.y_height = 24,

.y_stride = 1,

.uv_width = 32,

.uv_height = 40,

.uv_stride = 1,

.y = y,

.u = y,

.v = y};

theora_encode_YUVin(&t, &yuv); //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;

}

to the top