Skip to content

Latest commit

 

History

History
130 lines (105 loc) · 7.3 KB

mitigations.md

File metadata and controls

130 lines (105 loc) · 7.3 KB

Mitigation Strategies Analysis for olivere/elastic

Mitigation Strategy: Comprehensive Error Handling (with olivere/elastic)

Description:

  1. Check Every olivere/elastic Error: After every call to an olivere/elastic function (e.g., client.Index(), client.Search(), client.Get()), immediately check the returned error value using if err != nil.
  2. Log with olivere/elastic Context: Inside the if err != nil block, log the error, including:
    • The specific olivere/elastic function that failed.
    • The parameters passed to the function (excluding sensitive data).
    • A descriptive message explaining the context.
    • Never log raw data from Elasticsearch or user input.
  3. Differentiate olivere/elastic Error Types: Use Go's error handling:
    • Use errors.Is and errors.As to check for specific error types.
    • Use type assertions (e.g., if _, ok := err.(*elastic.Error); ok { ... }) to check for elastic.Error and extract details like the status code. This is crucial for understanding Elasticsearch-specific errors.
  4. Implement Graceful Degradation (based on olivere/elastic errors):
    • Network Errors: Retry with exponential backoff (using olivere/elastic's retry mechanisms if available, or custom logic).
    • "Not Found" Errors (404): Handle gracefully (return a default value, user-friendly message).
    • Server Errors (5xx): Log and potentially alert an administrator.
    • Client Errors (4xx, excluding 404): Investigate (likely an application bug or incorrect Elasticsearch configuration).
    • Permission Errors (403): Return an "access denied" message.
  5. Centralized olivere/elastic Error Handling (Optional): Consider a helper function or middleware to handle common olivere/elastic error patterns.

Threats Mitigated:

  • Information Leakage (Severity: Medium): Prevents sensitive Elasticsearch cluster details or data snippets from being exposed in error messages.
  • Application Instability (Severity: High): Prevents unhandled olivere/elastic errors from crashing the application.
  • Denial of Service (DoS) (Severity: Medium): Prevents repeated olivere/elastic errors from causing resource exhaustion.

Impact:

  • Information Leakage: Risk significantly reduced.
  • Application Instability: Risk eliminated.
  • DoS: Risk reduced.

Currently Implemented:

  • Basic error checking (if err != nil) in data_ingestion.
  • Logging with logrus, but context is sometimes missing.

Missing Implementation:

  • Error type differentiation is inconsistent.
  • Graceful degradation is missing in search_api.
  • Centralized error handling is not implemented.

Mitigation Strategy: Secure Query Construction (using olivere/elastic Builders)

Description:

  1. Avoid String Concatenation: Never build Elasticsearch queries by concatenating strings, especially with user input.
  2. Exclusively Use olivere/elastic Query Builders:
    • elastic.NewMatchQuery, elastic.NewTermQuery, elastic.NewBoolQuery, elastic.NewRangeQuery, etc. Use the appropriate builder for each query type. This is the core of preventing query injection.
  3. Sanitize Input (if unavoidable, with olivere/elastic): If you must use user input (e.g., for a field name), sanitize it before passing it to an olivere/elastic builder:
    • Whitelist: Define allowed values.
    • Validation: Validate against the whitelist.
    • Rejection: Reject invalid input.
  4. Avoid elastic.NewRawStringQuery: Do not use elastic.NewRawStringQuery or similar constructs with user-provided data. This bypasses the safety of the builders.

Threats Mitigated:

  • Query Injection (Severity: Critical): Prevents attackers from injecting malicious Elasticsearch query clauses.
  • Denial of Service (DoS) (Severity: High): Prevents expensive query attacks.

Impact:

  • Query Injection: Risk almost entirely eliminated.
  • DoS: Risk significantly reduced.

Currently Implemented:

  • Query builders are used in most of search_api.

Missing Implementation:

  • Input sanitization is missing for some fields in advanced_search.

Mitigation Strategy: Secure Connection Configuration (with olivere/elastic)

Description:

  1. HTTPS with olivere/elastic: Use HTTPS: elastic.SetScheme("https").
  2. Authentication with olivere/elastic:
    • elastic.SetBasicAuth("username", "password") (less preferred).
    • elastic.SetAPIKey("your-api-key") (recommended).
  3. Disable Sniffing (if appropriate) with olivere/elastic: If not using a load balancer that handles node discovery: elastic.SetSniff(false).
  4. Certificate Validation with olivere/elastic:
    • Create an http.Client with proper TLS configuration (including CA certificates).
    • Use elastic.SetHttpClient(yourHttpClient) to set the custom client. This is essential for preventing MitM attacks.

Threats Mitigated:

  • Unauthorized Access (Severity: Critical): Prevents unauthorized connections.
  • Man-in-the-Middle (MitM) Attacks (Severity: Critical): Prevents interception and modification of communication.
  • Data Breaches (Severity: Critical): Protects data in transit.

Impact:

  • Unauthorized Access: Risk eliminated.
  • MitM Attacks: Risk eliminated.
  • Data Breaches: Risk significantly reduced.

Currently Implemented:

  • HTTPS is enabled.
  • Basic authentication is used.

Missing Implementation:

  • Certificate validation is not explicitly configured.
  • API key authentication should be implemented.
  • Sniffing is enabled incorrectly.

Mitigation Strategy: Excessive Data Retrieval (using olivere/elastic features)

Description:

  1. Pagination with olivere/elastic:
    • elastic.SearchService.From(offset)
    • elastic.SearchService.Size(limit)
    • Handle multiple pages in your application logic.
  2. Scroll API with olivere/elastic (for very large datasets):
    • elastic.ScrollService
    • Iterate with scrollService.Do(ctx).
    • Clear with scrollService.Clear(ctx).
  3. Aggregations with olivere/elastic: Use aggregations instead of retrieving all documents when possible:
    • elastic.NewSumAggregation, elastic.NewAvgAggregation, elastic.NewTermsAggregation, etc.
    • Add to search: searchService.Aggregation("name", aggregation).

Threats Mitigated:

  • Performance Degradation (Severity: Medium): Prevents slow queries.
  • Resource Exhaustion (Severity: High): Prevents out-of-memory errors.
  • Denial of Service (DoS) (Severity: Medium): Prevents data-based DoS attacks.

Impact:

  • Performance Degradation: Risk significantly reduced.
  • Resource Exhaustion: Risk significantly reduced.
  • DoS: Risk reduced.

Currently Implemented:

  • Pagination in main search.
  • Aggregations for some reports.

Missing Implementation:

  • Scroll API is not used.