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;