Top issues
Detected Windows executable files that were compiled without following the recommended SDL process.
Causes risk: misconfigured toolchains detected
hardening
Problem
Security Development Lifecycle (SDL) is a group of enhanced compile-time checks that report common coding mistakes as errors, preventing them from reaching production. These checks minimize the number of security issues by enforcing strict memory access checks. They also prevent the use of hard-to-secure string and memory manipulation functions. To prove the binary has been compiled with these checks enabled, the compiler emits a special debug object. Removing the debug table eliminates this proof. Therefore, this check only applies to binaries that still have their debug tables.Prevalence in NuGet community
0 packages
found in
Top 100
3 packages
found in
Top 1k
47 packages
found in
Top 10k
13120 packages
in community
Next steps
You should keep the debug table to prove that the SDL process has been followed.
To enable these checks, refer to your programming language toolchain documentation.
In Microsoft VisualStudio, you can enable this feature by setting the compiler option /SDL to ON.
Detected Linux executable files compiled without any kind of buffer overrun protection while using banned memory functions.
Causes risk: misconfigured toolchains detected
hardening
Problem
Buffer overrun protection on Linux is achieved in two ways. The most common solution is to use the stack canary (also called cookie). The stack canary is a special value written onto the stack that allows the operating system to detect and terminate the program if a stack overrun occurs. In most cases, compilers will apply the stack canary conservatively in order to avoid a negative performance impact. Therefore, stack canaries are often used together with another stack overrun mitigation - fortified functions. Fortified functions are usually wrappers around standard glibc functions (such as memcpy) which perform boundary checks either at compile time or run time to determine if a memory violation has occurred. The compiler needs additional context to generate such calls (for example, array size that needs to be known at compile time). Because of this, the compiler will virtually never substitute all viable functions with their fortified counterparts in complex programs. However, when combined with the stack canary, fortified functions provide a good measure of buffer overrun protection.Prevalence in NuGet community
0 packages
found in
Top 100
1 packages
found in
Top 1k
19 packages
found in
Top 10k
2641 packages
in community
Next steps
Presence of unfortified memory functions may indicate use of unsafe programming practices, and you should avoid it if possible.
In GCC, enable fortified functions with -fstack-protector and -D_FORTIFY_SOURCE=2 flag, while using at least -O1 optimization level.
Detected Linux executable files compiled without any kind of buffer overrun protection while using banned input functions.
Causes risk: misconfigured toolchains detected
hardening
Problem
Buffer overrun protection on Linux is achieved in two ways. The most common solution is to use the stack canary (also called cookie). The stack canary is a special value written onto the stack that allows the operating system to detect and terminate the program if a stack overrun occurs. In most cases, compilers will apply the stack canary conservatively in order to avoid a negative performance impact. Therefore, stack canaries are often used together with another stack overrun mitigation - fortified functions. Fortified functions are usually wrappers around standard glibc functions (such as memcpy) which perform boundary checks either at compile time or run time to determine if a memory violation has occurred. The compiler needs additional context to generate such calls (for example, array size that needs to be known at compile time). Because of this, the compiler will virtually never substitute all viable functions with their fortified counterparts in complex programs. However, when combined with the stack canary, fortified functions provide a good measure of buffer overrun protection.Prevalence in NuGet community
0 packages
found in
Top 100
1 packages
found in
Top 1k
19 packages
found in
Top 10k
2224 packages
in community
Next steps
Presence of some input functions may indicate use of unsafe programming practices, and you should avoid it if possible.
In GCC, enable fortified functions with -fstack-protector and -D_FORTIFY_SOURCE=2 flag, while using at least -O1 optimization level.
Detected Linux executable files that use a deprecated method to store the security cookie, making the buffer overrun vulnerability mitigation protection less effective.
Causes risk: reduced effectiveness mitigations
hardening
Problem
Stack canary is a special value written onto the stack that allows the operating system to detect and terminate the program if a stack overrun occurs. Older compilers might generate stack cookies in a way that makes it possible to determine their value, allowing the attacker to render the mitigation ineffective.Prevalence in NuGet community
0 packages
found in
Top 100
0 packages
found in
Top 1k
13 packages
found in
Top 10k
2591 packages
in community
Next steps
In GCC, you can enable the stack canary with -fstack-protector-strong or -fstack-protector-all flag, but it may also be enabled by default in more recent versions of the compiler.
Consider upgrading your compiler.
Problem
Software developers use programming and design knowledge to build reusable software components. Software components are the basic building blocks for modern applications. Software consumed by an enterprise consists of hundreds, and sometimes even thousands of open source components. Open source communities depend on the work of thousands of software developers that volunteer their time to maintain software components. Software developers build up the reputation of their open source projects by developing in public. Modern source code repositories have many social features that allow software developers to handle bug reports, have discussions with their users, and convey reaching significant project milestones. It is uncommon to find open source projects that omit linking their component to a publicly accessible source code repository.Prevalence in NuGet community
No prevalence information at this timeNext steps
Check the software component behaviors for anomalies.
Consider exploratory software component testing within a sandbox environment.
Consider replacing the software component with a more widely used alternative.
Avoid using this software package until it is vetted as safe.
Top behaviors
Checks operating system version.
search
Prevalence in NuGet community
Behavior often found in this community (Common)
0 packages
found in
Top 100
9 packages
found in
Top 1k
67 packages
found in
Top 10k
16582 packages
in community
Reads path to temporary file location on Windows.
search
Prevalence in NuGet community
Behavior uncommon for this community (Uncommon)
0 packages
found in
Top 100
3 packages
found in
Top 1k
44 packages
found in
Top 10k
9207 packages
in community
Enumerates system information.
search
Prevalence in NuGet community
Behavior often found in this community (Common)
0 packages
found in
Top 100
23 packages
found in
Top 1k
177 packages
found in
Top 10k
65686 packages
in community
Contains URLs.
network
Prevalence in NuGet community
Behavior often found in this community (Common)
0 packages
found in
Top 100
63 packages
found in
Top 1k
513 packages
found in
Top 10k
735907 packages
in community
Modifies file/directory attributes.
file
Prevalence in NuGet community
Behavior often found in this community (Common)
0 packages
found in
Top 100
4 packages
found in
Top 1k
76 packages
found in
Top 10k
25671 packages
in community
Top vulnerabilities
No vulnerabilities found.