//== 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 using namespace clang; using namespace ento; namespace { class MIGChecker : public Checker, 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. std::vector> Deallocators = { #define CALL(required_args, deallocated_arg, ...) \ {{{__VA_ARGS__}, required_args}, deallocated_arg} // E.g., if the checker sees a C function 'vm_deallocate' that is // defined on class 'IOUserClient' 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"), // 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{{"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(MR); if (VR && VR->hasStackParametersStorage() && VR->getStackFrame()->inTopFrame()) return cast(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 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()) return true; // See if there's an annotated method in the superclass. if (const auto *MD = dyn_cast(D)) for (const auto *OMD: MD->overridden_methods()) if (OMD->hasAttr()) 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(PVD)); } return; } if (!isInMIGCall(C)) return; auto I = llvm::find_if(Deallocators, [&](const std::pair &Item) { return Item.first.matches(Call); }); if (I == Deallocators.end()) return; ProgramStateRef State = C.getState(); unsigned ArgIdx = I->second; SVal Arg = Call.getArgSVal(ArgIdx); const ParmVarDecl *PVD = getOriginParam(Arg, C); if (!PVD || State->contains(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(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()) return; SVal V = C.getSVal(RS); if (mayBeSuccess(V, C)) return; ExplodedNode *N = C.generateErrorNode(); if (!N) return; auto R = std::make_unique( 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(); } bool ento::shouldRegisterMIGChecker(const CheckerManager &mgr) { return true; }