| f0020) | nsprpub/lib/msgc/src/prmsgc.c:456 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0021) | nsprpub/lib/msgc/src/prmsgc.c:1945 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0022) | nsprpub/lib/msgc/src/prmsgc.c:1974 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0023) | nsprpub/lib/msgc/src/prmsgc.c:3471 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0034) | nsprpub/pr/include/md/_pcos.h:59 [3] (buffer) getopt: this does not protect against buffer overflows by itself, so use with caution. .
|
| f0036) | nsprpub/pr/include/md/sunos4.h:73 [3] (buffer) getopt: this does not protect against buffer overflows by itself, so use with caution. .
|
| f0037) | nsprpub/pr/include/md/sunos4.h:76 [3] (random) srandom: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0038) | nsprpub/pr/include/md/sunos4.h:77 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0039) | nsprpub/pr/include/md/sunos4.h:92 [4] (format) printf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0040) | nsprpub/pr/include/md/sunos4.h:93 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0041) | nsprpub/pr/include/md/sunos4.h:94 [4] (format) vprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0042) | nsprpub/pr/include/md/sunos4.h:95 [4] (format) vfprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0043) | nsprpub/pr/include/md/sunos4.h:96 [4] (format) vsprintf: Potential format string problem. Make format string constant.
|
| f0044) | nsprpub/pr/include/md/sunos4.h:97 [4] (buffer) scanf: the scanf() family's %s operation, without a limit specification, permits buffer overflows. Specify a limit to %s, or use a different input function. If the scanf format is influenceable by an attacker, it's exploitable.
|
| f0045) | nsprpub/pr/include/md/sunos4.h:98 [4] (buffer) sscanf: the scanf() family's %s operation, without a limit specification, permits buffer overflows. Specify a limit to %s, or use a different input function. If the scanf format is influenceable by an attacker, it's exploitable.
|
| f0046) | nsprpub/pr/include/md/sunos4.h:99 [4] (buffer) fscanf: the scanf() family's %s operation, without a limit specification, permits buffer overflows. Specify a limit to %s, or use a different input function. If the scanf format is influenceable by an attacker, it's exploitable.
|
| f0047) | nsprpub/pr/include/md/sunos4.h:114 [4] (tmpfile) system: this calls out to a new process and is difficult to use safely. try using a library call that implements the same functionality if available..
|
| f0048) | nsprpub/pr/include/md/sunos4.h:115 [4] (tmpfile) popen: this calls out to a new process and is difficult to use safely. try using a library call that implements the same functionality if available..
|
| f0049) | nsprpub/pr/include/md/sunos4.h:125 [3] (random) lrand48: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0050) | nsprpub/pr/include/md/sunos4.h:126 [3] (random) drand48: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0051) | nsprpub/pr/include/md/sunos4.h:156 [3] (buffer) getwd: this does not protect against buffer overflows by itself, so use with caution. .
|
| f0061) | nsprpub/pr/src/io/prlayer.c:638 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0062) | nsprpub/pr/src/io/prprf.c:362 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0066) | nsprpub/pr/src/linking/prlink.c:379 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0069) | nsprpub/pr/src/linking/prlink.c:406 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0070) | nsprpub/pr/src/linking/prlink.c:890 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0071) | nsprpub/pr/src/linking/prlink.c:891 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0072) | nsprpub/pr/src/malloc/prmalloc.c:89 [4] (format) printf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0075) | nsprpub/pr/src/md/beos/bfile.c:466 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0076) | nsprpub/pr/src/md/beos/bfile.c:502 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0077) | nsprpub/pr/src/md/beos/bproc.c:153 [4] (tmpfile) execv: this calls out to a new process and is difficult to use safely. try using a library call that implements the same functionality if available..
|
| f0078) | nsprpub/pr/src/md/mac/macio.c:1631 [1] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant character.
|
| f0079) | nsprpub/pr/src/md/mac/macio.c:1632 [1] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant character.
|
| f0080) | nsprpub/pr/src/md/mac/macio.c:1659 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0081) | nsprpub/pr/src/md/mac/macio.c:1660 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0082) | nsprpub/pr/src/md/mac/macio.c:1832 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0083) | nsprpub/pr/src/md/mac/macio.c:1835 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0086) | nsprpub/pr/src/md/os2/os2io.c:145 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0087) | nsprpub/pr/src/md/os2/os2io.c:154 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0088) | nsprpub/pr/src/md/os2/os2io.c:157 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0089) | nsprpub/pr/src/md/os2/os2io.c:159 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0090) | nsprpub/pr/src/md/os2/os2io.c:161 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0091) | nsprpub/pr/src/md/os2/os2io.c:193 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0092) | nsprpub/pr/src/md/os2/os2io.c:523 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0093) | nsprpub/pr/src/md/os2/os2io.c:657 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0094) | nsprpub/pr/src/md/os2/os2io.c:660 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0095) | nsprpub/pr/src/md/os2/os2io.c:663 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0100) | nsprpub/pr/src/md/unix/irix.c:1173 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0101) | nsprpub/pr/src/md/unix/irix.c:1175 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0102) | nsprpub/pr/src/md/unix/irix.c:1177 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0103) | nsprpub/pr/src/md/unix/irix.c:1325 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0104) | nsprpub/pr/src/md/unix/irix.c:1327 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0105) | nsprpub/pr/src/md/unix/irix.c:1329 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0106) | nsprpub/pr/src/md/unix/irix.c:1379 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0107) | nsprpub/pr/src/md/unix/irix.c:1381 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0108) | nsprpub/pr/src/md/unix/irix.c:1383 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0110) | nsprpub/pr/src/md/unix/ncr.c:93 [2] (tmpfile) tmpfile: tmpfile() has a security flaw on some systems (e.g., older System V systems). .
|
| f0111) | nsprpub/pr/src/md/unix/nextstep.c:169 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0112) | nsprpub/pr/src/md/unix/scoos.c:93 [2] (tmpfile) tmpfile: tmpfile() has a security flaw on some systems (e.g., older System V systems). .
|
| f0113) | nsprpub/pr/src/md/unix/unix.c:233 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0114) | nsprpub/pr/src/md/unix/unix.c:268 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0120) | nsprpub/pr/src/md/unix/unixware.c:96 [2] (tmpfile) tmpfile: tmpfile() has a security flaw on some systems (e.g., older System V systems). .
|
| f0121) | nsprpub/pr/src/md/unix/uxproces.c:391 [4] (tmpfile) execv: this calls out to a new process and is difficult to use safely. try using a library call that implements the same functionality if available..
|
| f0122) | nsprpub/pr/src/md/unix/uxshm.c:106 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0123) | nsprpub/pr/src/md/unix/uxshm.c:344 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0124) | nsprpub/pr/src/md/windows/ntio.c:2069 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0125) | nsprpub/pr/src/md/windows/ntio.c:2075 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0126) | nsprpub/pr/src/md/windows/ntio.c:2076 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0127) | nsprpub/pr/src/md/windows/ntio.c:2089 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0128) | nsprpub/pr/src/md/windows/ntio.c:2115 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0129) | nsprpub/pr/src/md/windows/ntio.c:2125 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0130) | nsprpub/pr/src/md/windows/ntio.c:2126 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0131) | nsprpub/pr/src/md/windows/ntio.c:2148 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0132) | nsprpub/pr/src/md/windows/ntio.c:2746 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0133) | nsprpub/pr/src/md/windows/ntio.c:2755 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0134) | nsprpub/pr/src/md/windows/ntio.c:2889 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0136) | nsprpub/pr/src/md/windows/w16callb.c:107 [4] (buffer) vsscanf: the scanf() family's %s operation, without a limit specification, permits buffer overflows. Specify a limit to %s, or use a different input function. If the scanf format is influenceable by an attacker, it's exploitable.
|
| f0138) | nsprpub/pr/src/md/windows/w16io.c:92 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0139) | nsprpub/pr/src/md/windows/w16io.c:100 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0140) | nsprpub/pr/src/md/windows/w16io.c:102 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0141) | nsprpub/pr/src/md/windows/w16io.c:104 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0142) | nsprpub/pr/src/md/windows/w16io.c:107 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0143) | nsprpub/pr/src/md/windows/w16io.c:111 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0144) | nsprpub/pr/src/md/windows/w16io.c:113 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0145) | nsprpub/pr/src/md/windows/w16io.c:115 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0146) | nsprpub/pr/src/md/windows/w16io.c:120 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0147) | nsprpub/pr/src/md/windows/w16io.c:583 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0149) | nsprpub/pr/src/md/windows/w16thred.c:170 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0150) | nsprpub/pr/src/md/windows/w32shm.c:102 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0151) | nsprpub/pr/src/md/windows/w32shm.c:178 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0152) | nsprpub/pr/src/md/windows/w32shm.c:184 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0153) | nsprpub/pr/src/md/windows/w32shm.c:187 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0154) | nsprpub/pr/src/md/windows/w95io.c:182 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0155) | nsprpub/pr/src/md/windows/w95io.c:189 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0156) | nsprpub/pr/src/md/windows/w95io.c:191 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0157) | nsprpub/pr/src/md/windows/w95io.c:208 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0158) | nsprpub/pr/src/md/windows/w95io.c:226 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0159) | nsprpub/pr/src/md/windows/w95io.c:247 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0160) | nsprpub/pr/src/md/windows/w95io.c:249 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0161) | nsprpub/pr/src/md/windows/w95io.c:266 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0162) | nsprpub/pr/src/md/windows/w95io.c:499 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0163) | nsprpub/pr/src/md/windows/w95io.c:508 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0164) | nsprpub/pr/src/md/windows/w95io.c:646 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0166) | nsprpub/pr/src/misc/pratom.c:344 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0167) | nsprpub/pr/src/misc/prcountr.c:192 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0168) | nsprpub/pr/src/misc/prcountr.c:214 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0169) | nsprpub/pr/src/misc/prcountr.c:215 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0170) | nsprpub/pr/src/misc/prdtoa.c:1952 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0171) | nsprpub/pr/src/misc/prerrortable.c:153 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0172) | nsprpub/pr/src/misc/prerrortable.c:155 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0173) | nsprpub/pr/src/misc/prerrortable.c:156 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0175) | nsprpub/pr/src/misc/prinit.c:570 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0176) | nsprpub/pr/src/misc/pripc.c:116 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0177) | nsprpub/pr/src/misc/prtrace.c:277 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0178) | nsprpub/pr/src/misc/prtrace.c:299 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0179) | nsprpub/pr/src/misc/prtrace.c:300 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0180) | nsprpub/pr/src/pthreads/ptio.c:3527 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0181) | nsprpub/pr/src/pthreads/ptio.c:3530 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0182) | nsprpub/pr/src/pthreads/ptio.c:3534 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0183) | nsprpub/pr/src/pthreads/ptio.c:3572 [4] (race) access: this usually indicates a security flaw. If an attacker can change anything along the path between the call to access() and the file's actual use (e.g., by moving files), the attacker can exploit the race condition. Set up the correct permissions (e.g., using setuid()) and try to open the file directly.
|
| f0184) | nsprpub/pr/src/pthreads/ptthread.c:65 [4] (tmpfile) system: this calls out to a new process and is difficult to use safely. try using a library call that implements the same functionality if available..
|
| f0185) | nsprpub/pr/src/pthreads/ptthread.c:230 [4] (tmpfile) system: this calls out to a new process and is difficult to use safely. try using a library call that implements the same functionality if available..
|
| f0186) | nsprpub/pr/src/pthreads/ptthread.c:433 [4] (tmpfile) system: this calls out to a new process and is difficult to use safely. try using a library call that implements the same functionality if available..
|
| f0187) | nsprpub/pr/src/pthreads/ptthread.c:481 [4] (tmpfile) system: this calls out to a new process and is difficult to use safely. try using a library call that implements the same functionality if available..
|
| f0188) | nsprpub/pr/src/pthreads/ptthread.c:873 [4] (tmpfile) system: this calls out to a new process and is difficult to use safely. try using a library call that implements the same functionality if available..
|
| f0189) | nsprpub/pr/src/pthreads/ptthread.c:938 [4] (tmpfile) system: this calls out to a new process and is difficult to use safely. try using a library call that implements the same functionality if available..
|
| f0190) | nsprpub/pr/src/threads/prrwlock.c:146 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0360) | security/nss/cmd/SSLsample/server.c:68 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0361) | security/nss/cmd/atob/atob.c:43 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0362) | security/nss/cmd/bltest/blapitest.c:1647 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0363) | security/nss/cmd/bltest/blapitest.c:1654 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0364) | security/nss/cmd/bltest/blapitest.c:1660 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0365) | security/nss/cmd/bltest/blapitest.c:1662 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0366) | security/nss/cmd/bltest/blapitest.c:1664 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0367) | security/nss/cmd/bltest/blapitest.c:1687 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0368) | security/nss/cmd/bltest/blapitest.c:1692 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0369) | security/nss/cmd/bltest/blapitest.c:1695 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0370) | security/nss/cmd/bltest/blapitest.c:1699 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0371) | security/nss/cmd/bltest/blapitest.c:1702 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0372) | security/nss/cmd/bltest/blapitest.c:1705 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0373) | security/nss/cmd/bltest/blapitest.c:1807 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0374) | security/nss/cmd/bltest/blapitest.c:1827 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0375) | security/nss/cmd/bltest/blapitest.c:1833 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0376) | security/nss/cmd/btoa/btoa.c:43 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0377) | security/nss/cmd/certcgi/certcgi.c:98 [4] (format) printf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0378) | security/nss/cmd/certutil/certutil.c:122 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0379) | security/nss/cmd/certutil/certutil.c:195 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0380) | security/nss/cmd/certutil/certutil.c:1095 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0381) | security/nss/cmd/certutil/certutil.c:1512 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0382) | security/nss/cmd/certutil/certutil.c:1527 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0383) | security/nss/cmd/certutil/certutil.c:1654 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0384) | security/nss/cmd/certutil/certutil.c:1693 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0385) | security/nss/cmd/certutil/certutil.c:1722 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0386) | security/nss/cmd/certutil/certutil.c:1733 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0387) | security/nss/cmd/certutil/certutil.c:1784 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0388) | security/nss/cmd/certutil/certutil.c:1789 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0389) | security/nss/cmd/certutil/certutil.c:1799 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0390) | security/nss/cmd/certutil/certutil.c:1930 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0391) | security/nss/cmd/certutil/certutil.c:1985 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0392) | security/nss/cmd/certutil/certutil.c:2053 [5] (buffer) gets: does not check for buffer overflows. Use fgets() instead.
|
| f0393) | security/nss/cmd/certutil/keystuff.c:51 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0394) | security/nss/cmd/certutil/keystuff.c:86 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0395) | security/nss/cmd/cmdlib/cmdline.c:121 [4] (format) vsprintf: Potential format string problem. Make format string constant.
|
| f0396) | security/nss/cmd/crmf-cgi/crmfcgi.c:69 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0397) | security/nss/cmd/crmf-cgi/crmfcgi.c:689 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0398) | security/nss/cmd/crmf-cgi/crmfcgi.c:804 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0399) | security/nss/cmd/crmf-cgi/crmfcgi.c:846 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0400) | security/nss/cmd/crmf-cgi/crmfcgi.c:1044 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0401) | security/nss/cmd/crmf-cgi/crmfcgi.c:1090 [3] (random) srand: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0402) | security/nss/cmd/crmftest/testcrmf.c:62 [3] (buffer) getopt: this does not protect against buffer overflows by itself, so use with caution. .
|
| f0403) | security/nss/cmd/crmftest/testcrmf.c:121 [4] (buffer) scanf: the scanf() family's %s operation, without a limit specification, permits buffer overflows. Specify a limit to %s, or use a different input function.
|
| f0404) | security/nss/cmd/crmftest/testcrmf.c:153 [4] (buffer) scanf: the scanf() family's %s operation, without a limit specification, permits buffer overflows. Specify a limit to %s, or use a different input function.
|
| f0405) | security/nss/cmd/crmftest/testcrmf.c:689 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0406) | security/nss/cmd/crmftest/testcrmf.c:736 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0407) | security/nss/cmd/crmftest/testcrmf.c:1429 [3] (buffer) getopt: this does not protect against buffer overflows by itself, so use with caution. .
|
| f0408) | security/nss/cmd/dbck/dbck.c:126 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0409) | security/nss/cmd/derdump/derdump.c:40 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0410) | security/nss/cmd/digest/digest.c:42 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0411) | security/nss/cmd/digest/digest.c:105 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0412) | security/nss/cmd/keyutil/keyutil.c:53 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0413) | security/nss/cmd/keyutil/keyutil.c:54 [3] (buffer) getopt: this does not protect against buffer overflows by itself, so use with caution. .
|
| f0414) | security/nss/cmd/keyutil/keyutil.c:242 [3] (buffer) getopt: this does not protect against buffer overflows by itself, so use with caution. .
|
| f0415) | security/nss/cmd/lib/derprint.c:37 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0416) | security/nss/cmd/lib/filestub.c:330 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0417) | security/nss/cmd/lib/filestub.c:352 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0418) | security/nss/cmd/lib/filestub.c:483 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0419) | security/nss/cmd/lib/filestub.c:487 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0420) | security/nss/cmd/lib/filestub.c:492 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0421) | security/nss/cmd/lib/filestub.c:499 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0422) | security/nss/cmd/lib/filestub.c:593 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0423) | security/nss/cmd/lib/filestub.c:677 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0424) | security/nss/cmd/lib/filestub.c:681 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0425) | security/nss/cmd/lib/filestub.c:693 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0426) | security/nss/cmd/lib/filestub.c:705 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0427) | security/nss/cmd/lib/filestub.c:707 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0428) | security/nss/cmd/lib/filestub.c:709 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0429) | security/nss/cmd/lib/filestub.c:733 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0430) | security/nss/cmd/lib/filestub.c:735 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0431) | security/nss/cmd/lib/filestub.c:740 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0432) | security/nss/cmd/lib/filestub.c:745 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0433) | security/nss/cmd/lib/filestub.c:747 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0434) | security/nss/cmd/lib/filestub.c:752 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0435) | security/nss/cmd/lib/filestub.c:757 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0436) | security/nss/cmd/lib/filestub.c:759 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0437) | security/nss/cmd/lib/filestub.c:769 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0438) | security/nss/cmd/lib/filestub.c:781 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0439) | security/nss/cmd/lib/filestub.c:786 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0440) | security/nss/cmd/lib/filestub.c:790 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0441) | security/nss/cmd/lib/filestub.c:802 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0442) | security/nss/cmd/lib/filestub.c:806 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0443) | security/nss/cmd/lib/filestub.c:819 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0444) | security/nss/cmd/lib/filestub.c:821 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0445) | security/nss/cmd/lib/filestub.c:834 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0446) | security/nss/cmd/lib/filestub.c:846 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0447) | security/nss/cmd/lib/filestub.c:859 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0448) | security/nss/cmd/lib/filestub.c:873 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0449) | security/nss/cmd/lib/filestub.c:877 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0450) | security/nss/cmd/lib/filestub.c:881 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0451) | security/nss/cmd/lib/filestub.c:885 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0452) | security/nss/cmd/lib/filestub.c:889 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0453) | security/nss/cmd/lib/filestub.c:893 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0454) | security/nss/cmd/lib/filestub.c:902 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0455) | security/nss/cmd/lib/filestub.c:914 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0456) | security/nss/cmd/lib/filestub.c:921 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0457) | security/nss/cmd/lib/filestub.c:927 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0458) | security/nss/cmd/lib/filestub.c:940 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0459) | security/nss/cmd/lib/filestub.c:972 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0460) | security/nss/cmd/lib/secarb.c:36 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0461) | security/nss/cmd/lib/secarb.c:120 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0462) | security/nss/cmd/lib/secutil.c:82 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0463) | security/nss/cmd/lib/secutil.c:96 [4] (format) vfprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0464) | security/nss/cmd/lib/secutil.c:112 [4] (format) vfprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0465) | security/nss/cmd/lib/secutil.c:229 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0467) | security/nss/cmd/lib/secutil.c:395 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0468) | security/nss/cmd/lib/secutil.c:409 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0469) | security/nss/cmd/lib/secutil.c:411 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0471) | security/nss/cmd/lib/secutil.c:431 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0472) | security/nss/cmd/lib/secutil.c:433 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0473) | security/nss/cmd/lib/secutil.c:435 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0474) | security/nss/cmd/lib/secutil.c:876 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0475) | security/nss/cmd/lib/secutil.c:1109 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0476) | security/nss/cmd/lib/secutil.c:1541 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0477) | security/nss/cmd/lib/secutil.c:1858 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0478) | security/nss/cmd/lib/secutil.c:1873 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0479) | security/nss/cmd/lib/secutil.c:1896 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0480) | security/nss/cmd/lib/secutil.c:1897 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0481) | security/nss/cmd/lib/secutil.c:1932 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0482) | security/nss/cmd/lib/secutil.c:1948 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0483) | security/nss/cmd/lib/secutil.c:1962 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0484) | security/nss/cmd/lib/secutil.c:1980 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0485) | security/nss/cmd/lib/secutil.c:2009 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0486) | security/nss/cmd/lib/secutil.c:2044 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0487) | security/nss/cmd/lib/secutil.c:2054 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0488) | security/nss/cmd/lib/secutil.c:2067 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0489) | security/nss/cmd/lib/secutil.c:2081 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0490) | security/nss/cmd/lib/secutil.c:2099 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0491) | security/nss/cmd/lib/secutil.c:2458 [1] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source is a constant character.
|
| f0492) | security/nss/cmd/lib/secutil.c:2460 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0493) | security/nss/cmd/lib/secutil.c:2462 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0494) | security/nss/cmd/lib/secutil.c:2464 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0495) | security/nss/cmd/lib/secutil.c:2466 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0496) | security/nss/cmd/lib/secutil.c:2468 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0497) | security/nss/cmd/lib/secutil.c:2470 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0498) | security/nss/cmd/lib/secutil.c:2472 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0499) | security/nss/cmd/lib/secutil.c:2474 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0500) | security/nss/cmd/lib/secutil.c:2476 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0501) | security/nss/cmd/lib/secutil.c:2478 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0502) | security/nss/cmd/lib/secutil.c:2480 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0503) | security/nss/cmd/lib/secutil.c:2482 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0504) | security/nss/cmd/lib/secutil.c:2484 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0505) | security/nss/cmd/lib/secutil.c:2486 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0506) | security/nss/cmd/lib/secutil.c:2488 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0507) | security/nss/cmd/lib/secutil.c:2490 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0508) | security/nss/cmd/lib/secutil.c:2492 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0509) | security/nss/cmd/lib/secutil.c:2494 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0510) | security/nss/cmd/lib/secutil.c:2496 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0511) | security/nss/cmd/lib/secutil.c:2498 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0512) | security/nss/cmd/lib/secutil.c:2500 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0513) | security/nss/cmd/lib/secutil.c:2502 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0514) | security/nss/cmd/lib/secutil.c:2504 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0515) | security/nss/cmd/lib/secutil.c:2506 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0516) | security/nss/cmd/lib/secutil.c:2508 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0517) | security/nss/cmd/lib/secutil.c:2510 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0518) | security/nss/cmd/lib/secutil.c:2512 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0519) | security/nss/cmd/lib/secutil.c:2514 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0520) | security/nss/cmd/lib/secutil.c:2516 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0521) | security/nss/cmd/lib/secutil.c:2518 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0522) | security/nss/cmd/lib/secutil.c:2520 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0523) | security/nss/cmd/lib/secutil.c:2523 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0524) | security/nss/cmd/lib/secutil.c:2525 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0525) | security/nss/cmd/lib/secutil.c:2527 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0526) | security/nss/cmd/lib/secutil.c:2529 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0527) | security/nss/cmd/lib/secutil.c:2531 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0528) | security/nss/cmd/lib/secutil.c:2533 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0529) | security/nss/cmd/lib/secutil.c:2535 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0530) | security/nss/cmd/lib/secutil.c:2537 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0531) | security/nss/cmd/lib/secutil.c:2539 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0532) | security/nss/cmd/lib/secutil.c:2541 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0533) | security/nss/cmd/lib/secutil.c:2543 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0534) | security/nss/cmd/lib/secutil.c:2545 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0535) | security/nss/cmd/lib/secutil.c:2561 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0536) | security/nss/cmd/modutil/install-ds.c:642 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0537) | security/nss/cmd/modutil/install-ds.c:643 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0538) | security/nss/cmd/modutil/install-ds.c:646 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0539) | security/nss/cmd/modutil/install-ds.c:647 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0540) | security/nss/cmd/modutil/install-ds.c:1321 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0541) | security/nss/cmd/modutil/install.c:698 [5] (race) chmod: this accepts filename arguments; if an attacker can move those files, a race condition results. . Use fchmod( ) instead.
|
| f0542) | security/nss/cmd/modutil/install.c:825 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0543) | security/nss/cmd/modutil/install.c:856 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0546) | security/nss/cmd/modutil/lex.Pk11Install_yy.c:1656 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0547) | security/nss/cmd/modutil/pk11.c:160 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0548) | security/nss/cmd/modutil/pk11.c:207 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0549) | security/nss/cmd/modutil/pk11.c:209 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0550) | security/nss/cmd/ocspclnt/ocspclnt.c:543 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0551) | security/nss/cmd/p7content/p7content.c:57 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0552) | security/nss/cmd/p7env/p7env.c:58 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0553) | security/nss/cmd/p7sign/p7sign.c:61 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0554) | security/nss/cmd/p7verify/p7verify.c:59 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0555) | security/nss/cmd/pk12util/pk12util.c:516 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0556) | security/nss/cmd/pk12util/pk12util.c:520 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0557) | security/nss/cmd/pp/pp.c:44 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0558) | security/nss/cmd/selfserv/selfserv.c:75 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0559) | security/nss/cmd/selfserv/selfserv.c:164 [4] (format) printf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0560) | security/nss/cmd/selfserv/selfserv.c:165 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0561) | security/nss/cmd/selfserv/selfserv.c:1532 [2] (tmpfile) tmpfile: tmpfile() has a security flaw on some systems (e.g., older System V systems). .
|
| f0562) | security/nss/cmd/selfserv/selfserv.c:1534 [2] (tmpfile) tmpfile: tmpfile() has a security flaw on some systems (e.g., older System V systems). .
|
| f0563) | security/nss/cmd/selfserv/selfserv.c:1535 [2] (tmpfile) tmpfile: tmpfile() has a security flaw on some systems (e.g., older System V systems). .
|
| f0564) | security/nss/cmd/selfserv/selfserv.c:1536 [2] (tmpfile) tmpfile: tmpfile() has a security flaw on some systems (e.g., older System V systems). .
|
| f0569) | security/nss/cmd/signtool/certgen.c:155 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0570) | security/nss/cmd/signtool/certgen.c:160 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0571) | security/nss/cmd/signtool/certgen.c:176 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0572) | security/nss/cmd/signtool/certgen.c:193 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0573) | security/nss/cmd/signtool/certgen.c:209 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0574) | security/nss/cmd/signtool/certgen.c:228 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0575) | security/nss/cmd/signtool/certgen.c:244 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0576) | security/nss/cmd/signtool/certgen.c:260 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0577) | security/nss/cmd/signtool/certgen.c:269 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0578) | security/nss/cmd/signtool/certgen.c:682 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0579) | security/nss/cmd/signtool/certgen.c:709 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0580) | security/nss/cmd/signtool/javascript.c:136 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0581) | security/nss/cmd/signtool/javascript.c:1651 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0582) | security/nss/cmd/signtool/sign.c:95 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0583) | security/nss/cmd/signtool/sign.c:96 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0584) | security/nss/cmd/signtool/sign.c:101 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0585) | security/nss/cmd/signtool/sign.c:102 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0586) | security/nss/cmd/signtool/sign.c:107 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0587) | security/nss/cmd/signtool/sign.c:108 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0588) | security/nss/cmd/signtool/sign.c:251 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0589) | security/nss/cmd/signtool/sign.c:252 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0590) | security/nss/cmd/signtool/sign.c:351 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0591) | security/nss/cmd/signtool/sign.c:353 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0592) | security/nss/cmd/signtool/sign.c:357 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0593) | security/nss/cmd/signtool/sign.c:358 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0594) | security/nss/cmd/signtool/sign.c:402 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0595) | security/nss/cmd/signtool/sign.c:403 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0596) | security/nss/cmd/signtool/sign.c:404 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0597) | security/nss/cmd/signtool/sign.c:447 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0598) | security/nss/cmd/signtool/sign.c:684 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0599) | security/nss/cmd/signtool/util.c:157 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0600) | security/nss/cmd/signtool/util.c:288 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0601) | security/nss/cmd/signtool/util.c:310 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0602) | security/nss/cmd/signtool/util.c:345 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0603) | security/nss/cmd/signtool/util.c:347 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0604) | security/nss/cmd/signtool/util.c:348 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0605) | security/nss/cmd/signtool/util.c:370 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0606) | security/nss/cmd/signtool/util.c:372 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0607) | security/nss/cmd/signtool/util.c:375 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0608) | security/nss/cmd/signtool/util.c:376 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0609) | security/nss/cmd/signtool/util.c:378 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0610) | security/nss/cmd/signtool/util.c:383 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0611) | security/nss/cmd/signtool/util.c:385 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0612) | security/nss/cmd/signtool/util.c:386 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0613) | security/nss/cmd/signtool/util.c:398 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0614) | security/nss/cmd/signtool/util.c:400 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0615) | security/nss/cmd/signtool/util.c:402 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0616) | security/nss/cmd/signtool/util.c:577 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0618) | security/nss/cmd/signtool/util.c:861 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0620) | security/nss/cmd/signtool/util.c:875 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0621) | security/nss/cmd/signtool/util.c:890 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0622) | security/nss/cmd/signtool/util.c:906 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0623) | security/nss/cmd/signver/pk7print.c:79 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0624) | security/nss/cmd/signver/pk7print.c:136 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0625) | security/nss/cmd/signver/pk7print.c:139 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0626) | security/nss/cmd/signver/pk7print.c:181 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0627) | security/nss/cmd/signver/pk7print.c:191 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0628) | security/nss/cmd/signver/pk7print.c:277 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0629) | security/nss/cmd/signver/pk7print.c:280 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0630) | security/nss/cmd/signver/pk7print.c:282 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0631) | security/nss/cmd/signver/pk7print.c:286 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0632) | security/nss/cmd/signver/pk7print.c:297 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0633) | security/nss/cmd/signver/pk7print.c:303 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0634) | security/nss/cmd/signver/pk7print.c:305 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0635) | security/nss/cmd/signver/pk7print.c:316 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0636) | security/nss/cmd/signver/pk7print.c:325 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0637) | security/nss/cmd/signver/pk7print.c:327 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0638) | security/nss/cmd/signver/pk7print.c:334 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0639) | security/nss/cmd/signver/pk7print.c:336 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0640) | security/nss/cmd/signver/pk7print.c:338 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0641) | security/nss/cmd/signver/pk7print.c:340 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0642) | security/nss/cmd/signver/pk7print.c:352 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0643) | security/nss/cmd/signver/pk7print.c:364 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0644) | security/nss/cmd/signver/pk7print.c:371 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0645) | security/nss/cmd/signver/pk7print.c:428 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0646) | security/nss/cmd/signver/pk7print.c:450 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0647) | security/nss/cmd/signver/pk7print.c:452 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0648) | security/nss/cmd/signver/pk7print.c:454 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0649) | security/nss/cmd/signver/pk7print.c:456 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0650) | security/nss/cmd/signver/pk7print.c:466 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0651) | security/nss/cmd/signver/pk7print.c:470 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0652) | security/nss/cmd/signver/pk7print.c:500 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0653) | security/nss/cmd/signver/pk7print.c:502 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0654) | security/nss/cmd/signver/pk7print.c:504 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0655) | security/nss/cmd/signver/pk7print.c:506 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0656) | security/nss/cmd/signver/pk7print.c:508 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0657) | security/nss/cmd/signver/pk7print.c:510 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0658) | security/nss/cmd/signver/pk7print.c:516 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0659) | security/nss/cmd/signver/pk7print.c:553 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0660) | security/nss/cmd/signver/pk7print.c:556 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0661) | security/nss/cmd/signver/pk7print.c:589 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0662) | security/nss/cmd/signver/pk7print.c:608 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0663) | security/nss/cmd/signver/pk7print.c:621 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0664) | security/nss/cmd/signver/pk7print.c:622 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0665) | security/nss/cmd/signver/pk7print.c:626 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0666) | security/nss/cmd/signver/pk7print.c:628 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0667) | security/nss/cmd/signver/pk7print.c:642 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0668) | security/nss/cmd/signver/pk7print.c:672 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0669) | security/nss/cmd/signver/pk7print.c:707 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0670) | security/nss/cmd/signver/pk7print.c:717 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0671) | security/nss/cmd/signver/pk7print.c:730 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0672) | security/nss/cmd/signver/pk7print.c:744 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0673) | security/nss/cmd/signver/pk7print.c:762 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0674) | security/nss/cmd/ssltap/ssltap.c:991 [1] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant character.
|
| f0675) | security/nss/cmd/ssltap/ssltap.c:1006 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0676) | security/nss/cmd/ssltap/ssltap.c:1009 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0677) | security/nss/cmd/ssltap/ssltap.c:1012 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0678) | security/nss/cmd/ssltap/ssltap.c:1016 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0679) | security/nss/cmd/strsclnt/strsclnt.c:60 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0680) | security/nss/cmd/strsclnt/strsclnt.c:148 [4] (format) printf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0681) | security/nss/cmd/strsclnt/strsclnt.c:149 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0684) | security/nss/cmd/swfort/instinit/instinit.c:130 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0686) | security/nss/cmd/swfort/instinit/instinit.c:138 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0687) | security/nss/cmd/swfort/newuser/newuser.c:301 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0688) | security/nss/cmd/swfort/newuser/newuser.c:650 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0689) | security/nss/cmd/swfort/newuser/newuser.c:765 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0690) | security/nss/cmd/swfort/newuser/newuser.c:766 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0692) | security/nss/cmd/swfort/newuser/newuser.c:767 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0693) | security/nss/cmd/swfort/newuser/newuser.c:768 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0695) | security/nss/cmd/tstclnt/tstclnt.c:64 [4] (format) printf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0696) | security/nss/cmd/tstclnt/tstclnt.c:65 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0697) | security/nss/cmd/zlib/example.c:65 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0698) | security/nss/cmd/zlib/example.c:105 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0699) | security/nss/cmd/zlib/example.c:168 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0700) | security/nss/cmd/zlib/example.c:260 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0701) | security/nss/cmd/zlib/example.c:336 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0702) | security/nss/cmd/zlib/example.c:414 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0703) | security/nss/cmd/zlib/gzio.c:95 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0704) | security/nss/cmd/zlib/gzio.c:171 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0705) | security/nss/cmd/zlib/gzio.c:533 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0706) | security/nss/cmd/zlib/gzio.c:534 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0707) | security/nss/cmd/zlib/gzio.c:535 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0708) | security/nss/cmd/zlib/minigzip.c:144 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0709) | security/nss/cmd/zlib/minigzip.c:145 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0710) | security/nss/cmd/zlib/minigzip.c:175 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0711) | security/nss/cmd/zlib/minigzip.c:184 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0712) | security/nss/cmd/zlib/zutil.h:180 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0713) | security/nss/cmd/zlib/zutil.h:181 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0714) | security/nss/cmd/zlib/zutil.h:182 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0715) | security/nss/cmd/zlib/zutil.h:183 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0716) | security/nss/cmd/zlib/zutil.h:184 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0717) | security/nss/lib/certdb/genname.c:1396 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0718) | security/nss/lib/fortcrypt/fortpk11.c:66 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0719) | security/nss/lib/fortcrypt/fortpk11.c:509 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0720) | security/nss/lib/fortcrypt/fortpk11.c:914 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0721) | security/nss/lib/fortcrypt/fortpk11.c:916 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0722) | security/nss/lib/fortcrypt/fortpk11.c:919 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0723) | security/nss/lib/fortcrypt/fortpk11.c:2177 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0724) | security/nss/lib/fortcrypt/fortpk11.c:2179 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0725) | security/nss/lib/fortcrypt/fortpk11.c:2188 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0726) | security/nss/lib/fortcrypt/swfort/swflib.c:377 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0727) | security/nss/lib/fortcrypt/swfort/swflib.c:381 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0728) | security/nss/lib/fortcrypt/swfort/swflib.c:912 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0729) | security/nss/lib/fortcrypt/swfort/swflib.c:932 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0731) | security/nss/lib/fortcrypt/swfort/swflib.c:942 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0734) | security/nss/lib/fortcrypt/swfort/swfutl.c:722 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0737) | security/nss/lib/freebl/os2_rand.c:126 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0738) | security/nss/lib/freebl/os2_rand.c:127 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0739) | security/nss/lib/freebl/os2_rand.c:129 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0740) | security/nss/lib/freebl/os2_rand.c:130 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0741) | security/nss/lib/freebl/os2_rand.c:139 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0742) | security/nss/lib/freebl/os2_rand.c:253 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0743) | security/nss/lib/freebl/os2_rand.c:254 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0744) | security/nss/lib/freebl/unix_rand.c:706 [4] (tmpfile) execvp: this calls out to a new process and is difficult to use safely. try using a library call that implements the same functionality if available..
|
| f0747) | security/nss/lib/freebl/win_rand.c:181 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0748) | security/nss/lib/freebl/win_rand.c:182 [2] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant string.
|
| f0749) | security/nss/lib/freebl/win_rand.c:195 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0750) | security/nss/lib/freebl/mpi/mdxptest.c:130 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0751) | security/nss/lib/freebl/mpi/mpi-priv.h:54 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0752) | security/nss/lib/freebl/mpi/mpi-test.c:418 [3] (random) srand: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0753) | security/nss/lib/freebl/mpi/mpi-test.c:920 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0754) | security/nss/lib/freebl/mpi/mpi-test.c:936 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0755) | security/nss/lib/freebl/mpi/mpi-test.c:1160 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0756) | security/nss/lib/freebl/mpi/mpi-test.c:1968 [4] (format) vfprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0757) | security/nss/lib/freebl/mpi/mpi.c:2418 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0758) | security/nss/lib/freebl/mpi/mulsqr.c:77 [3] (random) srand: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0759) | security/nss/lib/freebl/mpi/mulsqr.c:88 [3] (random) srand: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0771) | security/nss/lib/freebl/mpi/utils/identest.c:70 [3] (random) srand: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0775) | security/nss/lib/freebl/mpi/utils/metime.c:96 [3] (random) srand: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0777) | security/nss/lib/freebl/mpi/utils/primegen.c:90 [3] (random) srand: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0778) | security/nss/lib/freebl/mpi/utils/primegen.c:92 [3] (random) srand: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0779) | security/nss/lib/freebl/mpi/utils/prng.c:67 [3] (random) srand: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0780) | security/nss/lib/jar/jarfile.c:257 [5] (race) chmod: this accepts filename arguments; if an attacker can move those files, a race condition results. . Use fchmod( ) instead.
|
| f0781) | security/nss/lib/pk11wrap/pk11skey.c:3810 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0782) | security/nss/lib/pk11wrap/pk11skey.c:3813 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0784) | security/nss/lib/pk11wrap/pk11skey.c:3825 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0786) | security/nss/lib/pk11wrap/pk11skey.c:3831 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0787) | security/nss/lib/pk11wrap/pk11skey.c:3833 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0789) | security/nss/lib/pki/tdcache.c:76 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0790) | security/nss/lib/pki/tdcache.c:79 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0791) | security/nss/lib/pki/tdcache.c:82 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0792) | security/nss/lib/softoken/pkcs11.c:2012 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0793) | security/nss/lib/softoken/pkcs11.c:2034 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0794) | security/nss/lib/softoken/pkcs11c.c:2949 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0796) | security/nss/lib/ssl/ssl3con.c:362 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0797) | security/nss/lib/ssl/ssl3con.c:382 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0798) | security/nss/lib/ssl/ssl3con.c:599 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0799) | security/nss/lib/ssl/ssl3con.c:604 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0800) | security/nss/lib/ssl/ssl3con.c:605 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0801) | security/nss/lib/ssl/ssl3con.c:606 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0802) | security/nss/lib/ssl/ssl3con.c:607 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0803) | security/nss/lib/ssl/ssl3con.c:610 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0804) | security/nss/lib/ssl/ssl3con.c:5327 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0805) | security/nss/lib/ssl/ssl3con.c:5381 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0806) | security/nss/lib/ssl/ssl3con.c:5393 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0807) | security/nss/lib/ssl/ssl3prot.h:168 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0808) | security/nss/lib/ssl/ssl3prot.h:177 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0809) | security/nss/lib/ssl/ssl3prot.h:253 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0814) | security/nss/lib/util/nssilock.c:153 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0815) | security/nss/lib/util/nssrwlk.c:127 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0816) | security/nss/lib/util/secport.c:549 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0817) | security/nss/lib/util/secport.c:550 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0818) | security/nss/lib/util/secport.c:551 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0819) | security/nss/lib/util/secport.h:204 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0820) | security/nss/lib/util/secport.h:208 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0821) | security/nss/lib/util/utf8.c:1863 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0822) | security/nss/lib/util/utf8.c:1868 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0860) | security/manager/ssl/src/nsPKCS12Blob.cpp:222 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0880) | directory/c-sdk/ldap/build/dirver.c:80 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0934) | directory/c-sdk/ldap/include/ldaplog.h:80 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0935) | directory/c-sdk/ldap/include/portable.h:359 [4] (format) fprintf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0936) | directory/c-sdk/ldap/include/proto-ntutil.h:46 [3] (buffer) getopt: this does not protect against buffer overflows by itself, so use with caution. .
|
| f0937) | directory/c-sdk/ldap/libraries/liblber/bprint.c:45 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0938) | directory/c-sdk/ldap/libraries/liblber/bprint.c:67 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0939) | directory/c-sdk/ldap/libraries/liblber/decode.c:439 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0940) | directory/c-sdk/ldap/libraries/liblber/decode.c:581 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0941) | directory/c-sdk/ldap/libraries/liblber/encode.c:566 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0942) | directory/c-sdk/ldap/libraries/liblber/encode.c:652 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0943) | directory/c-sdk/ldap/libraries/liblber/io.c:126 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0944) | directory/c-sdk/ldap/libraries/liblber/io.c:360 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0945) | directory/c-sdk/ldap/libraries/liblber/io.c:529 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0946) | directory/c-sdk/ldap/libraries/liblber/io.c:533 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0947) | directory/c-sdk/ldap/libraries/liblber/io.c:538 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0948) | directory/c-sdk/ldap/libraries/liblber/io.c:551 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0949) | directory/c-sdk/ldap/libraries/liblber/io.c:554 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0950) | directory/c-sdk/ldap/libraries/liblber/io.c:734 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0951) | directory/c-sdk/ldap/libraries/libldap/cache.c:118 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0952) | directory/c-sdk/ldap/libraries/libldap/cldap.c:504 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0953) | directory/c-sdk/ldap/libraries/libldap/cldap.c:505 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0954) | directory/c-sdk/ldap/libraries/libldap/cldap.c:532 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0955) | directory/c-sdk/ldap/libraries/libldap/error.c:146 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0956) | directory/c-sdk/ldap/libraries/libldap/error.c:156 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0957) | directory/c-sdk/ldap/libraries/libldap/error.c:166 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0958) | directory/c-sdk/ldap/libraries/libldap/error.c:171 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0959) | directory/c-sdk/ldap/libraries/libldap/error.c:179 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0960) | directory/c-sdk/ldap/libraries/libldap/getfilter.c:140 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0961) | directory/c-sdk/ldap/libraries/libldap/getfilter.c:364 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0962) | directory/c-sdk/ldap/libraries/libldap/memcache.c:607 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0963) | directory/c-sdk/ldap/libraries/libldap/memcache.c:640 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0964) | directory/c-sdk/ldap/libraries/libldap/memcache.c:646 [4] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat.
|
| f0965) | directory/c-sdk/ldap/libraries/libldap/memcache.c:647 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0966) | directory/c-sdk/ldap/libraries/libldap/memcache.c:650 [1] (buffer) strcat: does not check for buffer overflows. Consider using strncat or strlcat. Risk is low because the source is a constant character.
|
| f0967) | directory/c-sdk/ldap/libraries/libldap/memcache.c:905 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0968) | directory/c-sdk/ldap/libraries/libldap/memcache.c:912 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0969) | directory/c-sdk/ldap/libraries/libldap/mozock.c:315 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0970) | directory/c-sdk/ldap/libraries/libldap/mozock.c:316 [2] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy. Risk is low because the source is a constant string.
|
| f0971) | directory/c-sdk/ldap/libraries/libldap/nsprthreadtest.c:412 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0972) | directory/c-sdk/ldap/libraries/libldap/nsprthreadtest.c:413 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0973) | directory/c-sdk/ldap/libraries/libldap/nsprthreadtest.c:457 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0974) | directory/c-sdk/ldap/libraries/libldap/nsprthreadtest.c:458 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0975) | directory/c-sdk/ldap/libraries/libldap/open.c:830 [4] (buffer) strcpy: does not check for buffer overflows. Consider using strncpy or strlcpy.
|
| f0976) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:95 [3] (buffer) getopt: this does not protect against buffer overflows by itself, so use with caution. .
|
| f0977) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:143 [3] (random) srandom: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0978) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:146 [3] (random) srandom: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0979) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:469 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0980) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:559 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0981) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:560 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0982) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:653 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0983) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:654 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0984) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:694 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0985) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:695 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0986) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:739 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0987) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:740 [4] (format) sprintf: Potential format string problem. Make format string constant.
|
| f0988) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:741 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0990) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:798 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0991) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:801 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0992) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:804 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0993) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:809 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0994) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:1002 [3] (random) random: This function is not sufficiently random for security-related functions such as key and nonce creation. use a more secure technique for acquiring random values.
|
| f0995) | directory/c-sdk/ldap/libraries/libldap/pthreadtest.c:1011 [2] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf. Risk is low because the source has a constant maximum length.
|
| f0996) | directory/c-sdk/ldap/libraries/libldap/regex.c:806 [4] (format) printf: if format strings can be influenced by an attacker, they can be exploited. Use a constant for the format specification.
|
| f0997) | directory/c-sdk/ldap/libraries/libldap/regex.c:811 [4] (format) vsprintf: Potential format string problem. Make format string constant.
|
| f0998) | directory/c-sdk/ldap/libraries/libldap/request.c:112 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|
| f0999) | directory/c-sdk/ldap/libraries/libldap/request.c:634 [4] (buffer) sprintf: does not check for buffer overflows. Use snprintf or vsnprintf.
|