Enum FindingKind 

#[non_exhaustive]
pub enum FindingKind {
    Vulnerability,
    Misconfiguration,
    Exposure,
    TechDetect,
    DefaultCredentials,
    InfoDisclosure,
    FileDiscovery,
    SecretLeak,
    MaliciousCode,
    SupplyChain,
    Unclassified,
    Other,
}

What kind of security issue was found.

Extensible via #[non_exhaustive] — new variants can be added without breaking downstream consumers.

Examples

use secfinding::FindingKind;

assert!(FindingKind::SecretLeak.is_actionable());
assert_eq!(FindingKind::TechDetect.to_string(), "tech-detect");

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Vulnerability

A confirmed exploitable vulnerability (SQLi, XSS, RCE, etc.).

Misconfiguration

A security misconfiguration (missing headers, weak TLS, etc.).

Exposure

An exposed service, panel, or endpoint that should not be public.

TechDetect

Technology detection — informational, no direct security impact.

DefaultCredentials

Default or weak credentials found.

InfoDisclosure

Information disclosure (stack traces, internal IPs, version numbers).

FileDiscovery

A file, directory, or backup found that should not be accessible.

SecretLeak

A hardcoded secret (API key, password, token) in source or artifacts.

MaliciousCode

A malicious or suspicious code pattern (malware, backdoor).

SupplyChain

A supply chain risk (dependency confusion, typosquatting).

Unclassified

Unclassified — kind has not been explicitly set. Distinct from Other which is an intentional classification.

Other

Intentionally classified as “other” (doesn’t fit existing categories).

Implementations

impl FindingKind

pub fn is_actionable(&self) -> bool

Whether this finding kind typically requires immediate attention.

pub fn is_classified(&self) -> bool

Whether a kind has been explicitly set (not Unclassified).

pub fn requires_severity_bump(&self) -> bool

Whether findings of this kind should always escalate severity to at least High in triage pipelines.

pub fn severity_floor(&self) -> Severity

The minimum severity a finding of this kind should have.

Useful for dashboards that want to enforce severity floors based on finding classification.

Trait Implementations

impl Clone for FindingKind

fn clone(&self) -> FindingKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FindingKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FindingKind

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for FindingKind

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for FindingKind

type Err = String

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for FindingKind

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for FindingKind

fn eq(&self, other: &FindingKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for FindingKind

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for FindingKind

impl Eq for FindingKind

impl StructuralPartialEq for FindingKind