整数溢出

     转自:   https://blog.youkuaiyun.com/ioio_jy/article/details/50576353

        整数分为无符号整数以及有符号整数两种。其中有符号整数会在最高位用0表示正数,用1表示负数,而无符号整数则没有这种限制。另外,我们常见的整数类型有8位(单字节字符、布尔类型)、16位(短整型)、32位(长整型)等。关于整数溢出,其实它与其它类型的溢出一样,都是将数据放入了比它本身小的存储空间中,从而出现了溢出

1、无符号整数的下溢和上溢

       无符号整数的下溢问题是由于无符号整数不能识别负数所导致

  1. BOOL fun(size_t cbSize)
    {
        if( cbSize > 1024 )
        {
            return FALSE;
        }
        char *pBuf = new char[cbSize-1];
        // 存在溢出隐患
        memset(pBuf, 0x90, cbSize-1);
        ...
        return TRUE;
    }

           程序并没有对调用结果的正确性进行检测。如果cbSize为0的话,则cbSize-1的值为-1,而memset中第三个参数本身是无符号数,所以会将-1视为正的0xFFFFFFFF,系统无法操作这么大的空间,于是程序也就崩溃了。

          无符号整数的上溢

  1. BOOL fun(char *s1, size_t len1, char *s2, size_t len2)
    {
        if(len1 + len2 + 1 > 1024)
        {
            return FALSE;
        }
        char pBuf = new char[len1 + len2 + 1];
        if(pBuf == NULL)
        {
            return FALSE;
        }
        memcpy(pBuf, s1, len1);
        // 存在溢出隐患
        memcpy(pBuf + len1, s2, len2);
        ...
        return TRUE;
    }

             因为len1和len2都是无符号整数,如果len1=8,len2=0xFFFFFFFF,那么对于len1+len2+1这个运算来说,len2+1会变成0,然后再加上8,那么它的结果就是8。也就是说,new可能只分配了8个字节的空间,但是却要将长为0xFFFFFFFF的字符串复制到这个空间,那么结果就会造成程序的崩溃。

                  无符号上溢,导致分配的缓冲区过小。

                  无符号下溢,导致拷贝数据过多

2、符号问题

       (1)有符号整数之间的比较。

       (2)有符号整数的运算。

       (3)无符号整数和有符号整数的对比。

int copy_something(char *buf, int len)

{
    char szBuf[800];
    if(len > sizeof(szBuf))
    {
        return -1;
    }
    // 存在溢出隐患
    return memcpy(szBuf, buf, len);
}
  1. 由于memcpy使用的是无符号整数作为第三个参数的,但是最初的len是有符号整数。假设我们赋予len一个负值,那么就一定能够通过if语句的检测,但是当这个负值被运用在memcpy函数中时,len就可能变成一个非常大的正数,导致缓冲区及其后面的内容被改写,使得程序崩溃。

 3、截断问题

         截断问题主要发生在高位数的整数(如32位)复制到低位数的整数(如16位)的时候,发生的溢出现象

  1. BOOL fun(byte *name, DWORD cbBuf)
    {
        unsigned short cbCalculatedBufSize = cbBuf;
        byte *buf = new byte(cbCalculatedBufSize);
        if(buf == NULL)
        {
        return FALSE;
        }
        // 存在溢出隐患
        memcpy(buf, name, cbBuf);
        ...
        return TRUE;
    }

    对于fun函数来说,如果它的第二个参数cbBuf的值为0x00010020,由于cbCalculatedBufSize只能接收16位的内容,那么在赋值后,该变量的值为0x0020,因此new仅仅分配了0x20这么多的字节,但是name的大小实际为0x00010020,这就造成了缓冲区溢出情况的出现

 

### Java 中整数溢出的原因 在 Java 编程中,整数溢出是指当一个运算的结果超出了目标数据类型的表示范围时所引发的现象。例如,在 `int` 类型的情况下,其取值范围是从 `-2,147,483,648 (-2^31)` 到 `2,147,483,647 (2^31 - 1)`[^1]。如果计算结果超出此范围,则会发生静默的数值回绕现象,这意味着结果会从最大值跳转至最小值或者反之。 这种行为通常不会抛出任何运行时错误或警告,因此可能导致难以察觉的逻辑错误。例如,两个正整数相乘可能返回负数的情况就是典型的整数溢出示例[^2]。 ### 解决方案 #### 使用更大容量的数据类型 一种简单的解决方案是采用可以容纳更大数据值的数据类型来代替默认的 `int` 数据类型。对于大多数情况来说,可以选择使用 `long` 类型替代 `int`,因为它的取值范围更为宽广(从 `-9,223,372,036,854,775,808 (-2^63)` 至 `9,223,372,036,854,775,807 (2^63 - 1)`)。然而需要注意的是,即使使用了 `long` 类型也可能面临类似的溢出风险,只是发生的可能性较小而已。 #### 应用 BigInteger 类型 为了完全规避由于有限位宽度带来的潜在问题,推荐利用 Java 提供的大整数类——`BigInteger` 来执行精确无误的大规模数值操作。该类支持任意长度的整数运算,并且自动管理内部存储结构以适应不断增长的需求。尽管如此,它也存在性能上的代价以及额外内存消耗等问题需要权衡考虑。 下面给出一段基于上述两种策略的实际编码例子: ```java // Example using long type to prevent overflow within reasonable limits. public class OverflowExample { public static void main(String[] args) { try { int a = Integer.MAX_VALUE; System.out.println("Integer max value is: " + a); // Using 'long' instead of 'int' long b = (long)a * a; System.out.println("Result without overflow by casting to long: " + b); } catch(Exception e){ System.err.println(e.getMessage()); } // Example with BigInteger for arbitrary precision arithmetic operations. import java.math.BigInteger; String bigIntStrA = ""+a; BigInteger bi_a = new BigInteger(bigIntStrA), bi_b = null; bi_b = bi_a.multiply(bi_a); System.out.println("Using BigInteger result: "+bi_b.toString()); } } ``` ### 总结 通过选用合适大小的数据类型或是借助于专门设计用于处理大规模数值的工具库如 `BigInteger` ,可以在很大程度上缓解甚至彻底消除由整数溢出引起的各种隐患。与此同时,遵循良好的编程实践原则也是预防此类问题的关键所在,比如提前做好充分测试、合理估计变量可能出现的最大值等措施均有助于提升软件系统的稳定性和可靠性[^4]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值