Проблема возникает, когда ваш код содержит функции, которые вызывают себя прямо или косвенно.

Переменные, локальные к функции, хранятся в стеке вызовов. Если функция вызывает себя прямо или косвенно несколько раз, доступное пространство стека может быть превышено, вызывая серьезный отказ. Если рекурсия не контролируется жестко, трудно определить максимальное требуемое пространство стека.

void foo1( void ) {     /* Non-compliant */
          /*- Indirect recursion foo1->foo2->foo1... */
    foo2();
    foo1();   /* Non-compliant - Direct recursion */
}

void foo2( void ) {/*Noncompliant*/
         /* Indirect Recursion - Foo2->foo1->foo2*/
    foo1();
}

В этом примере правило нарушается из-за:

Массив переменной длины с неположительным размером возникает, когда размер массива переменной длины равен нулю или отрицательному.

Если размер массива переменной длины равен нулю или отрицательному, может произойти неожиданное поведение, такое как переполнение стека.

Когда вы объявляете массив переменной длины как локальную переменную в функции:

Можно поместить тест на положительное значение либо перед вызовом функции, либо объявлением массива в теле функции.

int input(void);

void add_scalar(int n, int m) {
    int r=0;
    int arr[m][n];
    for (int i=0; i<m; i++) {
        for (int j=0; j<n; j++) {
            arr[i][j] = input();
            r += arr[i][j];
        }
    }
}

void main() {
    add_scalar(2,2);
    add_scalar(-1,2);
    add_scalar(2,0);
}

В этом примере второй и третий вызовы add_scalar привести к отрицательному и нулевому размеру arr.

Одной из возможных коррекций является исправление или удаление вызовов, которые приводят к непозитивному размеру массива.

Испорченный размер массива переменной длины обнаруживает массивы переменной длины (VLA), размер которых получен из небезопасного источника.

Если атакующий изменил размер вашего VLA на неожиданное значение, это может привести к сбою или неожиданному поведению вашей программы.

Если размер не положителен, поведение VLA не определено. Ваша программа работает не так, как ожидалось.

Если размер не ограничен, VLA может вызвать истощение памяти или переполнение стека.

Проверьте размер VLA, чтобы убедиться, что он положительный и меньше максимального значения.

#include<stdio.h>
#inclule<stdlib.h>
#define LIM 40

long squaredSum(int size) {

	int tabvla[size];
	long res = 0;
	for (int i=0 ; i<LIM-1 ; ++i) {
		tabvla[i] = i*i;
		res += tabvla[i];
	}
	return res;
}
int main(){
	int size;
	scanf("%d",&size);
	//...
	long result = squaredSum(size);
	//...
	return 0;
}

В этом примере размер массива переменной длины основан на входном параметре. Поскольку этот входной параметр не проверен, размер может быть отрицательным или слишком большим.

Одной из возможных коррекций является проверка переменной size перед созданием массива переменной длины. Этот пример проверяет, больше ли размер 10 и меньше 100, перед созданием VLA

enum {
    SIZE10  =  10,
    SIZE100 = 100,
    SIZE128 = 128
};

int taintedvlasize(int size) {
    int res = 0;
    if (size>SIZE10 && size<SIZE100) {
        int tabvla[size]; 
        for (int i=0 ; i<SIZE10 ; ++i) {
            tabvla[i] = i*i;
            res += tabvla[i];
        }
    }
    return res;
}