假阴性当使用Polyspace代码验证

18视图(30天)

显示旧的评论

HONGJUN崔 2020年5月1日

0
链接

这个问题直接联系

https://es.mathworks.com/matlabcentral/answers/522161-false-negative-when-using-polyspace-code-prover

评论道: HONGJUN崔2020年5月18日

答:接受 Anirban

这个问题被标记基督教的吟游诗人

显示标志

你好。

我是一个初学者Polyspace工具感兴趣。

在63页的Polyspace®代码验证™入门指南,代码验证说没有假阴性。

然而,由于静态分析NIST朱丽叶测试套件的一部分使用Polyspace C / c++代码验证,假阴性存在于以下CWE ID。

CWE 126(缓冲罩上)
CWE 561(死代码)
CWE 674(不受控制的递归)
CWE 835(循环与遥不可及的退出条件(无限循环))

我分析了代码,但是我问,因为我不明白为什么假阴性。

CWE的例子,561真阳性(代码验证检测它。)

空白CWE561_Dead_Code__return_before_code_01_bad ()

{

返回;

/ *缺陷:代码后返回* /

printLine (“Hello”);

}

CWE的例子561假阴性(代码验证不能检测到)

静态孔隙helperBad ()

{

printLine (“helperBad () ");

}

没有叫helperBad函数。

1评论
显示隐藏 None

马特·罗兹 2020年5月11日

嗨Hongjun,

死代码是一个非常模糊的术语。你可以有逻辑unreacheable代码(这是主要的检查代码验证)和未收功能(功能代码库中不被任何东西)。代码验证将会发现,没有假阴性, 范围内的假设提供了证据。

在这个第二个例子的例子中,你所拥有的可能是一个未调用的函数,如果它被称为在代码库的其他地方。这个实例可以指向一个不正确的行为,但是所有的代码实际上是逻辑上可及。

对于这种问题,如果它对你很重要,你是更好的启发式搜索来找到所有的情况下,字符串的函数调用。困难的方面是,不知道您的需求,是不可能知道是否故意只有一个字符串文字参照一个函数,或者有一个返回值包含在字符串。上下文可能会提供一些线索。在这个做作的例子中,我将问题的有效性证明工具,声称它发现这是死代码。

登录置评。

在回答这个问题。

接受的答案

Anirban 2020年5月7日

0
链接

直接链接到这个答案

https://es.mathworks.com/matlabcentral/answers/522161-false-negative-when-using-polyspace-code-prover answer_431071

嗨Hongjun,

对你所提供的两个具体的例子,你必须打开检查函数不叫和函数不可以。通常用户不感兴趣这两个检查,例如,因为它们是运行代码验证单位和一些功能可能未收在一个单位但最终会从另一个单位。这两个检查默认是禁用的。让他们使用这个选项。

相关的所有选项来优化代码验证检查,看到的部分检查行为和验证假设。

4评论
显示隐藏 3年长的评论

HONGJUN崔 2020年5月11日

是否可以检查误-从其他连续波?

这里的原始朱丽叶文件和必要的头文件。

https://samate.nist.gov/SARD/testsuites/juliet/Juliet_Test_Suite_v1.3_for_C_Cpp.zip

CWE 126(缓冲罩上)

                                  / *模板生成TESTCASE文件
                                 
                                  文件名:CWE126_Buffer_Overread__char_declare_memcpy_32.c
                                 
                                  标签定义文件:CWE126_Buffer_Overread.stack.label.xml
                                 
                                  模板文件:来源- - 32. tmpl.c下沉
                                 
                                  * /
                                 
                                  / *
                                 
                                  * @description
                                 
                                  * 126 (CWE:缓冲区上了
                                 
                                  * BadSource:设置数据指针指向一个小缓冲区
                                 
                                  * GoodSource:设置数据指针指向一个大型缓冲区
                                 
                                  *水槽:memcpy
                                 
                                  * BadSink:复制数据字符串使用memcpy
                                 
                                  *流变体:32个数据流使用两个指针指向相同的值在同一个函数
                                 
                                  *
                                 
                                  * * /
                                 
                                  #包括“std_testcase.h”
                                 
                                  #包括< wchar.h >
                                 
                                  #如果未定义OMITBAD
                                 
                                  无效CWE126_Buffer_Overread__char_declare_memcpy_32_bad ()
                                 
                                  {
                                 
                                  char *数据;
                                 
                                  char * * dataPtr1 =平差;
                                 
                                  char * * dataPtr2 =平差;
                                 
                                  char dataBadBuffer [50];
                                 
                                  char dataGoodBuffer [100];
                                 
                                  memset (dataBadBuffer,“一个”、博彩);/ *充满“一个”s * /
                                 
                                  博彩dataBadBuffer [] =' \ 0;/ *空终止* /
                                 
                                  memset (dataGoodBuffer,“一个”,100 - 1);/ *充满“一个”s * /
                                 
                                  dataGoodBuffer (100 - 1) =' \ 0;/ *空终止* /
                                 
                                  {
                                 
                                  char * = * dataPtr1数据;
                                 
                                  / *缺陷:设置数据指针指向一个小缓冲区* /
                                 
                                  数据= dataBadBuffer;
                                 
                                  * dataPtr1 =数据;
                                 
                                  }
                                 
                                  {
                                 
                                  char * = * dataPtr2数据;
                                 
                                  {
                                 
                                  char dest [100];
                                 
                                  memset(桌子,“C”,100 - 1);
                                 
                                  (100 - 1)=不在座位上' \ 0;/ *空终止* /
                                 
                                  / *潜在缺陷:使用memcpy与桌子的长度数据
                                 
                                  *可能小于dest造成缓冲通读* /
                                 
                                  memcpy(服务台、数据strlen(桌子)* sizeof (char));
                                 
                                  (100 - 1)=不在座位上' \ 0;
                                 
                                  printLine(桌子);
                                 
                                  }
                                 
                                  }
                                 
                                  }
                                 
                                  #endif / * OMITBAD * /
                                 
                                  #如果未定义OMITGOOD
                                 
                                  / * goodG2B()使用的GoodSource BadSink * /
                                 
                                  静态空白goodG2B ()
                                 
                                  {
                                 
                                  char *数据;
                                 
                                  char * * dataPtr1 =平差;
                                 
                                  char * * dataPtr2 =平差;
                                 
                                  char dataBadBuffer [50];
                                 
                                  char dataGoodBuffer [100];
                                 
                                  memset (dataBadBuffer,“一个”、博彩);/ *充满“一个”s * /
                                 
                                  博彩dataBadBuffer [] =' \ 0;/ *空终止* /
                                 
                                  memset (dataGoodBuffer,“一个”,100 - 1);/ *充满“一个”s * /
                                 
                                  dataGoodBuffer (100 - 1) =' \ 0;/ *空终止* /
                                 
                                  {
                                 
                                  char * = * dataPtr1数据;
                                 
                                  / *解决办法:设置数据指针指向一个大型缓冲区* /
                                 
                                  数据= dataGoodBuffer;
                                 
                                  * dataPtr1 =数据;
                                 
                                  }
                                 
                                  {
                                 
                                  char * = * dataPtr2数据;
                                 
                                  {
                                 
                                  char dest [100];
                                 
                                  memset(桌子,“C”,100 - 1);
                                 
                                  (100 - 1)=不在座位上' \ 0;/ *空终止* /
                                 
                                  / *潜在缺陷:使用memcpy与桌子的长度数据
                                 
                                  *可能小于dest造成缓冲通读* /
                                 
                                  memcpy(服务台、数据strlen(桌子)* sizeof (char));
                                 
                                  (100 - 1)=不在座位上' \ 0;
                                 
                                  printLine(桌子);
                                 
                                  }
                                 
                                  }
                                 
                                  }
                                 
                                  无效CWE126_Buffer_Overread__char_declare_memcpy_32_good ()
                                 
                                  {
                                 
                                  goodG2B ();
                                 
                                  }
                                 
                                  #endif / * OMITGOOD * /
                                 
                                  / *以下是main ()。只有构建这个testcase时使用
                                 
                                  *自己的为测试或建立一个二进制在测试中使用二进制
                                 
                                  *分析工具。它是不习惯当编译所有的测试点
                                 
                                  *应用程序,源代码分析工具进行测试。
                                 
                                  * /
                                 
                                  #如果定义了INCLUDEMAIN
                                 
                                  int主要(int命令行参数个数,char * argv [])
                                 
                                  {
                                 
                                  / *种子随机性* /
                                 
                                  将srand ((unsigned)时间(NULL));
                                 
                                  #如果未定义OMITGOOD
                                 
                                  printLine (“打电话好()……”);
                                 
                                  CWE126_Buffer_Overread__char_declare_memcpy_32_good ();
                                 
                                  printLine (“完成好()”);
                                 
                                  #endif / * OMITGOOD * /
                                 
                                  #如果未定义OMITBAD
                                 
                                  printLine (“叫坏()……”);
                                 
                                  CWE126_Buffer_Overread__char_declare_memcpy_32_bad ();
                                 
                                  printLine (“完成坏()”);
                                 
                                  #endif / * OMITBAD * /
                                 
                                  返回0;
                                 
                                  }
                                 
                                  #endif

CWE 674(不受控制的递归)

                                  / *
                                 
                                  * @description不受控制递归
                                 
                                  *
                                 
                                  * * /
                                 
                                  #包括“std_testcase.h”
                                 
                                  #如果未定义OMITBAD
                                 
                                  静态空白helperBad(无符号级别)
                                 
                                  {
                                 
                                  / *缺陷:虽然这不能引起“无限”递归,UINT_MAX本质上是有限的
                                 
                                  *在大多数系统相当大* /
                                 
                                  如果(要求等级= = 0)
                                 
                                  {
                                 
                                  返回;
                                 
                                  }
                                 
                                  helperBad(- 1)水平;
                                 
                                  }
                                 
                                  无效CWE674_Uncontrolled_Recursion__unbounded_recursive_call_01_bad ()
                                 
                                  {
                                 
                                  helperBad (UINT_MAX);
                                 
                                  }
                                 
                                  #endif / * OMITBAD * /
                                 
                                  #如果未定义OMITGOOD
                                 
                                  #定义MAX_RECURSION10
                                 
                                  静态空白helperGood(无符号级别)
                                 
                                  {
                                 
                                  / *修复:限制递归到一个正常水平* /
                                 
                                  如果(水平> MAX_RECURSION)
                                 
                                  {
                                 
                                  printLine (“递归错误”);
                                 
                                  返回;
                                 
                                  }
                                 
                                  如果(要求等级= = 0)
                                 
                                  {
                                 
                                  返回;
                                 
                                  }
                                 
                                  helperGood(- 1)水平;
                                 
                                  }
                                 
                                  静态空白good1 ()
                                 
                                  {
                                 
                                  helperGood (UINT_MAX);
                                 
                                  }
                                 
                                  无效CWE674_Uncontrolled_Recursion__unbounded_recursive_call_01_good ()
                                 
                                  {
                                 
                                  good1 ();
                                 
                                  }
                                 
                                  #endif / * OMITGOOD * /
                                 
                                  / *以下是main ()。只有构建这个testcase时使用
                                 
                                  *自己的为测试或建立一个二进制在测试中使用二进制
                                 
                                  *分析工具。它是不习惯当编译所有的测试点
                                 
                                  *应用程序,源代码分析工具进行测试。
                                 
                                  * /
                                 
                                  #如果定义了INCLUDEMAIN
                                 
                                  int主要(int命令行参数个数,char * argv [])
                                 
                                  {
                                 
                                  / *种子随机性* /
                                 
                                  将srand ((unsigned)时间(NULL));
                                 
                                  #如果未定义OMITGOOD
                                 
                                  printLine (“打电话好()……”);
                                 
                                  CWE674_Uncontrolled_Recursion__unbounded_recursive_call_01_good ();
                                 
                                  printLine (“完成好()”);
                                 
                                  #endif / * OMITGOOD * /
                                 
                                  #如果未定义OMITBAD
                                 
                                  printLine (“叫坏()……”);
                                 
                                  CWE674_Uncontrolled_Recursion__unbounded_recursive_call_01_bad ();
                                 
                                  printLine (“完成坏()”);
                                 
                                  #endif / * OMITBAD * /
                                 
                                  返回0;
                                 
                                  }
                                 
                                  #endif

CWE 835(循环与遥不可及的退出条件(无限循环))

                                  / *
                                 
                                  * @description无限循环——做. .而()
                                 
                                  *
                                 
                                  * * /
                                 
                                  #包括“std_testcase.h”
                                 
                                  #如果未定义OMITBAD
                                 
                                  无效CWE835_Infinite_Loop__do_true_01_bad ()
                                 
                                  {
                                 
                                  int i = 0;
                                 
                                  / *缺陷:无限循环,做. .而(真正的)没有断点* /
                                 
                                  做
                                 
                                  {
                                 
                                  printIntLine(我);
                                 
                                  我+ +;
                                 
                                  }而(1);
                                 
                                  }
                                 
                                  #endif / * OMITBAD * /
                                 
                                  #如果未定义OMITGOOD
                                 
                                  静态空白good1 ()
                                 
                                  {
                                 
                                  int i = 0;
                                 
                                  做
                                 
                                  {
                                 
                                  / *修复:添加一个打破点如果我= 10 * /的循环
                                 
                                  如果(我= = 10)
                                 
                                  {
                                 
                                  打破;
                                 
                                  }
                                 
                                  printIntLine(我);
                                 
                                  我+ +;
                                 
                                  }而(1);
                                 
                                  }
                                 
                                  无效CWE835_Infinite_Loop__do_true_01_good ()
                                 
                                  {
                                 
                                  good1 ();
                                 
                                  }
                                 
                                  #endif / * OMITGOOD * /
                                 
                                  / *以下是main ()。只有构建这个testcase时使用
                                 
                                  *自己的为测试或建立一个二进制在测试中使用二进制
                                 
                                  *分析工具。它是不习惯当编译所有的测试点
                                 
                                  *应用程序,源代码分析工具进行测试。
                                 
                                  * /
                                 
                                  #如果定义了INCLUDEMAIN
                                 
                                  int主要(int命令行参数个数,char * argv [])
                                 
                                  {
                                 
                                  / *种子随机性* /
                                 
                                  将srand ((unsigned)时间(NULL));
                                 
                                  #如果未定义OMITGOOD
                                 
                                  printLine (“打电话好()……”);
                                 
                                  CWE835_Infinite_Loop__do_true_01_good ();
                                 
                                  printLine (“完成好()”);
                                 
                                  #endif / * OMITGOOD * /
                                 
                                  #如果未定义OMITBAD
                                 
                                  printLine (“叫坏()……”);
                                 
                                  CWE835_Infinite_Loop__do_true_01_bad ();
                                 
                                  printLine (“完成坏()”);
                                 
                                  #endif / * OMITBAD * /
                                 
                                  返回0;
                                 
                                  }
                                 
                                  #endif

Anirban 2020年5月11日

编辑:Anirban 2020年5月11日

嗨Hongjun,

抱歉我之前回答的不完整。代码验证确实需要一些设置,那么这些代码片段本身不会触发你期望的结果。在我解释之前,让我再给你一个建议。

既然你有代码验证,你也有缺陷者。所以,如果你运行错误发现者后启用所有检查使用的选项发现缺陷(检查) ,您应该看到你期待看到的问题。没有其他的设置应该是必要的。错误发现者是CWE的工具推荐,部分原因是它的简单。看到更多的细节 CWE编码标准和Polyspace结果。

代码验证还将检测的问题。因为代码验证更详尽,很可能没有假阴性在更复杂的场景中(不仅仅是简单的测试)。但是需要注意的是代码验证需要一些您的初始设置工作。

原始问题的两个具体的例子,如果你想使用代码验证,除了使选择检测未缴和遥不可及的功能,你也必须调整所谓主发电机的选择 ,具体选择 -main-generator-calls 。获得详尽的证明对于一个完整的应用程序,从代码验证分析主要然后调用树。如果你没有一个完整的应用程序,因此没有一个主要 ,代码验证生成一个。默认情况下,生成的主要调用函数都不叫在代码的任何地方提供给Polyspace。因为生成的主要调用 helperBad ,这不是视为未交。为了解决这个问题,您必须显式地指定在安装过程中生成的主要创建(或提供一个吗主要你自己)。我做了以下。这段代码:

                                  无效CWE561_Dead_Code__return_before_code_01_bad ()
                                 
                                  {
                                 
                                  返回;
                                 
                                  / /缺陷:代码之后“返回”
                                 
                                  printLine (“你好”);
                                 
                                  }
                                 
                                  无效printLine (char * str) {
                                 
                                  }
                                 
                                  静态空白helperBad ()
                                 
                                  {
                                 
                                  printLine (“helperBad ()”);
                                 
                                  }

我跑的代码验证使用这些选项:

                                  主发电机-main-generator-calls定制= CWE561_Dead_Code__return_before_code_01_bad未交函数检查所有
                                 

我看到预期的结果。如果您正在使用图形用户界面,你可以算出等效选项从上面的链接。我还发现预期的使用错误发现者通过启用所有检查的问题。

至于你的更大的问题的NIST朱丽叶对C / c++测试套件,请联系 MathWorks技术支持万博1manbetx 。我相信他们有运行该工具在这个测试套件,可以与你讨论所有的情况下。

HONGJUN崔 2020年5月18日

嗨Anirban,

对不起我没看到它是由不指定主函数入口点。

谢谢你的解释!

登录置评。

类别

代码验证 Polyspace代码验证开始使用Polyspace代码验证

验证、验证和测试 Polyspace代码验证开始使用Polyspace代码验证

找到更多的在开始使用Polyspace代码验证在帮助中心和文件交换

s manbetx 845

Polyspace代码验证

释放

R2020a

社区寻宝

找到宝藏在MATLAB中央,发现社区如何帮助你!

开始狩猎!

翻译的

假阴性当使用Polyspace代码验证

1评论
显示隐藏 None

接受的答案

4评论
显示隐藏 3年长的评论

更多的答案(0)

另请参阅

类别

标签

s manbetx 845

释放

社区寻宝

假阴性当使用Polyspace代码验证

1评论 显示隐藏 None

接受的答案

4评论 显示隐藏 3年长的评论

更多的答案(0)

另请参阅

类别

标签

s manbetx 845

释放

社区寻宝

1评论
显示隐藏 None

4评论
显示隐藏 3年长的评论