[{"data":1,"prerenderedAt":4054},["ShallowReactive",2],{"global-navigation":3,"page-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl55-cpp":28,"surround-\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl55-cpp":3347,"sidebar-sei-cert-cpp-coding-standard":3354},[4,8],{"title":5,"path":6,"_path":6,"fromAppConfig":7},"Home","\u002F",true,{"title":9,"path":10,"children":11,"_path":27,"fromAppConfig":7},"Coding Standards","\u002Fcoding-standards\u002F",[12,15,18,21,24],{"title":13,"path":14},"Android Coding Standard","\u002Fandroid-secure-coding-standard\u002F",{"title":16,"path":17},"C Coding Standard","\u002Fsei-cert-c-coding-standard\u002F",{"title":19,"path":20},"C++ Coding Standard","\u002Fsei-cert-cpp-coding-standard\u002F",{"title":22,"path":23},"Java Coding Standard","\u002Fsei-cert-oracle-coding-standard-for-java\u002F",{"title":25,"path":26},"Perl Coding Standard","\u002Fsei-cert-perl-coding-standard\u002F","\u002Fcoding-standards",{"id":29,"title":30,"body":31,"description":3331,"extension":3332,"meta":3333,"navigation":7,"path":3343,"seo":3344,"stem":3345,"__hash__":3346},"content\u002F5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F07.dcl55-cpp.md","DCL55-CPP. Avoid information leakage when passing a class object across a trust boundary",{"type":32,"value":33,"toc":3317},"minimark",[34,38,48,54,57,62,70,78,83,91,309,312,333,518,528,532,535,855,862,866,869,1196,1211,1214,1217,1242,1248,1687,1698,1956,1959,1962,2915,2920,2924,2927,2988,2992,3158,3163,3166,3183,3199,3211,3224,3228,3253,3257,3291,3313],[35,36,30],"h1",{"id":37},"dcl55-cpp-avoid-information-leakage-when-passing-a-class-object-across-a-trust-boundary",[39,40,41,42,47],"p",{},"The C++ Standard, [class.mem], paragraph 13 [ ",[43,44,46],"a",{"href":45},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography#AA.Bibliography-ISO\u002FIEC14882-2014","ISO\u002FIEC 14882-2014"," ], describes the layout of non-static data members of a non-union class, specifying the following:",[49,50,51],"blockquote",{},[39,52,53],{},"Nonstatic data members of a (non-union) class with the same access control are allocated so that later members have higher addresses within a class object. The order of allocation of non-static data members with different access control is unspecified. Implementation alignment requirements might cause two adjacent members not to be allocated immediately after each other; so might requirements for space for managing virtual functions and virtual base classes.",[39,55,56],{},"Further, [class.bit], paragraph 1, in part, states the following:",[49,58,59],{},[39,60,61],{},"Allocation of bit-fields within a class object is implementation-defined. Alignment of bit-fields is implementation-defined. Bit-fields are packed into some addressable allocation unit.",[39,63,64,65,69],{},"Thus, padding bits may be present at any location within a class object instance (including at the beginning of the object, in the case of an unnamed bit-field as the first member declared in a class). Unless initialized by zero-initialization, padding bits contain ",[43,66,68],{"href":67},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-indeterminatevalue","indeterminate values"," that may contain sensitive information.",[39,71,72,73,77],{},"When passing a pointer to a class object instance across a ",[43,74,76],{"href":75},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-trustboundary","trust boundary"," to a different trusted domain, the programmer must ensure that the padding bits of such an object do not contain sensitive information.",[79,80,82],"h2",{"id":81},"noncompliant-code-example","Noncompliant Code Example",[39,84,85,86,90],{},"This noncompliant code example runs in kernel space and copies data from ",[87,88,89],"code",{},"arg"," to user space. However, padding bits may be used within the object, for example, to ensure the proper alignment of class data members. These padding bits may contain sensitive information that may then be leaked when the data is copied to user space, regardless of how the data is copied.",[92,93,95],"code-block",{"quality":94},"bad",[96,97,102],"pre",{"className":98,"code":99,"language":100,"meta":101,"style":101},"language-cpp shiki shiki-themes github-light github-dark monokai","#include \u003Ccstddef>\n \nstruct test {\n  int a;\n  char b;\n  int c;\n};\n \n\u002F\u002F Safely copy bytes to user space\nextern int copy_to_user(void *dest, void *src, std::size_t size);\n \nvoid do_stuff(void *usr_buf) {\n  test arg{1, 2, 3};\n  copy_to_user(usr_buf, &arg, sizeof(arg));\n}\n","cpp","",[87,103,104,117,124,138,147,156,164,170,175,182,235,240,260,282,303],{"__ignoreMap":101},[105,106,109,113],"span",{"class":107,"line":108},"line",1,[105,110,112],{"class":111},"sC2Qs","#include",[105,114,116],{"class":115},"sstjo"," \u003Ccstddef>\n",[105,118,120],{"class":107,"line":119},2,[105,121,123],{"class":122},"sMOD_"," \n",[105,125,127,131,135],{"class":107,"line":126},3,[105,128,130],{"class":129},"sq6CD","struct",[105,132,134],{"class":133},"sz2Vg"," test",[105,136,137],{"class":122}," {\n",[105,139,141,144],{"class":107,"line":140},4,[105,142,143],{"class":129},"  int",[105,145,146],{"class":122}," a;\n",[105,148,150,153],{"class":107,"line":149},5,[105,151,152],{"class":129},"  char",[105,154,155],{"class":122}," b;\n",[105,157,159,161],{"class":107,"line":158},6,[105,160,143],{"class":129},[105,162,163],{"class":122}," c;\n",[105,165,167],{"class":107,"line":166},7,[105,168,169],{"class":122},"};\n",[105,171,173],{"class":107,"line":172},8,[105,174,123],{"class":122},[105,176,178],{"class":107,"line":177},9,[105,179,181],{"class":180},"s8-w5","\u002F\u002F Safely copy bytes to user space\n",[105,183,185,188,191,195,198,201,204,208,211,213,215,218,220,223,226,229,232],{"class":107,"line":184},10,[105,186,187],{"class":111},"extern",[105,189,190],{"class":129}," int",[105,192,194],{"class":193},"srTi1"," copy_to_user",[105,196,197],{"class":122},"(",[105,199,200],{"class":129},"void",[105,202,203],{"class":111}," *",[105,205,207],{"class":206},"sTHNf","dest",[105,209,210],{"class":122},", ",[105,212,200],{"class":129},[105,214,203],{"class":111},[105,216,217],{"class":206},"src",[105,219,210],{"class":122},[105,221,222],{"class":133},"std",[105,224,225],{"class":122},"::",[105,227,228],{"class":129},"size_t",[105,230,231],{"class":206}," size",[105,233,234],{"class":122},");\n",[105,236,238],{"class":107,"line":237},11,[105,239,123],{"class":122},[105,241,243,245,248,250,252,254,257],{"class":107,"line":242},12,[105,244,200],{"class":129},[105,246,247],{"class":193}," do_stuff",[105,249,197],{"class":122},[105,251,200],{"class":129},[105,253,203],{"class":111},[105,255,256],{"class":206},"usr_buf",[105,258,259],{"class":122},") {\n",[105,261,263,266,270,272,275,277,280],{"class":107,"line":262},13,[105,264,265],{"class":122},"  test arg{",[105,267,269],{"class":268},"s7F3e","1",[105,271,210],{"class":122},[105,273,274],{"class":268},"2",[105,276,210],{"class":122},[105,278,279],{"class":268},"3",[105,281,169],{"class":122},[105,283,285,288,291,294,297,300],{"class":107,"line":284},14,[105,286,287],{"class":193},"  copy_to_user",[105,289,290],{"class":122},"(usr_buf, ",[105,292,293],{"class":111},"&",[105,295,296],{"class":122},"arg, ",[105,298,299],{"class":111},"sizeof",[105,301,302],{"class":122},"(arg));\n",[105,304,306],{"class":107,"line":305},15,[105,307,308],{"class":122},"}\n",[79,310,82],{"id":311},"noncompliant-code-example-1",[39,313,314,315,317,318,321,322,325,326,329,330,332],{},"In this noncompliant code example, ",[87,316,89],{}," is value-initialized through direct initialization. Because ",[87,319,320],{},"test"," does not have a user-provided default constructor, the value-initialization is preceded by a zero-initialization that guarantees the padding bits are initialized to ",[87,323,324],{},"0"," before any further initialization occurs. It is akin to using ",[87,327,328],{},"std::memset()"," to initialize all of the bits in the object to ",[87,331,324],{}," .",[92,334,335],{"quality":94},[96,336,338],{"className":98,"code":337,"language":100,"meta":101,"style":101},"#include \u003Ccstddef>\n \nstruct test {\n  int a;\n  char b;\n  int c;\n};\n \n\u002F\u002F Safely copy bytes to user space\nextern int copy_to_user(void *dest, void *src, std::size_t size);\n \nvoid do_stuff(void *usr_buf) {\n  test arg{};\n \n  arg.a = 1;\n  arg.b = 2;\n  arg.c = 3;\n \n  copy_to_user(usr_buf, &arg, sizeof(arg));\n}\n",[87,339,340,346,350,358,364,370,376,380,384,388,424,428,444,449,453,467,480,493,498,513],{"__ignoreMap":101},[105,341,342,344],{"class":107,"line":108},[105,343,112],{"class":111},[105,345,116],{"class":115},[105,347,348],{"class":107,"line":119},[105,349,123],{"class":122},[105,351,352,354,356],{"class":107,"line":126},[105,353,130],{"class":129},[105,355,134],{"class":133},[105,357,137],{"class":122},[105,359,360,362],{"class":107,"line":140},[105,361,143],{"class":129},[105,363,146],{"class":122},[105,365,366,368],{"class":107,"line":149},[105,367,152],{"class":129},[105,369,155],{"class":122},[105,371,372,374],{"class":107,"line":158},[105,373,143],{"class":129},[105,375,163],{"class":122},[105,377,378],{"class":107,"line":166},[105,379,169],{"class":122},[105,381,382],{"class":107,"line":172},[105,383,123],{"class":122},[105,385,386],{"class":107,"line":177},[105,387,181],{"class":180},[105,389,390,392,394,396,398,400,402,404,406,408,410,412,414,416,418,420,422],{"class":107,"line":184},[105,391,187],{"class":111},[105,393,190],{"class":129},[105,395,194],{"class":193},[105,397,197],{"class":122},[105,399,200],{"class":129},[105,401,203],{"class":111},[105,403,207],{"class":206},[105,405,210],{"class":122},[105,407,200],{"class":129},[105,409,203],{"class":111},[105,411,217],{"class":206},[105,413,210],{"class":122},[105,415,222],{"class":133},[105,417,225],{"class":122},[105,419,228],{"class":129},[105,421,231],{"class":206},[105,423,234],{"class":122},[105,425,426],{"class":107,"line":237},[105,427,123],{"class":122},[105,429,430,432,434,436,438,440,442],{"class":107,"line":242},[105,431,200],{"class":129},[105,433,247],{"class":193},[105,435,197],{"class":122},[105,437,200],{"class":129},[105,439,203],{"class":111},[105,441,256],{"class":206},[105,443,259],{"class":122},[105,445,446],{"class":107,"line":262},[105,447,448],{"class":122},"  test arg{};\n",[105,450,451],{"class":107,"line":284},[105,452,123],{"class":122},[105,454,455,458,461,464],{"class":107,"line":305},[105,456,457],{"class":122},"  arg.a ",[105,459,460],{"class":111},"=",[105,462,463],{"class":268}," 1",[105,465,466],{"class":122},";\n",[105,468,470,473,475,478],{"class":107,"line":469},16,[105,471,472],{"class":122},"  arg.b ",[105,474,460],{"class":111},[105,476,477],{"class":268}," 2",[105,479,466],{"class":122},[105,481,483,486,488,491],{"class":107,"line":482},17,[105,484,485],{"class":122},"  arg.c ",[105,487,460],{"class":111},[105,489,490],{"class":268}," 3",[105,492,466],{"class":122},[105,494,496],{"class":107,"line":495},18,[105,497,123],{"class":122},[105,499,501,503,505,507,509,511],{"class":107,"line":500},19,[105,502,287],{"class":193},[105,504,290],{"class":122},[105,506,293],{"class":111},[105,508,296],{"class":122},[105,510,299],{"class":111},[105,512,302],{"class":122},[105,514,516],{"class":107,"line":515},20,[105,517,308],{"class":122},[39,519,520,521,524,525,527],{},"However, compilers are free to implement ",[87,522,523],{},"  arg.b = 2 "," by setting the low byte of a 32-bit register to ",[87,526,274],{}," , leaving the high bytes unchanged, and storing all 32 bits of the register into memory. This could leak the high-order bytes resident in the register to a user.",[79,529,531],{"id":530},"compliant-solution","Compliant Solution",[39,533,534],{},"This compliant solution serializes the structure data before copying it to an untrusted context.",[92,536,538],{"quality":537},"good",[96,539,541],{"className":98,"code":540,"language":100,"meta":101,"style":101},"#include \u003Ccstddef>\n#include \u003Ccstring>\n \nstruct test {\n  int a;\n  char b;\n  int c;\n};\n \n\u002F\u002F Safely copy bytes to user space.\nextern int copy_to_user(void *dest, void *src, std::size_t size);\n \nvoid do_stuff(void *usr_buf) {\n  test arg{1, 2, 3};\n  \u002F\u002F May be larger than strictly needed.\n  unsigned char buf[sizeof(arg)];\n  std::size_t offset = 0;\n \n  std::memcpy(buf + offset, &arg.a, sizeof(arg.a));\n  offset += sizeof(arg.a);\n  std::memcpy(buf + offset, &arg.b, sizeof(arg.b));\n  offset += sizeof(arg.b);\n  std::memcpy(buf + offset, &arg.c, sizeof(arg.c));\n  offset += sizeof(arg.c);\n \n  copy_to_user(usr_buf, buf, offset \u002F* size of info copied *\u002F);\n}\n",[87,542,543,549,556,561,569,575,581,587,591,595,600,636,640,656,672,677,693,712,716,744,758,783,795,820,832,837,850],{"__ignoreMap":101},[105,544,545,547],{"class":107,"line":108},[105,546,112],{"class":111},[105,548,116],{"class":115},[105,550,551,553],{"class":107,"line":119},[105,552,112],{"class":111},[105,554,555],{"class":115}," \u003Ccstring>\n",[105,557,558],{"class":107,"line":126},[105,559,560],{"class":122}," \n",[105,562,563,565,567],{"class":107,"line":140},[105,564,130],{"class":129},[105,566,134],{"class":133},[105,568,137],{"class":122},[105,570,571,573],{"class":107,"line":149},[105,572,143],{"class":129},[105,574,146],{"class":122},[105,576,577,579],{"class":107,"line":158},[105,578,152],{"class":129},[105,580,155],{"class":122},[105,582,583,585],{"class":107,"line":166},[105,584,143],{"class":129},[105,586,163],{"class":122},[105,588,589],{"class":107,"line":172},[105,590,169],{"class":122},[105,592,593],{"class":107,"line":177},[105,594,560],{"class":122},[105,596,597],{"class":107,"line":184},[105,598,599],{"class":180},"\u002F\u002F Safely copy bytes to user space.\n",[105,601,602,604,606,608,610,612,614,616,618,620,622,624,626,628,630,632,634],{"class":107,"line":237},[105,603,187],{"class":111},[105,605,190],{"class":129},[105,607,194],{"class":193},[105,609,197],{"class":122},[105,611,200],{"class":129},[105,613,203],{"class":111},[105,615,207],{"class":206},[105,617,210],{"class":122},[105,619,200],{"class":129},[105,621,203],{"class":111},[105,623,217],{"class":206},[105,625,210],{"class":122},[105,627,222],{"class":133},[105,629,225],{"class":122},[105,631,228],{"class":129},[105,633,231],{"class":206},[105,635,234],{"class":122},[105,637,638],{"class":107,"line":242},[105,639,560],{"class":122},[105,641,642,644,646,648,650,652,654],{"class":107,"line":262},[105,643,200],{"class":129},[105,645,247],{"class":193},[105,647,197],{"class":122},[105,649,200],{"class":129},[105,651,203],{"class":111},[105,653,256],{"class":206},[105,655,259],{"class":122},[105,657,658,660,662,664,666,668,670],{"class":107,"line":284},[105,659,265],{"class":122},[105,661,269],{"class":268},[105,663,210],{"class":122},[105,665,274],{"class":268},[105,667,210],{"class":122},[105,669,279],{"class":268},[105,671,169],{"class":122},[105,673,674],{"class":107,"line":305},[105,675,676],{"class":180},"  \u002F\u002F May be larger than strictly needed.\n",[105,678,679,682,685,688,690],{"class":107,"line":469},[105,680,681],{"class":129},"  unsigned",[105,683,684],{"class":129}," char",[105,686,687],{"class":122}," buf[",[105,689,299],{"class":111},[105,691,692],{"class":122},"(arg)];\n",[105,694,695,698,700,702,705,707,710],{"class":107,"line":482},[105,696,697],{"class":133},"  std",[105,699,225],{"class":122},[105,701,228],{"class":129},[105,703,704],{"class":122}," offset ",[105,706,460],{"class":111},[105,708,709],{"class":268}," 0",[105,711,466],{"class":122},[105,713,714],{"class":107,"line":495},[105,715,560],{"class":122},[105,717,718,720,722,725,728,731,734,736,739,741],{"class":107,"line":500},[105,719,697],{"class":133},[105,721,225],{"class":122},[105,723,724],{"class":193},"memcpy",[105,726,727],{"class":122},"(buf ",[105,729,730],{"class":111},"+",[105,732,733],{"class":122}," offset, ",[105,735,293],{"class":111},[105,737,738],{"class":122},"arg.a, ",[105,740,299],{"class":111},[105,742,743],{"class":122},"(arg.a));\n",[105,745,746,749,752,755],{"class":107,"line":515},[105,747,748],{"class":122},"  offset ",[105,750,751],{"class":111},"+=",[105,753,754],{"class":111}," sizeof",[105,756,757],{"class":122},"(arg.a);\n",[105,759,761,763,765,767,769,771,773,775,778,780],{"class":107,"line":760},21,[105,762,697],{"class":133},[105,764,225],{"class":122},[105,766,724],{"class":193},[105,768,727],{"class":122},[105,770,730],{"class":111},[105,772,733],{"class":122},[105,774,293],{"class":111},[105,776,777],{"class":122},"arg.b, ",[105,779,299],{"class":111},[105,781,782],{"class":122},"(arg.b));\n",[105,784,786,788,790,792],{"class":107,"line":785},22,[105,787,748],{"class":122},[105,789,751],{"class":111},[105,791,754],{"class":111},[105,793,794],{"class":122},"(arg.b);\n",[105,796,798,800,802,804,806,808,810,812,815,817],{"class":107,"line":797},23,[105,799,697],{"class":133},[105,801,225],{"class":122},[105,803,724],{"class":193},[105,805,727],{"class":122},[105,807,730],{"class":111},[105,809,733],{"class":122},[105,811,293],{"class":111},[105,813,814],{"class":122},"arg.c, ",[105,816,299],{"class":111},[105,818,819],{"class":122},"(arg.c));\n",[105,821,823,825,827,829],{"class":107,"line":822},24,[105,824,748],{"class":122},[105,826,751],{"class":111},[105,828,754],{"class":111},[105,830,831],{"class":122},"(arg.c);\n",[105,833,835],{"class":107,"line":834},25,[105,836,560],{"class":122},[105,838,840,842,845,848],{"class":107,"line":839},26,[105,841,287],{"class":193},[105,843,844],{"class":122},"(usr_buf, buf, offset",[105,846,847],{"class":180}," \u002F* size of info copied *\u002F",[105,849,234],{"class":122},[105,851,853],{"class":107,"line":852},27,[105,854,308],{"class":122},[39,856,857,858,861],{},"This code ensures that no uninitialized padding bits are copied to unprivileged users. The structure copied to user space is now a packed structure and the ",[87,859,860],{},"copy_to_user()"," function would need to unpack it to recreate the original, padded structure.",[79,863,865],{"id":864},"compliant-solution-padding-bytes","Compliant Solution (Padding Bytes)",[39,867,868],{},"Padding bits can be explicitly declared as fields within the structure. This solution is not portable, however, because it depends on the implementation and target memory architecture. The following solution is specific to the x86-32 architecture.",[92,870,871],{"quality":537},[96,872,874],{"className":98,"code":873,"language":100,"meta":101,"style":101},"#include \u003Ccstddef>\n\nstruct test {\n  int a;\n  char b;\n  char padding_1, padding_2, padding_3;\n  int c;\n \n  test(int a, char b, int c) : a(a), b(b),\n    padding_1(0), padding_2(0), padding_3(0),\n    c(c) {}\n};\n\u002F\u002F Ensure c is the next byte after the last padding byte.\nstatic_assert(offsetof(test, c) == offsetof(test, padding_3) + 1,\n              \"Object contains intermediate padding\");\n\u002F\u002F Ensure there is no trailing padding.\nstatic_assert(sizeof(test) == offsetof(test, c) + sizeof(int),\n              \"Object contains trailing padding\");\n\n\n\n\u002F\u002F Safely copy bytes to user space.\nextern int copy_to_user(void *dest, void *src, std::size_t size);\n\nvoid do_stuff(void *usr_buf) {\n  test arg{1, 2, 3};\n  copy_to_user(usr_buf, &arg, sizeof(arg));\n}\n",[87,875,876,882,887,895,901,907,914,920,924,966,997,1005,1009,1014,1043,1050,1055,1082,1089,1093,1097,1101,1105,1141,1145,1161,1177,1191],{"__ignoreMap":101},[105,877,878,880],{"class":107,"line":108},[105,879,112],{"class":111},[105,881,116],{"class":115},[105,883,884],{"class":107,"line":119},[105,885,886],{"emptyLinePlaceholder":7},"\n",[105,888,889,891,893],{"class":107,"line":126},[105,890,130],{"class":129},[105,892,134],{"class":133},[105,894,137],{"class":122},[105,896,897,899],{"class":107,"line":140},[105,898,143],{"class":129},[105,900,146],{"class":122},[105,902,903,905],{"class":107,"line":149},[105,904,152],{"class":129},[105,906,155],{"class":122},[105,908,909,911],{"class":107,"line":158},[105,910,152],{"class":129},[105,912,913],{"class":122}," padding_1, padding_2, padding_3;\n",[105,915,916,918],{"class":107,"line":166},[105,917,143],{"class":129},[105,919,163],{"class":122},[105,921,922],{"class":107,"line":172},[105,923,123],{"class":122},[105,925,926,929,931,934,937,939,942,945,947,949,952,955,957,960,963],{"class":107,"line":177},[105,927,928],{"class":193},"  test",[105,930,197],{"class":122},[105,932,933],{"class":129},"int",[105,935,936],{"class":206}," a",[105,938,210],{"class":122},[105,940,941],{"class":129},"char",[105,943,944],{"class":206}," b",[105,946,210],{"class":122},[105,948,933],{"class":129},[105,950,951],{"class":206}," c",[105,953,954],{"class":122},") : ",[105,956,43],{"class":193},[105,958,959],{"class":122},"(a), ",[105,961,962],{"class":193},"b",[105,964,965],{"class":122},"(b),\n",[105,967,968,971,973,975,978,981,983,985,987,990,992,994],{"class":107,"line":184},[105,969,970],{"class":193},"    padding_1",[105,972,197],{"class":122},[105,974,324],{"class":268},[105,976,977],{"class":122},"), ",[105,979,980],{"class":193},"padding_2",[105,982,197],{"class":122},[105,984,324],{"class":268},[105,986,977],{"class":122},[105,988,989],{"class":193},"padding_3",[105,991,197],{"class":122},[105,993,324],{"class":268},[105,995,996],{"class":122},"),\n",[105,998,999,1002],{"class":107,"line":237},[105,1000,1001],{"class":193},"    c",[105,1003,1004],{"class":122},"(c) {}\n",[105,1006,1007],{"class":107,"line":242},[105,1008,169],{"class":122},[105,1010,1011],{"class":107,"line":262},[105,1012,1013],{"class":180},"\u002F\u002F Ensure c is the next byte after the last padding byte.\n",[105,1015,1016,1019,1021,1024,1027,1030,1033,1036,1038,1040],{"class":107,"line":284},[105,1017,1018],{"class":111},"static_assert",[105,1020,197],{"class":122},[105,1022,1023],{"class":193},"offsetof",[105,1025,1026],{"class":122},"(test, c) ",[105,1028,1029],{"class":111},"==",[105,1031,1032],{"class":193}," offsetof",[105,1034,1035],{"class":122},"(test, padding_3) ",[105,1037,730],{"class":111},[105,1039,463],{"class":268},[105,1041,1042],{"class":122},",\n",[105,1044,1045,1048],{"class":107,"line":305},[105,1046,1047],{"class":115},"              \"Object contains intermediate padding\"",[105,1049,234],{"class":122},[105,1051,1052],{"class":107,"line":469},[105,1053,1054],{"class":180},"\u002F\u002F Ensure there is no trailing padding.\n",[105,1056,1057,1059,1061,1063,1066,1068,1070,1072,1074,1076,1078,1080],{"class":107,"line":482},[105,1058,1018],{"class":111},[105,1060,197],{"class":122},[105,1062,299],{"class":111},[105,1064,1065],{"class":122},"(test) ",[105,1067,1029],{"class":111},[105,1069,1032],{"class":193},[105,1071,1026],{"class":122},[105,1073,730],{"class":111},[105,1075,754],{"class":111},[105,1077,197],{"class":122},[105,1079,933],{"class":129},[105,1081,996],{"class":122},[105,1083,1084,1087],{"class":107,"line":495},[105,1085,1086],{"class":115},"              \"Object contains trailing padding\"",[105,1088,234],{"class":122},[105,1090,1091],{"class":107,"line":500},[105,1092,886],{"emptyLinePlaceholder":7},[105,1094,1095],{"class":107,"line":515},[105,1096,886],{"emptyLinePlaceholder":7},[105,1098,1099],{"class":107,"line":760},[105,1100,886],{"emptyLinePlaceholder":7},[105,1102,1103],{"class":107,"line":785},[105,1104,599],{"class":180},[105,1106,1107,1109,1111,1113,1115,1117,1119,1121,1123,1125,1127,1129,1131,1133,1135,1137,1139],{"class":107,"line":797},[105,1108,187],{"class":111},[105,1110,190],{"class":129},[105,1112,194],{"class":193},[105,1114,197],{"class":122},[105,1116,200],{"class":129},[105,1118,203],{"class":111},[105,1120,207],{"class":206},[105,1122,210],{"class":122},[105,1124,200],{"class":129},[105,1126,203],{"class":111},[105,1128,217],{"class":206},[105,1130,210],{"class":122},[105,1132,222],{"class":133},[105,1134,225],{"class":122},[105,1136,228],{"class":129},[105,1138,231],{"class":206},[105,1140,234],{"class":122},[105,1142,1143],{"class":107,"line":822},[105,1144,886],{"emptyLinePlaceholder":7},[105,1146,1147,1149,1151,1153,1155,1157,1159],{"class":107,"line":834},[105,1148,200],{"class":129},[105,1150,247],{"class":193},[105,1152,197],{"class":122},[105,1154,200],{"class":129},[105,1156,203],{"class":111},[105,1158,256],{"class":206},[105,1160,259],{"class":122},[105,1162,1163,1165,1167,1169,1171,1173,1175],{"class":107,"line":839},[105,1164,265],{"class":122},[105,1166,269],{"class":268},[105,1168,210],{"class":122},[105,1170,274],{"class":268},[105,1172,210],{"class":122},[105,1174,279],{"class":268},[105,1176,169],{"class":122},[105,1178,1179,1181,1183,1185,1187,1189],{"class":107,"line":852},[105,1180,287],{"class":193},[105,1182,290],{"class":122},[105,1184,293],{"class":111},[105,1186,296],{"class":122},[105,1188,299],{"class":111},[105,1190,302],{"class":122},[105,1192,1194],{"class":107,"line":1193},28,[105,1195,308],{"class":122},[39,1197,1198,1199,1202,1203,1207,1208,1210],{},"The ",[87,1200,1201],{},"static_assert()"," declaration accepts a constant expression and an ",[43,1204,1206],{"href":1205},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-error","error message"," . The expression is evaluated at compile time and, if false, the compilation is terminated and the error message is used as the diagnostic. The explicit insertion of the padding bytes into the ",[87,1209,130],{}," should ensure that no additional padding bytes are added by the compiler, and consequently both static assertions should be true. However, it is necessary to validate these assumptions to ensure that the solution is correct for a particular implementation.",[79,1212,82],{"id":1213},"noncompliant-code-example-2",[39,1215,1216],{},"In this noncompliant code example, padding bits may abound, including",[1218,1219,1220,1224,1227,1230,1233,1236,1239],"ul",{},[1221,1222,1223],"li",{},"alignment padding bits after a virtual method table or virtual base class data to align a subsequent data member,",[1221,1225,1226],{},"alignment padding bits to position a subsequent data member on a properly aligned boundary,",[1221,1228,1229],{},"alignment padding bits to position data members of varying access control levels.",[1221,1231,1232],{},"bit-field padding bits when the sequential set of bit-fields does not fill an entire allocation unit,",[1221,1234,1235],{},"bit-field padding bits when two adjacent bit-fields are declared with different underlying types,",[1221,1237,1238],{},"padding bits when a bit-field is declared with a length greater than the number of bits in the underlying allocation unit, or",[1221,1240,1241],{},"padding bits to ensure a class instance will be appropriately aligned for use within an array.",[39,1243,1244,1245,1247],{},"This code example runs in kernel space and copies data from ",[87,1246,89],{}," to user space. However, the padding bits within the object instance may contain sensitive information that will then be leaked when the data is copied to user space.",[92,1249,1250],{"quality":94},[96,1251,1253],{"className":98,"code":1252,"language":100,"meta":101,"style":101},"#include \u003Ccstddef>\n\nclass base {\npublic:\n  virtual ~base() = default;\n};\n\nclass test : public virtual base {\n  alignas(32) double h;\n  char i;\n  unsigned j : 80;\nprotected:\n  unsigned k;\n  unsigned l : 4;\n  unsigned short m : 3;\npublic:\n  char n;\n  double o;\n  \n  test(double h, char i, unsigned j, unsigned k, unsigned l, unsigned short m,\n       char n, double o) :\n    h(h), i(i), j(j), k(k), l(l), m(m), n(n), o(o) {}\n  \n  virtual void foo();\n};\n\n\u002F\u002F Safely copy bytes to user space.\nextern int copy_to_user(void *dest, void *src, std::size_t size);\n\nvoid do_stuff(void *usr_buf) {\n  test arg{0.0, 1, 2, 3, 4, 5, 6, 7.0};\n  copy_to_user(usr_buf, &arg, sizeof(arg));\n}\n",[87,1254,1255,1261,1265,1275,1280,1298,1302,1306,1325,1339,1346,1358,1363,1370,1382,1396,1400,1407,1415,1420,1471,1489,1539,1543,1556,1560,1564,1568,1604,1609,1626,1667,1682],{"__ignoreMap":101},[105,1256,1257,1259],{"class":107,"line":108},[105,1258,112],{"class":111},[105,1260,116],{"class":115},[105,1262,1263],{"class":107,"line":119},[105,1264,886],{"emptyLinePlaceholder":7},[105,1266,1267,1270,1273],{"class":107,"line":126},[105,1268,1269],{"class":129},"class",[105,1271,1272],{"class":133}," base",[105,1274,137],{"class":122},[105,1276,1277],{"class":107,"line":140},[105,1278,1279],{"class":129},"public:\n",[105,1281,1282,1285,1288,1291,1293,1296],{"class":107,"line":149},[105,1283,1284],{"class":111},"  virtual",[105,1286,1287],{"class":193}," ~base",[105,1289,1290],{"class":122},"() ",[105,1292,460],{"class":111},[105,1294,1295],{"class":111}," default",[105,1297,466],{"class":122},[105,1299,1300],{"class":107,"line":158},[105,1301,169],{"class":122},[105,1303,1304],{"class":107,"line":166},[105,1305,886],{"emptyLinePlaceholder":7},[105,1307,1308,1310,1312,1315,1318,1321,1323],{"class":107,"line":172},[105,1309,1269],{"class":129},[105,1311,134],{"class":133},[105,1313,1314],{"class":122}," : ",[105,1316,1317],{"class":129},"public",[105,1319,1320],{"class":129}," virtual",[105,1322,1272],{"class":133},[105,1324,137],{"class":122},[105,1326,1327,1330,1333,1336],{"class":107,"line":177},[105,1328,1329],{"class":193},"  alignas",[105,1331,1332],{"class":122},"(32) ",[105,1334,1335],{"class":129},"double",[105,1337,1338],{"class":122}," h;\n",[105,1340,1341,1343],{"class":107,"line":184},[105,1342,152],{"class":129},[105,1344,1345],{"class":122}," i;\n",[105,1347,1348,1350,1353,1356],{"class":107,"line":237},[105,1349,681],{"class":129},[105,1351,1352],{"class":122}," j : ",[105,1354,1355],{"class":268},"80",[105,1357,466],{"class":122},[105,1359,1360],{"class":107,"line":242},[105,1361,1362],{"class":129},"protected:\n",[105,1364,1365,1367],{"class":107,"line":262},[105,1366,681],{"class":129},[105,1368,1369],{"class":122}," k;\n",[105,1371,1372,1374,1377,1380],{"class":107,"line":284},[105,1373,681],{"class":129},[105,1375,1376],{"class":122}," l : ",[105,1378,1379],{"class":268},"4",[105,1381,466],{"class":122},[105,1383,1384,1386,1389,1392,1394],{"class":107,"line":305},[105,1385,681],{"class":129},[105,1387,1388],{"class":129}," short",[105,1390,1391],{"class":122}," m : ",[105,1393,279],{"class":268},[105,1395,466],{"class":122},[105,1397,1398],{"class":107,"line":469},[105,1399,1279],{"class":129},[105,1401,1402,1404],{"class":107,"line":482},[105,1403,152],{"class":129},[105,1405,1406],{"class":122}," n;\n",[105,1408,1409,1412],{"class":107,"line":495},[105,1410,1411],{"class":129},"  double",[105,1413,1414],{"class":122}," o;\n",[105,1416,1417],{"class":107,"line":500},[105,1418,1419],{"class":122},"  \n",[105,1421,1422,1424,1426,1428,1431,1433,1435,1438,1440,1443,1446,1448,1450,1453,1455,1457,1460,1462,1464,1466,1469],{"class":107,"line":515},[105,1423,928],{"class":193},[105,1425,197],{"class":122},[105,1427,1335],{"class":129},[105,1429,1430],{"class":206}," h",[105,1432,210],{"class":122},[105,1434,941],{"class":129},[105,1436,1437],{"class":206}," i",[105,1439,210],{"class":122},[105,1441,1442],{"class":129},"unsigned",[105,1444,1445],{"class":206}," j",[105,1447,210],{"class":122},[105,1449,1442],{"class":129},[105,1451,1452],{"class":206}," k",[105,1454,210],{"class":122},[105,1456,1442],{"class":129},[105,1458,1459],{"class":206}," l",[105,1461,210],{"class":122},[105,1463,1442],{"class":129},[105,1465,1388],{"class":129},[105,1467,1468],{"class":206}," m",[105,1470,1042],{"class":122},[105,1472,1473,1476,1479,1481,1483,1486],{"class":107,"line":760},[105,1474,1475],{"class":129},"       char",[105,1477,1478],{"class":206}," n",[105,1480,210],{"class":122},[105,1482,1335],{"class":129},[105,1484,1485],{"class":206}," o",[105,1487,1488],{"class":122},") :\n",[105,1490,1491,1494,1497,1500,1503,1506,1509,1512,1515,1518,1521,1524,1527,1530,1533,1536],{"class":107,"line":785},[105,1492,1493],{"class":193},"    h",[105,1495,1496],{"class":122},"(h), ",[105,1498,1499],{"class":193},"i",[105,1501,1502],{"class":122},"(i), ",[105,1504,1505],{"class":193},"j",[105,1507,1508],{"class":122},"(j), ",[105,1510,1511],{"class":193},"k",[105,1513,1514],{"class":122},"(k), ",[105,1516,1517],{"class":193},"l",[105,1519,1520],{"class":122},"(l), ",[105,1522,1523],{"class":193},"m",[105,1525,1526],{"class":122},"(m), ",[105,1528,1529],{"class":193},"n",[105,1531,1532],{"class":122},"(n), ",[105,1534,1535],{"class":193},"o",[105,1537,1538],{"class":122},"(o) {}\n",[105,1540,1541],{"class":107,"line":797},[105,1542,1419],{"class":122},[105,1544,1545,1547,1550,1553],{"class":107,"line":822},[105,1546,1284],{"class":111},[105,1548,1549],{"class":129}," void",[105,1551,1552],{"class":193}," foo",[105,1554,1555],{"class":122},"();\n",[105,1557,1558],{"class":107,"line":834},[105,1559,169],{"class":122},[105,1561,1562],{"class":107,"line":839},[105,1563,886],{"emptyLinePlaceholder":7},[105,1565,1566],{"class":107,"line":852},[105,1567,599],{"class":180},[105,1569,1570,1572,1574,1576,1578,1580,1582,1584,1586,1588,1590,1592,1594,1596,1598,1600,1602],{"class":107,"line":1193},[105,1571,187],{"class":111},[105,1573,190],{"class":129},[105,1575,194],{"class":193},[105,1577,197],{"class":122},[105,1579,200],{"class":129},[105,1581,203],{"class":111},[105,1583,207],{"class":206},[105,1585,210],{"class":122},[105,1587,200],{"class":129},[105,1589,203],{"class":111},[105,1591,217],{"class":206},[105,1593,210],{"class":122},[105,1595,222],{"class":133},[105,1597,225],{"class":122},[105,1599,228],{"class":129},[105,1601,231],{"class":206},[105,1603,234],{"class":122},[105,1605,1607],{"class":107,"line":1606},29,[105,1608,886],{"emptyLinePlaceholder":7},[105,1610,1612,1614,1616,1618,1620,1622,1624],{"class":107,"line":1611},30,[105,1613,200],{"class":129},[105,1615,247],{"class":193},[105,1617,197],{"class":122},[105,1619,200],{"class":129},[105,1621,203],{"class":111},[105,1623,256],{"class":206},[105,1625,259],{"class":122},[105,1627,1629,1631,1634,1636,1638,1640,1642,1644,1646,1648,1650,1652,1655,1657,1660,1662,1665],{"class":107,"line":1628},31,[105,1630,265],{"class":122},[105,1632,1633],{"class":268},"0.0",[105,1635,210],{"class":122},[105,1637,269],{"class":268},[105,1639,210],{"class":122},[105,1641,274],{"class":268},[105,1643,210],{"class":122},[105,1645,279],{"class":268},[105,1647,210],{"class":122},[105,1649,1379],{"class":268},[105,1651,210],{"class":122},[105,1653,1654],{"class":268},"5",[105,1656,210],{"class":122},[105,1658,1659],{"class":268},"6",[105,1661,210],{"class":122},[105,1663,1664],{"class":268},"7.0",[105,1666,169],{"class":122},[105,1668,1670,1672,1674,1676,1678,1680],{"class":107,"line":1669},32,[105,1671,287],{"class":193},[105,1673,290],{"class":122},[105,1675,293],{"class":111},[105,1677,296],{"class":122},[105,1679,299],{"class":111},[105,1681,302],{"class":122},[105,1683,1685],{"class":107,"line":1684},33,[105,1686,308],{"class":122},[39,1688,1689,1690,1694,1695,1697],{},"Padding bits are implementation-defined, so the layout of the class object may differ between compilers or architectures. When compiled with ",[43,1691,1693],{"href":1692},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-gcc","GCC"," 5.3.0 for x86-32, the ",[87,1696,320],{}," object requires 96 bytes of storage to accommodate 29 bytes of data (33 bytes including the vtable) and has the following layout.",[1699,1700,1703],"table",{"className":1701},[1702],"wrapped",[1704,1705,1706,1737,1766,1794,1824,1852,1878,1904,1931],"tbody",{},[1707,1708,1711,1715,1718,1721,1729,1732,1735],"tr",{"className":1709},[1710],"header",[1712,1713,1714],"th",{},"Offset (bytes (bits))",[1712,1716,1717],{},"Storage Size (bytes (bits))",[1712,1719,1720],{},"Reason",[1712,1722,1726],{"className":1723,"dataHighlightColour":1725},[1724],"highlight-grey","grey",[1727,1728],"br",{},[1712,1730,1731],{},"Offset",[1712,1733,1734],{},"Storage Size",[1712,1736,1720],{},[1707,1738,1741,1744,1747,1750,1755,1758,1761],{"className":1739},[1740],"odd",[1742,1743,324],"td",{},[1742,1745,1746],{},"1 (32)",[1742,1748,1749],{},"vtable pointer",[1742,1751,1753],{"className":1752,"dataHighlightColour":1725},[1724],[1727,1754],{},[1742,1756,1757],{},"56 (448)",[1742,1759,1760],{},"4 (32)",[1742,1762,1763],{},[87,1764,1765],{},"      unsigned k     ",[1707,1767,1770,1772,1775,1778,1783,1786,1789],{"className":1768},[1769],"even",[1742,1771,1760],{},[1742,1773,1774],{},"28 (224)",[1742,1776,1777],{},"data member alignment padding",[1742,1779,1781],{"className":1780,"dataHighlightColour":1725},[1724],[1727,1782],{},[1742,1784,1785],{},"60 (480)",[1742,1787,1788],{},"0 (4)",[1742,1790,1791],{},[87,1792,1793],{},"      unsigned l : 4     ",[1707,1795,1797,1800,1803,1808,1813,1816,1819],{"className":1796},[1740],[1742,1798,1799],{},"32 (256)",[1742,1801,1802],{},"8 (64)",[1742,1804,1805],{},[87,1806,1807],{},"      double h     ",[1742,1809,1811],{"className":1810,"dataHighlightColour":1725},[1724],[1727,1812],{},[1742,1814,1815],{},"60 (484)",[1742,1817,1818],{},"0 (3)",[1742,1820,1821],{},[87,1822,1823],{},"      unsigned short m : 3     ",[1707,1825,1827,1830,1833,1838,1843,1846,1849],{"className":1826},[1769],[1742,1828,1829],{},"40 (320)",[1742,1831,1832],{},"1 (8)",[1742,1834,1835],{},[87,1836,1837],{},"      char i     ",[1742,1839,1841],{"className":1840,"dataHighlightColour":1725},[1724],[1727,1842],{},[1742,1844,1845],{},"60 (487)",[1742,1847,1848],{},"0 (1)",[1742,1850,1851],{},"unused bit-field bits",[1707,1853,1855,1858,1861,1863,1868,1871,1873],{"className":1854},[1740],[1742,1856,1857],{},"41 (328)",[1742,1859,1860],{},"3 (24)",[1742,1862,1777],{},[1742,1864,1866],{"className":1865,"dataHighlightColour":1725},[1724],[1727,1867],{},[1742,1869,1870],{},"61 (488)",[1742,1872,1832],{},[1742,1874,1875],{},[87,1876,1877],{},"      char n     ",[1707,1879,1881,1884,1886,1891,1896,1899,1902],{"className":1880},[1769],[1742,1882,1883],{},"44 (352)",[1742,1885,1760],{},[1742,1887,1888],{},[87,1889,1890],{},"      unsigned j : 80     ",[1742,1892,1894],{"className":1893,"dataHighlightColour":1725},[1724],[1727,1895],{},[1742,1897,1898],{},"62 (496)",[1742,1900,1901],{},"2 (16)",[1742,1903,1777],{},[1707,1905,1907,1910,1913,1916,1921,1924,1926],{"className":1906},[1740],[1742,1908,1909],{},"48 (384)",[1742,1911,1912],{},"6 (48)",[1742,1914,1915],{},"extended bit-field size padding",[1742,1917,1919],{"className":1918,"dataHighlightColour":1725},[1724],[1727,1920],{},[1742,1922,1923],{},"64 (512)",[1742,1925,1802],{},[1742,1927,1928],{},[87,1929,1930],{},"      double o     ",[1707,1932,1934,1937,1939,1942,1947,1950,1953],{"className":1933},[1769],[1742,1935,1936],{},"54 (432)",[1742,1938,1901],{},[1742,1940,1941],{},"alignment padding",[1742,1943,1945],{"className":1944,"dataHighlightColour":1725},[1724],[1727,1946],{},[1742,1948,1949],{},"72 (576)",[1742,1951,1952],{},"24 (192)",[1742,1954,1955],{},"class alignment padding",[79,1957,531],{"id":1958},"compliant-solution-1",[39,1960,1961],{},"Due to the complexity of the data structure, this compliant solution serializes the object data before copying it to an untrusted context instead of attempting to account for all of the padding bytes manually.",[92,1963,1964],{"quality":537},[96,1965,1967],{"className":98,"code":1966,"language":100,"meta":101,"style":101},"#include \u003Ccstddef>\n#include \u003Ccstring>\n \nclass base {\npublic:\n  virtual ~base() = default;\n};\nclass test : public virtual base {\n  alignas(32) double h;\n  char i;\n  unsigned j : 80;\nprotected:\n  unsigned k;\n  unsigned l : 4;\n  unsigned short m : 3;\npublic:\n  char n;\n  double o;\n  \n  test(double h, char i, unsigned j, unsigned k, unsigned l, unsigned short m,\n       char n, double o) :\n    h(h), i(i), j(j), k(k), l(l), m(m), n(n), o(o) {}\n  \n  virtual void foo();\n  bool serialize(unsigned char *buffer, std::size_t &size) {\n    if (size \u003C sizeof(test)) {\n      return false;\n    }\n    \n    std::size_t offset = 0;\n    std::memcpy(buffer + offset, &h, sizeof(h));\n    offset += sizeof(h);\n    std::memcpy(buffer + offset, &i, sizeof(i));\n    offset += sizeof(i);\n    unsigned loc_j = j; \u002F\u002F Only sizeof(unsigned) bits are valid, so this is not narrowing.\n    std::memcpy(buffer + offset, &loc_j, sizeof(loc_j));\n    offset += sizeof(loc_j);\n    std::memcpy(buffer + offset, &k, sizeof(k));\n    offset += sizeof(k);\n    unsigned char loc_l = l & 0b1111;\n    std::memcpy(buffer + offset, &loc_l, sizeof(loc_l));\n    offset += sizeof(loc_l);\n    unsigned short loc_m = m & 0b111;\n    std::memcpy(buffer + offset, &loc_m, sizeof(loc_m));\n    offset += sizeof(loc_m);\n    std::memcpy(buffer + offset, &n, sizeof(n));\n    offset += sizeof(n);\n    std::memcpy(buffer + offset, &o, sizeof(o));\n    offset += sizeof(o);\n    \n    size -= offset;\n    return true;\n  }\n};\n \n\u002F\u002F Safely copy bytes to user space.\nextern int copy_to_user(void *dest, void *src, size_t size);\n \nvoid do_stuff(void *usr_buf) {\n  test arg{0.0, 1, 2, 3, 4, 5, 6, 7.0};\n  \n  \u002F\u002F May be larger than strictly needed, will be updated by\n  \u002F\u002F calling serialize() to the size of the buffer remaining.\n  std::size_t size = sizeof(arg);\n  unsigned char buf[sizeof(arg)];\n  if (arg.serialize(buf, size)) {\n    copy_to_user(usr_buf, buf, sizeof(test) - size);\n  } else {\n    \u002F\u002F Handle error\n  }\n}\n",[87,1968,1969,1975,1981,1985,1993,1997,2011,2015,2031,2041,2047,2057,2061,2067,2077,2089,2093,2099,2105,2109,2153,2167,2201,2205,2215,2250,2266,2276,2281,2286,2303,2328,2340,2364,2376,2393,2418,2430,2455,2467,2492,2517,2529,2553,2578,2590,2615,2627,2652,2664,2669,2681,2692,2698,2703,2708,2713,2746,2751,2768,2805,2810,2816,2822,2841,2854,2869,2888,2899,2905,2910],{"__ignoreMap":101},[105,1970,1971,1973],{"class":107,"line":108},[105,1972,112],{"class":111},[105,1974,116],{"class":115},[105,1976,1977,1979],{"class":107,"line":119},[105,1978,112],{"class":111},[105,1980,555],{"class":115},[105,1982,1983],{"class":107,"line":126},[105,1984,560],{"class":122},[105,1986,1987,1989,1991],{"class":107,"line":140},[105,1988,1269],{"class":129},[105,1990,1272],{"class":133},[105,1992,137],{"class":122},[105,1994,1995],{"class":107,"line":149},[105,1996,1279],{"class":129},[105,1998,1999,2001,2003,2005,2007,2009],{"class":107,"line":158},[105,2000,1284],{"class":111},[105,2002,1287],{"class":193},[105,2004,1290],{"class":122},[105,2006,460],{"class":111},[105,2008,1295],{"class":111},[105,2010,466],{"class":122},[105,2012,2013],{"class":107,"line":166},[105,2014,169],{"class":122},[105,2016,2017,2019,2021,2023,2025,2027,2029],{"class":107,"line":172},[105,2018,1269],{"class":129},[105,2020,134],{"class":133},[105,2022,1314],{"class":122},[105,2024,1317],{"class":129},[105,2026,1320],{"class":129},[105,2028,1272],{"class":133},[105,2030,137],{"class":122},[105,2032,2033,2035,2037,2039],{"class":107,"line":177},[105,2034,1329],{"class":193},[105,2036,1332],{"class":122},[105,2038,1335],{"class":129},[105,2040,1338],{"class":122},[105,2042,2043,2045],{"class":107,"line":184},[105,2044,152],{"class":129},[105,2046,1345],{"class":122},[105,2048,2049,2051,2053,2055],{"class":107,"line":237},[105,2050,681],{"class":129},[105,2052,1352],{"class":122},[105,2054,1355],{"class":268},[105,2056,466],{"class":122},[105,2058,2059],{"class":107,"line":242},[105,2060,1362],{"class":129},[105,2062,2063,2065],{"class":107,"line":262},[105,2064,681],{"class":129},[105,2066,1369],{"class":122},[105,2068,2069,2071,2073,2075],{"class":107,"line":284},[105,2070,681],{"class":129},[105,2072,1376],{"class":122},[105,2074,1379],{"class":268},[105,2076,466],{"class":122},[105,2078,2079,2081,2083,2085,2087],{"class":107,"line":305},[105,2080,681],{"class":129},[105,2082,1388],{"class":129},[105,2084,1391],{"class":122},[105,2086,279],{"class":268},[105,2088,466],{"class":122},[105,2090,2091],{"class":107,"line":469},[105,2092,1279],{"class":129},[105,2094,2095,2097],{"class":107,"line":482},[105,2096,152],{"class":129},[105,2098,1406],{"class":122},[105,2100,2101,2103],{"class":107,"line":495},[105,2102,1411],{"class":129},[105,2104,1414],{"class":122},[105,2106,2107],{"class":107,"line":500},[105,2108,1419],{"class":122},[105,2110,2111,2113,2115,2117,2119,2121,2123,2125,2127,2129,2131,2133,2135,2137,2139,2141,2143,2145,2147,2149,2151],{"class":107,"line":515},[105,2112,928],{"class":193},[105,2114,197],{"class":122},[105,2116,1335],{"class":129},[105,2118,1430],{"class":206},[105,2120,210],{"class":122},[105,2122,941],{"class":129},[105,2124,1437],{"class":206},[105,2126,210],{"class":122},[105,2128,1442],{"class":129},[105,2130,1445],{"class":206},[105,2132,210],{"class":122},[105,2134,1442],{"class":129},[105,2136,1452],{"class":206},[105,2138,210],{"class":122},[105,2140,1442],{"class":129},[105,2142,1459],{"class":206},[105,2144,210],{"class":122},[105,2146,1442],{"class":129},[105,2148,1388],{"class":129},[105,2150,1468],{"class":206},[105,2152,1042],{"class":122},[105,2154,2155,2157,2159,2161,2163,2165],{"class":107,"line":760},[105,2156,1475],{"class":129},[105,2158,1478],{"class":206},[105,2160,210],{"class":122},[105,2162,1335],{"class":129},[105,2164,1485],{"class":206},[105,2166,1488],{"class":122},[105,2168,2169,2171,2173,2175,2177,2179,2181,2183,2185,2187,2189,2191,2193,2195,2197,2199],{"class":107,"line":785},[105,2170,1493],{"class":193},[105,2172,1496],{"class":122},[105,2174,1499],{"class":193},[105,2176,1502],{"class":122},[105,2178,1505],{"class":193},[105,2180,1508],{"class":122},[105,2182,1511],{"class":193},[105,2184,1514],{"class":122},[105,2186,1517],{"class":193},[105,2188,1520],{"class":122},[105,2190,1523],{"class":193},[105,2192,1526],{"class":122},[105,2194,1529],{"class":193},[105,2196,1532],{"class":122},[105,2198,1535],{"class":193},[105,2200,1538],{"class":122},[105,2202,2203],{"class":107,"line":797},[105,2204,1419],{"class":122},[105,2206,2207,2209,2211,2213],{"class":107,"line":822},[105,2208,1284],{"class":111},[105,2210,1549],{"class":129},[105,2212,1552],{"class":193},[105,2214,1555],{"class":122},[105,2216,2217,2220,2223,2225,2227,2229,2231,2234,2236,2238,2240,2242,2245,2248],{"class":107,"line":834},[105,2218,2219],{"class":129},"  bool",[105,2221,2222],{"class":193}," serialize",[105,2224,197],{"class":122},[105,2226,1442],{"class":129},[105,2228,684],{"class":129},[105,2230,203],{"class":111},[105,2232,2233],{"class":206},"buffer",[105,2235,210],{"class":122},[105,2237,222],{"class":133},[105,2239,225],{"class":122},[105,2241,228],{"class":129},[105,2243,2244],{"class":111}," &",[105,2246,2247],{"class":206},"size",[105,2249,259],{"class":122},[105,2251,2252,2255,2258,2261,2263],{"class":107,"line":839},[105,2253,2254],{"class":111},"    if",[105,2256,2257],{"class":122}," (size ",[105,2259,2260],{"class":111},"\u003C",[105,2262,754],{"class":111},[105,2264,2265],{"class":122},"(test)) {\n",[105,2267,2268,2271,2274],{"class":107,"line":852},[105,2269,2270],{"class":111},"      return",[105,2272,2273],{"class":268}," false",[105,2275,466],{"class":122},[105,2277,2278],{"class":107,"line":1193},[105,2279,2280],{"class":122},"    }\n",[105,2282,2283],{"class":107,"line":1606},[105,2284,2285],{"class":122},"    \n",[105,2287,2288,2291,2293,2295,2297,2299,2301],{"class":107,"line":1611},[105,2289,2290],{"class":133},"    std",[105,2292,225],{"class":122},[105,2294,228],{"class":129},[105,2296,704],{"class":122},[105,2298,460],{"class":111},[105,2300,709],{"class":268},[105,2302,466],{"class":122},[105,2304,2305,2307,2309,2311,2314,2316,2318,2320,2323,2325],{"class":107,"line":1628},[105,2306,2290],{"class":133},[105,2308,225],{"class":122},[105,2310,724],{"class":193},[105,2312,2313],{"class":122},"(buffer ",[105,2315,730],{"class":111},[105,2317,733],{"class":122},[105,2319,293],{"class":111},[105,2321,2322],{"class":122},"h, ",[105,2324,299],{"class":111},[105,2326,2327],{"class":122},"(h));\n",[105,2329,2330,2333,2335,2337],{"class":107,"line":1669},[105,2331,2332],{"class":122},"    offset ",[105,2334,751],{"class":111},[105,2336,754],{"class":111},[105,2338,2339],{"class":122},"(h);\n",[105,2341,2342,2344,2346,2348,2350,2352,2354,2356,2359,2361],{"class":107,"line":1684},[105,2343,2290],{"class":133},[105,2345,225],{"class":122},[105,2347,724],{"class":193},[105,2349,2313],{"class":122},[105,2351,730],{"class":111},[105,2353,733],{"class":122},[105,2355,293],{"class":111},[105,2357,2358],{"class":122},"i, ",[105,2360,299],{"class":111},[105,2362,2363],{"class":122},"(i));\n",[105,2365,2367,2369,2371,2373],{"class":107,"line":2366},34,[105,2368,2332],{"class":122},[105,2370,751],{"class":111},[105,2372,754],{"class":111},[105,2374,2375],{"class":122},"(i);\n",[105,2377,2379,2382,2385,2387,2390],{"class":107,"line":2378},35,[105,2380,2381],{"class":129},"    unsigned",[105,2383,2384],{"class":122}," loc_j ",[105,2386,460],{"class":111},[105,2388,2389],{"class":122}," j;",[105,2391,2392],{"class":180}," \u002F\u002F Only sizeof(unsigned) bits are valid, so this is not narrowing.\n",[105,2394,2396,2398,2400,2402,2404,2406,2408,2410,2413,2415],{"class":107,"line":2395},36,[105,2397,2290],{"class":133},[105,2399,225],{"class":122},[105,2401,724],{"class":193},[105,2403,2313],{"class":122},[105,2405,730],{"class":111},[105,2407,733],{"class":122},[105,2409,293],{"class":111},[105,2411,2412],{"class":122},"loc_j, ",[105,2414,299],{"class":111},[105,2416,2417],{"class":122},"(loc_j));\n",[105,2419,2421,2423,2425,2427],{"class":107,"line":2420},37,[105,2422,2332],{"class":122},[105,2424,751],{"class":111},[105,2426,754],{"class":111},[105,2428,2429],{"class":122},"(loc_j);\n",[105,2431,2433,2435,2437,2439,2441,2443,2445,2447,2450,2452],{"class":107,"line":2432},38,[105,2434,2290],{"class":133},[105,2436,225],{"class":122},[105,2438,724],{"class":193},[105,2440,2313],{"class":122},[105,2442,730],{"class":111},[105,2444,733],{"class":122},[105,2446,293],{"class":111},[105,2448,2449],{"class":122},"k, ",[105,2451,299],{"class":111},[105,2453,2454],{"class":122},"(k));\n",[105,2456,2458,2460,2462,2464],{"class":107,"line":2457},39,[105,2459,2332],{"class":122},[105,2461,751],{"class":111},[105,2463,754],{"class":111},[105,2465,2466],{"class":122},"(k);\n",[105,2468,2470,2472,2474,2477,2479,2482,2484,2487,2490],{"class":107,"line":2469},40,[105,2471,2381],{"class":129},[105,2473,684],{"class":129},[105,2475,2476],{"class":122}," loc_l ",[105,2478,460],{"class":111},[105,2480,2481],{"class":122}," l ",[105,2483,293],{"class":111},[105,2485,2486],{"class":111}," 0b",[105,2488,2489],{"class":268},"1111",[105,2491,466],{"class":122},[105,2493,2495,2497,2499,2501,2503,2505,2507,2509,2512,2514],{"class":107,"line":2494},41,[105,2496,2290],{"class":133},[105,2498,225],{"class":122},[105,2500,724],{"class":193},[105,2502,2313],{"class":122},[105,2504,730],{"class":111},[105,2506,733],{"class":122},[105,2508,293],{"class":111},[105,2510,2511],{"class":122},"loc_l, ",[105,2513,299],{"class":111},[105,2515,2516],{"class":122},"(loc_l));\n",[105,2518,2520,2522,2524,2526],{"class":107,"line":2519},42,[105,2521,2332],{"class":122},[105,2523,751],{"class":111},[105,2525,754],{"class":111},[105,2527,2528],{"class":122},"(loc_l);\n",[105,2530,2532,2534,2536,2539,2541,2544,2546,2548,2551],{"class":107,"line":2531},43,[105,2533,2381],{"class":129},[105,2535,1388],{"class":129},[105,2537,2538],{"class":122}," loc_m ",[105,2540,460],{"class":111},[105,2542,2543],{"class":122}," m ",[105,2545,293],{"class":111},[105,2547,2486],{"class":111},[105,2549,2550],{"class":268},"111",[105,2552,466],{"class":122},[105,2554,2556,2558,2560,2562,2564,2566,2568,2570,2573,2575],{"class":107,"line":2555},44,[105,2557,2290],{"class":133},[105,2559,225],{"class":122},[105,2561,724],{"class":193},[105,2563,2313],{"class":122},[105,2565,730],{"class":111},[105,2567,733],{"class":122},[105,2569,293],{"class":111},[105,2571,2572],{"class":122},"loc_m, ",[105,2574,299],{"class":111},[105,2576,2577],{"class":122},"(loc_m));\n",[105,2579,2581,2583,2585,2587],{"class":107,"line":2580},45,[105,2582,2332],{"class":122},[105,2584,751],{"class":111},[105,2586,754],{"class":111},[105,2588,2589],{"class":122},"(loc_m);\n",[105,2591,2593,2595,2597,2599,2601,2603,2605,2607,2610,2612],{"class":107,"line":2592},46,[105,2594,2290],{"class":133},[105,2596,225],{"class":122},[105,2598,724],{"class":193},[105,2600,2313],{"class":122},[105,2602,730],{"class":111},[105,2604,733],{"class":122},[105,2606,293],{"class":111},[105,2608,2609],{"class":122},"n, ",[105,2611,299],{"class":111},[105,2613,2614],{"class":122},"(n));\n",[105,2616,2618,2620,2622,2624],{"class":107,"line":2617},47,[105,2619,2332],{"class":122},[105,2621,751],{"class":111},[105,2623,754],{"class":111},[105,2625,2626],{"class":122},"(n);\n",[105,2628,2630,2632,2634,2636,2638,2640,2642,2644,2647,2649],{"class":107,"line":2629},48,[105,2631,2290],{"class":133},[105,2633,225],{"class":122},[105,2635,724],{"class":193},[105,2637,2313],{"class":122},[105,2639,730],{"class":111},[105,2641,733],{"class":122},[105,2643,293],{"class":111},[105,2645,2646],{"class":122},"o, ",[105,2648,299],{"class":111},[105,2650,2651],{"class":122},"(o));\n",[105,2653,2655,2657,2659,2661],{"class":107,"line":2654},49,[105,2656,2332],{"class":122},[105,2658,751],{"class":111},[105,2660,754],{"class":111},[105,2662,2663],{"class":122},"(o);\n",[105,2665,2667],{"class":107,"line":2666},50,[105,2668,2285],{"class":122},[105,2670,2672,2675,2678],{"class":107,"line":2671},51,[105,2673,2674],{"class":122},"    size ",[105,2676,2677],{"class":111},"-=",[105,2679,2680],{"class":122}," offset;\n",[105,2682,2684,2687,2690],{"class":107,"line":2683},52,[105,2685,2686],{"class":111},"    return",[105,2688,2689],{"class":268}," true",[105,2691,466],{"class":122},[105,2693,2695],{"class":107,"line":2694},53,[105,2696,2697],{"class":122},"  }\n",[105,2699,2701],{"class":107,"line":2700},54,[105,2702,169],{"class":122},[105,2704,2706],{"class":107,"line":2705},55,[105,2707,560],{"class":122},[105,2709,2711],{"class":107,"line":2710},56,[105,2712,599],{"class":180},[105,2714,2716,2718,2720,2722,2724,2726,2728,2730,2732,2734,2736,2738,2740,2742,2744],{"class":107,"line":2715},57,[105,2717,187],{"class":111},[105,2719,190],{"class":129},[105,2721,194],{"class":193},[105,2723,197],{"class":122},[105,2725,200],{"class":129},[105,2727,203],{"class":111},[105,2729,207],{"class":206},[105,2731,210],{"class":122},[105,2733,200],{"class":129},[105,2735,203],{"class":111},[105,2737,217],{"class":206},[105,2739,210],{"class":122},[105,2741,228],{"class":129},[105,2743,231],{"class":206},[105,2745,234],{"class":122},[105,2747,2749],{"class":107,"line":2748},58,[105,2750,560],{"class":122},[105,2752,2754,2756,2758,2760,2762,2764,2766],{"class":107,"line":2753},59,[105,2755,200],{"class":129},[105,2757,247],{"class":193},[105,2759,197],{"class":122},[105,2761,200],{"class":129},[105,2763,203],{"class":111},[105,2765,256],{"class":206},[105,2767,259],{"class":122},[105,2769,2771,2773,2775,2777,2779,2781,2783,2785,2787,2789,2791,2793,2795,2797,2799,2801,2803],{"class":107,"line":2770},60,[105,2772,265],{"class":122},[105,2774,1633],{"class":268},[105,2776,210],{"class":122},[105,2778,269],{"class":268},[105,2780,210],{"class":122},[105,2782,274],{"class":268},[105,2784,210],{"class":122},[105,2786,279],{"class":268},[105,2788,210],{"class":122},[105,2790,1379],{"class":268},[105,2792,210],{"class":122},[105,2794,1654],{"class":268},[105,2796,210],{"class":122},[105,2798,1659],{"class":268},[105,2800,210],{"class":122},[105,2802,1664],{"class":268},[105,2804,169],{"class":122},[105,2806,2808],{"class":107,"line":2807},61,[105,2809,1419],{"class":122},[105,2811,2813],{"class":107,"line":2812},62,[105,2814,2815],{"class":180},"  \u002F\u002F May be larger than strictly needed, will be updated by\n",[105,2817,2819],{"class":107,"line":2818},63,[105,2820,2821],{"class":180},"  \u002F\u002F calling serialize() to the size of the buffer remaining.\n",[105,2823,2825,2827,2829,2831,2834,2836,2838],{"class":107,"line":2824},64,[105,2826,697],{"class":133},[105,2828,225],{"class":122},[105,2830,228],{"class":129},[105,2832,2833],{"class":122}," size ",[105,2835,460],{"class":111},[105,2837,754],{"class":111},[105,2839,2840],{"class":122},"(arg);\n",[105,2842,2844,2846,2848,2850,2852],{"class":107,"line":2843},65,[105,2845,681],{"class":129},[105,2847,684],{"class":129},[105,2849,687],{"class":122},[105,2851,299],{"class":111},[105,2853,692],{"class":122},[105,2855,2857,2860,2863,2866],{"class":107,"line":2856},66,[105,2858,2859],{"class":111},"  if",[105,2861,2862],{"class":122}," (arg.",[105,2864,2865],{"class":193},"serialize",[105,2867,2868],{"class":122},"(buf, size)) {\n",[105,2870,2872,2875,2878,2880,2882,2885],{"class":107,"line":2871},67,[105,2873,2874],{"class":193},"    copy_to_user",[105,2876,2877],{"class":122},"(usr_buf, buf, ",[105,2879,299],{"class":111},[105,2881,1065],{"class":122},[105,2883,2884],{"class":111},"-",[105,2886,2887],{"class":122}," size);\n",[105,2889,2891,2894,2897],{"class":107,"line":2890},68,[105,2892,2893],{"class":122},"  } ",[105,2895,2896],{"class":111},"else",[105,2898,137],{"class":122},[105,2900,2902],{"class":107,"line":2901},69,[105,2903,2904],{"class":180},"    \u002F\u002F Handle error\n",[105,2906,2908],{"class":107,"line":2907},70,[105,2909,2697],{"class":122},[105,2911,2913],{"class":107,"line":2912},71,[105,2914,308],{"class":122},[39,2916,857,2917,2919],{},[87,2918,860],{}," function would need to unpack it to re-create the original, padded structure.",[79,2921,2923],{"id":2922},"risk-assessment","Risk Assessment",[39,2925,2926],{},"Padding bits might inadvertently contain sensitive data such as pointers to kernel data structures or passwords. A pointer to such a structure could be passed to other functions, causing information leakage.",[1699,2928,2929,2930,2929,2958],{},"\n  ",[2931,2932,2933,2934,2929],"thead",{},"\n    ",[1707,2935,2936,2937,2936,2940,2936,2943,2936,2946,2936,2949,2936,2952,2936,2955,2933],{},"\n      ",[1712,2938,2939],{},"Rule",[1712,2941,2942],{},"Severity",[1712,2944,2945],{},"Likelihood",[1712,2947,2948],{},"Detectable",[1712,2950,2951],{},"Repairable",[1712,2953,2954],{},"Priority",[1712,2956,2957],{},"Level",[1704,2959,2933,2960,2929],{},[1707,2961,2936,2962,2936,2965,2936,2968,2936,2971,2936,2974,2936,2977,2936,2983,2933],{},[1742,2963,2964],{},"DCL55-CPP",[1742,2966,2967],{},"Low",[1742,2969,2970],{},"Unlikely",[1742,2972,2973],{},"No",[1742,2975,2976],{},"Yes",[1742,2978,2980],{"style":2979},"color: #27ae60;",[962,2981,2982],{},"P2",[1742,2984,2985],{"style":2979},[962,2986,2987],{},"L3",[79,2989,2991],{"id":2990},"automated-detection","Automated Detection",[1699,2993,2995,3020],{"className":2994},[1702],[2931,2996,2997],{},[1707,2998,3000,3005,3010,3015],{"className":2999},[1710],[1712,3001,3002],{},[39,3003,3004],{},"Tool",[1712,3006,3007],{},[39,3008,3009],{},"Version",[1712,3011,3012],{},[39,3013,3014],{},"Checker",[1712,3016,3017],{},[39,3018,3019],{},"Description",[1704,3021,3022,3051,3078,3104,3132],{},[1707,3023,3025,3031,3041,3047],{"className":3024},[1740],[1742,3026,3027],{},[43,3028,3030],{"href":3029},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Faxivion-bauhaus-suite","Axivion Bauhaus Suite",[1742,3032,3033],{},[3034,3035,3038],"div",{"className":3036},[3037],"content-wrapper",[39,3039,3040],{},"7.2.0",[1742,3042,3043],{},[3044,3045,3046],"strong",{},"CertC++-DCL55",[1742,3048,3049],{},[1727,3050],{},[1707,3052,3054,3060,3066,3073],{"className":3053},[1769],[1742,3055,3056],{},[43,3057,3059],{"href":3058},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodesonar","CodeSonar",[1742,3061,3062],{},[3034,3063,3065],{"className":3064},[3037],"9.1p0",[1742,3067,3068],{},[39,3069,3070],{},[3044,3071,3072],{},"MISC.PADDING.POTB",[1742,3074,3075],{},[39,3076,3077],{},"Padding Passed Across a Trust Boundary",[1707,3079,3081,3087,3095,3100],{"className":3080},[1740],[1742,3082,3083],{},[43,3084,3086],{"href":3085},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fhelix-qac","Helix QAC",[1742,3088,3089],{},[3034,3090,3092],{"className":3091},[3037],[39,3093,3094],{},"2025.2",[1742,3096,3097],{},[3044,3098,3099],{},"DF4941, DF4942, DF4943",[1742,3101,3102],{},[1727,3103],{},[1707,3105,3107,3113,3120,3127],{"className":3106},[1769],[1742,3108,3109],{},[43,3110,3112],{"href":3111},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fparasoft","Parasoft C\u002FC++test",[1742,3114,3115],{},[3034,3116,3118],{"className":3117},[3037],[39,3119,3094],{},[1742,3121,3122],{},[39,3123,3124],{},[3044,3125,3126],{},"CERT_CPP-DCL55-a",[1742,3128,3129],{},[39,3130,3131],{},"A pointer to a structure should not be passed to a function that can copy data to the user space",[1707,3133,3135,3141,3149,3155],{"className":3134},[1740],[1742,3136,3137],{},[43,3138,3140],{"href":3139},"\u002Fsei-cert-c-coding-standard\u002Fback-matter\u002Fee-analyzers\u002Fpolyspace-bug-finder","Polyspace Bug Finder",[1742,3142,3143],{},[3034,3144,3146],{"className":3145},[3037],[39,3147,3148],{},"R2025b",[1742,3150,3151],{},[43,3152,3154],{"href":3153},"https:\u002F\u002Fwww.mathworks.com\u002Fhelp\u002Fbugfinder\u002Fref\u002Fcertcdcl55cpp.html","CERT C++: DCL55-CPP",[1742,3156,3157],{},"Checks for information leakage due to structure padding (rule partially covered)",[3159,3160,3162],"h3",{"id":3161},"related-vulnerabilities","Related Vulnerabilities",[39,3164,3165],{},"Numerous vulnerabilities in the Linux Kernel have resulted from violations of this rule.",[39,3167,3168,3174,3175,3178,3179,3182],{},[43,3169,3173],{"href":3170,"rel":3171},"http:\u002F\u002Fcve.mitre.org\u002Fcgi-bin\u002Fcvename.cgi?name=CVE-2010-4083",[3172],"nofollow","CVE-2010-4083"," describes a vulnerability in which the ",[87,3176,3177],{},"semctl()"," system call allows unprivileged users to read uninitialized kernel stack memory because various fields of a ",[87,3180,3181],{},"  semid_ds struct "," declared on the stack are not altered or zeroed before being copied back to the user.",[39,3184,3185,3190,3191,3194,3195,3198],{},[43,3186,3189],{"href":3187,"rel":3188},"http:\u002F\u002Fcve.mitre.org\u002Fcgi-bin\u002Fcvename.cgi?name=CVE-2010-3881",[3172],"CVE-2010-3881"," describes a vulnerability in which structure padding and reserved fields in certain data structures in ",[87,3192,3193],{},"QEMU-KVM"," were not initialized properly before being copied to user space. A privileged host user with access to ",[87,3196,3197],{},"\u002Fdev\u002Fkvm"," could use this flaw to leak kernel stack memory to user space.",[39,3200,3201,3206,3207,3210],{},[43,3202,3205],{"href":3203,"rel":3204},"http:\u002F\u002Fcve.mitre.org\u002Fcgi-bin\u002Fcvename.cgi?name=CVE-2010-3477",[3172],"CVE-2010-3477"," describes a kernel information leak in ",[87,3208,3209],{},"act_police"," where incorrectly initialized structures in the traffic-control dump code may allow the disclosure of kernel memory to user space applications.",[39,3212,3213,3214,3218,3219,332],{},"Search for ",[43,3215,3217],{"href":3216},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions#BB.Definitions-vulnerability","vulnerabilities"," resulting from the violation of this rule on the ",[43,3220,3223],{"href":3221,"rel":3222},"https:\u002F\u002Fwww.kb.cert.org\u002Fvulnotes\u002Fbymetric?searchview&query=FIELD+KEYWORDS+contains+DCL55-CPP",[3172],"CERT website",[79,3225,3227],{"id":3226},"related-guidelines","Related Guidelines",[1699,3229,3230,3238],{},[2931,3231,3232],{},[1707,3233,3234,3236],{},[1712,3235],{},[1712,3237],{},[1704,3239,3240],{},[1707,3241,3242,3247],{},[1742,3243,3244],{},[43,3245,3246],{"href":17},"SEI CERT C Coding Standard",[1742,3248,3249],{},[43,3250,3252],{"href":3251},"\u002Fsei-cert-c-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl39-c","DCL39-C. Avoid information leakage when passing a structure across a trust boundary",[79,3254,3256],{"id":3255},"bibliography","Bibliography",[1699,3258,3260,3269],{"className":3259},[1702],[3261,3262,3263,3267],"colgroup",{},[3264,3265],"col",{"style":3266},"width: 50%",[3264,3268],{"style":3266},[1704,3270,3271],{},[1707,3272,3274,3280],{"className":3273},[1740],[1742,3275,3276,3277,3279],{},"[ ",[43,3278,46],{"href":45}," ]",[1742,3281,3282],{},[39,3283,3284,3285,3287,3288,3290],{},"Subclause 8.5, \"Initializers\"",[1727,3286],{},"\nSubclause 9.2, \"Class Members\"",[1727,3289],{},"\nSubclause 9.6, \"Bit-fields\"",[39,3292,3293,3300,3301,3300,3307],{},[43,3294,3296],{"href":3295},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl54-cpp",[3297,3298],"img",{"src":3299},"\u002Fattachments\u002F88046682\u002F88480621.png"," ",[43,3302,3304],{"href":3303},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002F",[3297,3305],{"src":3306},"\u002Fattachments\u002F88046682\u002F88475556.png",[43,3308,3310],{"href":3309},"\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl56-cpp",[3297,3311],{"src":3312},"\u002Fattachments\u002F88046682\u002F88475555.png",[3314,3315,3316],"style",{},"html pre.shiki code .sC2Qs, html code.shiki .sC2Qs{--shiki-default:#D73A49;--shiki-dark:#F97583;--shiki-sepia:#F92672}html pre.shiki code .sstjo, html code.shiki .sstjo{--shiki-default:#032F62;--shiki-dark:#9ECBFF;--shiki-sepia:#E6DB74}html pre.shiki code .sMOD_, html code.shiki .sMOD_{--shiki-default:#24292E;--shiki-dark:#E1E4E8;--shiki-sepia:#F8F8F2}html pre.shiki code .sq6CD, html code.shiki .sq6CD{--shiki-default:#D73A49;--shiki-default-font-style:inherit;--shiki-dark:#F97583;--shiki-dark-font-style:inherit;--shiki-sepia:#66D9EF;--shiki-sepia-font-style:italic}html pre.shiki code .sz2Vg, html code.shiki .sz2Vg{--shiki-default:#6F42C1;--shiki-default-text-decoration:inherit;--shiki-dark:#B392F0;--shiki-dark-text-decoration:inherit;--shiki-sepia:#A6E22E;--shiki-sepia-text-decoration:underline}html pre.shiki code .s8-w5, html code.shiki .s8-w5{--shiki-default:#6A737D;--shiki-dark:#6A737D;--shiki-sepia:#88846F}html pre.shiki code .srTi1, html code.shiki .srTi1{--shiki-default:#6F42C1;--shiki-dark:#B392F0;--shiki-sepia:#A6E22E}html pre.shiki code .sTHNf, html code.shiki .sTHNf{--shiki-default:#E36209;--shiki-default-font-style:inherit;--shiki-dark:#FFAB70;--shiki-dark-font-style:inherit;--shiki-sepia:#FD971F;--shiki-sepia-font-style:italic}html pre.shiki code .s7F3e, html code.shiki .s7F3e{--shiki-default:#005CC5;--shiki-dark:#79B8FF;--shiki-sepia:#AE81FF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html .sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}html.sepia .shiki span {color: var(--shiki-sepia);background: var(--shiki-sepia-bg);font-style: var(--shiki-sepia-font-style);font-weight: var(--shiki-sepia-font-weight);text-decoration: var(--shiki-sepia-text-decoration);}",{"title":101,"searchDepth":119,"depth":119,"links":3318},[3319,3320,3321,3322,3323,3324,3325,3326,3329,3330],{"id":81,"depth":119,"text":82},{"id":311,"depth":119,"text":82},{"id":530,"depth":119,"text":531},{"id":864,"depth":119,"text":865},{"id":1213,"depth":119,"text":82},{"id":1958,"depth":119,"text":531},{"id":2922,"depth":119,"text":2923},{"id":2990,"depth":119,"text":2991,"children":3327},[3328],{"id":3161,"depth":126,"text":3162},{"id":3226,"depth":119,"text":3227},{"id":3255,"depth":119,"text":3256},"The C++ Standard, [class.mem], paragraph 13 [ ISO\u002FIEC 14882-2014 ], describes the layout of non-static data members of a non-union class, specifying the following:","md",{"tags":3334},[3335,3336,3337,3338,3339,3340,3341,3342],"review","dcl","review-dms","nptc-intent","rule","review-ajb","no-autodetect","nptc","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl55-cpp",{"title":30,"description":3331},"5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F07.dcl55-cpp","-sRD5I17UEt70R-rJ88EeDi0HXfxnz_-fxpCDycFqGA",[3348,3351],{"title":3349,"path":3295,"stem":3350,"children":-1},"DCL54-CPP. Overload allocation and deallocation functions as a pair in the same scope","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F06.dcl54-cpp",{"title":3352,"path":3309,"stem":3353,"children":-1},"DCL56-CPP. Avoid cycles during initialization of static objects","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F08.dcl56-cpp",[3355],{"title":3356,"path":3357,"stem":3358,"children":3359},"SEI CERT C++ Coding Standard","\u002Fsei-cert-cpp-coding-standard","5.sei-cert-cpp-coding-standard\u002F1.index",[3360,3361,3428,3823,4040,4050],{"title":3356,"path":3357,"stem":3358},{"title":3362,"path":3363,"stem":3364,"children":3365},"Front Matter","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F1.index",[3366,3367],{"title":3362,"path":3363,"stem":3364},{"title":3368,"path":3369,"stem":3370,"children":3371},"Introduction","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F01.index",[3372,3373,3377,3381,3385,3389,3393,3397,3401,3405,3409,3413,3417,3421,3425],{"title":3368,"path":3369,"stem":3370},{"title":3374,"path":3375,"stem":3376},"Scope","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fscope","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F02.scope",{"title":3378,"path":3379,"stem":3380},"Audience","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Faudience","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F03.audience",{"title":3382,"path":3383,"stem":3384},"Usage","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fusage","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F04.usage",{"title":3386,"path":3387,"stem":3388},"How this Coding Standard Is Organized","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fhow-this-coding-standard-is-organized","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F05.how-this-coding-standard-is-organized",{"title":3390,"path":3391,"stem":3392},"Relation to the CERT C Coding Standard","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Frelation-to-the-cert-c-coding-standard","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F06.relation-to-the-cert-c-coding-standard",{"title":3394,"path":3395,"stem":3396},"Rules Versus Recommendations","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Frules-versus-recommendations","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F07.rules-versus-recommendations",{"title":3398,"path":3399,"stem":3400},"Tool Selection and Validation","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Ftool-selection-and-validation","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F08.tool-selection-and-validation",{"title":3402,"path":3403,"stem":3404},"Conformance Testing","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fconformance-testing","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F09.conformance-testing",{"title":3406,"path":3407,"stem":3408},"Development Process","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fdevelopment-process","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F10.development-process",{"title":3410,"path":3411,"stem":3412},"System Qualities","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fsystem-qualities","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F11.system-qualities",{"title":3414,"path":3415,"stem":3416},"Automatically Generated Code","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fautomatically-generated-code","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F12.automatically-generated-code",{"title":3418,"path":3419,"stem":3420},"Government Regulations","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fgovernment-regulations","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F13.government-regulations",{"title":3422,"path":3423,"stem":3424},"Acknowledgments","\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Facknowledgments","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F14.acknowledgments",{"title":2991,"path":3426,"stem":3427},"\u002Fsei-cert-cpp-coding-standard\u002Ffront-matter\u002Fintroduction\u002Fautomated-detection","5.sei-cert-cpp-coding-standard\u002F2.front-matter\u002F2.introduction\u002F15.automated-detection",{"title":3429,"path":3430,"stem":3431,"children":3432},"Rules","\u002Fsei-cert-cpp-coding-standard\u002Frules","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F01.index",[3433,3434,3456,3490,3532,3573,3631,3693,3707,3717,3755,3781],{"title":3429,"path":3430,"stem":3431},{"title":3435,"path":3436,"stem":3437,"children":3438},"Characters and Strings (STR)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcharacters-and-strings-str","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F02.characters-and-strings-str\u002F1.index",[3439,3440,3444,3448,3452],{"title":3435,"path":3436,"stem":3437},{"title":3441,"path":3442,"stem":3443},"STR50-CPP. Guarantee that storage for strings has sufficient space for character data and the null terminator","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F02.characters-and-strings-str\u002F2.str50-cpp",{"title":3445,"path":3446,"stem":3447},"STR52-CPP. Use valid references, pointers, and iterators to reference elements of a basic_string","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F02.characters-and-strings-str\u002F3.str52-cpp",{"title":3449,"path":3450,"stem":3451},"STR53-CPP. Range check element access","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstr53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F02.characters-and-strings-str\u002F4.str53-cpp",{"title":3453,"path":3454,"stem":3455},"string from a null pointer","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcharacters-and-strings-str\u002Fstring-from-a-null-pointer","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F02.characters-and-strings-str\u002F5.string-from-a-null-pointer",{"title":3457,"path":3458,"stem":3459,"children":3460},"Concurrency (CON)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F1.index",[3461,3462,3466,3470,3474,3478,3482,3486],{"title":3457,"path":3458,"stem":3459},{"title":3463,"path":3464,"stem":3465},"CON50-CPP. Do not destroy a mutex while it is locked","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F2.con50-cpp",{"title":3467,"path":3468,"stem":3469},"CON51-CPP. Ensure actively held locks are released on exceptional conditions","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F3.con51-cpp",{"title":3471,"path":3472,"stem":3473},"CON52-CPP. Prevent data races when accessing bit-fields from multiple threads","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F4.con52-cpp",{"title":3475,"path":3476,"stem":3477},"CON53-CPP. Avoid deadlock by locking in a predefined order","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F5.con53-cpp",{"title":3479,"path":3480,"stem":3481},"CON54-CPP. Wrap functions that can spuriously wake up in a loop","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F6.con54-cpp",{"title":3483,"path":3484,"stem":3485},"CON55-CPP. Preserve thread safety and liveness when using condition variables","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F7.con55-cpp",{"title":3487,"path":3488,"stem":3489},"CON56-CPP. Do not speculatively lock a non-recursive mutex that is already owned by the calling thread","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fconcurrency-con\u002Fcon56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F03.concurrency-con\u002F8.con56-cpp",{"title":3491,"path":3492,"stem":3493,"children":3494},"Containers (CTR)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F01.index",[3495,3496,3500,3504,3508,3512,3516,3520,3524,3528],{"title":3491,"path":3492,"stem":3493},{"title":3497,"path":3498,"stem":3499},"CTR50-CPP. Guarantee that container indices and iterators are within the valid range","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F02.ctr50-cpp",{"title":3501,"path":3502,"stem":3503},"CTR51-CPP. Use valid references, pointers, and iterators to reference elements of a container","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F03.ctr51-cpp",{"title":3505,"path":3506,"stem":3507},"CTR52-CPP. Guarantee that library functions do not overflow","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F04.ctr52-cpp",{"title":3509,"path":3510,"stem":3511},"CTR53-CPP. Use valid iterator ranges","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F05.ctr53-cpp",{"title":3513,"path":3514,"stem":3515},"CTR54-CPP. Do not subtract iterators that do not refer to the same container","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F06.ctr54-cpp",{"title":3517,"path":3518,"stem":3519},"CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F07.ctr55-cpp",{"title":3521,"path":3522,"stem":3523},"CTR56-CPP. Do not use pointer arithmetic on polymorphic objects","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F08.ctr56-cpp",{"title":3525,"path":3526,"stem":3527},"CTR57-CPP. Provide a valid ordering predicate","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F09.ctr57-cpp",{"title":3529,"path":3530,"stem":3531},"CTR58-CPP. Predicate function objects should not be mutable","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fcontainers-ctr\u002Fctr58-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F04.containers-ctr\u002F10.ctr58-cpp",{"title":3533,"path":3534,"stem":3535,"children":3536},"Declarations and Initialization (DCL)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F01.index",[3537,3538,3542,3546,3550,3554,3555,3556,3557,3561,3565,3569],{"title":3533,"path":3534,"stem":3535},{"title":3539,"path":3540,"stem":3541},"DCL50-CPP. Do not define a C-style variadic function","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F02.dcl50-cpp",{"title":3543,"path":3544,"stem":3545},"DCL51-CPP. Do not declare or define a reserved identifier","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F03.dcl51-cpp",{"title":3547,"path":3548,"stem":3549},"DCL52-CPP. Never qualify a reference type with const or volatile","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F04.dcl52-cpp",{"title":3551,"path":3552,"stem":3553},"DCL53-CPP. Do not write syntactically ambiguous declarations","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F05.dcl53-cpp",{"title":3349,"path":3295,"stem":3350},{"title":30,"path":3343,"stem":3345},{"title":3352,"path":3309,"stem":3353},{"title":3558,"path":3559,"stem":3560},"DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F09.dcl57-cpp",{"title":3562,"path":3563,"stem":3564},"DCL58-CPP. Do not modify the standard namespaces","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl58-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F10.dcl58-cpp",{"title":3566,"path":3567,"stem":3568},"DCL59-CPP. Do not define an unnamed namespace in a header file","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl59-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F11.dcl59-cpp",{"title":3570,"path":3571,"stem":3572},"DCL60-CPP. Obey the one-definition rule","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fdeclarations-and-initialization-dcl\u002Fdcl60-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F05.declarations-and-initialization-dcl\u002F12.dcl60-cpp",{"title":3574,"path":3575,"stem":3576,"children":3577},"Exceptions and Error Handling (ERR)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F01.index",[3578,3579,3583,3587,3591,3595,3599,3603,3607,3611,3615,3619,3623,3627],{"title":3574,"path":3575,"stem":3576},{"title":3580,"path":3581,"stem":3582},"ERR50-CPP. Do not abruptly terminate the program","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F02.err50-cpp",{"title":3584,"path":3585,"stem":3586},"ERR51-CPP. Handle all exceptions","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F03.err51-cpp",{"title":3588,"path":3589,"stem":3590},"ERR52-CPP. Do not use setjmp() or longjmp()","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F04.err52-cpp",{"title":3592,"path":3593,"stem":3594},"ERR53-CPP. Do not reference base classes or class data members in a constructor or destructor function-try-block handler","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F05.err53-cpp",{"title":3596,"path":3597,"stem":3598},"ERR54-CPP. Catch handlers should order their parameter types from most derived to least derived","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F06.err54-cpp",{"title":3600,"path":3601,"stem":3602},"ERR55-CPP. Honor exception specifications","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F07.err55-cpp",{"title":3604,"path":3605,"stem":3606},"ERR56-CPP. Guarantee exception safety","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F08.err56-cpp",{"title":3608,"path":3609,"stem":3610},"ERR57-CPP. Do not leak resources when handling exceptions","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F09.err57-cpp",{"title":3612,"path":3613,"stem":3614},"ERR58-CPP. Handle all exceptions thrown before main() begins executing","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr58-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F10.err58-cpp",{"title":3616,"path":3617,"stem":3618},"ERR59-CPP. Do not throw an exception across execution boundaries","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr59-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F11.err59-cpp",{"title":3620,"path":3621,"stem":3622},"ERR60-CPP. Exception objects must be nothrow copy constructible","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr60-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F12.err60-cpp",{"title":3624,"path":3625,"stem":3626},"ERR61-CPP. Catch exceptions by lvalue reference","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr61-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F13.err61-cpp",{"title":3628,"path":3629,"stem":3630},"ERR62-CPP. Detect errors when converting a string to a number","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexceptions-and-error-handling-err\u002Ferr62-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F06.exceptions-and-error-handling-err\u002F14.err62-cpp",{"title":3632,"path":3633,"stem":3634,"children":3635},"Expressions (EXP)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F01.index",[3636,3637,3641,3645,3649,3653,3657,3661,3665,3669,3673,3677,3681,3685,3689],{"title":3632,"path":3633,"stem":3634},{"title":3638,"path":3639,"stem":3640},"EXP50-CPP. Do not depend on the order of evaluation for side effects","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F02.exp50-cpp",{"title":3642,"path":3643,"stem":3644},"EXP51-CPP. Do not delete an array through a pointer of the incorrect type","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F03.exp51-cpp",{"title":3646,"path":3647,"stem":3648},"EXP52-CPP. Do not rely on side effects in unevaluated operands","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F04.exp52-cpp",{"title":3650,"path":3651,"stem":3652},"EXP53-CPP. Do not read uninitialized memory","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F05.exp53-cpp",{"title":3654,"path":3655,"stem":3656},"EXP54-CPP. Do not access an object outside of its lifetime","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F06.exp54-cpp",{"title":3658,"path":3659,"stem":3660},"EXP55-CPP. Do not access a cv-qualified object through a cv-unqualified type","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F07.exp55-cpp",{"title":3662,"path":3663,"stem":3664},"EXP56-CPP. Do not call a function with a mismatched language linkage","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F08.exp56-cpp",{"title":3666,"path":3667,"stem":3668},"EXP57-CPP. Do not cast or delete pointers to incomplete classes","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F09.exp57-cpp",{"title":3670,"path":3671,"stem":3672},"EXP58-CPP. Pass an object of the correct type to va_start","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp58-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F10.exp58-cpp",{"title":3674,"path":3675,"stem":3676},"EXP59-CPP. Use offsetof() on valid types and members","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp59-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F11.exp59-cpp",{"title":3678,"path":3679,"stem":3680},"EXP60-CPP. Do not pass a nonstandard-layout type object across execution boundaries","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp60-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F12.exp60-cpp",{"title":3682,"path":3683,"stem":3684},"EXP61-CPP. A lambda object must not outlive any of its reference captured objects","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp61-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F13.exp61-cpp",{"title":3686,"path":3687,"stem":3688},"EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp62-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F14.exp62-cpp",{"title":3690,"path":3691,"stem":3692},"EXP63-CPP. Do not rely on the value of a moved-from object","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fexpressions-exp\u002Fexp63-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F07.expressions-exp\u002F15.exp63-cpp",{"title":3694,"path":3695,"stem":3696,"children":3697},"Input Output (FIO)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Finput-output-fio","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F08.input-output-fio\u002F1.index",[3698,3699,3703],{"title":3694,"path":3695,"stem":3696},{"title":3700,"path":3701,"stem":3702},"FIO50-CPP. Do not alternately input and output from a file stream without an intervening positioning call","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F08.input-output-fio\u002F2.fio50-cpp",{"title":3704,"path":3705,"stem":3706},"FIO51-CPP. Close files when they are no longer needed","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Finput-output-fio\u002Ffio51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F08.input-output-fio\u002F3.fio51-cpp",{"title":3708,"path":3709,"stem":3710,"children":3711},"Integers (INT)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fintegers-int","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F09.integers-int\u002F1.index",[3712,3713],{"title":3708,"path":3709,"stem":3710},{"title":3714,"path":3715,"stem":3716},"INT50-CPP. Do not cast to an out-of-range enumeration value","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fintegers-int\u002Fint50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F09.integers-int\u002F2.int50-cpp",{"title":3718,"path":3719,"stem":3720,"children":3721},"Memory Management (MEM)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F1.index",[3722,3723,3727,3731,3735,3739,3743,3747,3751],{"title":3718,"path":3719,"stem":3720},{"title":3724,"path":3725,"stem":3726},"MEM50-CPP. Do not access freed memory","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F2.mem50-cpp",{"title":3728,"path":3729,"stem":3730},"MEM51-CPP. Properly deallocate dynamically allocated resources","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F3.mem51-cpp",{"title":3732,"path":3733,"stem":3734},"MEM52-CPP. Detect and handle memory allocation errors","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F4.mem52-cpp",{"title":3736,"path":3737,"stem":3738},"MEM53-CPP. Explicitly construct and destruct objects when manually managing object lifetime","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F5.mem53-cpp",{"title":3740,"path":3741,"stem":3742},"MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F6.mem54-cpp",{"title":3744,"path":3745,"stem":3746},"MEM55-CPP. Honor replacement dynamic storage management requirements","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F7.mem55-cpp",{"title":3748,"path":3749,"stem":3750},"MEM56-CPP. Do not store an already-owned pointer value in an unrelated smart pointer","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F8.mem56-cpp",{"title":3752,"path":3753,"stem":3754},"MEM57-CPP. Avoid using default operator new for over-aligned types","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmemory-management-mem\u002Fmem57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F10.memory-management-mem\u002F9.mem57-cpp",{"title":3756,"path":3757,"stem":3758,"children":3759},"Miscellaneous (MSC)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F1.index",[3760,3761,3765,3769,3773,3777],{"title":3756,"path":3757,"stem":3758},{"title":3762,"path":3763,"stem":3764},"MSC51-CPP. Ensure your random number generator is properly seeded","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F2.msc51-cpp",{"title":3766,"path":3767,"stem":3768},"MSC52-CPP. Value-returning functions must return a value from all exit paths","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F3.msc52-cpp",{"title":3770,"path":3771,"stem":3772},"MSC53-CPP. Do not return from a function declared [[noreturn]]","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F4.msc53-cpp",{"title":3774,"path":3775,"stem":3776},"MSC54-CPP. A signal handler must be a plain old function","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Fmsc54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F5.msc54-cpp",{"title":3778,"path":3779,"stem":3780},"rand() for generating pseudorandom numbers","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fmiscellaneous-msc\u002Frand-for-generating-pseudorandom-numbers","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F11.miscellaneous-msc\u002F6.rand-for-generating-pseudorandom-numbers",{"title":3782,"path":3783,"stem":3784,"children":3785},"Object Oriented Programming (OOP)","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F01.index",[3786,3787,3791,3795,3799,3803,3807,3811,3815,3819],{"title":3782,"path":3783,"stem":3784},{"title":3788,"path":3789,"stem":3790},"OOP50-CPP. Do not invoke virtual functions from constructors or destructors","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop50-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F02.oop50-cpp",{"title":3792,"path":3793,"stem":3794},"OOP51-CPP. Do not slice derived objects","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop51-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F03.oop51-cpp",{"title":3796,"path":3797,"stem":3798},"OOP52-CPP. Do not delete a polymorphic object without a virtual destructor","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop52-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F04.oop52-cpp",{"title":3800,"path":3801,"stem":3802},"OOP53-CPP. Write constructor member initializers in the canonical order","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop53-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F05.oop53-cpp",{"title":3804,"path":3805,"stem":3806},"OOP54-CPP. Gracefully handle self-copy assignment","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop54-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F06.oop54-cpp",{"title":3808,"path":3809,"stem":3810},"OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop55-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F07.oop55-cpp",{"title":3812,"path":3813,"stem":3814},"OOP56-CPP. Honor replacement handler requirements","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop56-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F08.oop56-cpp",{"title":3816,"path":3817,"stem":3818},"OOP57-CPP. Prefer special member functions and overloaded operators to C Standard Library functions","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop57-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F09.oop57-cpp",{"title":3820,"path":3821,"stem":3822},"OOP58-CPP. Copy operations must not mutate the source object","\u002Fsei-cert-cpp-coding-standard\u002Frules\u002Fobject-oriented-programming-oop\u002Foop58-cpp","5.sei-cert-cpp-coding-standard\u002F3.rules\u002F12.object-oriented-programming-oop\u002F10.oop58-cpp",{"title":3824,"path":3825,"stem":3826,"children":3827},"Back Matter","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F1.index",[3828,3829,3833,3837,4022,4036],{"title":3824,"path":3825,"stem":3826},{"title":3830,"path":3831,"stem":3832},"AA. Bibliography","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Faa-bibliography","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F2.aa-bibliography",{"title":3834,"path":3835,"stem":3836},"BB. Definitions","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fbb-definitions","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F3.bb-definitions",{"title":3838,"path":3839,"stem":3840,"children":3841},"CC. Analyzers","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F01.index",[3842,3843,3847,3851,3853,3857,3861,3865,3869,3873,3877,3881,3885,3887,3891,3895,3899,3903,3907,3911,3915,3918,3922,3924,3928,3932,3936,3940,3944,3947,3951,3954,3958,3962,3966,3970,3974,3978,3982,3986,3990,3994,3998,4002,4006,4010,4014,4018],{"title":3838,"path":3839,"stem":3840},{"title":3844,"path":3845,"stem":3846},"Astrée","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fastree","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F02.astree",{"title":3848,"path":3849,"stem":3850},"Astrée_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fastree_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F03.astree_v",{"title":3030,"path":3029,"stem":3852},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F04.axivion-bauhaus-suite",{"title":3854,"path":3855,"stem":3856},"Axivion Bauhaus Suite_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Faxivion-bauhaus-suite_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F05.axivion-bauhaus-suite_v",{"title":3858,"path":3859,"stem":3860},"Clang","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F06.clang",{"title":3862,"path":3863,"stem":3864},"Clang_38_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang_38_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F07.clang_38_v",{"title":3866,"path":3867,"stem":3868},"Clang_39_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang_39_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F08.clang_39_v",{"title":3870,"path":3871,"stem":3872},"Clang_40_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang_40_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F09.clang_40_v",{"title":3874,"path":3875,"stem":3876},"Clang_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fclang_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F10.clang_v",{"title":3878,"path":3879,"stem":3880},"Codee","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodee","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F11.codee",{"title":3882,"path":3883,"stem":3884},"Codee_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodee_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F12.codee_v",{"title":3059,"path":3058,"stem":3886},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F13.codesonar",{"title":3888,"path":3889,"stem":3890},"CodeSonar_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcodesonar_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F14.codesonar_v",{"title":3892,"path":3893,"stem":3894},"Coverity","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcoverity","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F15.coverity",{"title":3896,"path":3897,"stem":3898},"Coverity_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fcoverity_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F16.coverity_v",{"title":3900,"path":3901,"stem":3902},"ECLAIR","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Feclair","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F17.eclair",{"title":3904,"path":3905,"stem":3906},"ECLAIR_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Feclair_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F18.eclair_v",{"title":3908,"path":3909,"stem":3910},"EDG","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fedg","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F19.edg",{"title":3912,"path":3913,"stem":3914},"Edg_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fedg_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F20.edg_v",{"title":1693,"path":3916,"stem":3917},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fgcc","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F21.gcc",{"title":3919,"path":3920,"stem":3921},"Gcc_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fgcc_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F22.gcc_v",{"title":3086,"path":3085,"stem":3923},"5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F23.helix-qac",{"title":3925,"path":3926,"stem":3927},"Helix QAC_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fhelix-qac_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F24.helix-qac_v",{"title":3929,"path":3930,"stem":3931},"Klocwork","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fklocwork","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F25.klocwork",{"title":3933,"path":3934,"stem":3935},"Klocwork_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fklocwork_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F26.klocwork_v",{"title":3937,"path":3938,"stem":3939},"LDRA","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fldra","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F27.ldra",{"title":3941,"path":3942,"stem":3943},"Ldra_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fldra_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F28.ldra_v",{"title":3945,"path":3111,"stem":3946},"Parasoft","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F29.parasoft",{"title":3948,"path":3949,"stem":3950},"Parasoft_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fparasoft_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F30.parasoft_v",{"title":3140,"path":3952,"stem":3953},"\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpolyspace-bug-finder","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F31.polyspace-bug-finder",{"title":3955,"path":3956,"stem":3957},"Polyspace Bug Finder_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpolyspace-bug-finder_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F32.polyspace-bug-finder_v",{"title":3959,"path":3960,"stem":3961},"PRQA QA-C++","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fprqa-qa-cpp","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F33.prqa-qa-cpp",{"title":3963,"path":3964,"stem":3965},"PRQA QA-C++_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fprqa-qa-cpp_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F34.prqa-qa-cpp_v",{"title":3967,"path":3968,"stem":3969},"PVS-Studio","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpvs-studio","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F35.pvs-studio",{"title":3971,"path":3972,"stem":3973},"PVS-Studio_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fpvs-studio_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F36.pvs-studio_v",{"title":3975,"path":3976,"stem":3977},"Rose","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frose","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F37.rose",{"title":3979,"path":3980,"stem":3981},"Rose_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frose_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F38.rose_v",{"title":3983,"path":3984,"stem":3985},"RuleChecker","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frulechecker","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F39.rulechecker",{"title":3987,"path":3988,"stem":3989},"RuleChecker_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Frulechecker_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F40.rulechecker_v",{"title":3991,"path":3992,"stem":3993},"Security Reviewer - Static Reviewer","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsecurity-reviewer-static-reviewer","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F41.security-reviewer-static-reviewer",{"title":3995,"path":3996,"stem":3997},"Security Reviewer - Static Reviewer_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsecurity-reviewer-static-reviewer_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F42.security-reviewer-static-reviewer_v",{"title":3999,"path":4000,"stem":4001},"Semgrep","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsemgrep","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F43.semgrep",{"title":4003,"path":4004,"stem":4005},"Semgrep_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsemgrep_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F44.semgrep_v",{"title":4007,"path":4008,"stem":4009},"SonarQube C\u002FC++ Plugin","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsonarqube-ccpp-plugin","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F45.sonarqube-ccpp-plugin",{"title":4011,"path":4012,"stem":4013},"SonarQube C\u002FC++ Plugin_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsonarqube-ccpp-plugin_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F46.sonarqube-ccpp-plugin_v",{"title":4015,"path":4016,"stem":4017},"Splint","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsplint","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F47.splint",{"title":4019,"path":4020,"stem":4021},"Splint_V","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fcc-analyzers\u002Fsplint_v","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F4.cc-analyzers\u002F48.splint_v",{"title":4023,"path":4024,"stem":4025,"children":4026},"DD. Related Guidelines","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fdd-related-guidelines","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F5.dd-related-guidelines\u002F1.index",[4027,4028,4032],{"title":4023,"path":4024,"stem":4025},{"title":4029,"path":4030,"stem":4031},"2008","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fdd-related-guidelines\u002F2.2008","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F5.dd-related-guidelines\u002F2.2008",{"title":4033,"path":4034,"stem":4035},"MITRE CWE","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fdd-related-guidelines\u002Fmitre-cwe","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F5.dd-related-guidelines\u002F3.mitre-cwe",{"title":4037,"path":4038,"stem":4039},"EE. Risk Assessments","\u002Fsei-cert-cpp-coding-standard\u002Fback-matter\u002Fee-risk-assessments","5.sei-cert-cpp-coding-standard\u002F4.back-matter\u002F6.ee-risk-assessments",{"title":4041,"path":4042,"stem":4043,"children":4044},"Admin","\u002Fsei-cert-cpp-coding-standard\u002Fadmin","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F1.index",[4045,4046],{"title":4041,"path":4042,"stem":4043},{"title":4047,"path":4048,"stem":4049},"TODO List","\u002Fsei-cert-cpp-coding-standard\u002Fadmin\u002Ftodo-list","5.sei-cert-cpp-coding-standard\u002F5.admin\u002F2.todo-list",{"title":4051,"path":4052,"stem":4053},"Errata for SEI CERT C++ Coding Standard (2016 Edition)","\u002Fsei-cert-cpp-coding-standard\u002Ferrata-for-sei-cert-cpp-coding-standard-2016-edition","5.sei-cert-cpp-coding-standard\u002F6.errata-for-sei-cert-cpp-coding-standard-2016-edition",1775657779533]