SVF::BufOverflowDetector Class Reference

Detector for identifying buffer overflow issues. More...

#include <AEDetector.h>

Inheritance diagram for SVF::BufOverflowDetector:

Public Member Functions
	BufOverflowDetector ()
	Constructor initializes the detector kind to BUF_OVERFLOW and sets up external API buffer overflow rules.
	~BufOverflowDetector ()=default
	Destructor.
void	updateGepObjOffsetFromBase (AddressValue gepAddrs, AddressValue objAddrs, IntervalValue offset)
	Updates the offset of a GEP object from its base.
void	detect (AbstractState &as, const ICFGNode *)
	Detect buffer overflow issues within a node.
void	handleStubFunctions (const CallICFGNode *)
	Handles external API calls related to buffer overflow detection.
void	addToGepObjOffsetFromBase (const GepObjVar *obj, const IntervalValue &offset)
	Adds an offset to a GEP object.
bool	hasGepObjOffsetFromBase (const GepObjVar *obj) const
	Checks if a GEP object has an associated offset.
IntervalValue	getGepObjOffsetFromBase (const GepObjVar *obj) const
	Retrieves the offset of a GEP object from its base.
IntervalValue	getAccessOffset (AbstractState &as, NodeID objId, const GepStmt *gep)
	Retrieves the access offset for a given object and GEP statement.
void	addBugToReporter (const AEException &e, const ICFGNode *node)
	Adds a bug to the reporter based on an exception.
void	reportBug ()
	Reports all detected buffer overflow bugs.
void	initExtAPIBufOverflowCheckRules ()
	Initializes external API buffer overflow check rules.
void	detectExtAPI (AbstractState &as, const CallICFGNode *call)
	Handles external API calls related to buffer overflow detection.
bool	canSafelyAccessMemory (AbstractState &as, const SVFVar *value, const IntervalValue &len)
	Checks if memory can be safely accessed.
Public Member Functions inherited from SVF::AEDetector
	AEDetector ()
	Constructor initializes the detector kind to UNKNOWN.
virtual	~AEDetector ()=default
	Virtual destructor for safe polymorphic use.
DetectorKind	getKind () const
	Get the kind of the detector.

Static Public Member Functions
static bool	classof (const AEDetector *detector)
	Check if the detector is of the BUF_OVERFLOW kind.
Static Public Member Functions inherited from SVF::AEDetector
static bool	classof (const AEDetector *detector)
	Check if the detector is of the UNKNOWN kind.

Private Member Functions
bool	detectStrcat (AbstractState &as, const CallICFGNode *call)
	Detects buffer overflow in 'strcat' function calls.
bool	detectStrcpy (AbstractState &as, const CallICFGNode *call)
	Detects buffer overflow in 'strcpy' function calls.

Private Attributes
Map< const GepObjVar *, IntervalValue >	gepObjOffsetFromBase
	Maps GEP objects to their offsets from the base.
Map< std::string, std::vector< std::pair< u32_t, u32_t > > >	extAPIBufOverflowCheckRules
	Rules for checking buffer overflows in external APIs.
Set< std::string >	bugLoc
	Set of locations where bugs have been reported.
SVFBugReport	recoder
	Recorder for abstract execution bugs.
Map< const ICFGNode *, std::string >	nodeToBugInfo
	Maps ICFG nodes to bug information.

Friends
class	AbstractInterpretation

Additional Inherited Members
Public Types inherited from SVF::AEDetector
enum	DetectorKind { BUF_OVERFLOW , UNKNOWN }
	Enumerates the types of detectors available. More...
Protected Attributes inherited from SVF::AEDetector
DetectorKind	kind
	The kind of the detector.

Detailed Description

Detector for identifying buffer overflow issues.

Definition at line 133 of file AEDetector.h.

Constructor & Destructor Documentation

BufOverflowDetector()

SVF::BufOverflowDetector::BufOverflowDetector ( )

inline

Constructor initializes the detector kind to BUF_OVERFLOW and sets up external API buffer overflow rules.

Definition at line 140 of file AEDetector.h.

    {
        kind = BUF_OVERFLOW;
        initExtAPIBufOverflowCheckRules();
    }

~BufOverflowDetector()

SVF::BufOverflowDetector::~BufOverflowDetector ( )

default

Destructor.

Member Function Documentation

addBugToReporter()

void SVF::BufOverflowDetector::addBugToReporter ( const AEException &  e, const ICFGNode *  node  )

inline

Adds a bug to the reporter based on an exception.

Parameters

e	The exception that was thrown.
node	Pointer to the ICFG node where the bug was detected.

Definition at line 232 of file AEDetector.h.

    {
 
        GenericBug::EventStack eventStack;
        SVFBugEvent sourceInstEvent(SVFBugEvent::EventType::SourceInst, node);
        eventStack.push_back(sourceInstEvent); // Add the source instruction event to the event stack
 
        if (eventStack.empty())
        {
            return; // If the event stack is empty, return early
        }
 
        std::string loc = eventStack.back().getEventLoc(); // Get the location of the last event in the stack
 
        // Check if the bug at this location has already been reported
        if (bugLoc.find(loc) != bugLoc.end())
        {
            return; // If the bug location is already reported, return early
        }
        else
        {
            bugLoc.insert(loc); // Otherwise, mark this location as reported
        }
 
        // Add the bug to the recorder with details from the event stack
        recoder.addAbsExecBug(GenericBug::FULLBUFOVERFLOW, eventStack, 0, 0, 0, 0);
        nodeToBugInfo[node] = e.what(); // Record the exception information for the node
    }

addToGepObjOffsetFromBase()

void SVF::BufOverflowDetector::addToGepObjOffsetFromBase ( const GepObjVar *  obj, const IntervalValue &  offset  )

inline

Adds an offset to a GEP object.

Parameters

obj	Pointer to the GEP object.
offset	The interval value of the offset.

Definition at line 190 of file AEDetector.h.

    {
        gepObjOffsetFromBase[obj] = offset;
    }

canSafelyAccessMemory()

bool BufOverflowDetector::canSafelyAccessMemory	(	AbstractState &	as,
		const SVFVar *	value,
		const IntervalValue &	len
	)

Checks if memory can be safely accessed.

Checks if a memory access is safe given a specific buffer length.

Parameters

as	Reference to the abstract state.
value	Pointer to the SVF var.
len	The interval value representing the length of the memory access.

Returns

True if the memory access is safe, false otherwise.

This function ensures that a given memory access, starting at a specific value, does not exceed the allocated size of the buffer.

Parameters

as	Reference to the abstract state.
value	Pointer to the SVF var.
len	The interval value representing the length of the memory access.

Returns

True if the memory access is safe, false otherwise.

Definition at line 455 of file AEDetector.cpp.

{
    SVFIR* svfir = PAG::getPAG();
    NodeID value_id = value->getId();
 
    assert(as[value_id].isAddr());
    for (const auto& addr : as[value_id].getAddrs())
    {
        NodeID objId = AbstractState::getInternalID(addr);
        u32_t size = 0;
 
        // if the object is a constant size object, get the size directly
        if (svfir->getBaseObject(objId)->isConstantByteSize())
        {
            size = svfir->getBaseObject(objId)->getByteSizeOfObj();
        }
        else
        {
            // if the object is not a constant size object, get the size from the addrStmt
            const ICFGNode* addrNode = svfir->getBaseObject(objId)->getICFGNode();
            for (const SVFStmt* stmt2 : addrNode->getSVFStmts())
            {
                if (const AddrStmt* addrStmt = SVFUtil::dyn_cast<AddrStmt>(stmt2))
                {
                    size = as.getAllocaInstByteSize(addrStmt);
                }
            }
        }
 
        IntervalValue offset(0);
        // if the object is a GepObjVar, get the offset from the base object
        if (SVFUtil::isa<GepObjVar>(svfir->getGNode(objId)))
        {
            offset = getGepObjOffsetFromBase(SVFUtil::cast<GepObjVar>(svfir->getGNode(objId))) + len;
        }
        else
        {
            // if the object is a BaseObjVar, get the offset directly
            offset = len;
        }
        // if the offset is greater than the size, return false
        if (offset.ub().getIntNumeral() >= size)
        {
            return false;
        }
    }
    return true;
}

classof()

static bool SVF::BufOverflowDetector::classof ( const AEDetector *  detector )

inlinestatic

Check if the detector is of the BUF_OVERFLOW kind.

Parameters

detector

Pointer to the detector.

Returns

True if the detector is of type BUF_OVERFLOW, false otherwise.

Definition at line 156 of file AEDetector.h.

    {
        return detector->getKind() == AEDetector::BUF_OVERFLOW;
    }

detect()

void BufOverflowDetector::detect ( AbstractState &  as, const ICFGNode *  node  )

virtual

Detect buffer overflow issues within a node.

Detects buffer overflow issues within a given ICFG node.

Parameters

as	Reference to the abstract state.
node	Pointer to the ICFG node.

This function handles both non-call nodes, where it analyzes GEP (GetElementPtr) instructions for potential buffer overflows, and call nodes, where it checks for external API calls that may cause overflows.

Parameters

as	Reference to the abstract state.
node	Pointer to the ICFG node.

Implements SVF::AEDetector.

Definition at line 44 of file AEDetector.cpp.

{
    if (!SVFUtil::isa<CallICFGNode>(node))
    {
        // Handle non-call nodes by analyzing GEP instructions
        for (const SVFStmt* stmt : node->getSVFStmts())
        {
            if (const GepStmt* gep = SVFUtil::dyn_cast<GepStmt>(stmt))
            {
                SVFIR* svfir = PAG::getPAG();
                NodeID lhs = gep->getLHSVarID();
                NodeID rhs = gep->getRHSVarID();
 
                // Update the GEP object offset from its base
                updateGepObjOffsetFromBase(as[lhs].getAddrs(), as[rhs].getAddrs(), as.getByteOffset(gep));
 
                IntervalValue baseObjSize = IntervalValue::bottom();
                AddressValue objAddrs = as[gep->getRHSVarID()].getAddrs();
                for (const auto& addr : objAddrs)
                {
                    NodeID objId = AbstractState::getInternalID(addr);
                    u32_t size = 0;
 
                    if (svfir->getBaseObject(objId)->isConstantByteSize())
                    {
                        size = svfir->getBaseObject(objId)->getByteSizeOfObj();
                    }
                    else
                    {
                        const ICFGNode* addrNode = svfir->getBaseObject(objId)->getICFGNode();
                        for (const SVFStmt* stmt2 : addrNode->getSVFStmts())
                        {
                            if (const AddrStmt* addrStmt = SVFUtil::dyn_cast<AddrStmt>(stmt2))
                            {
                                size = as.getAllocaInstByteSize(addrStmt);
                            }
                        }
                    }
 
                    // Calculate access offset and check for potential overflow
                    IntervalValue accessOffset = getAccessOffset(as, objId, gep);
                    if (accessOffset.ub().getIntNumeral() >= size)
                    {
                        AEException bug(stmt->toString());
                        addBugToReporter(bug, stmt->getICFGNode());
                    }
                }
            }
        }
    }
    else
    {
        // Handle call nodes by checking for external API calls
        const CallICFGNode* callNode = SVFUtil::cast<CallICFGNode>(node);
        if (SVFUtil::isExtCall(callNode->getCalledFunction()))
        {
            detectExtAPI(as, callNode);
        }
    }
}

detectExtAPI()

void BufOverflowDetector::detectExtAPI	(	AbstractState &	as,
		const CallICFGNode *	call
	)

Handles external API calls related to buffer overflow detection.

Parameters

as	Reference to the abstract state.
call	Pointer to the call ICFG node.

This function checks the type of external memory API (e.g., memcpy, memset, strcpy, strcat) and applies the corresponding buffer overflow checks based on predefined rules.

Parameters

as	Reference to the abstract state.
call	Pointer to the call ICFG node.

Definition at line 219 of file AEDetector.cpp.

{
    assert(call->getCalledFunction() && "FunObjVar* is nullptr");
 
    AbsExtAPI::ExtAPIType extType = AbsExtAPI::UNCLASSIFIED;
 
    // Determine the type of external memory API
    for (const std::string &annotation : ExtAPI::getExtAPI()->getExtFuncAnnotations(call->getCalledFunction()))
    {
        if (annotation.find("MEMCPY") != std::string::npos)
            extType = AbsExtAPI::MEMCPY;
        if (annotation.find("MEMSET") != std::string::npos)
            extType = AbsExtAPI::MEMSET;
        if (annotation.find("STRCPY") != std::string::npos)
            extType = AbsExtAPI::STRCPY;
        if (annotation.find("STRCAT") != std::string::npos)
            extType = AbsExtAPI::STRCAT;
    }
 
    // Apply buffer overflow checks based on the determined API type
    if (extType == AbsExtAPI::MEMCPY)
    {
        if (extAPIBufOverflowCheckRules.count(call->getCalledFunction()->getName()) == 0)
        {
            SVFUtil::errs() << "Warning: " << call->getCalledFunction()->getName() << " is not in the rules, please implement it\n";
            return;
        }
        std::vector<std::pair<u32_t, u32_t>> args =
                                              extAPIBufOverflowCheckRules.at(call->getCalledFunction()->getName());
        for (auto arg : args)
        {
            IntervalValue offset = as[call->getArgument(arg.second)->getId()].getInterval() - IntervalValue(1);
            const SVFVar* argVar = call->getArgument(arg.first);
            if (!canSafelyAccessMemory(as, argVar, offset))
            {
                AEException bug(call->toString());
                addBugToReporter(bug, call);
            }
        }
    }
    else if (extType == AbsExtAPI::MEMSET)
    {
        if (extAPIBufOverflowCheckRules.count(call->getCalledFunction()->getName()) == 0)
        {
            SVFUtil::errs() << "Warning: " << call->getCalledFunction()->getName() << " is not in the rules, please implement it\n";
            return;
        }
        std::vector<std::pair<u32_t, u32_t>> args =
                                              extAPIBufOverflowCheckRules.at(call->getCalledFunction()->getName());
        for (auto arg : args)
        {
            IntervalValue offset = as[call->getArgument(arg.second)->getId()].getInterval() - IntervalValue(1);
            const SVFVar* argVar = call->getArgument(arg.first);
            if (!canSafelyAccessMemory(as, argVar, offset))
            {
                AEException bug(call->toString());
                addBugToReporter(bug, call);
            }
        }
    }
    else if (extType == AbsExtAPI::STRCPY)
    {
        if (!detectStrcpy(as, call))
        {
            AEException bug(call->toString());
            addBugToReporter(bug, call);
        }
    }
    else if (extType == AbsExtAPI::STRCAT)
    {
        if (!detectStrcat(as, call))
        {
            AEException bug(call->toString());
            addBugToReporter(bug, call);
        }
    }
    else
    {
        // Handle other cases
    }
}

detectStrcat()

bool BufOverflowDetector::detectStrcat ( AbstractState &  as, const CallICFGNode *  call  )

private

Detects buffer overflow in 'strcat' function calls.

Parameters

as	Reference to the abstract state.
call	Pointer to the call ICFG node.

Returns

True if a buffer overflow is detected, false otherwise.

This function checks if the destination buffer can safely accommodate both the existing string and the concatenated string from the source.

Parameters

as	Reference to the abstract state.
call	Pointer to the call ICFG node.

Returns

True if the memory access is safe, false otherwise.

Definition at line 414 of file AEDetector.cpp.

{
    const std::vector<std::string> strcatGroup = {"__strcat_chk", "strcat", "__wcscat_chk", "wcscat"};
    const std::vector<std::string> strncatGroup = {"__strncat_chk", "strncat", "__wcsncat_chk", "wcsncat"};
 
    if (std::find(strcatGroup.begin(), strcatGroup.end(), call->getCalledFunction()->getName()) != strcatGroup.end())
    {
        const SVFVar* arg0Val = call->getArgument(0);
        const SVFVar* arg1Val = call->getArgument(1);
        IntervalValue strLen0 = AbstractInterpretation::getAEInstance().getUtils()->getStrlen(as, arg0Val);
        IntervalValue strLen1 = AbstractInterpretation::getAEInstance().getUtils()->getStrlen(as, arg1Val);
        IntervalValue totalLen = strLen0 + strLen1;
        return canSafelyAccessMemory(as, arg0Val, totalLen);
    }
    else if (std::find(strncatGroup.begin(), strncatGroup.end(), call->getCalledFunction()->getName()) != strncatGroup.end())
    {
        const SVFVar* arg0Val = call->getArgument(0);
        const SVFVar* arg2Val = call->getArgument(2);
        IntervalValue arg2Num = as[arg2Val->getId()].getInterval();
        IntervalValue strLen0 = AbstractInterpretation::getAEInstance().getUtils()->getStrlen(as, arg0Val);
        IntervalValue totalLen = strLen0 + arg2Num;
        return canSafelyAccessMemory(as, arg0Val, totalLen);
    }
    else
    {
        assert(false && "Unknown strcat function, please add it to strcatGroup or strncatGroup");
        abort();
    }
}

detectStrcpy()

bool BufOverflowDetector::detectStrcpy ( AbstractState &  as, const CallICFGNode *  call  )

private

Detects buffer overflow in 'strcpy' function calls.

Parameters

as	Reference to the abstract state.
call	Pointer to the call ICFG node.

Returns

True if a buffer overflow is detected, false otherwise.

This function checks if the destination buffer can safely accommodate the source string being copied, accounting for the null terminator.

Parameters

as	Reference to the abstract state.
call	Pointer to the call ICFG node.

Returns

True if the memory access is safe, false otherwise.

Definition at line 396 of file AEDetector.cpp.

{
    const SVFVar* arg0Val = call->getArgument(0);
    const SVFVar* arg1Val = call->getArgument(1);
    IntervalValue strLen = AbstractInterpretation::getAEInstance().getUtils()->getStrlen(as, arg1Val);
    return canSafelyAccessMemory(as, arg0Val, strLen);
}

getAccessOffset()

IntervalValue BufOverflowDetector::getAccessOffset	(	SVF::AbstractState &	as,
		SVF::NodeID	objId,
		const GepStmt *	gep
	)

Retrieves the access offset for a given object and GEP statement.

Parameters

as	Reference to the abstract state.
objId	The ID of the object.
gep	Pointer to the GEP statement.

Returns

The interval value of the access offset.

This function calculates the access offset for a base object or a sub-object of an aggregate object (using GEP). If the object is a dummy object, it returns a top interval value.

Parameters

as	Reference to the abstract state.
objId	The ID of the object.
gep	Pointer to the GEP statement.

Returns

The interval value of the access offset.

Definition at line 313 of file AEDetector.cpp.

{
    SVFIR* svfir = PAG::getPAG();
    auto obj = svfir->getGNode(objId);
 
    // if the object is a BaseObjVar, return the byte offset directly
    if (SVFUtil::isa<BaseObjVar>(obj))
    {
        return as.getByteOffset(gep);
    }
    else if (SVFUtil::isa<GepObjVar>(obj))
    {
        // if the object is a GepObjVar, return the offset from the base object
        return getGepObjOffsetFromBase(SVFUtil::cast<GepObjVar>(obj)) + as.getByteOffset(gep);
    }
    else
    {
        assert(SVFUtil::isa<DummyObjVar>(obj) && "Unknown object type");
        return IntervalValue::top();
    }
}

getGepObjOffsetFromBase()

IntervalValue SVF::BufOverflowDetector::getGepObjOffsetFromBase ( const GepObjVar *  obj ) const

inline

Retrieves the offset of a GEP object from its base.

Parameters

obj	Pointer to the GEP object.

Returns

The interval value of the offset.

Definition at line 210 of file AEDetector.h.

    {
        if (hasGepObjOffsetFromBase(obj))
            return gepObjOffsetFromBase.at(obj);
        else
            assert(false && "GepObjVar not found in gepObjOffsetFromBase");
    }

handleStubFunctions()

void BufOverflowDetector::handleStubFunctions ( const CallICFGNode *  callNode )

virtual

Handles external API calls related to buffer overflow detection.

Handles stub functions within the ICFG node.

Parameters

call	Pointer to the call ICFG node.

This function is a placeholder for handling stub functions within the ICFG node.

Parameters

node	Pointer to the ICFG node.

Implements SVF::AEDetector.

Definition at line 113 of file AEDetector.cpp.

{
    // get function name
    std::string funcName = callNode->getCalledFunction()->getName();
    if (funcName == "SAFE_BUFACCESS")
    {
        // void SAFE_BUFACCESS(void* data, int size);
        AbstractInterpretation::getAEInstance().checkpoints.erase(callNode);
        if (callNode->arg_size() < 2)
            return;
        AbstractState& as =
            AbstractInterpretation::getAEInstance().getAbsStateFromTrace(
                callNode);
        u32_t size_id = callNode->getArgument(1)->getId();
        IntervalValue val = as[size_id].getInterval();
        if (val.isBottom())
        {
            val = IntervalValue(0);
            assert(false && "SAFE_BUFACCESS size is bottom");
        }
        const SVFVar* arg0Val = callNode->getArgument(0);
        bool isSafe = canSafelyAccessMemory(as, arg0Val, val);
        if (isSafe)
        {
            std::cout << "safe buffer access success: " << callNode->toString()
                      << std::endl;
            return;
        }
        else
        {
            std::string err_msg = "this SAFE_BUFACCESS should be a safe access but detected buffer overflow. Pos: ";
            err_msg += callNode->getSourceLoc();
            std::cerr << err_msg << std::endl;
            assert(false);
        }
    }
    else if (funcName == "UNSAFE_BUFACCESS")
    {
        // handle other stub functions
        //void UNSAFE_BUFACCESS(void* data, int size);
        AbstractInterpretation::getAEInstance().checkpoints.erase(callNode);
        if (callNode->arg_size() < 2) return;
        AbstractState&as = AbstractInterpretation::getAEInstance().getAbsStateFromTrace(callNode);
        u32_t size_id = callNode->getArgument(1)->getId();
        IntervalValue val = as[size_id].getInterval();
        if (val.isBottom())
        {
            assert(false && "UNSAFE_BUFACCESS size is bottom");
        }
        const SVFVar* arg0Val = callNode->getArgument(0);
        bool isSafe = canSafelyAccessMemory(as, arg0Val, val);
        if (!isSafe)
        {
            std::cout << "detect buffer overflow success: " << callNode->toString() << std::endl;
            return;
        }
        else
        {
            std::string err_msg = "this UNSAFE_BUFACCESS should be a buffer overflow but not detected. Pos: ";
            err_msg += callNode->getSourceLoc();
            std::cerr << err_msg << std::endl;
            assert(false);
        }
    }
}

hasGepObjOffsetFromBase()

bool SVF::BufOverflowDetector::hasGepObjOffsetFromBase ( const GepObjVar *  obj ) const

inline

Checks if a GEP object has an associated offset.

Parameters

obj	Pointer to the GEP object.

Returns

True if the GEP object has an offset, false otherwise.

Definition at line 200 of file AEDetector.h.

    {
        return gepObjOffsetFromBase.find(obj) != gepObjOffsetFromBase.end();
    }

initExtAPIBufOverflowCheckRules()

void BufOverflowDetector::initExtAPIBufOverflowCheckRules

(

)

Initializes external API buffer overflow check rules.

This function sets up rules for various memory-related functions like memcpy, memset, etc., defining which arguments should be checked for buffer overflows.

Definition at line 185 of file AEDetector.cpp.

{
    extAPIBufOverflowCheckRules["llvm_memcpy_p0i8_p0i8_i64"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["llvm_memcpy_p0_p0_i64"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["llvm_memcpy_p0i8_p0i8_i32"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["llvm_memcpy"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["llvm_memmove"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["llvm_memmove_p0i8_p0i8_i64"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["llvm_memmove_p0_p0_i64"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["llvm_memmove_p0i8_p0i8_i32"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["__memcpy_chk"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["memmove"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["bcopy"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["memccpy"] = {{0, 3}, {1, 3}};
    extAPIBufOverflowCheckRules["__memmove_chk"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["llvm_memset"] = {{0, 2}};
    extAPIBufOverflowCheckRules["llvm_memset_p0i8_i32"] = {{0, 2}};
    extAPIBufOverflowCheckRules["llvm_memset_p0i8_i64"] = {{0, 2}};
    extAPIBufOverflowCheckRules["llvm_memset_p0_i64"] = {{0, 2}};
    extAPIBufOverflowCheckRules["__memset_chk"] = {{0, 2}};
    extAPIBufOverflowCheckRules["wmemset"] = {{0, 2}};
    extAPIBufOverflowCheckRules["strncpy"] = {{0, 2}, {1, 2}};
    extAPIBufOverflowCheckRules["iconv"] = {{1, 2}, {3, 4}};
}

reportBug()

void SVF::BufOverflowDetector::reportBug ( )

inlinevirtual

Reports all detected buffer overflow bugs.

Implements SVF::AEDetector.

Definition at line 264 of file AEDetector.h.

    {
        if (!nodeToBugInfo.empty())
        {
            std::cerr << "######################Buffer Overflow (" + std::to_string(nodeToBugInfo.size())
                      + " found)######################\n";
            std::cerr << "---------------------------------------------\n";
            for (const auto& it : nodeToBugInfo)
            {
                std::cerr << it.second << "\n---------------------------------------------\n";
            }
        }
    }

updateGepObjOffsetFromBase()

void BufOverflowDetector::updateGepObjOffsetFromBase	(	SVF::AddressValue	gepAddrs,
		SVF::AddressValue	objAddrs,
		SVF::IntervalValue	offset
	)

Updates the offset of a GEP object from its base.

Parameters

gepAddrs	Address value for GEP.
objAddrs	Address value for the object.
offset	The interval value of the offset.

This function calculates and stores the offset of a GEP object from its base object using the addresses and offsets provided.

Parameters

gepAddrs	The addresses of the GEP objects.
objAddrs	The addresses of the base objects.
offset	The interval value of the offset.

Definition at line 345 of file AEDetector.cpp.

{
    SVFIR* svfir = PAG::getPAG();
 
    for (const auto& objAddr : objAddrs)
    {
        NodeID objId = AbstractState::getInternalID(objAddr);
        auto obj = svfir->getGNode(objId);
        // if the object is a BaseObjVar, add the offset directly
        if (SVFUtil::isa<BaseObjVar>(obj))
        {
            for (const auto& gepAddr : gepAddrs)
            {
                NodeID gepObj = AbstractState::getInternalID(gepAddr);
                const GepObjVar* gepObjVar = SVFUtil::cast<GepObjVar>(svfir->getGNode(gepObj));
                addToGepObjOffsetFromBase(gepObjVar, offset);
            }
        }
        else if (SVFUtil::isa<GepObjVar>(obj))
        {
            // if the object is a GepObjVar, add the offset from the base object
            const GepObjVar* objVar = SVFUtil::cast<GepObjVar>(obj);
            for (const auto& gepAddr : gepAddrs)
            {
                NodeID gepObj = AbstractState::getInternalID(gepAddr);
                const GepObjVar* gepObjVar = SVFUtil::cast<GepObjVar>(svfir->getGNode(gepObj));
                if (hasGepObjOffsetFromBase(objVar))
                {
                    IntervalValue objOffsetFromBase = getGepObjOffsetFromBase(objVar);
                    if (!hasGepObjOffsetFromBase(gepObjVar))
                        addToGepObjOffsetFromBase(gepObjVar, objOffsetFromBase + offset);
                }
                else
                {
                    assert(false && "GEP RHS object has no offset from base");
                }
            }
        }
    }
}

Friends And Related Symbol Documentation

AbstractInterpretation

friend class AbstractInterpretation

friend

Definition at line 135 of file AEDetector.h.

Member Data Documentation

bugLoc

Set<std::string> SVF::BufOverflowDetector::bugLoc

private

Set of locations where bugs have been reported.

Definition at line 319 of file AEDetector.h.

extAPIBufOverflowCheckRules

Map<std::string, std::vector<std::pair<u32_t, u32_t> > > SVF::BufOverflowDetector::extAPIBufOverflowCheckRules

private

Rules for checking buffer overflows in external APIs.

Definition at line 318 of file AEDetector.h.

gepObjOffsetFromBase

Map<const GepObjVar*, IntervalValue> SVF::BufOverflowDetector::gepObjOffsetFromBase

private

Maps GEP objects to their offsets from the base.

Definition at line 317 of file AEDetector.h.

nodeToBugInfo

Map<const ICFGNode*, std::string> SVF::BufOverflowDetector::nodeToBugInfo

private

Maps ICFG nodes to bug information.

Definition at line 321 of file AEDetector.h.

recoder

SVFBugReport SVF::BufOverflowDetector::recoder

private

Recorder for abstract execution bugs.

Definition at line 320 of file AEDetector.h.

---

The documentation for this class was generated from the following files:

• /home/runner/work/SVF/SVF/svf/include/AE/Svfexe/AEDetector.h
• /home/runner/work/SVF/SVF/svf/lib/AE/Svfexe/AEDetector.cpp