265 reads New Story

Code Smell 260 - Crowdstrike NULL

by Maximiliano ContieriJuly 22nd, 2024

Too Long; Didn't Read

Using null pointers in critical code can crash your system. Avoid nulls, use address sanitizers, apply defensive programming, and improve QA testing to prevent memory access violations, system instability, and security risks in privilege mode drivers.

featured image - Code Smell 260 - Crowdstrike NULL

How to Avoid the Null Trap in Privilege Mode Drivers

TL;DR: Using null pointers in critical code can crash your system

Problems

Memory access violation
Unpredictable behavior
Null Pointer Dereference
Unexpected program termination
System instability
No healing/recovery strategy
Security Risk

Solutions

Avoid using NULLs
Use address sanitizers
Make controlled releases to mission-critical software
Create better rollback strategies instead of BSOD
Use Smart Pointers: Manage memory automatically and avoid null pointers with smart pointers
Create self-healing software.
Apply defensive programming
Improve your QA tests before deploying to production.

Context

When you use nulls in a privileged driver, you risk causing serious issues.

Privilege mode drivers run with high permissions, and if you use a null pointer, the system might try to access an invalid memory address.

For example, trying to read from address 0x9c (156) or using 0x0 as a special value can lead to critical errors.

You can't just abort the program in privileged mode, so you must handle these cases carefully.

In privileged drivers, null pointer usage poses significant risks. You can mitigate these risks using modern C++ features like std::optional.

This problem caused one of the worst software blackouts in 2024.

Sample Code

Wrong

// This case is not exactly what happened with Crowdstrike
// It is here for illustration purposes
void* get_data() {
  if (data_available) {
    return data_ptr;  // This could be null!
  } else {
    // Uh oh, what if data_ptr is null here?
    return NULL;  
    // Using Null to indicate no data
    // knowing Null is schizophrenic
  }
}

int process_data(void* data) {
  if (data != NULL) { 
    // Maybe a null check, but not guaranteed!
    // Accessing data... (crash if data is Null)
    return *data;
  }
  // No check? Silent failure or unexpected behavior.
  return -1;
}

Right

// You should ideally replace the null with a polymorphic call
// You can see the technique in related articles

std::unique_ptr<int> get_data() { 
  if (data_available) {
    return std::make_unique<int>(data_value);
  } else {
    return nullptr;  // Explicitly return nullptr
  }
}

int process_data(const std::unique_ptr<int>& data) {
  if (data) { // Check for valid pointer
    return *data;
  } else {
    // Handle no data case (e.g., return default value)
    return 0;
  }
}

Important Notes About this Code Smell

Detection

[x]Semi-Automatic

You can detect this smell by checking for null pointer usage in critical parts of your code. Look for functions that process pointers and see if they handle null pointers safely.

Human code reviews are good for checking this kind of problem.