filename
stringlengths 5
36
| vulnerability
stringclasses 43
values | description
stringclasses 56
values | insecure_code
stringlengths 11
347
|
|---|---|---|---|
codec.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( dest, pass_str ); |
codec.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( dest, last_dot ); |
colormodels.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_RGB888: strcpy(string, "RGB-8 Bit"); break; |
colormodels.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_RGBA8888: strcpy(string, "RGBA-8 Bit"); break; |
colormodels.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_RGB161616: strcpy(string, "RGB-16 Bit"); break; |
colormodels.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_RGBA16161616: strcpy(string, "RGBA-16 Bit"); break; |
colormodels.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_YUV888: strcpy(string, "YUV-8 Bit"); break; |
colormodels.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_YUVA8888: strcpy(string, "YUVA-8 Bit"); break; |
colormodels.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_YUV161616: strcpy(string, "YUV-16 Bit"); break; |
colormodels.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_YUVA16161616: strcpy(string, "YUVA-16 Bit"); break; |
colormodels.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_RGB_FLOAT: strcpy(string, "RGB-FLOAT"); break; |
colormodels.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_RGBA_FLOAT: strcpy(string, "RGBA-FLOAT"); break; |
colormodels.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). | default: strcpy(string, "RGB-8 Bit"); break; |
command_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]) ; |
comment.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(tc->user_comments[tc->comments], comment); |
comment.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, tag); |
comment.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, "="); |
comment.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, value); |
comment.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(fulltag, tag); |
comment.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(fulltag, "="); |
comment.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(fulltag,tag); |
common.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 (newname, filename); |
common.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 (newname, filename, dotpos); |
common.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 (newname, extname); |
compare.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 ("%s is too short\n", argv[1]); |
compare.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 ("%s is too short\n", argv[2]); |
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(buf,data); |
configure.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, ".ini"); |
console.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 ( mfp -> str_up, "\033[A" ); |
console.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 ( mfp -> str_up, tp ); |
console.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 ( mfp -> str_clreoln, tp ); |
console.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 ( mfp -> str_emph, tp ); |
console.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 ( mfp -> str_norm, tp ); |
convert_cascade.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'. | sprintf( comment, "Automatically converted from %s, window size = %dx%d", argv[2], size.width, size.height ); |
cooledit-fixer.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 (newfilename, filename, sizeof (newfilename)) ; |
cooledit-fixer.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 (newfilename, "fixed.wav", sizeof (newfilename) - strlen (newfilename) - 1) ; |
cooledit-fixer.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 (newfilename, "fixed.wav", sizeof (newfilename) - 1) ; |
cstrdup.h | 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). | return strcpy(new char[strlen(cp)+1],cp); |
cuesheet.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(cs->media_catalog_number, field); |
cuesheet.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(cs->tracks[cs->num_tracks-1].isrc, field); |
dcraw.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 (make, table[i].make ); |
dcraw.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 (model, table[i].model); |
dcraw.c | c.lang.security.use-after-free.use-after-free | Variable 'image' was used after being freed. This can lead to undefined behavior. | image[r*width+c][FC(row,col)] = pixel[col]; |
dcraw.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 (model, mod[i]); |
dcraw.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 (make, "Sarnoff"); |
dcraw.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 (make, "Leaf"); |
dcraw.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 (make, "Imacon"); |
dcraw.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). | if (!make[0]) strcpy (make, "Hasselblad"); |
dcraw.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). | if (!make[0]) strcpy (make, "DNG"); |
dcraw.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 (jname, ifname); |
dcraw.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 (jext, isupper(ext[1]) ? ".JPG":".jpg"); |
dcraw.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 (make, "Rollei"); |
dcraw.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 (model,"d530flex"); |
dcraw.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 (model, cp+1); |
dcraw.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 (make, "Phase One"); |
dcraw.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 2060: strcpy (model,"LightPhase"); break; |
dcraw.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 2682: strcpy (model,"H 10"); break; |
dcraw.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 4128: strcpy (model,"H 20"); break; |
dcraw.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 5488: strcpy (model,"H 25"); break; |
dcraw.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 (make, "SMaL"); |
dcraw.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 (make, "CINE"); |
dcraw.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 (make, value); |
dcraw.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 (model, value); |
dcraw.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 (model2, value); |
dcraw.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 (make, "Contax"); |
dcraw.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 (model,"N Digital"); |
dcraw.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 (make, "Logitech"); |
dcraw.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 (model,"Fotoman Pixtura"); |
dcraw.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 (make, "Apple"); |
dcraw.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 (model,"QuickTake 100"); |
dcraw.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 (model,"QuickTake 150"); |
dcraw.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 (make, "NOKIA"); |
dcraw.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 (model, "X2"); |
dcraw.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 (make, "ARRI"); |
dcraw.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 (make, "RED"); |
dcraw.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 (model,"ONE"); |
dcraw.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 (make, corp[i]); |
dcraw.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 (model, model+8); |
dcraw.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 (model, model+15); |
dcraw.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). | if (canon_s2is()) strcpy (model+10, "S2 IS"); |
dcraw.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 (model, "E995"); |
dcraw.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 (model, "E2500"); |
dcraw.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 (make, "Minolta"); |
dcraw.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 (model,"DiMAGE Z2"); |
dcraw.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 (model,"S2Pro"); |
dcraw.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 (model, "WB550"); |
dcraw.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 (cdesc, "RGBE"); |
dcraw.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 (cdesc, colors == 3 ? "RGBG":"GMCY"); |
dcraw.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 *)oprof+pbody[2]+8, "auto-generated by dcraw"); |
dcraw.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 *)oprof+pbody[5]+12, name[output_color-1]); |
dcraw.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 (th->desc, desc, 512); |
dcraw.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 (th->make, make, 64); |
dcraw.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 (th->model, model, 64); |
dcraw.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 (th->soft, "dcraw v"DCRAW_VERSION); |
dcraw.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 (th->artist, artist, 64); |
dcraw.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 (ofname,_("standard output")); |
dcraw.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 (ofname, ifname); |
dcraw.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 (ofname, ".thumb"); |
dcraw.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 (ofname, write_ext); |
dither_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]) ; |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.