不可控的内存分配（CWE-789）

漏洞描述：内存分配的大小受外部控制的输入数据影响，且程序没有指定内存分配大小的上限

漏洞风险：攻击者可以使程序分配大量的内存，程序可能会因为内存资源不足而奔溃。

修复或规避建议：

1. 设定合理的内存分配上限：在程序设计时，明确规定允许分配的最大内存，并拒绝超过该限制的请求。
2. 输入验证与边界检查：在执行动态内存分配前，对用户输入或相关参数进行严格验证，防止异常值导致超大内存申请。
3. 异常处理机制：确保在内存分配失败时，程序能够正确处理异常，避免直接崩溃。

public class Example{        public int exampleFun(int length) {   //length为用户的输入数据            String[]  buffer;               if(length < 0 ) {   //没有验证length是否超过内存分配的上限                  return 0;               }               buffer = new String[length];               //其它语句     } }

示例1：不规范用法

示例2：不规范用法

以下 Java 代码示例在 new 一个字符串数组时，未限制申请的大小，可能导致内存溢出：

public class MemoryIssue {     public static void main(String[] args) {         int size = Integer.parseInt(args[0]); // 从外部输入获取数组大小         String[] data = new String[size]; // 直接使用外部输入值分配数组     } }

问题分析：

• 该代码从外部参数 args[0] 获取数组大小，并直接用于 new 数组。
• 如果 size 过大，可能导致 堆内存不足，抛出 OutOfMemoryError 异常。
• 在大内存环境（如服务器）下，虽然 -Xmx 选项可以调整 JVM 最大堆内存，但这 无法防止不受控的分配，仍可能导致服务异常中断。

Java语言中new 一个字符串对象，由于没有设定长度上限，可能会早造成分配堆内存不足。

现在主流的电脑或服务器内存都很大，可以设定更大的堆内存可以使用。通过java JVM中的-Xmx参数设定。虽然上述案例通过方法传入参数设定申请堆内存大小，一般开发人员是不太可能如此使用，但是由于可能被其他人调用该方法，传入超过可用堆内存的大小而造成创建对象失败，所以还是需要注意内存使用上要控制上限。

public class Example{        static int MAX_LENGTH = 1000;  //指定内存分配的上限或动态判断剩余内存大小自动分配        public int exampleFun(int length) {   //length为用户的输入数据            if(length >  MAX_LENGTH || length < 0 ) {   //对length进行验证                 return 0;               }               String buffer = new String[length];               //其它语句     } }

示例3：规范用法之一

增加一个合理的限制上限判断，这样不会导致对内存申请失败。

示例4：规范用法

public class SafeMemoryAllocation {     private static final int MAX_SIZE = 100_000; // 设定合理的内存上限     public static void main(String[] args) {         int size = Integer.parseInt(args[0]);                 if (size > MAX_SIZE) {             throw new IllegalArgumentException("内存申请超出最大限制");         }                 String[] data = new String[size]; // 安全的内存分配     } }

通过限制最大内存分配，避免异常情况：

优化点：

• 增加最大限制 (MAX_SIZE)，避免无限制申请内存。
• 在分配前进行检查，若 size 超出范围，则抛出 IllegalArgumentException，防止程序异常崩溃。
• 更好的错误处理，确保在分配失败时，系统能够优雅降级，而非直接崩溃。

安全标准与检测工具支持

• 该问题可通过 GB/T 34944 标准支持的安全检测工具进行自动检测，发现潜在的过量内存分配风险。
• 尽管 JVM 在 new 数组时会抛出 OutOfMemoryError，但 依赖异常处理并不能彻底解决问题，仍需在代码层面进行预防。

在代码审计中，需要在代码层面查找未经验证的用户输入直接影响内存分配的情况。也就是查找内存分配代码是否涉及外部输入，并检查是否有上限约束。

关键检查点：

• 动态数组或集合的创建：
  • new 关键字直接使用外部输入参数，例如：
  • int size = Integer.parseInt(userInput);
  • int[] data = new int[size];  // 未限制 size
  • 使用 ArrayList, HashMap, ByteBuffer 等动态结构时，初始大小受输入控制：
  • int size = Integer.parseInt(request.getParameter("size"));
  • List<String> list = new ArrayList<>(size);  // 可能引发内存溢出
• 对象的批量创建：
  • 例如 Java StringBuilder, byte[], char[] 分配：
  • int length = Integer.parseInt(input);
  • StringBuilder sb = new StringBuilder(length);
• 递归或循环中的过度分配：
  • 递归创建大量对象，可能导致内存溢出：
  • public void recursiveAllocation(int depth) {
  •     if (depth > 0) {
  •         int[] data = new int[1000000];  // 递归导致大量内存分配
  •         recursiveAllocation(depth - 1);
  •     }
  • }

总结：
不可控的内存分配是潜在的安全风险，合理的限制与验证机制是避免漏洞的关键。另外，该类缺陷涉及到的CVE安全漏洞有CVE-2023-30837、CVE-2024-32035、CVE-2013-0640、CVE-2022-4741、CVE-2022-31804、CVE-2021-34867、CVE-2021-34868、CVE-2021-34869、CVE-2021-1568、CVE-2021-27906、CVE-2021-1283、CVE-2024-37168。