/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2018 Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

// Buffer overrun..

//---------------------------------------------------------------------------

#include "checkbufferoverrun.h"

#include "astutils.h"

#include "library.h"

#include "mathlib.h"

#include "settings.h"

#include "symboldatabase.h"

#include "token.h"

#include "tokenize.h"

#include "tokenlist.h"

#include "utils.h"

#include "valueflow.h"

#include <tinyxml2.h>

#include <algorithm>

#include <cstdlib>

#include <sstream>

#include <stack>

#include <utility>

//---------------------------------------------------------------------------

// Register this check class (by creating a static instance of it)

namespace {

CheckBufferOverrun instance;

}

//---------------------------------------------------------------------------

// CWE ids used:

static const CWE CWE131(131U); // Incorrect Calculation of Buffer Size

static const CWE CWE170(170U); // Improper Null Termination

static const CWE CWE398(398U); // Indicator of Poor Code Quality

static const CWE CWE682(682U); // Incorrect Calculation

static const CWE CWE758(758U); // Reliance on Undefined, Unspecified, or Implementation-Defined Behavior

static const CWE CWE786(786U); // Access of Memory Location Before Start of Buffer

static const CWE CWE788(788U); // Access of Memory Location After End of Buffer

//---------------------------------------------------------------------------

static void makeArrayIndexOutOfBoundsError(std::ostream& oss, const CheckBufferOverrun::ArrayInfo &arrayInfo, const std::vector<MathLib::bigint> &index)

{

oss << "$symbol:" << arrayInfo.varname() << '\n';

oss << "Array '" << arrayInfo.varname();

for (std::size_t i = 0; i < arrayInfo.num().size(); ++i)

oss << "[" << arrayInfo.num(i) << "]";

if (index.size() == 1)

oss << "' accessed at index " << index[0] << ", which is";

else {

oss << "' index " << arrayInfo.varname();

for (std::size_t i = 0; i < index.size(); ++i)

oss << "[" << index[i] << "]";

}

oss << " out of bounds.";

}

void CheckBufferOverrun::arrayIndexOutOfBoundsError(const Token *tok, const ArrayInfo &arrayInfo, const std::vector<MathLib::bigint> &index)

{

std::ostringstream oss;

makeArrayIndexOutOfBoundsError(oss, arrayInfo, index);

reportError(tok, Severity::error, "arrayIndexOutOfBounds", oss.str(), CWE788, false);

}

void CheckBufferOverrun::arrayIndexOutOfBoundsError(const Token *tok, const ArrayInfo &arrayInfo, const std::vector<ValueFlow::Value> &index)

{

bool inconclusive = false;

const Token *condition = nullptr;

for (std::size_t i = 0; i < index.size(); ++i) {

inconclusive |= index[i].isInconclusive();

if (condition == nullptr)

condition = index[i].condition;

}

std::list<ErrorPathItem> errorPath;

if (mSettings->xml || !mSettings->templateLocation.empty()) {

for (std::size_t i = 0; i < index.size(); ++i) {

const ErrorPath &e = getErrorPath(tok, &index[i], "");

for (ErrorPath::const_iterator it = e.begin(); it != e.end(); ++it) {

const std::string &info = it->second;

if (info.empty())

continue;

std::string nr;

if (index.size() > 1U)

nr = "(" + MathLib::toString(i + 1) + getOrdinalText(i + 1) + " array index) ";

errorPath.emplace_back(it->first, nr + info);

}

}

errorPath.emplace_back(tok,"Array index out of bounds");

} else {

errorPath.emplace_back(tok, "Array index out of bounds");

if (condition)

errorPath.emplace_back(condition, "Assuming that condition '" + condition->expressionString() + "' is not redundant");

}

if (condition != nullptr) {

if (!mSettings->isEnabled(Settings::WARNING))

return;

std::ostringstream errmsg;

errmsg << "$symbol:" << arrayInfo.varname() << '\n';

errmsg << ValueFlow::eitherTheConditionIsRedundant(condition) << " or the array '$symbol";

for (std::size_t i = 0; i < arrayInfo.num().size(); ++i)

errmsg << "[" << arrayInfo.num(i) << "]";

if (index.size() == 1)

errmsg << "' is accessed at index " << index[0].intvalue << ", which is out of bounds.";

else {

errmsg << "' index " << arrayInfo.varname();

for (std::size_t i = 0; i < index.size(); ++i)

errmsg << "[" << index[i].intvalue << "]";

errmsg << " is out of bounds.";

}

reportError(errorPath, Severity::warning, "arrayIndexOutOfBoundsCond", errmsg.str(), CWE119, inconclusive);

} else {

std::ostringstream errmsg;

errmsg << "$symbol:" << arrayInfo.varname() << '\n';

errmsg << "Array '$symbol";

for (std::size_t i = 0; i < arrayInfo.num().size(); ++i)

errmsg << "[" << arrayInfo.num(i) << "]";

if (index.size() == 1)

errmsg << "' accessed at index " << index[0].intvalue << ", which is out of bounds.";

else {

errmsg << "' index " << arrayInfo.varname();

for (std::size_t i = 0; i < index.size(); ++i)

errmsg << "[" << index[i].intvalue << "]";

errmsg << " out of bounds.";

}

reportError(errorPath, Severity::error, "arrayIndexOutOfBounds", errmsg.str(), CWE119, inconclusive);

}

}

void CheckBufferOverrun::arrayIndexOutOfBoundsError(const std::list<const Token *> &callstack, const ArrayInfo &arrayInfo, const std::vector<MathLib::bigint> &index)

{

std::ostringstream oss;

makeArrayIndexOutOfBoundsError(oss, arrayInfo, index);

reportError(callstack, Severity::error, "arrayIndexOutOfBounds", oss.str());

}

static std::string bufferOverrunMessage(std::string varnames)

{

varnames.erase(std::remove(varnames.begin(), varnames.end(), ' '), varnames.end());

std::string errmsg("Buffer is accessed out of bounds");

if (!varnames.empty())

errmsg = "$symbol:" + varnames + '\n' + errmsg + ": " + varnames;

else

errmsg += ".";

return errmsg;

}

void CheckBufferOverrun::bufferOverrunError(const Token *tok, const std::string &varnames)

{

reportError(tok, Severity::error, "bufferAccessOutOfBounds", bufferOverrunMessage(varnames), CWE788, false);

}

void CheckBufferOverrun::bufferOverrunError(const std::list<const Token *> &callstack, const std::string &varnames)

{

reportError(callstack, Severity::error, "bufferAccessOutOfBounds", bufferOverrunMessage(varnames));

}

void CheckBufferOverrun::possibleBufferOverrunError(const Token *tok, const std::string &src, const std::string &dst, bool cat)

{

if (cat)

reportError(tok, Severity::warning, "possibleBufferAccessOutOfBounds",

"Possible buffer overflow if strlen(" + src + ") is larger than sizeof(" + dst + ")-strlen(" + dst +").\n"

"Possible buffer overflow if strlen(" + src + ") is larger than sizeof(" + dst + ")-strlen(" + dst +"). "

"The source buffer is larger than the destination buffer so there is the potential for overflowing the destination buffer.", CWE398, false);

else

reportError(tok, Severity::warning, "possibleBufferAccessOutOfBounds",

"Possible buffer overflow if strlen(" + src + ") is larger than or equal to sizeof(" + dst + ").\n"

"Possible buffer overflow if strlen(" + src + ") is larger than or equal to sizeof(" + dst + "). "

"The source buffer is larger than the destination buffer so there is the potential for overflowing the destination buffer.", CWE398, false);

}

void CheckBufferOverrun::strncatUsageError(const Token *tok)

{

if (mSettings && !mSettings->isEnabled(Settings::WARNING))

return;

reportError(tok, Severity::warning, "strncatUsage",

"Dangerous usage of strncat - 3rd parameter is the maximum number of characters to append.\n"

"At most, strncat appends the 3rd parameter's amount of characters and adds a terminating null byte.\n"

"The safe way to use strncat is to subtract one from the remaining space in the buffer and use it as 3rd parameter."

"Source: http://www.cplusplus.com/reference/cstring/strncat/\n"

"Source: http://www.opensource.apple.com/source/Libc/Libc-167/gen.subproj/i386.subproj/strncat.c", CWE119, false);

}

void CheckBufferOverrun::outOfBoundsError(const Token *tok, const std::string &what, const bool show_size_info, const MathLib::bigint &supplied_size, const MathLib::bigint &actual_size)

{

std::ostringstream oss;

oss << what << " is out of bounds";

if (show_size_info)

oss << ": Supplied size " << supplied_size << " is larger than actual size " << actual_size;

oss << '.';

reportError(tok, Severity::error, "outOfBounds", oss.str(), CWE788, false);

}

void CheckBufferOverrun::pointerOutOfBoundsError(const Token *tok, const Token *index, const MathLib::bigint indexvalue)

{

// The severity is portability instead of error since this ub doesn't

// cause bad behaviour on most implementations. people create out

// of bounds pointers by intention.

const std::string expr(tok ? tok->expressionString() : std::string());

std::string errmsg;

if (index && !index->isNumber()) {

errmsg = "Undefined behaviour, when '" +

index->expressionString() +

"' is " +

MathLib::toString(indexvalue) +

" the pointer arithmetic '" + expr + "' is out of bounds";

} else {

errmsg = "Undefined behaviour, pointer arithmetic '" + expr + "' is out of bounds";

}

const std::string verbosemsg(errmsg + ". From chapter 6.5.6 in the C specification:\n"

"\"When an expression that has integer type is added to or subtracted from a pointer, ..\" and then \"If both the pointer operand and the result point to elements of the same array object, or one past the last element of the array object, the evaluation shall not produce an overflow; otherwise, the behavior is undefined.\"");

reportError(tok, Severity::portability, "pointerOutOfBounds", errmsg + ".\n" + verbosemsg, CWE398, false);

/*

"Undefined behaviour: The result of this pointer arithmetic does not point into

or just one element past the end of the " + object + ".

Further information:

https://www.securecoding.cert.org/confluence/display/seccode/ARR30-C.+Do+not+form+or+use+out+of+bounds+pointers+or+array+subscripts");

*/

}

void CheckBufferOverrun::sizeArgumentAsCharError(const Token *tok)

{

if (mSettings && !mSettings->isEnabled(Settings::WARNING))

return;

reportError(tok, Severity::warning, "sizeArgumentAsChar", "The size argument is given as a char constant.", CWE682, false);

}

void CheckBufferOverrun::terminateStrncpyError(const Token *tok, const std::string &varname)

{

const std::string shortMessage = "The buffer '$symbol' may not be null-terminated after the call to strncpy().";

reportError(tok, Severity::warning, "terminateStrncpy",

"$symbol:" + varname + '\n' +

shortMessage + '\n' +

shortMessage + ' ' +

"If the source string's size fits or exceeds the given size, strncpy() does not add a "

"zero at the end of the buffer. This causes bugs later in the code if the code "

"assumes buffer is null-terminated.", CWE170, true);

}

void CheckBufferOverrun::cmdLineArgsError(const Token *tok)

{

reportError(tok, Severity::error, "insecureCmdLineArgs", "Buffer overrun possible for long command line arguments.", CWE119, false);

}

void CheckBufferOverrun::bufferNotZeroTerminatedError(const Token *tok, const std::string &varname, const std::string &function)

{

const std::string errmsg = "$symbol:" + varname + '\n' +

"$symbol:" + function + '\n' +

"The buffer '" + varname + "' is not null-terminated after the call to " + function + "().\n"

"The buffer '" + varname + "' is not null-terminated after the call to " + function + "(). "

"This will cause bugs later in the code if the code assumes the buffer is null-terminated.";

reportError(tok, Severity::warning, "bufferNotZeroTerminated", errmsg, CWE170, true);

}

void CheckBufferOverrun::argumentSizeError(const Token *tok, const std::string &functionName, const std::string &varname)

{

reportError(tok, Severity::warning, "argumentSize",

"$symbol:" + functionName + '\n' +

"$symbol:" + varname + '\n' +

"The array '" + varname + "' is too small, the function '" + functionName + "' expects a bigger one.", CWE398, false);

}

void CheckBufferOverrun::negativeMemoryAllocationSizeError(const Token *tok)

{

reportError(tok, Severity::error, "negativeMemoryAllocationSize",

"Memory allocation size is negative.\n"

"Memory allocation size is negative."

"Negative allocation size has no specified behaviour.", CWE131, false);

}

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------

// Check array usage..

//---------------------------------------------------------------------------

static bool isAddressOf(const Token *tok)

{

const Token *tok2 = tok->astParent();

while (Token::Match(tok2, "%name%|.|::|["))

tok2 = tok2->astParent();

return tok2 && tok2->isUnaryOp("&");

}

/**

* bailout if variable is used inside if/else/switch block or if there is "break"

* @param tok token for "if" or "switch"

* @param varid variable id

* @return is bailout recommended?

*/

static bool bailoutIfSwitch(const Token *tok, const unsigned int varid)

{

const Token* end = tok->linkAt(1)->linkAt(1);

if (Token::simpleMatch(end, "} else {")) // scan the else-block

end = end->linkAt(2);

if (Token::simpleMatch(end, "{")) // Ticket #5203: Invalid code, bailout

return true;

// Used later to check if the body belongs to a "if"

const bool is_if = tok->str() == "if";

for (; tok && tok != end; tok = tok->next()) {

// If scanning a "if" block then bailout for "break"

if (is_if && (tok->str() == "break" || tok->str() == "continue"))

return true;

// bailout for "return"

else if (tok->str() == "return")

return true;

// bailout if varid is found

else if (tok->varId() == varid)

return true;

}

// No bailout stuff found => return false

return false;

}

//---------------------------------------------------------------------------

static bool checkMinSizes(const std::vector<Library::ArgumentChecks::MinSize> &minsizes, const Token * const ftok, const MathLib::bigint arraySize, const Token **charSizeToken, const Settings * const settings)

{

if (charSizeToken)

*charSizeToken = nullptr;

if (minsizes.empty())

return false;

// All conditions must be true

bool error = true;

for (std::vector<Library::ArgumentChecks::MinSize>::const_iterator minsize = minsizes.begin(); minsize != minsizes.end(); ++minsize) {

if (!error)

return false;

error = false;

const Token *argtok = ftok->tokAt(2);

for (int argnum = 1; argtok && argnum < minsize->arg; argnum++)

argtok = argtok->nextArgument();

if (!argtok)

return false;

switch (minsize->type) {

case Library::ArgumentChecks::MinSize::ARGVALUE:

if (Token::Match(argtok, "%num% ,|)")) {

const MathLib::bigint sz = MathLib::toLongNumber(argtok->str());

if (sz > arraySize)

error = true;

} else if (argtok->tokType() == Token::eChar && Token::Match(argtok->next(), ",|)") && charSizeToken)

*charSizeToken = argtok; //sizeArgumentAsCharError(argtok);

break;

case Library::ArgumentChecks::MinSize::MUL:

// TODO: handle arbitrary arg2

if (minsize->arg2 == minsize->arg+1 && Token::Match(argtok, "%num% , %num% ,|)")) {

const MathLib::bigint sz = MathLib::toLongNumber(argtok->str()) * MathLib::toLongNumber(argtok->strAt(2));

if (sz > arraySize)

error = true;

}

break;

case Library::ArgumentChecks::MinSize::STRLEN: {

if (settings->library.isargformatstr(ftok,minsize->arg)) {

std::list<const Token *> parameters;

const std::string &formatstr(argtok->str());

const Token *argtok2 = argtok;

while ((argtok2 = argtok2->nextArgument()) != nullptr) {

if (Token::Match(argtok2, "%num%|%str% [,)]"))

parameters.push_back(argtok2);

else

parameters.push_back(nullptr);

}

const MathLib::biguint len = CheckBufferOverrun::countSprintfLength(formatstr, parameters);

if (len > arraySize + 2)

error = true;

} else {

const Token *strtoken = argtok->getValueTokenMaxStrLength();

if (strtoken && Token::getStrLength(strtoken) >= arraySize)

error = true;

}

}

break;

case Library::ArgumentChecks::MinSize::SIZEOF:

if (argtok->tokType() == Token::eString && Token::getStrLength(argtok) >= arraySize)

error = true;

break;

case Library::ArgumentChecks::MinSize::NONE:

return false;

};

}

return error;

}

void CheckBufferOverrun::checkFunctionParameter(const Token &ftok, unsigned int paramIndex, const ArrayInfo &arrayInfo, const std::list<const Token *>& callstack)

{

const std::vector<Library::ArgumentChecks::MinSize> * const minsizes = mSettings->library.argminsizes(&ftok, paramIndex);

if (minsizes) {

MathLib::bigint arraySize = arrayInfo.element_size();

if (arraySize == 0)

return;

for (std::size_t i = 0; i < arrayInfo.num().size(); ++i)

arraySize *= arrayInfo.num(i);

// dimension is 0 or unknown => bailout

if (arraySize == 0)

return;

const Token *charSizeToken = nullptr;

if (checkMinSizes(*minsizes, &ftok, arraySize, &charSizeToken, mSettings))

bufferOverrunError(callstack, arrayInfo.varname());

if (charSizeToken)

sizeArgumentAsCharError(charSizeToken);

}

// Calling a user function?

// only 1-dimensional arrays can be checked currently

else if (arrayInfo.num().size() == 1) {

const Function* const func = ftok.function();

if (func && func->hasBody()) {

// Get corresponding parameter..

const Variable* const parameter = func->getArgumentVar(paramIndex-1);

// Ensure that it has a compatible size..

if (!parameter || sizeOfType(parameter->typeStartToken()) != arrayInfo.element_size())

return;

// No variable id occur for instance when:

// - Variable function arguments: "void f(...)"

// - Unnamed parameter: "void f(char *)"

if (parameter->declarationId() == 0)

return;

// Check the parameter usage in the function scope..

for (const Token* ftok2 = func->functionScope->bodyStart; ftok2 != func->functionScope->bodyEnd; ftok2 = ftok2->next()) {

if (Token::Match(ftok2, "if|for|switch|while (")) {

// bailout if there is buffer usage..

if (bailoutIfSwitch(ftok2, parameter->declarationId())) {

break;

}

// no bailout is needed. skip the if-block

else {

// goto end of if block..

ftok2 = ftok2->linkAt(1)->linkAt(1);

if (Token::simpleMatch(ftok2, "} else {"))

ftok2 = ftok2->linkAt(2);

if (!ftok2)

break;

continue;

}

}

if (ftok2->str() == "}")

break;

if (ftok2->varId() == parameter->declarationId()) {

if (Token::Match(ftok2->previous(), "-- %name%") ||

Token::Match(ftok2, "%name% --"))

break;

if (Token::Match(ftok2->previous(), ";|{|}|%op% %name% [ %num% ]")) {

const MathLib::bigint index = MathLib::toLongNumber(ftok2->strAt(2));

if (index >= 0 && arrayInfo.num(0) > 0 && index >= arrayInfo.num(0)) {

std::list<const Token *> callstack2(callstack);

callstack2.push_back(ftok2);

const std::vector<MathLib::bigint> indexes(1, index);

arrayIndexOutOfBoundsError(callstack2, arrayInfo, indexes);

}

}

}

// Calling function..

if (Token::Match(ftok2, "%name% (")) {

ArrayInfo ai(arrayInfo);

ai.declarationId(parameter->declarationId());

checkFunctionCall(ftok2, ai, callstack);

}

}

}

}

// Check 'float x[10]' arguments in declaration

if (mSettings->isEnabled(Settings::WARNING)) {

const Function* const func = ftok.function();

// If argument is '%type% a[num]' then check bounds against num

if (func) {

const Variable* const argument = func->getArgumentVar(paramIndex-1);

const Token *nameToken;

if (argument && Token::Match(argument->typeStartToken(), "%type% %var% [ %num% ] [,)[]")

&& (nameToken = argument->nameToken()) != nullptr) {

const Token *tok2 = nameToken->next();

MathLib::bigint argsize = sizeOfType(argument->typeStartToken());

if (argsize == 100) // unknown size

argsize = 0;

do {

argsize *= MathLib::toLongNumber(tok2->strAt(1));

tok2 = tok2->tokAt(3);

} while (Token::Match(tok2, "[ %num% ] [,)[]"));

MathLib::bigint arraysize = arrayInfo.element_size();

if (arraysize == 100) // unknown size

arraysize = 0;

for (std::size_t i = 0; i < arrayInfo.num().size(); i++)

arraysize *= arrayInfo.num(i);

if (Token::Match(tok2, "[,)]") && arraysize > 0 && argsize > arraysize)

argumentSizeError(&ftok, ftok.str(), arrayInfo.varname());

}

}

}

}

void CheckBufferOverrun::checkFunctionCall(const Token *tok, const ArrayInfo &arrayInfo, std::list<const Token *> callstack)

{

// Don't go deeper than 2 levels, the checking can get very slow

// when there is no limit

if (callstack.size() >= 2)

return;

// Prevent recursion

for (std::list<const Token*>::const_iterator it = callstack.cbegin(); it != callstack.cend(); ++it) {

// Same function name => bail out

if (tok->str() == (*it)->str())

return;

}

callstack.push_back(tok);

const unsigned int declarationId = arrayInfo.declarationId();

const Token *argtok = tok->tokAt(2);

unsigned int argnr = 1U;

while (argtok) {

if (Token::Match(argtok, "%varid% ,|)", declarationId))

checkFunctionParameter(*tok, argnr, arrayInfo, callstack);

else if (Token::Match(argtok, "%varid% + %num% ,|)", declarationId)) {

const ArrayInfo ai(arrayInfo.limit(MathLib::toLongNumber(argtok->strAt(2))));

checkFunctionParameter(*tok, argnr, ai, callstack);

}

// goto next parameter..

argtok = argtok->nextArgument();

argnr++;

}

}

void CheckBufferOverrun::checkScope(const Token *tok, const std::vector<const std::string*> &varname, const ArrayInfo &arrayInfo)

{

const MathLib::bigint size = arrayInfo.num(0);

if (size <= 0) // unknown size

return;

if (tok->str() == "return") {

tok = tok->next();

if (!tok)

return;

}

const bool printInconclusive = mSettings->inconclusive;

const MathLib::bigint total_size = arrayInfo.element_size() * size;

const unsigned int declarationId = arrayInfo.declarationId();

std::string varnames;

for (std::size_t i = 0; i < varname.size(); ++i)

varnames += (i == 0 ? "" : " . ") + *varname[i];

const int varcount = varname.empty() ? 0 : static_cast<int>((varname.size() - 1) * 2U);

// ValueFlow array index..

if ((declarationId > 0 && Token::Match(tok, "%varid% [", declarationId)) ||

(declarationId == 0 && Token::simpleMatch(tok, (varnames + " [").c_str()))) {

const Token *tok2 = tok->next();

while (tok2->str() != "[")

tok2 = tok2->next();

valueFlowCheckArrayIndex(tok2, arrayInfo);

}

// If the result of pointer arithmetic means that the pointer is

// out of bounds then this flag will be set.

bool pointerIsOutOfBounds = false;

const bool printPortability = mSettings->isEnabled(Settings::PORTABILITY);

for (const Token* const end = tok->scope()->bodyEnd; tok && tok != end; tok = tok->next()) {

if (declarationId != 0 && Token::Match(tok, "%varid% = new|malloc|realloc", declarationId)) {

// Abort

break;

}

// reassign buffer

if (declarationId > 0 && Token::Match(tok, "[;{}] %varid% = %any%", declarationId)) {

// using varid .. bailout

if (tok->tokAt(3)->varId() != declarationId)

break;

pointerIsOutOfBounds = false;

}

// Array index..

if ((declarationId > 0 && ((tok->str() == "return" || (!tok->isName() && !Token::Match(tok, "[.&]"))) && Token::Match(tok->next(), "%varid% [", declarationId))) ||

(declarationId == 0 && ((tok->str() == "return" || (!tok->isName() && !Token::Match(tok, "[.&]"))) && (Token::Match(tok->next(), (varnames + " [").c_str()) || Token::Match(tok->next(), (*varname[0] +" [ %num% ] . " + *varname[1] + " [ %num% ]").c_str()))))) {

std::vector<MathLib::bigint> indexes;

const Token *tok2 = tok->tokAt(2 + varcount);

for (; Token::Match(tok2, "[ %num% ]"); tok2 = tok2->tokAt(3)) {

const MathLib::bigint index = MathLib::toLongNumber(tok2->strAt(1));

indexes.push_back(index);

}

for (; Token::Match(tok2->tokAt(3), "[ %num% ]"); tok2 = tok2->tokAt(3)) {

const MathLib::bigint index = MathLib::toLongNumber(tok2->strAt(4));

indexes.push_back(index);

}

if (indexes.empty() && arrayInfo.num().size() == 1U && Token::simpleMatch(tok2, "[") && tok2->astOperand2()) {

const ValueFlow::Value *value = tok2->astOperand2()->getMaxValue(false);

if (value) {

indexes.push_back(value->intvalue);

}

}

if (indexes.size() == arrayInfo.num().size()) {

// Check if the indexes point outside the whole array..

// char a[10][10];

// a[0][20] <-- ok.

// a[9][20] <-- error.

// total number of elements of array..

MathLib::bigint totalElements = 1;

// total index..

MathLib::bigint totalIndex = 0;

// calculate the totalElements and totalIndex..

for (std::size_t i = 0; i < indexes.size(); ++i) {

const std::size_t ri = indexes.size() - 1 - i;

totalIndex += indexes[ri] * totalElements;

totalElements *= arrayInfo.num(ri);

if (arrayInfo.num(ri) == -1) {

// unknown size

totalElements = 0;

break;

}

}

// totalElements == 0 => Unknown size

if (totalElements == 0)

continue;

const Token *tok3 = tok->previous();

while (tok3 && Token::Match(tok3->previous(), "%name% ."))

tok3 = tok3->tokAt(-2);

// taking address of 1 past end?

if (totalIndex == totalElements) {

const bool addr = (tok3 && (tok3->str() == "&" ||

Token::simpleMatch(tok3->previous(), "& (")));

if (addr)

continue;

}

// Is totalIndex in bounds?

if (totalIndex > totalElements || totalIndex < 0) {

arrayIndexOutOfBoundsError(tok->tokAt(1 + varcount), arrayInfo, indexes);

}

// Is any array index out of bounds?

else {

// check each index for overflow

for (std::size_t i = 0; i < indexes.size(); ++i) {

if (indexes[i] >= arrayInfo.num(i)) {

if (indexes.size() == 1U) {

arrayIndexOutOfBoundsError(tok->tokAt(1 + varcount), arrayInfo, indexes);

break; // only warn about the first one

}

// The access is still within the memory range for the array

// so it may be intentional.

else if (printInconclusive) {

arrayIndexOutOfBoundsError(tok->tokAt(1 + varcount), arrayInfo, indexes);

break; // only warn about the first one

}

}

}

}

}

tok = tok2;

continue;

}

// memset, memcmp, memcpy, strncpy, fgets..

if (declarationId == 0 && Token::Match(tok, "%name% ( !!)")) {

std::list<const Token *> callstack(1, tok);

const Token* tok2 = tok->tokAt(2);

if (Token::Match(tok2, (varnames + " ,").c_str()))

checkFunctionParameter(*tok, 1, arrayInfo, callstack);

tok2 = tok2->nextArgument();

if (Token::Match(tok2, (varnames + " ,").c_str()))

checkFunctionParameter(*tok, 2, arrayInfo, callstack);

}

if (total_size > 0) {

// Writing data into array..

if ((declarationId > 0 && Token::Match(tok, "strcpy|strcat ( %varid% , %str%|%var% )", declarationId)) ||

(declarationId == 0 && Token::Match(tok, ("strcpy|strcat ( " + varnames + " , %str%|%var% )").c_str()))) {

const Token* lastParamTok = tok->tokAt(varcount + 4);

if (lastParamTok->tokType() == Token::Type::eString) {

const std::size_t len = Token::getStrLength(lastParamTok);

if (len >= total_size) {

bufferOverrunError(tok, declarationId > 0 ? emptyString : varnames);

continue;

}

} else {

const Variable *var = lastParamTok->variable();

if (var && var->isArray() && var->dimensions().size() == 1) {

const MathLib::bigint len = var->dimension(0);

if (len > total_size) {

if (printInconclusive)

possibleBufferOverrunError(tok, tok->strAt(4), tok->strAt(2), tok->str() == "strcat");

continue;

}

}

}

}

// Detect few strcat() calls

const std::string strcatPattern = declarationId > 0 ? std::string("strcat ( %varid% , %str% ) ;") : ("strcat ( " + varnames + " , %str% ) ;");

if (Token::Match(tok, strcatPattern.c_str(), declarationId)) {

std::size_t charactersAppend = 0;

const Token *tok2 = tok;

do {

charactersAppend += Token::getStrLength(tok2->tokAt(4 + varcount));

if (charactersAppend >= static_cast<std::size_t>(total_size)) {

bufferOverrunError(tok2);

break;

}

tok2 = tok2->tokAt(7 + varcount);

} while (Token::Match(tok2, strcatPattern.c_str(), declarationId));

}

// Check function call..

if (Token::Match(tok, "%name% (")) {

// No varid => function calls are not handled

if (declarationId == 0)

continue;

const ArrayInfo arrayInfo1(declarationId, varnames, total_size / size, size);

const std::list<const Token *> callstack;

checkFunctionCall(tok, arrayInfo1, callstack);

}

}

// undefined behaviour: result of pointer arithmetic is out of bounds

if (declarationId && Token::Match(tok, "= %varid% + %num% ;", declarationId)) {

const MathLib::bigint index = MathLib::toLongNumber(tok->strAt(3));

if (printPortability && index > size)

pointerOutOfBoundsError(tok->tokAt(2));

if (index >= size && Token::Match(tok->tokAt(-2), "[;{}] %varid% =", declarationId))

pointerIsOutOfBounds = true;

}

else if (pointerIsOutOfBounds && Token::Match(tok, "[;{}=] * %varid% [;=]", declarationId)) {

outOfBoundsError(tok->tokAt(2), tok->strAt(2), false, 0, 0);

}

}

}

static std::vector<ValueFlow::Value> valueFlowGetArrayIndexes(const Token * const tok, bool conditional, std::size_t dimensions)

{

unsigned int indexvarid = 0;

const std::vector<ValueFlow::Value> empty;

std::vector<ValueFlow::Value> indexes;

for (const Token *tok2 = tok; indexes.size() < dimensions && Token::simpleMatch(tok2, "["); tok2 = tok2->link()->next()) {

if (!tok2->astOperand2())

return empty;

const ValueFlow::Value *index = tok2->astOperand2()->getMaxValue(conditional);

if (!index)

return empty;

if (indexvarid == 0U)

indexvarid = index->varId;

if (index->varId > 0 && indexvarid != index->varId)

return empty;

if (index->intvalue < 0)

return empty;

indexes.push_back(*index);

}

return indexes;

}

void CheckBufferOverrun::valueFlowCheckArrayIndex(const Token * const tok, const ArrayInfo &arrayInfo)

{

// Declaration in global scope or namespace?

if (tok->scope()->type == Scope::eGlobal || tok->scope()->type == Scope::eNamespace)

return;

/*

{

const Token *parent = tok->astParent();

while (Token::Match(parent, "%name%|::|*|&"))

parent = parent->astParent();

if (parent && !Token::simpleMatch(parent, "="))

return;

}

*/

const bool printInconclusive = mSettings->inconclusive;

// Taking address?

const bool addressOf = isAddressOf(tok);

// Look for errors first

for (int warn = 0; warn == 0 || warn == 1; ++warn) {

// Negative index..

for (const Token *tok2 = tok; tok2 && tok2->str() == "["; tok2 = tok2->link()->next()) {

const Token *index = tok2->astOperand2();

if (!index)

continue;

const ValueFlow::Value *value = index->getValueLE(-1LL,mSettings);

if (value)

negativeIndexError(index, *value);

}

// Index out of bounds..

const std::vector<ValueFlow::Value> indexes(valueFlowGetArrayIndexes(tok, warn==1, arrayInfo.num().size()));

if (indexes.size() != arrayInfo.num().size())

continue;

// Check if the indexes point outside the whole array..

// char a[10][10];

// a[0][20] <-- ok.

// a[9][20] <-- error.

// total number of elements of array..

const MathLib::bigint totalElements = arrayInfo.numberOfElements();

// total index..

const MathLib::bigint totalIndex = arrayInfo.totalIndex(indexes);

// totalElements <= 0 => Unknown size

if (totalElements <= 0)

continue;

if (addressOf && totalIndex == totalElements)

continue;

// Is totalIndex in bounds?

if (totalIndex >= totalElements) {

arrayIndexOutOfBoundsError(tok, arrayInfo, indexes);

break;

}

// Is any array index out of bounds?

if (printInconclusive) {

// check each index for overflow

for (std::size_t i = 0; i < indexes.size(); ++i) {

if (indexes[i].intvalue >= arrayInfo.num(i)) {

// The access is still within the memory range for the array

// so it may be intentional.

arrayIndexOutOfBoundsError(tok, arrayInfo, indexes);

break; // only warn about the first one

}

}

}

}

}

void CheckBufferOverrun::checkScope(const Token *tok, const ArrayInfo &arrayInfo)

{

bool reassigned = false;

for (const Token* const end = tok->scope()->bodyEnd; tok != end; tok = tok->next()) {

if (reassigned && tok->str() == ";")

break;

if (tok->varId() != arrayInfo.declarationId())

continue;

if (tok->strAt(1) == "=") {

reassigned = true;

}

checkScope_inner(tok, arrayInfo);

}

}

void CheckBufferOverrun::checkScope(const Token *tok, std::map<unsigned int, ArrayInfo> arrayInfos)

{

unsigned int reassigned = 0;

for (const Token* const end = tok->scope()->bodyEnd; tok != end; tok = tok->next()) {

if (reassigned && tok->str() == ";") {

arrayInfos.erase(reassigned);

reassigned = 0;

}

if (!tok->variable() || tok->variable()->nameToken() == tok)

continue;

const std::map<unsigned int, ArrayInfo>::const_iterator arrayInfo = arrayInfos.find(tok->varId());

if (arrayInfo == arrayInfos.cend())

continue;

if (tok->strAt(1) == "=") {

reassigned = tok->varId();

}

checkScope_inner(tok, arrayInfo->second);

}

}

void CheckBufferOverrun::checkScope_inner(const Token *tok, const ArrayInfo &arrayInfo)

{

const bool printPortability = mSettings->isEnabled(Settings::PORTABILITY);

const bool printWarning = mSettings->isEnabled(Settings::WARNING);

const bool printInconclusive = mSettings->inconclusive;

const Token *astParent = tok->astParent();

if (tok->strAt(1) == "[") {

valueFlowCheckArrayIndex(tok->next(), arrayInfo);

}

else if (printPortability && !tok->isCast() && astParent && astParent->str() == "+") {

// undefined behaviour: result of pointer arithmetic is out of bounds

const Token *index;

if (tok == astParent->astOperand1())

index = astParent->astOperand2();

else

index = astParent->astOperand1();

if (index) {

const ValueFlow::Value *value = index->getValueGE(arrayInfo.num(0) + 1U, mSettings);

if (!value)

value = index->getValueLE(-1, mSettings);

if (value)

pointerOutOfBoundsError(astParent, index, value->intvalue);

}

}

else if (printPortability && astParent && astParent->str() == "-") {

const SymbolDatabase *symbolDatabase = mTokenizer->getSymbolDatabase();

const Variable *var = symbolDatabase->getVariableFromVarId(arrayInfo.declarationId());

if (var && var->isArray()) {

const Token *index = astParent->astOperand2();

const ValueFlow::Value *value = index ? index->getValueGE(1,mSettings) : nullptr;

if (index && !value)

value = index->getValueLE(-1 - arrayInfo.num(0), mSettings);

if (value)

pointerOutOfBoundsError(astParent, index, value->intvalue);

}

}

if (!tok->scope()->isExecutable()) // No executable code outside of executable scope - continue to increase performance

return;

const Token* tok2 = astParent;

if (tok2) {

while (tok2->astParent() && !Token::Match(tok2->astParent(), "[,(]"))

tok2 = tok2->astParent();

while (tok2->astParent() && tok2->astParent()->str() == ",")

tok2 = tok2->astParent();

if (tok2->astParent() && tok2->astParent()->str() == "(")

tok2 = tok2->astParent();

if (tok2->str() != "(")

return;

tok2 = tok2->previous();

// Check function call..