filename
stringlengths 5
36
| vulnerability
stringclasses 43
values | description
stringclasses 56
values | insecure_code
stringlengths 11
347
|
---|---|---|---|
editline.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy((char *)newline,(char *)bol); |
editline.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat((char *)newline,(char *)nextline); |
editline.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(symbol,(char *)&Line[j+1],i-(j+1)); |
editline.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(p,possibles[0]+index,e-index); |
editline.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(word,text+start,end-start); |
editline.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(word,(char *)(Line+start),Point-start); |
editlist.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(realname, filename); |
egif_lib.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(GifVersionPrefix, GIF_STAMP, GIF_STAMP_LEN); |
egif_lib.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(GifVersionPrefix + GIF_VERSION_POS, Version, 3); |
el_complete.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | (void)strcpy(new, p); |
el_complete.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | (void)strcpy(new, dir); |
el_complete.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | (void)strcat(new, "/"); |
el_complete.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | (void)strcat(new, av[0]); |
el_sys_unix.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | (void)strcat(p, S_ISDIR(Sb.st_mode) ? "/" : " "); |
el_sys_win32.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | (void)strcat(p, S_ISDIR(Sb.st_mode) ? "\\" : " "); |
esd.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(socket_unix.sun_path, ESD_UNIX_SOCKET_NAME, sizeof(socket_unix.sun_path)); |
esd_config.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(fn, SYSCONFDIR "/esd.conf"); |
esd_config.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(esd_spawn_options, tmpenv); |
esd_config.c | c.lang.security.insecure-use-strtok-fn.insecure-use-strtok-fn | Avoid using 'strtok()'. This function directly modifies the first argument buffer, permanently erasing the delimiter character. Use 'strtok_r()' instead. | key = strtok(aline, "="); |
esd_config.c | c.lang.security.insecure-use-strtok-fn.insecure-use-strtok-fn | Avoid using 'strtok()'. This function directly modifies the first argument buffer, permanently erasing the delimiter character. Use 'strtok_r()' instead. | value = strtok(NULL, "="); |
esd_config.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(esd_spawn_options, value); |
esddsp.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy (ident, (str ? str : "esddsp"), ESD_NAME_MAX); |
esddsp.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat (buf, num); |
esddsp.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy (new_addr->sun_path, buf); |
esdfile.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy( name, name_prefix, ESD_NAME_MAX - 2 ); |
esdfile.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat( name, ":" ); |
esdfile.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy( name + strlen( name ), filename, ESD_NAME_MAX - strlen( name ) ); |
esdlib.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy( auth_filename, home ); |
esdlib.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat( auth_filename, "/.esd_auth" ); |
esdlib.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(connect_host, espeaker, sizeof(connect_host)); |
esdlib.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy( connect_host, default_host ); |
esdlib.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(socket_unix.sun_path, ESD_UNIX_SOCKET_NAME, sizeof(socket_unix.sun_path)); |
esdlib.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy( display_host, display, len ); |
esdlib.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy( name_buf, name, ESD_NAME_MAX ); |
esdlib.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy( namebuf, name, ESD_NAME_MAX ); |
esdsample.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy( filename, argv[0], ESD_NAME_MAX - 2 ); |
esdsample.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat( filename, ":" ); |
esdsample.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy( filename + strlen( filename ), argv[ arg ], |
esdsample.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(filename, name); |
fax2ps.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(temp, "/tmp/fax2psXXXXXX"); |
ffserver.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(buf2, p); |
ffserver.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(slash, "ffmpeg"); |
ffserver.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(filename + strlen(filename)-2, "m"); |
ffserver.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(eosf - 4, ".asx"); |
ffserver.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(eosf - 3, ".ram"); |
ffserver.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(eosf, ".sdp"); |
ffserver.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(eosf, ".rtsp"); |
ffserver.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(input_filename, c->stream->feed->feed_filename); |
ffserver.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(input_filename, c->stream->feed_filename); |
ffserver.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(arg, "mjpeg"); |
fftw-wisdom.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(output_fname, optarg); |
g72x_test.c | c.lang.security.insecure-use-printf-fn.insecure-use-printf-fn | Avoid using user-controlled format strings passed into 'sprintf', 'printf' and 'vsprintf'. These functions put you at risk of buffer overflow vulnerabilities through the use of format string exploits. Instead, use 'snprintf' and 'vsnprintf'. | printf ("Mono : * No '%s' test defined.\n", argv [1]) ; |
gen_uuid.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(ifr.ifr_name, ifrp->ifr_name, IFNAMSIZ); |
getarg.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(CtrlStrCopy, CtrlStr, sizeof(CtrlStrCopy)-1); |
getarg.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(LocalToken, "-?"); |
gif2rgb.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(OneFileName, FileName, sizeof(OneFileName)-1); |
gif2rgb.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strncat(OneFileName, Postfixes[i], |
gif_font.c | c.lang.security.insecure-use-strtok-fn.insecure-use-strtok-fn | Avoid using 'strtok()'. This function directly modifies the first argument buffer, permanently erasing the delimiter character. Use 'strtok_r()' instead. | cp = strtok((char *)legend, "\r\n"); |
gif_font.c | c.lang.security.insecure-use-strtok-fn.insecure-use-strtok-fn | Avoid using 'strtok()'. This function directly modifies the first argument buffer, permanently erasing the delimiter character. Use 'strtok_r()' instead. | cp = strtok((char *)NULL, "\r\n"); |
gifinfo.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(Format, DEFAULTFORMAT); |
gifinfo.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(Comment, "\0"); |
gifinfo.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat(Comment, (char*)Extension+1); |
gifinto.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(FullPath, *FileName, sizeof(FullPath)-1); |
gifinto.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(FoutTmpName, FullPath); /* Generate destination temporary name. */ |
gifinto.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat(FoutTmpName, p); |
gifinto.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(DefaultName, FullPath); |
gifinto.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat(DefaultName, DEFAULT_OUT_NAME); |
gtkanal.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(label,blockname); |
gtkanal.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | if (pplot1->mixed[gr][ch]) strcat(label,"(mixed)"); |
gtkanal.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat(label2,title2); |
gtkanal.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(frameinfo,"MP3x: "); |
gtkanal.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strncat(frameinfo,inPath,70); |
hdlr.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(hdlr->component_name, "Linux Media Handler"); |
hdlr.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(hdlr->component_name, "Linux Video Media Handler"); |
hdlr.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(hdlr->component_name, "Linux Sound Media Handler"); |
hdlr.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(hdlr->component_name, "Linux Alias Data Handler"); |
header_test.c | c.lang.security.insecure-use-printf-fn.insecure-use-printf-fn | Avoid using user-controlled format strings passed into 'sprintf', 'printf' and 'vsprintf'. These functions put you at risk of buffer overflow vulnerabilities through the use of format string exploits. Instead, use 'snprintf' and 'vsnprintf'. | printf ("Mono : * No '%s' test defined.\n", argv [1]) ; |
huffbuild.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(buffer,base); |
huffbuild.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat(buffer,".vqh"); |
iconvert.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(tocode1, tocode); |
iconvert.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat(tocode1, "//TRANSLIT"); |
iconvert.c | c.lang.security.double-free.double-free | Variable 'utfbuf' was freed twice. This can lead to undefined behavior. | free(utfbuf); |
in_faad.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(buf,data); |
in_faad.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(p+1,"ini"); |
in_faad.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(variable_bitrate_display, "1"); |
in_faad.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(priority, "4"); |
in_faad.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(memmap_file, "0"); |
in_faad.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(local_buffer_size, "128"); |
in_faad.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(stream_buffer_size, "64"); |
in_faad.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(lastfn,fn); |
in_flac.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(lastfn_, ""); |
in_flac.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(lastfn_, fn); |
infobox.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(c+1, "genres.txt"); |
infobox.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strncpy(data->filename, file, sizeof(data->filename)); |
infobox.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(buffer, infoTitle); |
infobox.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | strcat(buffer, " [Updated]"); |
infobox.c | c.lang.security.insecure-use-strcat-fn.insecure-use-strcat-fn | Finding triggers whenever there is a strcat or strncat used. This is an issue because strcat or strncat can lead to buffer overflow vulns. Fix this by using strcat_s instead. | else strcat(buffer, " [Failed]"); |
infobox.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | strcpy(buffer, GetFileName(fileName)); |
infobox.c | c.lang.security.double-free.double-free | Variable 'ucs2' was freed twice. This can lead to undefined behavior. | free(ucs2); |
interlacemodes.c | c.lang.security.insecure-use-string-copy-fn.insecure-use-string-copy-fn | Finding triggers whenever there is a strcpy or strncpy used. This is an issue because strcpy does not affirm the size of the destination array and strncpy will not automatically NULL-terminate strings. This can lead to buffer overflows, which can cause program crashes and potentially let an attacker inject code in the program. Fix this by using strcpy_s instead (although note that strcpy_s is an optional part of the C11 standard, and so may not be available). | case BC_ILACE_AUTOFIXOPTION_AUTO: strcpy(string, BC_ILACE_AUTOFIXOPTION_AUTO_T); break; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.