contrib/llvm/tools/clang/lib/StaticAnalyzer/Checkers/CStringSyntaxChecker.cpp

   1 //== CStringSyntaxChecker.cpp - CoreFoundation containers API *- C++ -*-==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // An AST checker that looks for common pitfalls when using C string APIs.
  11 //  - Identifies erroneous patterns in the last argument to strncat - the number
  12 //    of bytes to copy.
  13 //
  14 //===----------------------------------------------------------------------===//
  15 #include "ClangSACheckers.h"
  16 #include "clang/AST/Expr.h"
  17 #include "clang/AST/OperationKinds.h"
  18 #include "clang/AST/StmtVisitor.h"
  19 #include "clang/Analysis/AnalysisContext.h"
  20 #include "clang/Basic/TargetInfo.h"
  21 #include "clang/Basic/TypeTraits.h"
  22 #include "clang/StaticAnalyzer/Core/BugReporter/BugReporter.h"
  23 #include "clang/StaticAnalyzer/Core/Checker.h"
  24 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
  25 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
  26 #include "llvm/ADT/SmallString.h"
  27 #include "llvm/Support/raw_ostream.h"
  28
  29 using namespace clang;
  30 using namespace ento;
  31
  32 namespace {
  33 class WalkAST: public StmtVisitor<WalkAST> {
  34   BugReporter &BR;
  35   AnalysisDeclContext* AC;
  36
  37   /// Check if two expressions refer to the same declaration.
  38   inline bool sameDecl(const Expr *A1, const Expr *A2) {
  39     if (const DeclRefExpr *D1 = dyn_cast<DeclRefExpr>(A1->IgnoreParenCasts()))
  40       if (const DeclRefExpr *D2 = dyn_cast<DeclRefExpr>(A2->IgnoreParenCasts()))
  41         return D1->getDecl() == D2->getDecl();
  42     return false;
  43   }
  44
  45   /// Check if the expression E is a sizeof(WithArg).
  46   inline bool isSizeof(const Expr *E, const Expr *WithArg) {
  47     if (const UnaryExprOrTypeTraitExpr *UE =
  48     dyn_cast<UnaryExprOrTypeTraitExpr>(E))
  49       if (UE->getKind() == UETT_SizeOf)
  50         return sameDecl(UE->getArgumentExpr(), WithArg);
  51     return false;
  52   }
  53
  54   /// Check if the expression E is a strlen(WithArg).
  55   inline bool isStrlen(const Expr *E, const Expr *WithArg) {
  56     if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
  57       const FunctionDecl *FD = CE->getDirectCallee();
  58       if (!FD)
  59         return false;
  60       return (CheckerContext::isCLibraryFunction(FD, "strlen") &&
  61               sameDecl(CE->getArg(0), WithArg));
  62     }
  63     return false;
  64   }
  65
  66   /// Check if the expression is an integer literal with value 1.
  67   inline bool isOne(const Expr *E) {
  68     if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
  69       return (IL->getValue().isIntN(1));
  70     return false;
  71   }
  72
  73   inline StringRef getPrintableName(const Expr *E) {
  74     if (const DeclRefExpr *D = dyn_cast<DeclRefExpr>(E->IgnoreParenCasts()))
  75       return D->getDecl()->getName();
  76     return StringRef();
  77   }
  78
  79   /// Identify erroneous patterns in the last argument to strncat - the number
  80   /// of bytes to copy.
  81   bool containsBadStrncatPattern(const CallExpr *CE);
  82
  83 public:
  84   WalkAST(BugReporter &br, AnalysisDeclContext* ac) :
  85       BR(br), AC(ac) {
  86   }
  87
  88   // Statement visitor methods.
  89   void VisitChildren(Stmt *S);
  90   void VisitStmt(Stmt *S) {
  91     VisitChildren(S);
  92   }
  93   void VisitCallExpr(CallExpr *CE);
  94 };
  95 } // end anonymous namespace
  96
  97 // The correct size argument should look like following:
  98 //   strncat(dst, src, sizeof(dst) - strlen(dest) - 1);
  99 // We look for the following anti-patterns:
 100 //   - strncat(dst, src, sizeof(dst) - strlen(dst));
 101 //   - strncat(dst, src, sizeof(dst) - 1);
 102 //   - strncat(dst, src, sizeof(dst));
 103 bool WalkAST::containsBadStrncatPattern(const CallExpr *CE) {
 104   if (CE->getNumArgs() != 3)
 105     return false;
 106   const Expr *DstArg = CE->getArg(0);
 107   const Expr *SrcArg = CE->getArg(1);
 108   const Expr *LenArg = CE->getArg(2);
 109
 110   // Identify wrong size expressions, which are commonly used instead.
 111   if (const BinaryOperator *BE =
 112               dyn_cast<BinaryOperator>(LenArg->IgnoreParenCasts())) {
 113     // - sizeof(dst) - strlen(dst)
 114     if (BE->getOpcode() == BO_Sub) {
 115       const Expr *L = BE->getLHS();
 116       const Expr *R = BE->getRHS();
 117       if (isSizeof(L, DstArg) && isStrlen(R, DstArg))
 118         return true;
 119
 120       // - sizeof(dst) - 1
 121       if (isSizeof(L, DstArg) && isOne(R->IgnoreParenCasts()))
 122         return true;
 123     }
 124   }
 125   // - sizeof(dst)
 126   if (isSizeof(LenArg, DstArg))
 127     return true;
 128
 129   // - sizeof(src)
 130   if (isSizeof(LenArg, SrcArg))
 131     return true;
 132   return false;
 133 }
 134
 135 void WalkAST::VisitCallExpr(CallExpr *CE) {
 136   const FunctionDecl *FD = CE->getDirectCallee();
 137   if (!FD)
 138     return;
 139
 140   if (CheckerContext::isCLibraryFunction(FD, "strncat")) {
 141     if (containsBadStrncatPattern(CE)) {
 142       const Expr *DstArg = CE->getArg(0);
 143       const Expr *LenArg = CE->getArg(2);
 144       SourceRange R = LenArg->getSourceRange();
 145       PathDiagnosticLocation Loc =
 146         PathDiagnosticLocation::createBegin(LenArg, BR.getSourceManager(), AC);
 147
 148       StringRef DstName = getPrintableName(DstArg);
 149
 150       SmallString<256> S;
 151       llvm::raw_svector_ostream os(S);
 152       os << "Potential buffer overflow. ";
 153       if (!DstName.empty()) {
 154         os << "Replace with 'sizeof(" << DstName << ") "
 155               "- strlen(" << DstName <<") - 1'";
 156         os << " or u";
 157       } else
 158         os << "U";
 159       os << "se a safer 'strlcat' API";
 160
 161       BR.EmitBasicReport(FD, "Anti-pattern in the argument", "C String API",
 162                          os.str(), Loc, &R, 1);
 163     }
 164   }
 165
 166   // Recurse and check children.
 167   VisitChildren(CE);
 168 }
 169
 170 void WalkAST::VisitChildren(Stmt *S) {
 171   for (Stmt::child_iterator I = S->child_begin(), E = S->child_end(); I != E;
 172       ++I)
 173     if (Stmt *child = *I)
 174       Visit(child);
 175 }
 176
 177 namespace {
 178 class CStringSyntaxChecker: public Checker<check::ASTCodeBody> {
 179 public:
 180
 181   void checkASTCodeBody(const Decl *D, AnalysisManager& Mgr,
 182       BugReporter &BR) const {
 183     WalkAST walker(BR, Mgr.getAnalysisDeclContext(D));
 184     walker.Visit(D->getBody());
 185   }
 186 };
 187 }
 188
 189 void ento::registerCStringSyntaxChecker(CheckerManager &mgr) {
 190   mgr.registerChecker<CStringSyntaxChecker>();
 191 }
 192