warningRisk: Hardening

Scanned:

Gee.External.Capstone

latest

Capstone.NET is a .NET Core and a .NET Framework binding for the Capstone disassembly framework. It is written in C#, supports Capstone 4, and has a friendly and simple type safe API that is ridiculously easy to learn and quick to pick up.

License: Permissive (MIT)

Published:

See on NuGet

SAFE Assessment

Compliance

Licenses

No license compliance issues

Secrets

4 debugging symbols found

Security

Vulnerabilities

No known vulnerabilities detected

Hardening

2 reduced effectiveness mitigations

Threats

Tampering

No evidence of software tampering

Malware

No evidence of malware inclusion

List of software quality issues with the number of affected components.

Policies

Info

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

10 packages

found in

Top 1k

130 packages

found in

Top 10k

2.35k packages

in community

Next steps

Presence of unfortified string 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.

Problem

Prevalence in NuGet community

0 packages

found in

Top 100

10 packages

found in

Top 1k

150 packages

found in

Top 10k

2.88k 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.

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

8 packages

found in

Top 1k

137 packages

found in

Top 10k

2.84k 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

On Linux, external symbols are resolved via the procedure linkage table (PLT) and the global offset table (GOT). The global offset table is split into two tables - one for external data, and one for external functions. Without any protection, both are writable at runtime and thus leave the executable vulnerable to data overwrite attacks and pointer hijacking. Data overwrite attacks can be mitigated by using partial read-only relocations, while pointer hijacking can be mitigated with full read-only relocations. Both approaches have some drawbacks. Partial read-only relocations don't provide full protection, because the external function GOT remains writable. Full read-only relocations require that all external function symbols are resolved at load-time instead of during execution. This may increase loading time for large programs.

Prevalence in NuGet community

2 packages

found in

Top 100

10 packages

found in

Top 1k

120 packages

found in

Top 10k

1.47k packages

in community

Next steps

In most cases, it's recommended to use full read-only relocations (in GCC: -Wl,-z,relro,-z,now).

If the executable load-time is an issue, you should use partial read-only relocations.

Problem

Control Flow Guard (CFG/CFI) protects the code flow integrity by ensuring that dynamic calls are made only to vetted functions. Trusted execution paths rely on the ability of the operating system to build a list of valid function targets. Certain functions can intentionally be disallowed to prevent malicious code from deactivating vulnerability mitigation features. A list of such invalid function targets can include publicly exported symbols. Applications that enhance control flow integrity through export suppression rely on libraries to mark their publicly visible symbols as suppressed. This is done for all symbols that are considered to be sensitive functions, and to which access should be restricted. It is considered dangerous to mix applications that perform export suppression with libraries that do not.

Prevalence in NuGet community

0 packages

found in

Top 100

48 packages

found in

Top 1k

527 packages

found in

Top 10k

16.29k packages

in community

Next steps

To enable this mitigation on library code, refer to your programming language toolchain documentation.

In Microsoft VisualStudio, you can enable CFG mitigation by passing the /guard:cf parameter to the compiler and linker.

Problem

Control Flow Guard (CFG/CFI) protects the code flow integrity by ensuring that indirect calls are made only to vetted functions. This mitigation protects dynamically resolved function targets by instrumenting the code responsible for transferring execution control. Higher-level programming languages implement structured exception handling by managing their own code flow execution paths. As such, they are subject to code flow hijacking during runtime. Language-specific exception handling mitigation enforces execution integrity by instrumenting calls to manage execution context switching. Any deviation from the known and trusted code flow paths will cause the application to terminate. This makes malicious code less likely to execute.

Prevalence in NuGet community

0 packages

found in

Top 100

51 packages

found in

Top 1k

558 packages

found in

Top 10k

16.98k packages

in community

Next steps

It's highly recommended to enable this option for all software components used at security boundaries, or those that process user controlled inputs.

To enable this mitigation, refer to your programming language toolchain documentation.

In Microsoft VisualStudio, you can enable CFG mitigation by passing the /guard:cf parameter to the compiler and linker.

Problem

On Linux, external symbols are resolved via the procedure linkage table (PLT) and the global offset table (GOT). Without any protection, both are writable at runtime and thus leave the executable vulnerable to pointer hijacking - an attack where the function address is overwritten with an address of a malicious function. Pointer hijacking can be mitigated by using full read-only relocations, which instruct the compiler to unify global offset tables into a single read-only table. This requires that all external function symbols are resolved at load-time instead of during execution, and may increase loading time for large programs.

Prevalence in NuGet community

7 packages

found in

Top 100

18 packages

found in

Top 1k

273 packages

found in

Top 10k

4.73k packages

in community

Next steps

In most cases, it's recommended to use full read-only relocations (in GCC: -Wl,-z,relro,-z,now).

If the executable load-time is an issue, you should use partial read-only relocations.

Problem

Digital signatures are applied to applications, packages and documents as a cryptographically secured authenticity record. Signatures verify the origin and the integrity of the object they apply to. The integrity validation relies on the cryptographic strength of the encryption and the hash verification algorithm. If either of the two is considered weak by current standards, there is a chance the signed object could be maliciously modified, without triggering the integrity failure check.

Prevalence in NuGet community

100 packages

found in

Top 100

899 packages

found in

Top 1k

8997 packages

found in

Top 10k

755.66k packages

in community

Next steps

Create signatures with strong ECC key-length of at least 224 bits, or RSA key-length of at least 2048 bits, and use SHA256 as the hashing algorithm. While encryption key-length upgrade does require you to obtain a new certificate, the hashing algorithm can freely be selected during signing.

With Microsoft SignTool, you can specify the hashing algorithm using the /fd SHA256 parameter.

Problem

Common compilers often embed source code information into executables for debugging purposes, usually by mapping symbols to source filenames or paths. While this is typically desirable in open-source software and standard tools, that information can be used to determine security weaknesses, code repository layout, trade secrets and similar sensitive information. Such symbols make it easier to reverse-engineer a closed source application.

Prevalence in NuGet community

0 packages

found in

Top 100

13 packages

found in

Top 1k

259 packages

found in

Top 10k

5k packages

in community

Next steps

Strip out such information in the linking phase by using compiler options like the -s flag in GCC, or in the post-build phase by using the strip tool.

Problem

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, lack of any fortified functions may indicate that this compiler feature was not used at all.

Prevalence in NuGet community

9 packages

found in

Top 100

18 packages

found in

Top 1k

286 packages

found in

Top 10k

4.71k packages

in community

Next steps

In GCC, you can enable fortified functions with -D_FORTIFY_SOURCE=2 flag, while using at least -O1 optimization level.

Did you know...

... that you can use ReversingLabs’ Spectra Assure platform to perform regular risk assessments of packages you develop in-house?

We recommend continuous software safeness monitoring through CI/CD integrations and pre-release/deployment checks. In addition to basic package information found on this page our platform offers rich reports for developers and DevSecOps that help them remediate all reported issues.

This website uses cookies to ensure the best website experience. By continuing to use this website you are giving your consent to cookies being used. Detailed information about our use of cookies is here.

List of software quality issues with the number of affected components.

Policies

Info

Problem

Prevalence in NuGet community

0 packages

found in

Top 100

10 packages

found in

Top 1k

130 packages

found in

Top 10k

2.35k packages

in community

Next steps

Presence of unfortified string 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.

Problem

Prevalence in NuGet community

0 packages

found in

Top 100

10 packages

found in

Top 1k

150 packages

found in

Top 10k

2.88k 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.

Problem

Prevalence in NuGet community

0 packages

found in

Top 100

8 packages

found in

Top 1k

137 packages

found in

Top 10k

2.84k 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

Prevalence in NuGet community

2 packages

found in

Top 100

10 packages

found in

Top 1k

120 packages

found in

Top 10k

1.47k packages

in community

Next steps

In most cases, it's recommended to use full read-only relocations (in GCC: -Wl,-z,relro,-z,now).

If the executable load-time is an issue, you should use partial read-only relocations.

Problem

Prevalence in NuGet community

0 packages

found in

Top 100

48 packages

found in

Top 1k

527 packages

found in

Top 10k

16.29k packages

in community

Next steps

To enable this mitigation on library code, refer to your programming language toolchain documentation.

In Microsoft VisualStudio, you can enable CFG mitigation by passing the /guard:cf parameter to the compiler and linker.

Problem

Prevalence in NuGet community

0 packages

found in

Top 100

51 packages

found in

Top 1k

558 packages

found in

Top 10k

16.98k packages

in community

Next steps

It's highly recommended to enable this option for all software components used at security boundaries, or those that process user controlled inputs.

To enable this mitigation, refer to your programming language toolchain documentation.

In Microsoft VisualStudio, you can enable CFG mitigation by passing the /guard:cf parameter to the compiler and linker.

Problem

Prevalence in NuGet community

7 packages

found in

Top 100

18 packages

found in

Top 1k

273 packages

found in

Top 10k

4.73k packages

in community

Next steps

In most cases, it's recommended to use full read-only relocations (in GCC: -Wl,-z,relro,-z,now).

If the executable load-time is an issue, you should use partial read-only relocations.

Problem

Prevalence in NuGet community

100 packages

found in

Top 100

899 packages

found in

Top 1k

8997 packages

found in

Top 10k

755.66k packages

in community

Next steps

With Microsoft SignTool, you can specify the hashing algorithm using the /fd SHA256 parameter.

Problem

Prevalence in NuGet community

0 packages

found in

Top 100

13 packages

found in

Top 1k

259 packages

found in

Top 10k

5k packages

in community

Next steps

Strip out such information in the linking phase by using compiler options like the -s flag in GCC, or in the post-build phase by using the strip tool.

Problem

Prevalence in NuGet community

9 packages

found in

Top 100

18 packages

found in

Top 1k

286 packages

found in

Top 10k

4.71k packages

in community

Next steps

In GCC, you can enable fortified functions with -D_FORTIFY_SOURCE=2 flag, while using at least -O1 optimization level.

Gee.External.Capstone

SAFE Assessment

Compliance

Security

Threats

SQ18105Detected Linux executable files compiled without any kind of buffer overrun protection while using banned string functions.Causes risk: misconfigured toolchains detectedhardening

Problem

Prevalence in NuGet community

Next steps

SQ18106Detected Linux executable files compiled without any kind of buffer overrun protection while using banned memory functions.Causes risk: misconfigured toolchains detectedhardening

Problem

Prevalence in NuGet community

Next steps

SQ18109Detected 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 mitigationshardening

Problem

Prevalence in NuGet community

Next steps

SQ18112Detected Linux executable files that were compiled without any dynamic symbol hijacking protections.Causes risk: execution hijacking concernshardening

Problem

Prevalence in NuGet community

Next steps

SQ14125Detected Windows shared library files that do not suppress exports which reduces CFG vulnerability mitigation protection effectiveness.Causes risk: low priority mitigations absenthardening

Problem

Prevalence in NuGet community

Next steps

SQ14127Detected Windows executable files that do not implement long jump control flow vulnerability mitigation protection.Causes risk: low priority mitigations absenthardening

Problem

Prevalence in NuGet community

Next steps

SQ18113Detected Linux executable files that were compiled without the recommended dynamic symbol hijacking protections.Causes risk: execution hijacking concernshardening

Problem

Prevalence in NuGet community

Next steps

SQ20119Detected digital signatures that rely on a weak digest algorithm for integrity validation.signatures

Problem

Prevalence in NuGet community

Next steps

SQ34204Detected presence of hardcoded source code filenames or paths.Causes risk: debugging symbols foundsecrets

Problem

Prevalence in NuGet community

Next steps

SQ18108Detected Linux executable files without any fortified functions.Causes risk: low priority mitigations absenthardening

Problem

Prevalence in NuGet community

Next steps

Did you know...

SQ18105Detected Linux executable files compiled without any kind of buffer overrun protection while using banned string functions.Causes risk: misconfigured toolchains detectedhardening

Problem

Prevalence in NuGet community

Next steps

SQ18106Detected Linux executable files compiled without any kind of buffer overrun protection while using banned memory functions.Causes risk: misconfigured toolchains detectedhardening

Problem

Prevalence in NuGet community

Next steps

SQ18109Detected 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 mitigationshardening

Problem

Prevalence in NuGet community

Next steps

SQ18112Detected Linux executable files that were compiled without any dynamic symbol hijacking protections.Causes risk: execution hijacking concernshardening

Problem

Prevalence in NuGet community

Next steps

SQ14125Detected Windows shared library files that do not suppress exports which reduces CFG vulnerability mitigation protection effectiveness.Causes risk: low priority mitigations absenthardening

Problem

Prevalence in NuGet community

Next steps

SQ14127Detected Windows executable files that do not implement long jump control flow vulnerability mitigation protection.Causes risk: low priority mitigations absenthardening

Problem

Prevalence in NuGet community

Next steps

SQ18113Detected Linux executable files that were compiled without the recommended dynamic symbol hijacking protections.Causes risk: execution hijacking concernshardening

Problem

Prevalence in NuGet community

Next steps

SQ20119Detected digital signatures that rely on a weak digest algorithm for integrity validation.signatures

Problem

Prevalence in NuGet community

Next steps

SQ34204Detected presence of hardcoded source code filenames or paths.Causes risk: debugging symbols foundsecrets

Problem