Linux Kernel Security via Dynamic Message Filtering
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for securing the Linux kernel often require modifications to the kernel code, leading to lengthy testing and debugging processes and the risk of introducing new bugs, while methods that avoid kernel modification, such as loadable kernel modules, have limitations in enforcing security policies effectively.
Innovation Solution
An object-oriented message filter model is introduced that dynamically loads modules to provide filtering capabilities transparent to user applications, using wrappers around the kernel to intercept and filter messages based on specified rules, allowing for real-time monitoring and flexible security policy enforcement without modifying the kernel source.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If the kernel code is modified to secure the Linux kernel, then security is improved, but testing and debugging time increases and risk of introducing new bugs increases
Solution Approach 1:
The patent segments the security filtering functionality from the core kernel by introducing loadable kernel modules (LKMs) that operate as separate, dynamically loadable components. These modules implement message filtering capabilities without modifying the kernel source code, allowing security functionality to be added as independent segments that can be tested and deployed separately from the core kernel.
Solution Approach 2:
The patent introduces an intermediary layer in the form of message filters and wrappers that sit between user-space applications and the kernel. These intermediaries intercept and filter messages before they reach the kernel, providing security functionality without requiring changes to the kernel itself. The filter wrapper acts as a mediator that handles security checking externally.
2Loss of time
If loadable kernel modules are used to avoid modifying the kernel, then testing time is reduced, but security policy enforcement capability is limited
Solution Approach 1:
The patent implements dynamic security policy enforcement through loadable kernel modules that can be loaded and unloaded at runtime. The message filter model allows security policies to be dynamically configured and adapted without requiring kernel recompilation. Filters can be dynamically added to monitor and control specific system calls or message types, providing versatile security enforcement that adapts to different security requirements.
Solution Approach 2:
The patent enables flexible security policy enforcement by allowing parameters such as filter rules, message types to monitor, and security thresholds to be changed dynamically. The filter wrapper accepts configurable parameters that define security policies, and these can be modified without changing the kernel code structure, providing adaptability while maintaining the benefits of loadable modules.
3Reliability
If filters are added to the driver to check for illegal values, then security is improved, but processing time increases due to additional filtering operations
Solution Approach 1:
The patent applies partial filtering by implementing selective message filtering that focuses only on critical security checks rather than filtering every message exhaustively. The filter wrapper performs essential validation on message parameters and filters out obviously malicious messages, while allowing legitimate messages to pass through with minimal overhead. This partial action approach provides security protection without excessively slowing down normal message processing.
Data Source
AI summary
Systems and methods for providing security to the Linux kernel are described. Wrappers are provided around the kernel, thereby reducing the amount of testing needed since the new security code will be introduced only into the wrappers. This also provides flexibility in various layers. The filters may be customized per se to suit various security needs. Overhead incurred due to this is very low.