| //== MIGChecker.cpp - MIG calling convention checker ------------*- C++ -*--==// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This file defines MIGChecker, a Mach Interface Generator calling convention | |
| // checker. Namely, in MIG callback implementation the following rules apply: | |
| // - When a server routine returns an error code that represents success, it | |
| // must take ownership of resources passed to it (and eventually release | |
| // them). | |
| // - Additionally, when returning success, all out-parameters must be | |
| // initialized. | |
| // - When it returns any other error code, it must not take ownership, | |
| // because the message and its out-of-line parameters will be destroyed | |
| // by the client that called the function. | |
| // For now we only check the last rule, as its violations lead to dangerous | |
| // use-after-free exploits. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "clang/AST/Attr.h" | |
| #include "clang/Analysis/AnyCall.h" | |
| #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h" | |
| #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h" | |
| #include "clang/StaticAnalyzer/Core/Checker.h" | |
| #include "clang/StaticAnalyzer/Core/CheckerManager.h" | |
| #include "clang/StaticAnalyzer/Core/PathSensitive/CallDescription.h" | |
| #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h" | |
| #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h" | |
| #include <optional> | |
| using namespace clang; | |
| using namespace ento; | |
| namespace { | |
| class MIGChecker : public Checker<check::PostCall, check::PreStmt<ReturnStmt>, | |
| check::EndFunction> { | |
| BugType BT{this, "Use-after-free (MIG calling convention violation)", | |
| categories::MemoryError}; | |
| // The checker knows that an out-of-line object is deallocated if it is | |
| // passed as an argument to one of these functions. If this object is | |
| // additionally an argument of a MIG routine, the checker keeps track of that | |
| // information and issues a warning when an error is returned from the | |
| // respective routine. | |
| CallDescriptionMap<unsigned> Deallocators = { | |
| #define CALL(required_args, deallocated_arg, ...) \ | |
| {{CDM::SimpleFunc, {__VA_ARGS__}, required_args}, deallocated_arg} | |
| // E.g., if the checker sees a C function 'vm_deallocate' that has | |
| // exactly 3 parameters, it knows that argument #1 (starting from 0, i.e. | |
| // the second argument) is going to be consumed in the sense of the MIG | |
| // consume-on-success convention. | |
| CALL(3, 1, "vm_deallocate"), | |
| CALL(3, 1, "mach_vm_deallocate"), | |
| CALL(2, 0, "mig_deallocate"), | |
| CALL(2, 1, "mach_port_deallocate"), | |
| CALL(1, 0, "device_deallocate"), | |
| CALL(1, 0, "iokit_remove_connect_reference"), | |
| CALL(1, 0, "iokit_remove_reference"), | |
| CALL(1, 0, "iokit_release_port"), | |
| CALL(1, 0, "ipc_port_release"), | |
| CALL(1, 0, "ipc_port_release_sonce"), | |
| CALL(1, 0, "ipc_voucher_attr_control_release"), | |
| CALL(1, 0, "ipc_voucher_release"), | |
| CALL(1, 0, "lock_set_dereference"), | |
| CALL(1, 0, "memory_object_control_deallocate"), | |
| CALL(1, 0, "pset_deallocate"), | |
| CALL(1, 0, "semaphore_dereference"), | |
| CALL(1, 0, "space_deallocate"), | |
| CALL(1, 0, "space_inspect_deallocate"), | |
| CALL(1, 0, "task_deallocate"), | |
| CALL(1, 0, "task_inspect_deallocate"), | |
| CALL(1, 0, "task_name_deallocate"), | |
| CALL(1, 0, "thread_deallocate"), | |
| CALL(1, 0, "thread_inspect_deallocate"), | |
| CALL(1, 0, "upl_deallocate"), | |
| CALL(1, 0, "vm_map_deallocate"), | |
| #undef CALL | |
| #define CALL(required_args, deallocated_arg, ...) \ | |
| {{CDM::CXXMethod, {__VA_ARGS__}, required_args}, deallocated_arg} | |
| // E.g., if the checker sees a method 'releaseAsyncReference64()' that is | |
| // defined on class 'IOUserClient' that takes exactly 1 argument, it knows | |
| // that the argument is going to be consumed in the sense of the MIG | |
| // consume-on-success convention. | |
| CALL(1, 0, "IOUserClient", "releaseAsyncReference64"), | |
| CALL(1, 0, "IOUserClient", "releaseNotificationPort"), | |
| #undef CALL | |
| }; | |
| CallDescription OsRefRetain{CDM::SimpleFunc, {"os_ref_retain"}, 1}; | |
| void checkReturnAux(const ReturnStmt *RS, CheckerContext &C) const; | |
| public: | |
| void checkPostCall(const CallEvent &Call, CheckerContext &C) const; | |
| // HACK: We're making two attempts to find the bug: checkEndFunction | |
| // should normally be enough but it fails when the return value is a literal | |
| // that never gets put into the Environment and ends of function with multiple | |
| // returns get agglutinated across returns, preventing us from obtaining | |
| // the return value. The problem is similar to https://reviews.llvm.org/D25326 | |
| // but now we step into it in the top-level function. | |
| void checkPreStmt(const ReturnStmt *RS, CheckerContext &C) const { | |
| checkReturnAux(RS, C); | |
| } | |
| void checkEndFunction(const ReturnStmt *RS, CheckerContext &C) const { | |
| checkReturnAux(RS, C); | |
| } | |
| }; | |
| } // end anonymous namespace | |
| // A flag that says that the programmer has called a MIG destructor | |
| // for at least one parameter. | |
| REGISTER_TRAIT_WITH_PROGRAMSTATE(ReleasedParameter, bool) | |
| // A set of parameters for which the check is suppressed because | |
| // reference counting is being performed. | |
| REGISTER_SET_WITH_PROGRAMSTATE(RefCountedParameters, const ParmVarDecl *) | |
| static const ParmVarDecl *getOriginParam(SVal V, CheckerContext &C, | |
| bool IncludeBaseRegions = false) { | |
| // TODO: We should most likely always include base regions here. | |
| SymbolRef Sym = V.getAsSymbol(IncludeBaseRegions); | |
| if (!Sym) | |
| return nullptr; | |
| // If we optimistically assume that the MIG routine never re-uses the storage | |
| // that was passed to it as arguments when it invalidates it (but at most when | |
| // it assigns to parameter variables directly), this procedure correctly | |
| // determines if the value was loaded from the transitive closure of MIG | |
| // routine arguments in the heap. | |
| while (const MemRegion *MR = Sym->getOriginRegion()) { | |
| const auto *VR = dyn_cast<VarRegion>(MR); | |
| if (VR && VR->hasMemorySpace<StackArgumentsSpaceRegion>(C.getState()) && | |
| VR->getStackFrame()->inTopFrame()) | |
| return cast<ParmVarDecl>(VR->getDecl()); | |
| const SymbolicRegion *SR = MR->getSymbolicBase(); | |
| if (!SR) | |
| return nullptr; | |
| Sym = SR->getSymbol(); | |
| } | |
| return nullptr; | |
| } | |
| static bool isInMIGCall(CheckerContext &C) { | |
| const LocationContext *LC = C.getLocationContext(); | |
| assert(LC && "Unknown location context"); | |
| const StackFrameContext *SFC; | |
| // Find the top frame. | |
| while (LC) { | |
| SFC = LC->getStackFrame(); | |
| LC = SFC->getParent(); | |
| } | |
| const Decl *D = SFC->getDecl(); | |
| if (std::optional<AnyCall> AC = AnyCall::forDecl(D)) { | |
| // Even though there's a Sema warning when the return type of an annotated | |
| // function is not a kern_return_t, this warning isn't an error, so we need | |
| // an extra check here. | |
| // FIXME: AnyCall doesn't support blocks yet, so they remain unchecked | |
| // for now. | |
| if (!AC->getReturnType(C.getASTContext()) | |
| .getCanonicalType()->isSignedIntegerType()) | |
| return false; | |
| } | |
| if (D->hasAttr<MIGServerRoutineAttr>()) | |
| return true; | |
| // See if there's an annotated method in the superclass. | |
| if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) | |
| for (const auto *OMD: MD->overridden_methods()) | |
| if (OMD->hasAttr<MIGServerRoutineAttr>()) | |
| return true; | |
| return false; | |
| } | |
| void MIGChecker::checkPostCall(const CallEvent &Call, CheckerContext &C) const { | |
| if (OsRefRetain.matches(Call)) { | |
| // If the code is doing reference counting over the parameter, | |
| // it opens up an opportunity for safely calling a destructor function. | |
| // TODO: We should still check for over-releases. | |
| if (const ParmVarDecl *PVD = | |
| getOriginParam(Call.getArgSVal(0), C, /*IncludeBaseRegions=*/true)) { | |
| // We never need to clean up the program state because these are | |
| // top-level parameters anyway, so they're always live. | |
| C.addTransition(C.getState()->add<RefCountedParameters>(PVD)); | |
| } | |
| return; | |
| } | |
| if (!isInMIGCall(C)) | |
| return; | |
| const unsigned *ArgIdxPtr = Deallocators.lookup(Call); | |
| if (!ArgIdxPtr) | |
| return; | |
| ProgramStateRef State = C.getState(); | |
| unsigned ArgIdx = *ArgIdxPtr; | |
| SVal Arg = Call.getArgSVal(ArgIdx); | |
| const ParmVarDecl *PVD = getOriginParam(Arg, C); | |
| if (!PVD || State->contains<RefCountedParameters>(PVD)) | |
| return; | |
| const NoteTag *T = | |
| C.getNoteTag([this, PVD](PathSensitiveBugReport &BR) -> std::string { | |
| if (&BR.getBugType() != &BT) | |
| return ""; | |
| SmallString<64> Str; | |
| llvm::raw_svector_ostream OS(Str); | |
| OS << "Value passed through parameter '" << PVD->getName() | |
| << "\' is deallocated"; | |
| return std::string(OS.str()); | |
| }); | |
| C.addTransition(State->set<ReleasedParameter>(true), T); | |
| } | |
| // Returns true if V can potentially represent a "successful" kern_return_t. | |
| static bool mayBeSuccess(SVal V, CheckerContext &C) { | |
| ProgramStateRef State = C.getState(); | |
| // Can V represent KERN_SUCCESS? | |
| if (!State->isNull(V).isConstrainedFalse()) | |
| return true; | |
| SValBuilder &SVB = C.getSValBuilder(); | |
| ASTContext &ACtx = C.getASTContext(); | |
| // Can V represent MIG_NO_REPLY? | |
| static const int MigNoReply = -305; | |
| V = SVB.evalEQ(C.getState(), V, SVB.makeIntVal(MigNoReply, ACtx.IntTy)); | |
| if (!State->isNull(V).isConstrainedTrue()) | |
| return true; | |
| // If none of the above, it's definitely an error. | |
| return false; | |
| } | |
| void MIGChecker::checkReturnAux(const ReturnStmt *RS, CheckerContext &C) const { | |
| // It is very unlikely that a MIG callback will be called from anywhere | |
| // within the project under analysis and the caller isn't itself a routine | |
| // that follows the MIG calling convention. Therefore we're safe to believe | |
| // that it's always the top frame that is of interest. There's a slight chance | |
| // that the user would want to enforce the MIG calling convention upon | |
| // a random routine in the middle of nowhere, but given that the convention is | |
| // fairly weird and hard to follow in the first place, there's relatively | |
| // little motivation to spread it this way. | |
| if (!C.inTopFrame()) | |
| return; | |
| if (!isInMIGCall(C)) | |
| return; | |
| // We know that the function is non-void, but what if the return statement | |
| // is not there in the code? It's not a compile error, we should not crash. | |
| if (!RS) | |
| return; | |
| ProgramStateRef State = C.getState(); | |
| if (!State->get<ReleasedParameter>()) | |
| return; | |
| SVal V = C.getSVal(RS); | |
| if (mayBeSuccess(V, C)) | |
| return; | |
| ExplodedNode *N = C.generateErrorNode(); | |
| if (!N) | |
| return; | |
| auto R = std::make_unique<PathSensitiveBugReport>( | |
| BT, | |
| "MIG callback fails with error after deallocating argument value. " | |
| "This is a use-after-free vulnerability because the caller will try to " | |
| "deallocate it again", | |
| N); | |
| R->addRange(RS->getSourceRange()); | |
| bugreporter::trackExpressionValue( | |
| N, RS->getRetValue(), *R, | |
| {bugreporter::TrackingKind::Thorough, /*EnableNullFPSuppression=*/false}); | |
| C.emitReport(std::move(R)); | |
| } | |
| void ento::registerMIGChecker(CheckerManager &Mgr) { | |
| Mgr.registerChecker<MIGChecker>(); | |
| } | |
| bool ento::shouldRegisterMIGChecker(const CheckerManager &mgr) { | |
| return true; | |
| } |