Flawfinder version 2.0.10, (C) 2001-2019 David A. Wheeler.
Number of rules (primarily dangerous function names) in C/C++ ruleset: 223
Examining data/libpsortb-1.0+dfsg/svmloc/binding.h
Examining data/libpsortb-1.0+dfsg/svmloc/binding.cpp
Examining data/libpsortb-1.0+dfsg/svmloc/svmloc.h
Examining data/libpsortb-1.0+dfsg/svmloc/svmloc.cpp
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/hmmsearch.c
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/std_calculation_funcs.c
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/training_algorithms_multialpha.c
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/cmdline_hmmsearch.h
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/debug_funcs.c
Examining data/libpsortb-1.0+dfsg/modhmm0.92b/funcs.h
FINAL RESULTS:
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:62:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(hmmp->name, &s[6]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:72:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(hmmp->alphabet, &s[10]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:338:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(hmmp->name, &s[6]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:348:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(hmmp->alphabet, &s[10]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:600:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(modulep->name, &s[8]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:604:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(type, &s[6]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:638:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(prifile_name, (&s[21]));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:647:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(modulep->priorfile_name, prifile_name);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:687:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(type, &s[13]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1201:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(full_filename, path);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1202:7: [4] (buffer) strcat:
Does not check for buffer overflows when concatenating to destination
[MS-banned] (CWE-120). Consider using strcat_s, strncat, strlcat, or
snprintf (warning: strncat is easily misused).
strcat(full_filename, file_name);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1213:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(emission_priorsp->name, file_name);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:317:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(hmmp->name, &s[6]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:338:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(hmmp->alphabet, &s[12]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:351:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(hmmp->alphabet_2, &s[12]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:365:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(hmmp->alphabet_3, &s[12]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:379:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(hmmp->alphabet_4, &s[12]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:722:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(modulep->name, &s[8]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:729:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(type, &s[6]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:765:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(prifile_name, (&s[23]));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:774:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(modulep->priorfile_name, prifile_name);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:799:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(prifile_name_2, (&s[23]));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:808:2: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(modulep->priorfile_name_2, prifile_name_2);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:834:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(prifile_name_3, (&s[23]));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:843:2: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(modulep->priorfile_name_3, prifile_name_3);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:869:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(prifile_name_4, (&s[23]));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:878:2: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(modulep->priorfile_name_4, prifile_name_4);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:942:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(type, &s[13]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1584:5: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(emission_priorsp->name, file_name);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:388:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(alphabet, s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:505:2: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(alphabet, s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:708:5: [4] (buffer) strcat:
Does not check for buffer overflows when concatenating to destination
[MS-banned] (CWE-120). Consider using strcat_s, strncat, strlcat, or
snprintf (warning: strncat is easily misused).
strcat(s,c->letter);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:935:7: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(alphabet, s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1050:2: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(alphabet, s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1710:3: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(temp, fcvt(nr, 0, &dec, &sign));
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1729:3: [4] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused).
strcpy(temp, fcvt(nr, prec, &dec, &sign));
data/libpsortb-1.0+dfsg/svmloc/svmloc.cpp:9:2: [4] (format) vfprintf:
If format strings can be influenced by an attacker, they can be exploited
(CWE-134). Use a constant for the format specification.
vfprintf(stdout,a,alist);
data/libpsortb-1.0+dfsg/modhmm0.92b/training_algorithms_multialpha.c:3165:3: [3] (random) srand:
This function is not sufficiently random for security-related functions
such as key and nonce creation (CWE-327). Use a more secure technique for
acquiring random values.
srand(time(0));
data/libpsortb-1.0+dfsg/modhmm0.92b/training_algorithms_multialpha.c:3180:3: [3] (random) srand:
This function is not sufficiently random for security-related functions
such as key and nonce creation (CWE-327). Use a more secure technique for
acquiring random values.
srand(time(0));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:97:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq+1, s, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:100:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_2+1, s_2, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:104:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_3+1, s_3, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:108:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_4+1, s_4, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:319:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq+1, s, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:322:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_2+1, s_2, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:326:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_3+1, s_3, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:330:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_4+1, s_4, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:557:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq+1, s, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:560:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_2+1, s_2, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:564:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_3+1, s_3, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:568:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_4+1, s_4, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:862:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq+1, s, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:865:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_2+1, s_2, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:869:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_3+1, s_3, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:873:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_4+1, s_4, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:1095:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(best_labeling, ((cur_rowp + hmmp->nr_v - 1)->labeling) + 1, seq_len * sizeof(char));
data/libpsortb-1.0+dfsg/modhmm0.92b/core_algorithms_multialpha.c:2073:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(best_labeling, ((cur_rowp + hmmp->nr_v - 1)->labeling) + 1, seq_len * sizeof(char));
data/libpsortb-1.0+dfsg/modhmm0.92b/hmmsearch.c:103:19: [2] (misc) fopen:
Check when opening files - can an attacker redirect it (via symlinks),
force the opening of special file type (e.g., device files), move things
around to create a race condition, control its ancestors, or change its
contents? (CWE-362).
if((hmmfile = fopen(hmmfilename, "r")) == NULL) {
data/libpsortb-1.0+dfsg/modhmm0.92b/hmmsearch.c:123:22: [2] (misc) fopen:
Check when opening files - can an attacker redirect it (via symlinks),
force the opening of special file type (e.g., device files), move things
around to create a race condition, control its ancestors, or change its
contents? (CWE-362).
if((replfile = fopen(repfilename, "r")) == NULL) {
data/libpsortb-1.0+dfsg/modhmm0.92b/hmmsearch.c:234:19: [2] (misc) fopen:
Check when opening files - can an attacker redirect it (via symlinks),
force the opening of special file type (e.g., device files), move things
around to create a race condition, control its ancestors, or change its
contents? (CWE-362).
if((hmmfile = fopen(hmmfilename, "r")) == NULL) {
data/libpsortb-1.0+dfsg/modhmm0.92b/hmmsearch.c:250:22: [2] (misc) fopen:
Check when opening files - can an attacker redirect it (via symlinks),
force the opening of special file type (e.g., device files), move things
around to create a race condition, control its ancestors, or change its
contents? (CWE-362).
if((replfile = fopen(repfilename, "r")) == NULL) {
data/libpsortb-1.0+dfsg/modhmm0.92b/hmmsearch.c:329:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[MAX_LINE];
data/libpsortb-1.0+dfsg/modhmm0.92b/hmmsearch.c:342:28: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
null_model.nr_alphabets = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/hmmsearch.c:359:26: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
null_model.a_size = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/hmmsearch.c:363:28: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
null_model.a_size_2 = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/hmmsearch.c:367:28: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
null_model.a_size_3 = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/hmmsearch.c:371:28: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
null_model.a_size_4 = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:36:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[MAX_LINE], *c;
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:77:20: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->a_size = atoi(&s[17]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:81:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_m = atoi(&s[15]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:85:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_v = atoi(&s[16]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:111:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_t = atoi(&s[19]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:115:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_d = atoi(&s[27]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:120:20: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_ttg = atoi(&s[29]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:125:21: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_priorfiles = atoi(&s[27]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:138:27: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_trans_priorfiles = atoi(&s[29]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:198:9: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
*cur = atoi(&s[j]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:237:17: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
trans.from_v = atoi(&s[j]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:242:15: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
trans.to_v = atoi(&s[j]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:243:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(trans_ties, &trans, sizeof(struct transition_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:257:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(trans_ties, &trans, sizeof(struct transition_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:312:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[MAX_LINE], *c;
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:353:20: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->a_size = atoi(&s[17]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:357:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_m = atoi(&s[15]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:361:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_v = atoi(&s[16]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:387:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_t = atoi(&s[19]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:391:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_d = atoi(&s[27]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:396:20: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_ttg = atoi(&s[29]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:401:21: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_priorfiles = atoi(&s[27]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:414:27: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_trans_priorfiles = atoi(&s[29]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:474:9: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
*cur = atoi(&s[j]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:513:17: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
trans.from_v = atoi(&s[j]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:518:15: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
trans.to_v = atoi(&s[j]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:519:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(trans_ties, &trans, sizeof(struct transition_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:533:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(trans_ties, &trans, sizeof(struct transition_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:592:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char type[50];
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:593:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char prifile_name[500];
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:633:21: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
modulep->nr_v = atoi(&s[12]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:643:7: [2] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused). Risk is low because the source is a constant string.
strcpy(modulep->priorfile_name, "null");
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:679:16: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
from_v = atoi(&s[7]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:740:14: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_t = atoi(&s[17]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:744:15: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_et = atoi(&s[21]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:748:14: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_e = atoi(&s[15]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:754:9: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
to_v = atoi(&s[8]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:789:9: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
to_v = atoi(&s[8]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:974:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(temp_pathp + length, &cur_p_el, sizeof(struct path_element));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:987:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(*from_transp, &p_el, sizeof(struct path_element));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:990:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(*from_transp, &cur_p_el, sizeof(struct path_element));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1075:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(*to_transp, &p_el, sizeof(struct path_element));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1080:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(*to_transp, &p_el, sizeof(struct path_element));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1171:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[2048], *p;
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1172:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char ps[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1173:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char full_filename[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1203:23: [2] (misc) fopen:
Check when opening files - can an attacker redirect it (via symlinks),
force the opening of special file type (e.g., device files), move things
around to create a race condition, control its ancestors, or change its
contents? (CWE-362).
if((priorfile = fopen(full_filename,"r")) != NULL) {
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1239:45: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
(emission_priorsp + i)->nr_components = atoi(&ps[0]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1331:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:35:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[MAX_LINE];
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:56:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[MAX_LINE], s_2[MAX_LINE];
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:143:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->name, hmmp->name, 100); /* name of the HMM */
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:146:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->alphabet, hmmp->alphabet, 1000); /* the alphabet */
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:147:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->alphabet_2, hmmp->alphabet_2, 1000); /* the alphabet */
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:148:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->alphabet_3, hmmp->alphabet_3, 1000); /* the alphabet */
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:149:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->alphabet_4, hmmp->alphabet_4, 1000); /* the alphabet */
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:178:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->modules, hmmp->modules, hmmp->nr_m * sizeof(struct module_multi_s*) +
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:184:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->silent_vertices, hmmp->silent_vertices, (hmmp->nr_v + 1) * sizeof(int));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:185:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->locked_vertices, hmmp->locked_vertices, (hmmp->nr_v + 1) * sizeof(int));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:188:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->vertex_labels, hmmp->vertex_labels, hmmp->nr_v * sizeof(char));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:190:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->labels, hmmp->labels, hmmp->nr_v * sizeof(char));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:196:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->vertex_trans_prior_scalers, hmmp->vertex_trans_prior_scalers, hmmp->nr_v * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:199:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->vertex_emiss_prior_scalers, hmmp->vertex_emiss_prior_scalers, hmmp->nr_v * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:202:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->vertex_emiss_prior_scalers_2, hmmp->vertex_emiss_prior_scalers_2, hmmp->nr_v * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:207:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->vertex_emiss_prior_scalers_3, hmmp->vertex_emiss_prior_scalers_3, hmmp->nr_v * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:211:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->vertex_emiss_prior_scalers_4, hmmp->vertex_emiss_prior_scalers_4, hmmp->nr_v * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:216:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->transitions, hmmp->transitions, hmmp->nr_v * hmmp->nr_v * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:217:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->log_transitions, hmmp->log_transitions, hmmp->nr_v * hmmp->nr_v * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:221:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->emissions, hmmp->emissions, hmmp->nr_v * hmmp->a_size * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:222:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->log_emissions, hmmp->log_emissions, hmmp->nr_v * hmmp->a_size * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:228:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->emissions_2, hmmp->emissions_2, hmmp->nr_v * hmmp->a_size * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:229:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->log_emissions_2, hmmp->log_emissions_2, hmmp->nr_v * hmmp->a_size * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:236:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->emissions_3, hmmp->emissions_3, hmmp->nr_v * hmmp->a_size * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:237:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->log_emissions_3, hmmp->log_emissions_3, hmmp->nr_v * hmmp->a_size * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:244:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->emissions_4, hmmp->emissions_4, hmmp->nr_v * hmmp->a_size * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:245:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->log_emissions_4, hmmp->log_emissions_4, hmmp->nr_v * hmmp->a_size * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:271:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->distrib_groups, hmmp->distrib_groups,(hmmp->nr_d + hmmp->nr_v) * sizeof(int));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:274:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(retrain_hmmp->trans_tie_groups, hmmp->trans_tie_groups,(hmmp->nr_t + hmmp->nr_ttg) * sizeof(struct transition_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:295:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[MAX_LINE], *c;
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:329:26: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_alphabets = atoi(&s[17]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:346:20: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->a_size = atoi(&s[19]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:359:24: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->a_size_2 = atoi(&s[19]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:373:24: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->a_size_3 = atoi(&s[19]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:387:24: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->a_size_4 = atoi(&s[19]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:392:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_m = atoi(&s[15]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:398:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_v = atoi(&s[16]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:458:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_t = atoi(&s[19]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:462:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_d = atoi(&s[27]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:468:20: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
hmmp->nr_ttg = atoi(&s[29]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:474:21: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_priorfiles = atoi(&s[29]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:489:23: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_priorfiles = atoi(&s[29]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:505:23: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_priorfiles = atoi(&s[29]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:521:23: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_priorfiles = atoi(&s[29]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:536:27: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_trans_priorfiles = atoi(&s[29]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:598:9: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
*cur = atoi(&s[j]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:636:17: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
trans.from_v = atoi(&s[j]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:641:15: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
trans.to_v = atoi(&s[j]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:642:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(trans_ties, &trans, sizeof(struct transition_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:656:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(trans_ties, &trans, sizeof(struct transition_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:712:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char type[50];
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:713:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char prifile_name[500], prifile_name_2[500], prifile_name_3[500], prifile_name_4[500];
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:760:21: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
modulep->nr_v = atoi(&s[12]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:770:7: [2] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused). Risk is low because the source is a constant string.
strcpy(modulep->priorfile_name, "null");
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:804:2: [2] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused). Risk is low because the source is a constant string.
strcpy(modulep->priorfile_name_2, "null");
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:839:2: [2] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused). Risk is low because the source is a constant string.
strcpy(modulep->priorfile_name_3, "null");
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:874:2: [2] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused). Risk is low because the source is a constant string.
strcpy(modulep->priorfile_name_4, "null");
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:919:16: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
from_v = atoi(&s[7]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1013:14: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_t = atoi(&s[17]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1017:15: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_et = atoi(&s[21]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1021:14: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_e = atoi(&s[17]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1026:10: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_e2 = atoi(&s[17]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1032:10: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_e3 = atoi(&s[17]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1038:10: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_e4 = atoi(&s[17]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1045:9: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
to_v = atoi(&s[8]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1080:9: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
to_v = atoi(&s[8]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1345:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(temp_pathp + length, &cur_p_el, sizeof(struct path_element));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1358:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(*from_transp, &p_el, sizeof(struct path_element));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1361:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(*from_transp, &cur_p_el, sizeof(struct path_element));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1446:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(*to_transp, &p_el, sizeof(struct path_element));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1451:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(*to_transp, &p_el, sizeof(struct path_element));
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1542:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[2048], *p;
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1543:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char ps[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1574:23: [2] (misc) fopen:
Check when opening files - can an attacker redirect it (via symlinks),
force the opening of special file type (e.g., device files), move things
around to create a race condition, control its ancestors, or change its
contents? (CWE-362).
if((priorfile = fopen(file_name,"r")) != NULL) {
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1599:45: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
(emission_priorsp + i)->nr_components = atoi(&ps[0]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1692:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:30:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char row[30000];
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:116:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char line[MAX_LINE], *cur_line;
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:345:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char line[MAX_LINE], *cur_line;
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:717:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy((msa_seq_infop->msa_seq_1 + l * (hmmp->a_size + 1))->query_letter, &(cur_letter.letter),
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:834:4: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy((msa_seq_infop->msa_seq_2 + l * (hmmp->a_size_2 + 1))->query_letter, &(cur_letter.letter),
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:956:4: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy((msa_seq_infop->msa_seq_3 + l * (hmmp->a_size_3 + 1))->query_letter, &(cur_letter.letter),
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:1077:4: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy((msa_seq_infop->msa_seq_4 + l * (hmmp->a_size_4 + 1))->query_letter, &(cur_letter.letter),
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:1349:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[MAX_LINE];
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:1457:20: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
msa_length = atoi(&s[4]);
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:1561:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy((msa_seq_infop->msa_seq_1 + l * (hmmp->a_size + 1))->query_letter, &(cur_letter.letter),
data/libpsortb-1.0+dfsg/modhmm0.92b/std_calculation_funcs.c:1358:4: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy((cur_rowp + *(*(same_labeling_lists + i) + same_labeling_list_indices[i]))->labeling,
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:315:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[500];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:329:33: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
aa_distrib_mtxp->a_size = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:356:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[1000];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:377:16: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
a_size = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:399:25: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_repl_letters = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:454:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[1000];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:481:22: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_alphabets = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:492:11: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
a_size = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:515:22: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_repl_letters = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:522:22: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_repl_letters = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:529:22: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_repl_letters = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:536:22: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_repl_letters = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:840:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(loose_labels, labels, seq_len * sizeof(char));
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:902:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[1000];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:922:16: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
a_size = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:992:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[1000];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1013:22: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_alphabets = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1023:11: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
a_size = atoi(s);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1112:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1113:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char ps[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1120:3: [2] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused). Risk is low because the source is a constant string.
strcpy(em_di->name, "default");
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1135:26: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
em_di->nr_components = atoi(&ps[0]);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1218:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char ps[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1239:12: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
a_size = atoi(ps);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1273:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char ps[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1294:18: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
nr_alphabets = atoi(ps);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1309:14: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
a_size = atoi(ps);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1362:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1363:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char ps[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1400:3: [2] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused). Risk is low because the source is a constant string.
strcpy(em_di->name, "default");
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1415:26: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
em_di->nr_components = atoi(&ps[0]);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1506:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1507:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char ps[2048];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1548:3: [2] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused). Risk is low because the source is a constant string.
strcpy(em_di->name, "default");
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1554:22: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
cur_alphabet = atoi(&ps[9]);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1582:26: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
em_di->nr_components = atoi(&ps[0]);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1708:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char temp[30];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1726:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char temp[30];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1981:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(reverse_seq + i, seq, sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1985:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(reverse_seq + seq_len, seq, sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2030:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(reverse_seq + i, seq, sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2034:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(reverse_seq + seq_len, seq, sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2068:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(reverse_msa_seq_infop->msa_seq + (i * (a_size + 1)),
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2085:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(reverse_msa_seq_infop->gap_shares + i, msa_seq_infop->gap_shares + j, 1 * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2147:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(reverse_msa_seq_infop->msa_seq_1 + (i * (a_size + 1)),
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2155:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(reverse_msa_seq_infop->msa_seq_2 + (i * (a_size_2 + 1)),
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2164:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(reverse_msa_seq_infop->msa_seq_3 + (i * (a_size_3 + 1)),
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2173:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(reverse_msa_seq_infop->msa_seq_4 + (i * (a_size_4 + 1)),
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2193:5: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(reverse_msa_seq_infop->gap_shares + i, msa_seq_infop->gap_shares + j, 1 * sizeof(double));
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2214:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char row[30000];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2233:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char row[30000];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2370:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char row[30000];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2399:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char row[30000];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2429:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char row[30000];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2724:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char s[1000];
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:2740:11: [2] (integer) atoi:
Unless checked, the resulting number can exceed the expected range
(CWE-190). If source untrusted, check both minimum and maximum, even if the
input had no minus sign (large numbers can roll over into negative number;
consider saving to an unsigned value if that is intended).
return atoi(&s[17]);
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:140:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char name[100]; /* name of the HMM */
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:142:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char alphabet[1000]; /* the alphabet */
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:210:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char name[100]; /* name of the HMM */
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:213:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char alphabet[1000]; /* the alphabet */
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:214:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char alphabet_2[1000]; /* the alphabet */
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:215:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char alphabet_3[1000]; /* the alphabet */
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:216:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char alphabet_4[1000]; /* the alphabet */
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:327:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char alphabet[1000];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:342:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char alphabet[1000];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:343:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char alphabet_2[1000];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:344:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char alphabet_3[1000];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:345:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char alphabet_4[1000];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:359:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char name[50];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:364:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char priorfile_name[200];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:373:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char name[50];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:378:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char priorfile_name[200];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:379:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char priorfile_name_2[200];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:380:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char priorfile_name_3[200];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:381:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char priorfile_name_4[200];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:389:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char name[200];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:467:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char letter[5];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:477:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char name[MAX_SEQ_NAME_SIZE];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:488:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char name[MAX_SEQ_NAME_SIZE];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:535:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char query_letter[5];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:642:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char target_letter[5];
data/libpsortb-1.0+dfsg/modhmm0.92b/structs.h:643:3: [2] (buffer) char:
Statically-sized arrays can be improperly restricted, leading to potential
overflows or other issues (CWE-119!/CWE-120). Perform bounds checking, use
functions that limit length, or ensure that the size is larger than the
maximum possible length.
char template_letter[5];
data/libpsortb-1.0+dfsg/modhmm0.92b/training_algorithms_multialpha.c:187:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq+1, (seqsp + s)->seq_1, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/training_algorithms_multialpha.c:190:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_2+1, (seqsp + s)->seq_2, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/training_algorithms_multialpha.c:194:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_3+1, (seqsp + s)->seq_3, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/training_algorithms_multialpha.c:198:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_4+1, (seqsp + s)->seq_4, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/training_algorithms_multialpha.c:1038:7: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq+1, (seqsp + s)->seq_1, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/training_algorithms_multialpha.c:1041:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_2+1, (seqsp + s)->seq_2, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/training_algorithms_multialpha.c:1045:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_3+1, (seqsp + s)->seq_3, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/modhmm0.92b/training_algorithms_multialpha.c:1049:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(seq_4+1, (seqsp + s)->seq_4, seq_len * sizeof(struct letter_s));
data/libpsortb-1.0+dfsg/svmloc/svmloc.cpp:39:2: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(address,attributes,sizeof(struct svm_node)*(n+1));
data/libpsortb-1.0+dfsg/svmloc/svmloc.cpp:50:3: [2] (buffer) memcpy:
Does not check for buffer overflows when copying to destination (CWE-120).
Make sure destination can always hold the source data.
memcpy(address,attributes,sizeof(struct svm_node)*(n+1));
data/libpsortb-1.0+dfsg/svmloc/svmloc.cpp:305:10: [2] (misc) open:
Check when opening files - can an attacker redirect it (via symlinks),
force the opening of special file type (e.g., device files), move things
around to create a race condition, control its ancestors, or change its
contents? (CWE-362).
infile.open(filename, ifstream::in);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:648:7: [1] (buffer) strcat:
Does not check for buffer overflows when concatenating to destination
[MS-banned] (CWE-120). Consider using strcat_s, strncat, strlcat, or
snprintf (warning: strncat is easily misused). Risk is low because the
source is a constant character.
strcat(modulep->priorfile_name, "\0");
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm.c:1183:7: [1] (buffer) strncpy:
Easily used incorrectly; doesn't always \0-terminate or check for invalid
pointers [MS-banned] (CWE-120). Risk is low because the source is a
constant character.
strncpy(p, " ", 1);
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:775:7: [1] (buffer) strcat:
Does not check for buffer overflows when concatenating to destination
[MS-banned] (CWE-120). Consider using strcat_s, strncat, strlcat, or
snprintf (warning: strncat is easily misused). Risk is low because the
source is a constant character.
strcat(modulep->priorfile_name, "\0");
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:809:2: [1] (buffer) strcat:
Does not check for buffer overflows when concatenating to destination
[MS-banned] (CWE-120). Consider using strcat_s, strncat, strlcat, or
snprintf (warning: strncat is easily misused). Risk is low because the
source is a constant character.
strcat(modulep->priorfile_name_2, "\0");
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:844:2: [1] (buffer) strcat:
Does not check for buffer overflows when concatenating to destination
[MS-banned] (CWE-120). Consider using strcat_s, strncat, strlcat, or
snprintf (warning: strncat is easily misused). Risk is low because the
source is a constant character.
strcat(modulep->priorfile_name_3, "\0");
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:879:2: [1] (buffer) strcat:
Does not check for buffer overflows when concatenating to destination
[MS-banned] (CWE-120). Consider using strcat_s, strncat, strlcat, or
snprintf (warning: strncat is easily misused). Risk is low because the
source is a constant character.
strcat(modulep->priorfile_name_4, "\0");
data/libpsortb-1.0+dfsg/modhmm0.92b/readhmm_multialpha.c:1553:7: [1] (buffer) strncpy:
Easily used incorrectly; doesn't always \0-terminate or check for invalid
pointers [MS-banned] (CWE-120). Risk is low because the source is a
constant character.
strncpy(p, " ", 1);
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:65:16: [1] (buffer) strlen:
Does not handle strings that are not \0-terminated; if given one it may
perform an over-read (it could cause a crash if unprotected) (CWE-126).
nr_letters = strlen(seq);
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:139:14: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
while((i = fgetc(seqfile)) != EOF) {
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:251:16: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
c = (char)(fgetc(seqfile));
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:255:20: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
while((c = (char)(fgetc(seqfile))) != '\n') {
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:261:25: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
while((c = (char)(fgetc(seqfile))) != '>') {
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:279:7: [1] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused). Risk is low because the source is a constant character.
strcpy((seq_infop->seqs + seq_nr)->name, "\0");
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:307:7: [1] (buffer) strcpy:
Does not check for buffer overflows when copying to destination [MS-banned]
(CWE-120). Consider using snprintf, strcpy_s, or strlcpy (warning: strncpy
easily misused). Risk is low because the source is a constant character.
strcpy((seq_infop->seqs + seq_nr)->name, "\0");
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:365:9: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
i = fgetc(seqfile);
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:451:15: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
c = (char)fgetc(seqfile);
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:475:15: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
c = (char)fgetc(seqfile);
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:608:9: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
i = fgetc(seqfile);
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:675:24: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
while((c = (char)fgetc(seqfile)) != ';') {
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:734:11: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
i = fgetc(seqfile);
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:798:19: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
while((c = (char)fgetc(seqfile)) != ';') {
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:854:11: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
i = fgetc(seqfile);
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:920:19: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
while((c = (char)fgetc(seqfile)) != ';') {
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:975:11: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
i = fgetc(seqfile);
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:1041:19: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
while((c = (char)fgetc(seqfile)) != ';') {
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:1238:15: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
c = (char)fgetc(seqfile);
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:1262:24: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
while((c = (char)fgetc(seqfile)) != ';') {
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:1268:24: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
while((c = (char)fgetc(seqfile)) != ';') {
data/libpsortb-1.0+dfsg/modhmm0.92b/readseqs_multialpha.c:1437:15: [1] (buffer) fgetc:
Check buffer boundaries if used in a loop including recursive loops
(CWE-120, CWE-20).
c = (char)fgetc(seqfile);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1712:5: [1] (buffer) strncpy:
Easily used incorrectly; doesn't always \0-terminate or check for invalid
pointers [MS-banned] (CWE-120).
strncpy(s, temp, dec);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1717:5: [1] (buffer) strncpy:
Easily used incorrectly; doesn't always \0-terminate or check for invalid
pointers [MS-banned] (CWE-120).
strncpy(s+1, temp, dec);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1739:7: [1] (buffer) strncpy:
Easily used incorrectly; doesn't always \0-terminate or check for invalid
pointers [MS-banned] (CWE-120).
strncpy(s+pos, temp, prec);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1743:7: [1] (buffer) strncpy:
Easily used incorrectly; doesn't always \0-terminate or check for invalid
pointers [MS-banned] (CWE-120).
strncpy(s, temp, dec);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1745:7: [1] (buffer) strncpy:
Easily used incorrectly; doesn't always \0-terminate or check for invalid
pointers [MS-banned] (CWE-120).
strncpy(s+dec+1, temp+dec, prec);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1759:7: [1] (buffer) strncpy:
Easily used incorrectly; doesn't always \0-terminate or check for invalid
pointers [MS-banned] (CWE-120).
strncpy(s+pos, temp, prec);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1764:7: [1] (buffer) strncpy:
Easily used incorrectly; doesn't always \0-terminate or check for invalid
pointers [MS-banned] (CWE-120).
strncpy(s+1, temp, dec);
data/libpsortb-1.0+dfsg/modhmm0.92b/std_funcs.c:1766:7: [1] (buffer) strncpy:
Easily used incorrectly; doesn't always \0-terminate or check for invalid
pointers [MS-banned] (CWE-120).
strncpy(s+dec+2, temp+dec, prec);
ANALYSIS SUMMARY:
Hits = 333
Lines analyzed = 20681 in approximately 0.64 seconds (32543 lines/second)
Physical Source Lines of Code (SLOC) = 17175
Hits@level = [0] 854 [1] 37 [2] 257 [3] 2 [4] 37 [5] 0
Hits@level+ = [0+] 1187 [1+] 333 [2+] 296 [3+] 39 [4+] 37 [5+] 0
Hits/KSLOC@level+ = [0+] 69.1121 [1+] 19.3886 [2+] 17.2344 [3+] 2.27074 [4+] 2.15429 [5+] 0
Dot directories skipped = 1 (--followdotdir overrides)
Minimum risk level = 1
Not every hit is necessarily a security vulnerability.
There may be other security vulnerabilities; review your code!
See 'Secure Programming HOWTO'
(https://dwheeler.com/secure-programs) for more information.