Можно ли использовать функцию c ++ sizeof () для предотвращения переполнения целых чисел?

Я строю математические функции, которые планирую использовать для криптографии.

Ваш алгоритм бесполезен, если код уязвим для эксплуатации. Буферы довольно легко защитить от переполнения; но как насчет целых чисел?

Я не буду делиться функциями Galois, но вот одна из моих обычных функций добавления:

/**/
private:
    bool ERROR;
    signed int ret;

    void error(std::string msg){
            ERROR = true;
            std::cout<<"
[-] "<<msg<<std::endl;
    }
/**/
public:
signed int add(signed int a, signed int b){
                if(sizeof(a) > sizeof(signed int) || sizeof(b) > sizeof(signed int) || sizeof(a+b) > sizeof(signed int)){
                        error("Integer overflow!");
                        ERROR = true;
                        ret = 0;
                        return ret;
                }else{
                        ERROR = false;
                        ret = a + b;
                        return ret;
                }
                error("context failure");
                ret = 0;
                ERROR = true;
                return ret;
        }

Является ли условие if достаточным для предотвращения вредоносного ввода? Если нет, как бы устранить эту уязвимость?

c++,linux,security,integer-overflow,

-3

Ответов: 2

2

В соответствии с другим ответом нет, sizeof не защитит вас от того, что вы пытаетесь сделать. Он заботится о ширине байтов типов, а не о чем-либо еще.

Вы спрашиваете о переполнении целых чисел, но ваш пример имеет удвоение. Удваиваются точки с плавающей запятой, и AFAIK имеет четко определенную причину «переполнения». В случае значения, которое превышает максимальное значение, вы получите + INF, положительную бесконечность. Но до этого момента вы потеряете много точности. Значения с плавающей запятой не будут обтекаться.

AFAIK, в соответствии с текущими соответствующими стандартами C / C ++, нет возможности переносить неподписанное целое «переполнение» (которое хорошо определено), но gcc и clang имеют встроенные функции для их обнаружения. Вы можете попытаться предсказать переполнение без знака, но лучшие и самые портативные методы все еще горячо обсуждаются.

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

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

Также стоит отметить, что переполнения с защитой по принципу «целочисленный / плавающий» не совпадают с переполнениями буфера.

0 принят

Поэтому я нашел свой ответ.

Я решил использовать следующую логику, чтобы предотвратить переполнение целых чисел:

if((a >= 2000000000 || a <= -2000000000) ||
  (b >= 2000000000 || b <= -2000000000) || 
  ((a+b) >= 2000000000 || (a+b) <= -2000000000)){

После выполнения некоторых тестов я смог подтвердить, что целое число возвращается назад к отрицательным числам.

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

Если за пределами границ, выйдите.

~ edit: Исправлена ??логическая ошибка

C ++, Linux, безопасность, целочисленное переполнение,
Похожие вопросы
Яндекс.Метрика