entities

type CryptographicAsset struct {
	// StartLine is the first line number where the asset was detected
	StartLine int `json:"start_line"`

	// EndLine is the last line number where the asset was detected
	EndLine int `json:"end_line"`

	// Match is the actual code snippet that was matched
	Match string `json:"match"`

	// Rules contains information about all detection rules that triggered this finding
	// This allows multiple rules to detect the same cryptographic asset
	Rules []RuleInfo `json:"rules"`

	// Status represents the current state of this finding
	// Values: "pending", "identified", "dismissed", "reviewed"
	Status string `json:"status"`

	// Metadata contains metadata extracted from the cryptographic asset
	// such as key length, algorithm, etc.
	Metadata map[string]string `json:"metadata"`

	// OID is the Object Identifier for the cryptographic algorithm.
	// Sources: NIST CSOR, PKCS#1, ANSI X9.62, etc.
	// Example: "2.16.840.1.101.3.4.1.2" for AES-128-CBC
	OID string `json:"oid,omitempty"`

	// FindingID is a stable, short hash identifier for cross-referencing this finding
	// with the callgraph export. Generated as SHA-256(file_path:start_line:rule_id)[:8].
	FindingID string `json:"finding_id,omitempty"`

	// Source indicates how this finding was discovered.
	// Values: "direct" (found in user code), "dependency" (found in a dependency).
	Source string `json:"source,omitempty"`

	// DependencyInfo contains attribution data when the finding originates from a dependency.
	DependencyInfo *DependencyInfo `json:"dependency_info,omitempty"`
}

type DependencyInfo struct {
	// Module is the dependency module path (e.g., "golang.org/x/crypto").
	Module string `json:"module"`
	// Version is the dependency version (e.g., "v0.17.0").
	Version string `json:"version"`
}

type Finding struct {
	// FilePath is the path to the file containing cryptographic assets
	FilePath string `json:"file_path"`

	// Language is the programming language of the file (e.g., "java", "python", "go")
	Language string `json:"language"`

	// CryptographicAssets contains all cryptographic materials found in this file
	CryptographicAssets []CryptographicAsset `json:"cryptographic_assets"`
}

type InterimReport struct {
	// Version of the interim report schema (e.g., "1.0")
	Version string `json:"version"`

	// Tool contains information about the scanner that generated this report
	Tool ToolInfo `json:"tool"`

	// Rules describes the ruleset that was used for this scan. Downstream
	// systems (e.g. crypto-mining-service) stamp this on every persisted
	// result so a re-mine can be triggered when the rules pack changes,
	// and a finding's provenance is auditable. Empty when no rule source
	// could supply a version (e.g. ad-hoc local files with no manifest).
	Rules RulesInfo `json:"rules,omitempty"`

	// Findings contains all detected cryptographic assets grouped by file
	Findings []Finding `json:"findings"`
}

type MetavarInfo struct {
	Start struct {
		Line   int `json:"line"`
		Col    int `json:"col"`
		Offset int `json:"offset"`
	} `json:"start"`
	End struct {
		Line   int `json:"line"`
		Col    int `json:"col"`
		Offset int `json:"offset"`
	} `json:"end"`
	AbstractContent string                  `json:"abstract_content"`
	PropagatedValue *MetavarPropagatedValue `json:"propagated_value"`
}

type MetavarPropagatedValue struct {
	SvalueStart struct {
		Line   int `json:"line"`
		Col    int `json:"col"`
		Offset int `json:"offset"`
	} `json:"svalue_start"`
	SvalueEnd struct {
		Line   int `json:"line"`
		Col    int `json:"col"`
		Offset int `json:"offset"`
	} `json:"svalue_end"`
	SvalueAbstractContent string `json:"svalue_abstract_content"`
}

type RuleInfo struct {
	// ID is the unique identifier for the rule
	// Example: "<language>.crypto.<library>.<operation>-<specifics>"
	ID string `json:"id"`

	// Message is a human-readable description of what was detected
	Message string `json:"message"`

	// Severity indicates the importance level of the finding
	// Values: "WARNING", "ERROR", "INFO"
	Severity string `json:"severity"`

	// Version is the ruleset version when known (e.g., "latest", "v1.0.1")
	Version string `json:"version,omitempty"`
}

type RulesInfo struct {
	// Source is "remote" or "local". Empty when no rules were loaded.
	Source string `json:"source,omitempty"`

	// Name of the ruleset (e.g. "dca"). Remote sources only.
	Name string `json:"name,omitempty"`

	// Version of the ruleset (e.g. "v1.0.0", "latest"). Remote sources only.
	Version string `json:"version,omitempty"`

	// ChecksumSHA256 is the content fingerprint of the ruleset.
	// For remote sources: the manifest checksum reported by the API.
	// For local sources: SHA256 of concatenated rule file contents in path-sorted order.
	ChecksumSHA256 string `json:"checksum_sha256,omitempty"`
}

type SemgrepError struct {
	Code    int                `json:"code,omitempty"`  // Error code
	Type    any                `json:"type"`            // Error type (string or [string, locations])
	Level   string             `json:"level"`           // Error level
	Message string             `json:"message"`         // Error message
	Path    string             `json:"path"`            // File path (if applicable)
	Spans   []SemgrepErrorSpan `json:"spans,omitempty"` // Error spans
}

type SemgrepErrorSpan struct {
	File  string          `json:"file"`
	Start SemgrepLocation `json:"start"`
	End   SemgrepLocation `json:"end"`
}

type SemgrepExtra struct {
	Message  string                 `json:"message"`  // Human-readable message
	Metadata SemgrepMetadata        `json:"metadata"` // Rule metadata
	Metavars map[string]MetavarInfo `json:"metavars"` // Metavariables
	Severity string                 `json:"severity"` // Severity level
	Lines    string                 `json:"lines"`    // Matched code snippet
}

type SemgrepLocation struct {
	Line   int `json:"line"`   // Line number (1-indexed)
	Col    int `json:"col"`    // Column number (1-indexed)
	Offset int `json:"offset"` // Byte offset
}

type SemgrepMetadata struct {
	Category       string         `json:"category,omitempty"`
	Subcategory    string         `json:"subcategory,omitempty"`
	Confidence     string         `json:"confidence,omitempty"`
	Likelihood     string         `json:"likelihood,omitempty"`
	Impact         string         `json:"impact,omitempty"`
	CWE            any            `json:"cwe,omitempty"`
	Crypto         map[string]any `json:"crypto,omitempty"`
	Owasp          []string       `json:"owasp,omitempty"`
	References     []string       `json:"references,omitempty"`
	Recommendation string         `json:"recommendation,omitempty"`
}

type SemgrepOutput struct {
	Results []SemgrepResult `json:"results"`
	Errors  []SemgrepError  `json:"errors"`
}

type SemgrepResult struct {
	CheckID  string          `json:"check_id"` // Rule ID
	Path     string          `json:"path"`     // File path
	Start    SemgrepLocation `json:"start"`    // Start location
	End      SemgrepLocation `json:"end"`      // End location
	Extra    SemgrepExtra    `json:"extra"`    // Additional metadata
	Message  string          `json:"message"`  // Rule message
	Severity string          `json:"severity"` // WARNING, ERROR, INFO
}

type ToolInfo struct {
	// Name of the scanner tool (e.g., "crypto-finder", "cbom-toolkit", etc)
	Name string `json:"name"`

	// Version of the scanner tool (e.g., "1.45.0")
	Version string `json:"version"`
}