opencart网站,wordpress 输入 摘要,phpstorm,wordpress 修改链接地址讲动人的故事#xff0c;写懂人的代码 CrowdStrike前一阵在官网上发布了上周爆发的全球企业微软蓝屏事件的官方初步复盘结果。其中谈到了这次事件的根本原因#xff1a; 2024年7月19日#xff0c;我们部署了两个额外的IPC模板实例。由于内容验证器中的一个bug#xff0c;使… 讲动人的故事写懂人的代码 CrowdStrike前一阵在官网上发布了上周爆发的全球企业微软蓝屏事件的官方初步复盘结果。其中谈到了这次事件的根本原因 2024年7月19日我们部署了两个额外的IPC模板实例。由于内容验证器中的一个bug使得即使其中一个模板实例存在有问题的内容数据但这个模板实例也通过了验证。 基于模板类型在初次部署前2024年3月5日执行过测试我们对内容验证器中执行的检查采取信任态度以及之前成功的IPC模板实例部署所以这些模板实例被部署到生产环境中。 当传感器接收到并加载到内容解释器时通道文件291中的有问题内容导致内存读取越界从而触发异常。代码无法优雅地处理这个异常导致Windows操作系统崩溃蓝屏。 用大白话说根本原因是内容验证器由于有bug所以没有查出模板实例中有问题的内容数据。结果这些内容数据有问题的模板实例上了生产环境。之后生产环境的传感器中的内容解释器在读取这些内容数据有问题的模板实例时导致内存读取越界。而用C编写的内容解释器无法优雅地处理这个“内存读取越界”的异常情况从而导致全球范围的企业微软蓝屏事件。 什么是“内存读取越界”
内存读取越界是指程序试图访问或读取超出其被分配或合法范围的内存区域的行为。这种情况通常发生在数组或其他连续内存结构中当索引或指针超出了有效的边界时就会出现。具体来说内存读取越界的本质就是访问未经授权或未分配的内存位置。
内存读取越界常见的场景包括数组索引超出其定义的大小指针引用越过分配的内存块边界以及字符串操作超出字符串的实际长度。
内存读取越界的潜在后果包括读取未初始化或无关的数据程序不稳定或崩溃以及可能导致信息泄露或被攻击者利用这样的安全漏洞。
一些编程语言如C/C可能允许这种行为而不立即报错。其他语言如Java、Python、Rust通常会抛出异常或导致程序立即终止。
检测和预防内存读取越界的方法包括使用支持边界检查的数据结构和函数采用静态代码分析工具以及在编码时注意边界条件的处理。 C真的允许内存读取越界这种行为而不立即报错吗
是的。不信的话可以把下面的C代码复制粘贴到repl.com页面上运行看看运行结果。注意下面的C代码只是为了说明内存读取越界问题而模拟了数组索引超出其定义的大小的内存读取越界场景。这并不是这次事件真正出问题的代码哦。 1 #include iostream2 #include stdexcept3 #include vector4 5 // 模拟从传感器接收数据的函数6 std::vectorint receiveSensorData(int channel) {7 // 假设Channel 291的数据包含问题内容8 if (channel 291) {9 return {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // 问题数据
10 } else {
11 return {6, 7, 8, 9, 10}; // 正常数据
12 }
13 }
14
15 // 模拟内容解释器类
16 class ContentInterpreter {
17 public:
18 void loadContent(const std::vectorint data) {
19 if (data.size() 10) {
20 throw std::runtime_error(Data size too small for processing);
21 }
22
23 // 模拟处理数据
24 for (size_t i 0; i data.size(); i) {
25 // 越界访问最后一次循环会导致越界
26 std::cout Processing data: data[i] std::endl;
27 }
28 }
29 };
30
31 int main() {
32 int channel 291; // 指定故障发生的通道
33 try {
34 std::vectorint sensorData receiveSensorData(channel);
35 ContentInterpreter interpreter;
36 interpreter.loadContent(sensorData);
37 } catch (const std::exception e) {
38 std::cerr Exception caught: e.what() std::endl;
39 }
40
41 return 0;
42 }
// 运行结果
// Processing data: 1
// Processing data: 2
// Processing data: 3
// Processing data: 4
// Processing data: 5
// Processing data: 6
// Processing data: 7
// Processing data: 8
// Processing data: 9
// Processing data: 10
// Processing data: 1041注意上面代码第24行i data.size();就出现了越界。正确代码应该是i data.size();。结果一运行C代码并没有在内存读取越界后立即中止而是继续执行打印出Processing data: 1041。这个1041就是内存读取越界后获得的越界数据。
这个越界数据1041看起来貌似人畜无害但这种运行时遇到内存读取越界还继续执行的行为确实带来了下面更大的风险。
安全风险读取未定义的内存区域可能导致敏感信息泄露。稳定性问题程序可能在之后的某个时刻因为这个未检测到的错误而崩溃就像这次微软蓝屏那样。调试困难因为错误没有在发生点被捕获可能导致问题源头难以定位。 如果把上面的C代码转换成等效的Rust代码运行后会怎样 1 use std::fmt;2 use std::vec::Vec;3 4 #[derive(Debug)]5 struct DataSizeTooSmallError;6 7 impl fmt::Display for DataSizeTooSmallError {8 fn fmt(self, f: mut fmt::Formatter) - fmt::Result {9 write!(f, Data size too small for processing)
10 }
11 }
12
13 impl std::error::Error for DataSizeTooSmallError {}
14
15 fn receive_sensor_data(channel: i32) - Veci32 {
16 if channel 291 {
17 vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10] // 问题数据
18 } else {
19 vec![6, 7, 8, 9, 10] // 正常数据
20 }
21 }
22
23 struct ContentInterpreter;
24
25 impl ContentInterpreter {
26 fn load_content(self, data: [i32]) - Result(), Boxdyn std::error::Error {
27 if data.len() 10 {
28 return Err(Box::new(DataSizeTooSmallError));
29 }
30
31 // 模拟处理数据
32 for i in 0..data.len() {
33 // 越界访问最后一次循环会导致越界
34 println!(Processing data: {}, data[i]);
35 }
36 Ok(())
37 }
38 }
39
40 fn main() {
41 let channel 291; // 指定故障发生的通道
42 let sensor_data receive_sensor_data(channel);
43 let interpreter ContentInterpreter;
44
45 match interpreter.load_content(sensor_data) {
46 Ok(_) (),
47 Err(e) println!(Exception caught: {}, e),
48 }
49 }
// 运行结果
// Processing data: 1
// Processing data: 2
// Processing data: 3
// Processing data: 4
// Processing data: 5
// Processing data: 6
// Processing data: 7
// Processing data: 8
// Processing data: 9
// Processing data: 10
// thread main panicked at src/main.rs:34:45:
// index out of bounds: the len is 10 but the index is 10
// note: run with RUST_BACKTRACE1 environment variable to display a backtrace从上面代码可以看到第32行虽然发生了内存读取越界正确代码应该是for i in 0..data.len()但Rust代码在尝试访问越界内存时立即panic并中止了程序执行。输出清楚地指出了错误的位置和原因“index out of bounds: the len is 10 but the index is 10”。这种立即中止程序执行行为因为下面的原因而更安全。
立即发现问题错误在发生点被捕获便于定位和修复。防止未定义行为阻止了潜在的内存损坏或信息泄露。提高可靠性通过快速失败避免了程序在损坏状态下继续运行。
如果把上面的C代码转换成等效的Java代码运行后会怎样 1 import java.util.List;2 import java.util.ArrayList;3 4 public class Main {5 // 模拟从传感器接收数据的函数6 public static ListInteger receiveSensorData(int channel) {7 ListInteger data new ArrayList();8 if (channel 291) {9 // 问题数据
10 data.add(1);
11 data.add(2);
12 data.add(3);
13 data.add(4);
14 data.add(5);
15 data.add(6);
16 data.add(7);
17 data.add(8);
18 data.add(9);
19 data.add(10);
20 } else {
21 // 正常数据
22 data.add(6);
23 data.add(7);
24 data.add(8);
25 data.add(9);
26 data.add(10);
27 }
28 return data;
29 }
30
31 // 模拟内容解释器类
32 static class ContentInterpreter {
33 public void loadContent(ListInteger data) throws Exception {
34 if (data.size() 10) {
35 throw new Exception(Data size too small for processing);
36 }
37
38 // 模拟处理数据
39 for (int i 0; i data.size(); i) {
40 // 越界访问最后一次循环会导致越界
41 System.out.println(Processing data: data.get(i));
42 }
43 }
44 }
45
46 public static void main(String[] args) {
47 int channel 291; // 指定故障发生的通道
48 try {
49 ListInteger sensorData receiveSensorData(channel);
50 ContentInterpreter interpreter new ContentInterpreter();
51 interpreter.loadContent(sensorData);
52 } catch (Exception e) {
53 System.err.println(Exception caught: e.getMessage());
54 }
55 }
56 }
// 运行结果
// Processing data: 1
// Processing data: 2
// Processing data: 3
// Processing data: 4
// Processing data: 5
// Processing data: 6
// Processing data: 7
// Processing data: 8
// Processing data: 9
// Processing data: 10
// Exception caught: Index 10 out of bounds for length 10从上面代码可以看到第39行虽然发生了内存读取越界正确代码应该是i data.size();但Java的表现类似于Rust在尝试访问越界元素时抛出了IndexOutOfBoundsException异常。这个异常被main方法中的try-catch块捕获并打印。这种方式也提供了下面良好的安全性。
异常处理提供了结构化的错误处理机制。错误信息明确异常信息清楚地指出了问题所在。防止继续执行阻止了在错误状态下继续执行提高了程序的可靠性。
专业的C程序员会如何改进代码以避免内存读取越界问题
专业的C程序员会采用以下方式来改进代码以优雅地处理潜在的越界行为。这种方法注重预防、使用现代C特性并在适当的层次处理异常。 1 #include algorithm2 #include iostream3 #include stdexcept4 #include vector5 6 // 模拟从传感器接收数据的函数7 std::vectorint receiveSensorData(int channel) {8 if (channel 291) {9 return {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // 问题数据
10 } else {
11 return {6, 7, 8, 9, 10}; // 正常数据
12 }
13 }
14
15 // 模拟内容解释器类
16 class ContentInterpreter {
17 public:
18 void loadContent(const std::vectorint data) {
19 if (data.size() 10) {
20 throw std::runtime_error(Data size too small for processing);
21 }
22
23 // 使用基于范围的for循环避免手动索引
24 for (const auto value : data) {
25 processData(value);
26 }
27 }
28
29 private:
30 void processData(int value) {
31 std::cout Processing data: value std::endl;
32 }
33 };
34
35 // 错误处理函数
36 void handleError(const std::exception e) {
37 std::cerr Error: e.what() std::endl;
38 // 在这里可以添加日志记录、错误报告等逻辑
39 }
40
41 int main() {
42 int channel 291; // 指定故障发生的通道
43
44 try {
45 std::vectorint sensorData receiveSensorData(channel);
46 ContentInterpreter interpreter;
47 interpreter.loadContent(sensorData);
48 } catch (const std::exception e) {
49 handleError(e);
50 return 1; // 非正常退出
51 }
52
53 return 0;
54 }
// 运行结果
// Processing data: 1
// Processing data: 2
// Processing data: 3
// Processing data: 4
// Processing data: 5
// Processing data: 6
// Processing data: 7
// Processing data: 8
// Processing data: 9
// Processing data: 10这一版的C代码主要包括以下改进。
第24行使用基于范围的for循环 在 loadContent 方法中使用基于范围的for循环替代了手动索引。这完全消除了越界访问的可能性。错误处理策略 第36行创建了一个单独的 handleError 函数来集中处理错误。这使得错误处理逻辑更加集中和一致。异常处理 在 main 函数中捕获所有可能的异常并使用 handleError 函数处理它们。这提供了一个统一的错误处理机制。返回错误代码 第50行在发生错误时程序返回非零值表示非正常退出。模块化 第30行将数据处理逻辑封装在 processData 私有方法中提高了代码的模块性和可维护性。
专业的Rust程序员会如何改进代码以避免内存读取越界问题
类似地专业Rust程序员通常会使用以下方法来改进这段代码避免内存读取越界的问题。即使用 for 循环与迭代器而不是索引访问。这是最常用且最安全的方法因为它完全避免了手动索引从而消除了越界访问的可能性。 // 使用 for 循环遍历数据for item in data {println!(Processing data: {}, item);}专业的Java程序员会如何改进代码以避免内存读取越界问题
专业的Java程序员通常会使用以下方法来改进这段代码避免内存读取越界的问题。
使用增强型for循环for-each循环或者Java 8引入的流式API。
这些都是最常用且最安全的方法因为它完全避免了手动索引从而消除了越界访问的可能性。修改后的loadContent方法如下所示
public void loadContent(ListInteger data) throws Exception {if (data.size() 10) {throw new Exception(Data size too small for processing);}// 使用增强型for循环遍历数据for (Integer item : data) {System.out.println(Processing data: item);}
}
或者使用Java 8的流式API
public void loadContent(ListInteger data) throws Exception {if (data.size() 10) {throw new Exception(Data size too small for processing);}// 使用流式API遍历数据data.forEach(item - System.out.println(Processing data: item));
}
这些方法有以下优点。
安全性完全消除了越界访问的可能性。可读性代码更加简洁清晰意图更加明确。性能在大多数情况下这种方法的性能与传统的索引遍历相当。
此外这些方法还符合Java的现代编程风格更加符合函数式编程的思想。
如果喜欢这篇文章别忘了给文章点个“赞”好鼓励我继续写哦
