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

Индекс может найтись вне допустимой области значений массивов. Если испорченный индекс находится вне области значений массивов, он может вызвать:

Атакующий может использовать недопустимую операцию чтения, или операция записи создают к проблемам в вашей программе.

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

#include <stdlib.h>
#include <stdio.h>
#define SIZE100 100
extern int tab[SIZE100];
static int tainted_int_source(void) {
  return strtol(getenv("INDEX"),NULL,10);
}
int taintedarrayindex(void) {
	int num = tainted_int_source();
    return tab[num];  
}

В этом примере, индекс num получает доступ к массиву tab. Индекс num получен из небезопасного источника и функционального taintedarrayindex не проверяет, чтобы видеть если num в области значений tab.

Одна возможная коррекция должна проверять тот num находится в области значений перед использованием его.

#include <stdlib.h>
#include <stdio.h>
#define SIZE100 100
extern int tab[SIZE100];
static int tainted_int_source(void) {
	return strtol(getenv("INDEX"),NULL,10);
}
int taintedarrayindex(void) {
	int num = tainted_int_source();
	if (num >= 0 && num < SIZE100) {
		return tab[num]; 
	} else {
		return -1;
	}
}

Цикл, ограниченный с испорченным значением, обнаруживает циклы, которые ограничены значениями из небезопасного источника.

Испорченное значение может вызвать по цикличному выполнению или бесконечным циклам. Атакующие могут использовать эту уязвимость, чтобы разрушить вашу программу или вызвать другое непреднамеренное поведение.

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

#include<stdio.h>
enum {
    SIZE10  =  10,
    SIZE100 = 100,
    SIZE128 = 128
};

int taintedloopboundary(void) {
    int count;
    scanf("%d", &count);
    int res = 0;
    for (int i=0 ; i < count; ++i) {
        res += i;
    }
    return res;
}

В этом примере функция использует входной параметр, чтобы циклично выполнить count \times. count мог быть любой номер, потому что значение не проверяется прежде, чем запустить for цикл.

Одна возможная коррекция должна зафиксировать испорченное управление циклом. Подтверждать испорченную переменную цикла count, этот пример ограничивает count к минимальному значению и максимальному значению при помощи подставляемых функций min и max. Независимо от ввода данных пользователем, значения count остается в известной области значений.

#include<stdio.h>
#include<algorithm>
#define MIN 50
#define MAX 128
static  inline int max(int a, int b) { return a > b ? a : b;}
static inline int min(int a, int b) { return a < b ? a : b; }

int taintedloopboundary(void) {
	int count;
	scanf("%d", &count);
	int res = 0;
	count = max(MIN, min(count, MAX));
	for (int i=0 ; i<count ; ++i) { 
		res += i;
	} 
	return res;
}

Другая возможная коррекция должна проверять нижнюю границу и верхнюю границу испорченной переменной контура цикла прежде, чем запустить for цикл. Этот пример проверяет нижние и верхние границы count и выполняет цикл только когда count между 0 и 127.

#include<stdio.h>

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


int taintedloopboundary(void) {
    int count;
    scanf("%d", &count);
    int res = 0;

    if (count>=0 && count<SIZE128) {
        for (int i=0 ; i<count ; ++i) { 
            res += i;
        }
    }
    return res;
}

Выделение памяти с испорченным размером проверяет функции выделения памяти, такие как calloc или malloc, для аргументов размера из необеспеченных источников.

Неконтролируемое выделение памяти может заставить вашу программу запрашивать слишком много системной памяти. Это последствие может привести к катастрофическому отказу из-за условия из памяти, или присваивающий слишком много ресурсов.

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

#include<stdio.h>
#include <stdlib.h>

int* bug_taintedmemoryallocsize(void) {
    size_t size;
    scanf("%zu", &size);
    int* p = (int*)malloc(size);
    return p;
}

В этом примере, malloc выделяет size байты памяти для указателя p. Переменная size прибывает от пользователя программы. Его значение не проверяется, и это могло быть больше, чем сумма доступной памяти. Если size больше, чем количество доступных байтов, ваша программа могла отказать.

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

#include<stdio.h>
#include <stdlib.h>

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

int* corrected_taintedmemoryallocsize(void) {
    size_t size;
    scanf("%zu", &size);
    int* p = NULL;
    if (size>0 && size<SIZE128) {          /* Fix: Check entry range before use */
        p = (int*)malloc((unsigned int)size);
    }
    return p;
}

Испорченный размер массива переменной длины обнаруживает массивы переменной длины (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;
}

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

Одна возможная коррекция должна проверять переменную размера прежде, чем создать массив переменной длины. Этот пример проверяет, больше ли размер, чем 0 и меньше чем 40, прежде, чем создать VLA

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

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