Integer overflow что значит

Integer overflow что значит

Здравствуйте! В последнее время значительно выросло количество людей занимающихся безопасностью ИТ. Следовательно, и произошел прорыв в матодах реализации некоторых атак. И именно поэтому эта статья о новом виде атак Integer Overflow.

Что такое Integer?

В каждом языке программирования существуют типы данных. Основными являются char, string, pointer, float и integer. Не будем останавливаться на каждом типе отдельно, а поговорим о последнем — Integer. Integer это тип целого числа, например 2, 1024, 31337, и т.д. Согласно стандарту RFC1832, в 32 битных системах значения переменных данного типа могут лежать в пределах [-2147483648,2147483647]. Его структура выглядит следующим образом:

Как видно целое число занимает в памяти 32 бита, что ровно 4 байтам. Для нас Integer представляется в виде целого числа, но система работает с ним как с двоичным кодом. Где бит MSB устанавливается в единицу если число отрицательное. Хочу сразу уточнить, что если Integer используется как unsigned(только положительные значения), то значения попадут в пределы [0,4294967295].

Что такое Integer Overflow?

Как было изложено выше для переменной типа Integer, отводится в памяти 4 байта. Переполнение происходит при попытке записать в переменную значение превышающее максимально возможное число. Поведение программы в таких ситуациях полностью зависят от используемого компилятора. Потому, как согласно стандарту ISO C99 каждый компилятор при таком переполнении может делать все что угодно, от игнорирования до аварийного завершения программы. В большинства компиляторах какраз ничего и не делается 🙂 Этот вид атаки опасен еще и тем, что приложение не может определить произошло переполнение или нет (вообще-то есть способ определить произошло переполнение или нет, но это уже другая тема. ). Переполнения целых чисел можно использовать для влияния на значения некоторых критических данных, например размера буфера, индекса элемента массива, и т.д. Но на практике можно столкнутся с трудностью использования этой уязвимости. Все дело в том это переполнение в большинстве случяев не может непосредственно переписать область памяти(в отличии от Buffer Overflow и Heap overflow). Но применение этой уязвимости может легко вызвать и ошибки другого класса. В большинстве случаев возникает возможность переполнения буфера (Buffer Overflow). По словам ISO C99 уязвимость исчезает при использовании в вычислениях Unsigned Integer. Но давайте проверим действительно ли это так. Обьявим две переменные A и B, типа Unsigned Integer. Далее занесем в А максимальное значение Unsigned Integer — 4294967295, а в В -1:
В результате выполнения операции (А+В) полученное значение, согласно стандарту ISO, не вмещается в 32 бита. В таком случае результатом будет (А+В) mod 0x100000000. mod — остаток от деления, например (8 mod 2 =0), а (8 mod 3=2). Следовательно, наш результат будет равен выражению:
подставив наши значения получим следующее: Как видно результат вышел равен нулю. Не совсем то, что должно было выйти 🙂 Этот эффект называют «wrap around», тоесть вращение вокруг нуля.

На этом теоретическая часть заканчивается. Дальше мы рассмотрим несколько примеров уязвимых программ, и попробуем реализовать успешную атаку.

Как применить Integer Overflow?

Для начала рассмотрим самый простой вариант. Есть некая программа для роботы с ней нужно ввести логи пароль и длину пароля. Такой вариант вы нигде не встретите в реальной ситуации, хотя если речь идет о Web приложениях такая авторизация возможна.
Хочу сразу сказать что явную возможность Buffer Overflow я упускаю, так как нас интересует другое. Давайте внимательно посмотрим на исходник, есть некая переменная admin, которая используется как флаг. Если ее значение равно нулю, значит пользователь не имеет прав администратора и наоборот. По умолчанию значение флага устанавливается в ноль (то есть гость) , если введенный логин «admin», то флаг устанавливается в один. Дальше происходит посимвольная проверка пароля введенного пользователем и настоящим паролем. В случае нахождения различий флаг снова устанавливается в ноль. Хочу обратить ваше внимание на цикл:
Все дело в том что если intPasswordLength меньше за начальное значение(в данном случае ноль), то цикл выполнятся не будет. Но это в программе предусмотрено:
Но тут как раз вспомнить о Integer Overflow! Поскольку используется не Unsigned Integer, установив значение в 2147483647(0xFFFFFFFF) оно пройдет проверку и увеличится на один, но из выше сказанного получается что результатом будет не 2147483648, а -2147483648. При такой ситуации цикл исполняться не будет и достаточно просто угадать логин.

В принципе механизм взлома зависит от структуры программы. Для прошлого примера упрощенный вариант выглядел бы следующим образом:
Как видите все просто. Но как было сказано в начале статьи эта ошибка дает доступ использованию других видов атак. Рассмотрим следующий пример:
А теперь давайте поиграем с входными параметрами. Скомпилим наш пример:
Проведем три эксперимента: Все, это уже переполнение буфера! Оно возникает, потому что chData размером в 100 байт, не может принять значение длинной (sizeof(chData)-intOffset). Потому как после инкремента intOffset будет отрицательным и результат выражения (sizeof(chData)-intOffset) намного превысит размер буфера chData.

Вот еще один интересный пример: Проведем снова три эксперимента: Кажется ничего нельзя сделать , но тут мы ввели тип short его длинна 16 бит. Указав в качестве первого параметра 65536, intLength будет равно 65536, так как для Integer максимальное значение 2147483647. Но в проверке длинны используется тип Unsigned Short, максимальное значение которого 65535. А поскольку мы ввели 65536, то при переводе с Integer в Unsigned Short, значение shLength станет 0, вспомните «wrap around». Следовательно проверка пройдет успешно, а переполнение буфера все равно произойдет: Следующий пример прост до невозможного: Весь трюк заключается в том, чтобы обойти проверку: Учитывая особенности типа Unsigned Integer, легко увидеть, что нужно подобрать два числа которые в суме перевалили бы за максимальное значение типа, например: Примеров можно приводить сколько угодно и в каждом из них будет своя изюминка. Невозможно объять необъятное, поэтому если вы решили попробовать себя в этом деле, советую почитать следующие материалы:

Источник

Целочисленное переполнение — Integer overflow

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

Наиболее частый результат переполнения — сохранение наименее значимых представимых цифр результата; считается, что результат оборачивается вокруг максимума (т. е. по модулю степени системы счисления , обычно два в современных компьютерах, но иногда десять или другое основание системы счисления).

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

Для некоторых приложений, таких как таймеры и часы, может быть желательно перенос при переполнении. Стандарт C11 утверждает, что для беззнаковых целых чисел перенос по модулю является определенным поведением, и термин «переполнение» никогда не применяется: «вычисление с участием беззнаковых операндов никогда не может переполниться».

На некоторых процессорах, таких как графические процессоры (GPU) и процессоры цифровых сигналов (DSP), которые поддерживают арифметику насыщения , результаты переполнения будут «фиксироваться», то есть устанавливаться на минимальное или максимальное значение в представляемом диапазоне, а не обертываться.

СОДЕРЖАНИЕ

Источник

Ширина регистра процессора определяет диапазон значений , которые могут быть представлены в его регистрах. Хотя подавляющее большинство компьютеров могут выполнять арифметические операции с множественной точностью для операндов в памяти, позволяя числам быть произвольно длинными и избегать переполнения, ширина регистра ограничивает размеры чисел, с которыми можно работать (например, складывать или вычитать) с использованием одна инструкция на операцию. Типичная ширина двоичного регистра для целых чисел без знака включает:

• 4 бита: максимальное представимое значение 2 4 — 1 = 15
• 8 бит: максимальное представимое значение 2 8 — 1 = 255
• 16 бит: максимальное представимое значение 2 16 — 1 = 65 535
• 32 бита: максимальное представимое значение 2 32 — 1 = 4294967295 (наиболее распространенная ширина для персональных компьютеров с 2005 года),
• 64 бита: максимальное представимое значение 2 64 — 1 = 18 446 744 073 709 551 615 (наиболее распространенная ширина для процессоров персональных компьютеров по состоянию на 2017 год),
• 128 бит: Максимальное значение представима 2 128 — 1 = 340.282.366.920.938.463.463.374.607.431.768.211.455

Когда арифметическая операция дает результат, превышающий указанный выше максимум для N-битового целого числа, переполнение уменьшает результат до N-й степени по модулю 2, сохраняя только наименее значимые биты результата и эффективно вызывая циклический переход .

В частности, умножение или сложение двух целых чисел может привести к неожиданно маленькому значению, а вычитание из небольшого целого числа может привести к переносу к большому положительному значению (например, сложение 8-битных целых чисел 255 + 2 приводит к 1, что равно 257 по модулю 2 8 , и аналогичным образом вычитание 0 — 1 дает 255, представление с дополнением до двух для −1).

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

Если переменная имеет целочисленный тип со знаком , программа может сделать предположение, что переменная всегда содержит положительное значение. Целочисленное переполнение может привести к переносу значения и стать отрицательным, что нарушает предположение программы и может привести к неожиданному поведению (например, сложение 8-битных целых чисел 127 + 1 дает -128, дополнение до двух до 128). (Решением этой конкретной проблемы является использование целочисленных типов без знака для значений, которые программа ожидает и предполагает, что они никогда не будут отрицательными.)

Флаги

Большинство компьютеров имеют два выделенных флага процессора для проверки условий переполнения.

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

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

Варианты определения и неоднозначность

Для беззнакового типа, когда идеальный результат операции находится за пределами представимого диапазона типа и возвращаемый результат получается путем упаковки, это событие обычно определяется как переполнение. Напротив, стандарт C11 определяет, что это событие не является переполнением, и заявляет, что «вычисление с использованием беззнаковых операндов никогда не может переполниться».

Когда идеальный результат целочисленной операции выходит за пределы представимого диапазона типа и возвращаемый результат получается путем ограничения, то это событие обычно определяется как насыщение. Использование зависит от того, является ли насыщение переполнением или нет. Чтобы устранить двусмысленность, можно использовать термины «переносить переполнение» и «насыщающее переполнение».

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

Когда идеальный результат операции не является точным целым числом, значение переполнения может быть неоднозначным в крайних случаях. Рассмотрим случай, когда идеальный результат имеет значение 127,25, а максимальное представимое значение типа вывода — 127. Если переполнение определено как идеальное значение, выходящее за пределы представимого диапазона типа вывода, то этот случай будет классифицирован как переполнение. Для операций, которые имеют четко определенное поведение округления, может потребоваться отложить классификацию переполнения до тех пор, пока не будет применено округление. Стандарт C11 определяет, что преобразования из числа с плавающей запятой в целое число должны округляться до нуля. Если C используется для преобразования значения 127,25 с плавающей запятой в целое число, то сначала следует применить округление, чтобы получить идеальное целое число на выходе 127. Поскольку округленное целое число находится в диапазоне выходных значений, стандарт C не классифицирует это преобразование как переполнение. .

Непоследовательное поведение

Стоит отметить, что поведение при возникновении переполнения может быть непротиворечивым во всех обстоятельствах. В Русте программирование языка , например, в то время как функциональность будет предоставлена дать выбор пользователей и управление, поведение для основного использования математических операторов естественно фиксированным; однако это фиксированное поведение различается между программой, встроенной в режим «отладки», и программой, встроенной в режим «выпуска». В C целочисленное переполнение без знака определено для обхода, в то время как целочисленное переполнение со знаком вызывает неопределенное поведение .

Методы решения проблем целочисленного переполнения

Обработка целочисленного переполнения в различных языках программирования

Язык	Беззнаковое целое	Знаковое целое число
Ада	по модулю модуля типа	поднять Constraint_Error
C / C ++	степень двойки по модулю	неопределенное поведение
C #	степень по модулю 2 в непроверенном контексте; System.OverflowException поднимается в проверяемом контексте
Джава	N / A	степень двойки по модулю
JavaScript	все числа с плавающей запятой двойной точности, кроме нового BigInt
MATLAB	Встроенные целые числа насыщают. Целые числа с фиксированной запятой, настраиваемые для переноса или насыщения
Python 2	N / A	преобразовать в длинный тип (bigint)
Семя7	N / A	поднять OVERFLOW_ERROR
Схема	N / A	преобразовать в bigNum
Simulink	настраивается для обертывания или насыщения
Болтовня	N / A	преобразовать в LargeInteger
Быстрый	Вызывает ошибку, если не используются специальные операторы переполнения.

Обнаружение

Реализация обнаружения переполнения Запуск времени UBSan доступна для компиляторов C .

В Java 8 есть перегруженные методы , например, такие как Math.addExact(int, int) , которые сработают ArithmeticException в случае переполнения.

Группа реагирования на компьютерные чрезвычайные ситуации (CERT) разработала целочисленную модель с неограниченным диапазоном значений (AIR) — в значительной степени автоматизированный механизм для устранения переполнения и усечения целых чисел в C / C ++ с использованием обработки ошибок во время выполнения.

Избегание

Располагая переменные с типами данных, которые достаточно велики, чтобы содержать все значения, которые могут быть вычислены и сохранены в них, всегда можно избежать переполнения. Даже когда доступное пространство или фиксированные типы данных, предоставляемые языком программирования или средой, слишком ограничены, чтобы позволить переменным быть защищенным с большими размерами, тщательно упорядочивая операции и заранее проверяя операнды, часто можно гарантировать априори что результат никогда не будет больше, чем можно сохранить. Инструменты статического анализа , формальная проверка и методы проектирования по контракту могут использоваться для более надежной и надежной гарантии того, что переполнение не может произойти случайно.

Умение обращаться

Если ожидается, что может произойти переполнение, тогда в программу можно вставить тесты, чтобы определить, когда это произойдет или вот-вот произойдет, и выполнить другую обработку, чтобы смягчить его. Например, если важный результат, вычисленный на основе пользовательского ввода, переполняется, программа может остановиться, отклонить ввод и, возможно, предложить пользователю другой ввод, вместо того, чтобы программа продолжала работать с недопустимым переполненным вводом и, возможно, как следствие, работала неправильно. Этот полный процесс можно автоматизировать: можно автоматически синтезировать обработчик целочисленного переполнения, где обработчик, например, является чистым выходом.

У ЦП обычно есть способ обнаружения этого для поддержки добавления чисел, превышающих размер их регистра, обычно с использованием бита состояния; этот метод называется арифметикой с высокой точностью. Таким образом, можно добавить два числа каждые два байта шириной, используя только добавление байтов по шагам: сначала добавьте младшие байты, затем добавьте старшие байты, но если необходимо выполнить младшие байты, это арифметическое переполнение добавление байтов, и становится необходимым обнаруживать и увеличивать сумму старших байтов.

Обработка возможного переполнения при вычислении может иногда представлять выбор между выполнением проверки перед фактическим вычислением (чтобы определить, произойдет ли переполнение) или после него (чтобы определить, произошло ли это, вероятно, на основе полученного значения) . К последнему выбору следует проявлять осторожность. Во-первых, поскольку это может быть ненадежный метод обнаружения (например, добавление не обязательно может привести к более низкому значению). Во-вторых, потому что возникновение переполнения может в некоторых случаях быть неопределенным . В языке программирования C переполнение целочисленных типов без знака приводит к переносу, однако переполнение целочисленных типов со знаком является неопределенным поведением; следовательно, компилятор C может предположить, что программист обеспечил невозможность подписанного переполнения, и, таким образом, он может молча оптимизировать любую проверку после вычисления, которая включает проверку результата для его обнаружения, не давая программисту какого-либо предупреждения о том, что это было сделано. Поэтому рекомендуется всегда проводить проверки до расчетов, а не после них.

Явное распространение

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

Поддержка языков программирования

В языках программирования реализованы различные методы предотвращения случайного переполнения: Ada , Seed7 (и некоторые варианты функциональных языков) запускают условие исключения при переполнении, а Python (начиная с версии 2.4) легко преобразует внутреннее представление числа в соответствии с его ростом, в конечном итоге представляя это как long — чьи возможности ограничены только доступной памятью.

В языках с встроенной поддержкой арифметики произвольной точности и безопасности типов (таких как Python , Smalltalk или Common Lisp ) числа автоматически увеличиваются до большего размера при возникновении переполнения или выдаче исключений (сигнализация условий) при наличии ограничения диапазона. Таким образом, использование таких языков может помочь смягчить эту проблему. Однако в некоторых таких языках все еще возможны ситуации, когда может произойти целочисленное переполнение. Примером является явная оптимизация пути кода, который профилировщик считает узким местом. В случае Common Lisp это возможно с помощью явного объявления для обозначения типа переменной слова машинного размера (fixnum) и понижения уровня безопасности типа до нуля для конкретного блока кода.

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

Насыщенная арифметика

В компьютерной графике или обработке сигналов обычно работают с данными в диапазоне от 0 до 1 или от -1 до 1. Например, возьмите изображение в градациях серого, где 0 представляет черный цвет, 1 представляет белый цвет, а значения между ними представляют оттенки серого. Одна операция, которую можно поддержать, — это осветление изображения путем умножения каждого пикселя на константу. Насыщенная арифметика позволяет просто слепо умножать каждый пиксель на эту константу, не беспокоясь о переполнении, просто придерживаясь разумного результата, что все эти пиксели больше 1 (т. Е. «Ярче белого» ) просто становятся белыми, а все значения «темнее черного». «просто стать черным.

Примеры

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

Получение среднего арифметического двух чисел путем добавления их и деления на два, как это делается во многих алгоритмах поиска , вызывает ошибку, если сумма (хотя и не результирующее среднее) слишком велика для представления и, следовательно, выходит за пределы.

Необработанное арифметическое переполнение в программном обеспечении управления двигателем было основной причиной крушения первого полета ракеты Ariane 5 в 1996 году . Считалось, что программное обеспечение не содержит ошибок, поскольку оно использовалось во многих предыдущих полетах, но в них использовались ракеты меньшего размера, которые генерировали меньшее ускорение, чем Ariane 5. К сожалению, часть программного обеспечения, в которой произошла ошибка переполнения, даже не требовалась. запускался для Ariane 5 в то время, когда он привел к отказу ракеты — это был процесс режима запуска для меньшего предшественника Ariane 5, который остался в программном обеспечении, когда он был адаптирован для новой ракеты. Кроме того, фактической причиной сбоя был недостаток в технической спецификации того, как программное обеспечение справлялось с переполнением, когда оно было обнаружено: оно выполнило диагностический дамп на свою шину, которая должна была быть подключена к испытательному оборудованию во время тестирования программного обеспечения во время разработки. но был связан с двигателями рулевого управления ракеты во время полета; сброс данных сильно отклонил сопло двигателя в сторону, что вывело ракету из-под контроля аэродинамики и ускорило ее быстрое разрушение в воздухе.

30 апреля 2015 года Федеральное управление гражданской авиации США объявило, что прикажет операторам Boeing 787 периодически перезагружать его электрическую систему, чтобы избежать целочисленного переполнения, которое может привести к потере электроэнергии и развертыванию воздушной турбины с набегающим потоком , и Boeing развернул обновление программного обеспечения в четвертый квартал. Европейское агентство по авиационной безопасности последовало 4 мая 2015. ошибка происходит после того, как 2³¹ сантисекундах (248.55134814815 дней), что указывает на 32-битовую подписанную целое .

Ошибки переполнения очевидны в некоторых компьютерных играх. В аркадной игре Donkey Kong , невозможно продвинуться мимо уровня 22 из — за целочисленное переполнение в свое время / бонус. Игра берет номер уровня, на котором находится пользователь, умножает его на 10 и добавляет 40. Когда они достигают уровня 22, количество времени / бонуса равно 260, что слишком велико для его 8-битного регистра значений 256, поэтому он сам себя сбрасывает. до 0 и дает оставшиеся 4 как время / бонус — слишком мало для завершения уровня. В Donkey Kong Jr. Math при попытке вычислить число, превышающее 10 000, отображаются только первые 4 цифры. Переполнение является причиной известного уровня «разделенного экрана» в Pac-Man . Печально известная ошибка Nuclear Gandhi в Civilization якобы была вызвана целочисленным переполнением, которое произошло, когда игра попыталась вычесть 2 из уровня агрессии Ганди по умолчанию 1, установив его на 255, что почти в 26 раз выше, чем нормальный максимум, равный 10. ( Сид Мейер утверждал в интервью, что это было на самом деле преднамеренным.) Такая ошибка также вызвала «Дальние земли» в Minecraft, которые существовали с периода разработки Infdev до Beta 1.7.3; Позже он был исправлен в бета-версии 1.8, но все еще существует в версиях Minecraft Pocket Edition и Windows 10 Edition . В игре Lamborghini American Challenge для Super NES игрок может заставить свою сумму денег упасть ниже 0 долларов во время гонки, будучи оштрафованным сверх лимита оставшихся денег после уплаты сбора за гонку, что приводит к сбоям в целых числах и дает игроку 65 535 000 долларов. больше, чем было бы после отрицательного результата. Аналогичный сбой происходит в STALKER: Clear Sky, где игрок может упасть до отрицательной суммы, быстро путешествуя без достаточных средств, а затем перейти к событию, где игрока ограбят и у него отберут всю его валюту. После того, как игра попытается забрать деньги игрока на сумму 0 долларов, игроку предоставляется 2147482963 игровой валюты.

В структуре данных Pokémon в играх Pokémon количество полученных очков опыта хранится в виде 3-байтового целого числа. Однако в первом и втором поколениях группа среднего медленного опыта, которой требуется 1 059 860 очков опыта для достижения 100 уровня, по расчетам имеет -54 очка опыта на уровне 1 (уровень, который обычно не встречается во время обычной игры). Поскольку целое число не имеет знака, значение превращается в 16 777 162. Если покемон набирает менее 54 очков опыта в битве, то покемон мгновенно переходит на 100-й уровень.

Microsoft / IBM Macro Assembler (MASM) версии 1.00 и, вероятно, все другие программы, созданные одним и тем же компилятором Pascal, имели целочисленное переполнение и ошибку подписи в коде настройки стека, что не позволяло им запускаться на новых машинах DOS или эмуляторах в некоторых общих конфигурации с объемом памяти более 512 КБ. Программа либо зависает, либо отображает сообщение об ошибке и выходит в DOS.

В августе 2016 года автомат в казино Resorts World распечатал призовой билет на 42 949 672,76 долларов в результате ошибки переполнения. Казино отказалось выплатить эту сумму, назвав это неисправностью, используя в свою защиту то, что в автомате четко указано, что максимальная выплата составляет 10 000 долларов, поэтому любой приз, превышающий эту сумму, должен быть результатом ошибки программирования. Верховный суд штата Айова вынес решение в пользу казино.

Источник