1. Available Checkers¶
The analyzer performs checks that are categorized into families or “checkers”.
The default set of checkers covers a variety of checks targeted at finding security and API usage bugs, dead code, and other logic errors. See the Default Checkers checkers list below.
In addition to these, the analyzer contains a number of Experimental Checkers (aka alpha checkers). These checkers are under development and are switched off by default. They may crash or emit a higher number of false positives.
The debug package contains checkers for analyzer developers for debugging purposes.
1.1. Default Checkers¶
1.1.1. core¶
Models core language features and contains general-purpose checkers such as division by zero, null pointer dereference, usage of uninitialized values, etc. These checkers must be always switched on as other checker rely on them.
1.1.1.1. core.BitwiseShift (C, C++)¶
Finds undefined behavior caused by the bitwise left- and right-shift operator operating on integer types.
By default, this checker only reports situations when the right operand is either negative or larger than the bit width of the type of the left operand; these are logically unsound.
Moreover, if the pedantic mode is activated by
-analyzer-config core.BitwiseShift:Pedantic=true, then this checker also
reports situations where the _left_ operand of a shift operator is negative or
overflow occurs during the right shift of a signed value. (Most compilers
handle these predictably, but the C standard and the C++ standards before C++20
say that they’re undefined behavior. In the C++20 standard these constructs are
well-defined, so activating pedantic mode in C++20 has no effect.)
Examples
static_assert(sizeof(int) == 4, "assuming 32-bit int")
void basic_examples(int a, int b) {
if (b < 0) {
b = a << b; // warn: right operand is negative in left shift
} else if (b >= 32) {
b = a >> b; // warn: right shift overflows the capacity of 'int'
}
}
int pedantic_examples(int a, int b) {
if (a < 0) {
return a >> b; // warn: left operand is negative in right shift
}
a = 1000u << 31; // OK, overflow of unsigned value is well-defined, a == 0
if (b > 10) {
a = b << 31; // this is undefined before C++20, but the checker doesn't
// warn because it doesn't know the exact value of b
}
return 1000 << 31; // warn: this overflows the capacity of 'int'
}
Solution
Ensure the shift operands are in proper range before shifting.
1.1.1.2. core.CallAndMessage (C, C++, ObjC)¶
Check for logical errors for function calls and Objective-C message expressions (e.g., uninitialized arguments, null function pointers).
//C
void test() {
void (*foo)(void);
foo = 0;
foo(); // warn: function pointer is null
}
// C++
class C {
public:
void f();
};
void test() {
C *pc;
pc->f(); // warn: object pointer is uninitialized
}
// C++
class C {
public:
void f();
};
void test() {
C *pc = 0;
pc->f(); // warn: object pointer is null
}
// Objective-C
@interface MyClass : NSObject
@property (readwrite,assign) id x;
- (long double)longDoubleM;
@end
void test() {
MyClass *obj1;
long double ld1 = [obj1 longDoubleM];
// warn: receiver is uninitialized
}
// Objective-C
@interface MyClass : NSObject
@property (readwrite,assign) id x;
- (long double)longDoubleM;
@end
void test() {
MyClass *obj1;
id i = obj1.x; // warn: uninitialized object pointer
}
// Objective-C
@interface Subscriptable : NSObject
- (id)objectAtIndexedSubscript:(unsigned int)index;
@end
@interface MyClass : Subscriptable
@property (readwrite,assign) id x;
- (long double)longDoubleM;
@end
void test() {
MyClass *obj1;
id i = obj1[0]; // warn: uninitialized object pointer
}
1.1.1.3. core.DivideZero (C, C++, ObjC)¶
Check for division by zero.
void test(int z) {
if (z == 0)
int x = 1 / z; // warn
}
void test() {
int x = 1;
int y = x % 0; // warn
}
1.1.1.4. core.NonNullParamChecker (C, C++, ObjC)¶
Check for null pointers passed as arguments to a function whose arguments are references or marked with the ‘nonnull’ attribute.
int f(int *p) __attribute__((nonnull));
void test(int *p) {
if (!p)
f(p); // warn
}
1.1.1.5. core.NullDereference (C, C++, ObjC)¶
Check for dereferences of null pointers.
This checker specifically does not report null pointer dereferences for x86 and x86-64 targets when the address space is 256 (x86 GS Segment), 257 (x86 FS Segment), or 258 (x86 SS segment). See X86/X86-64 Language Extensions for reference.
The SuppressAddressSpaces option suppresses
warnings for null dereferences of all pointers with address spaces. You can
disable this behavior with the option
-analyzer-config core.NullDereference:SuppressAddressSpaces=false.
Defaults to true.
// C
void test(int *p) {
if (p)
return;
int x = p[0]; // warn
}
// C
void test(int *p) {
if (!p)
*p = 0; // warn
}
// C++
class C {
public:
int x;
};
void test() {
C *pc = 0;
int k = pc->x; // warn
}
// Objective-C
@interface MyClass {
@public
int x;
}
@end
void test() {
MyClass *obj = 0;
obj->x = 1; // warn
}
1.1.1.6. core.StackAddressEscape (C)¶
Check that addresses to stack memory do not escape the function.
char const *p;
void test() {
char const str[] = "string";
p = str; // warn
}
void* test() {
return __builtin_alloca(12); // warn
}
void test() {
static int *x;
int y;
x = &y; // warn
}
1.1.1.7. core.UndefinedBinaryOperatorResult (C)¶
Check for undefined results of binary operators.
void test() {
int x;
int y = x + 1; // warn: left operand is garbage
}
1.1.1.8. core.VLASize (C)¶
Check for declarations of Variable Length Arrays (VLA) of undefined, zero or negative size.
void test() {
int x;
int vla1[x]; // warn: garbage as size
}
void test() {
int x = 0;
int vla2[x]; // warn: zero size
}
The checker also gives warning if the TaintPropagation checker is switched on and an unbound, attacker controlled (tainted) value is used to define the size of the VLA.
void taintedVLA(void) {
int x;
scanf("%d", &x);
int vla[x]; // Declared variable-length array (VLA) has tainted (attacker controlled) size, that can be 0 or negative
}
void taintedVerfieidVLA(void) {
int x;
scanf("%d", &x);
if (x<1)
return;
int vla[x]; // no-warning. The analyzer can prove that x must be positive.
}
1.1.1.9. core.uninitialized.ArraySubscript (C)¶
Check for uninitialized values used as array subscripts.
void test() {
int i, a[10];
int x = a[i]; // warn: array subscript is undefined
}
1.1.1.10. core.uninitialized.Assign (C)¶
Check for assigning uninitialized values.
void test() {
int x;
x |= 1; // warn: left expression is uninitialized
}
1.1.1.11. core.uninitialized.Branch (C)¶
Check for uninitialized values used as branch conditions.
void test() {
int x;
if (x) // warn
return;
}
1.1.1.12. core.uninitialized.CapturedBlockVariable (C)¶
Check for blocks that capture uninitialized values.
void test() {
int x;
^{ int y = x; }(); // warn
}
1.1.1.13. core.uninitialized.UndefReturn (C)¶
Check for uninitialized values being returned to the caller.
int test() {
int x;
return x; // warn
}
1.1.1.14. core.uninitialized.NewArraySize (C++)¶
Check if the element count in new[] is garbage or undefined.
void test() {
int n;
int *arr = new int[n]; // warn: Element count in new[] is a garbage value
delete[] arr;
}
1.1.2. cplusplus¶
C++ Checkers.
1.1.2.1. cplusplus.ArrayDelete (C++)¶
Reports destructions of arrays of polymorphic objects that are destructed as their base class. If the dynamic type of the array is different from its static type, calling delete[] is undefined.
This checker corresponds to the SEI CERT rule EXP51-CPP: Do not delete an array through a pointer of the incorrect type.
class Base {
public:
virtual ~Base() {}
};
class Derived : public Base {};
Base *create() {
Base *x = new Derived[10]; // note: Casting from 'Derived' to 'Base' here
return x;
}
void foo() {
Base *x = create();
delete[] x; // warn: Deleting an array of 'Derived' objects as their base class 'Base' is undefined
}
Limitations
The checker does not emit note tags when casting to and from reference types, even though the pointer values are tracked across references.
void foo() {
Derived *d = new Derived[10];
Derived &dref = *d;
Base &bref = static_cast<Base&>(dref); // no note
Base *b = &bref;
delete[] b; // warn: Deleting an array of 'Derived' objects as their base class 'Base' is undefined
}
1.1.2.2. cplusplus.InnerPointer (C++)¶
Check for inner pointers of C++ containers used after re/deallocation.
Many container methods in the C++ standard library are known to invalidate “references” (including actual references, iterators and raw pointers) to elements of the container. Using such references after they are invalidated causes undefined behavior, which is a common source of memory errors in C++ that this checker is capable of finding.
The checker is currently limited to std::string objects and doesn’t
recognize some of the more sophisticated approaches to passing unowned pointers
around, such as std::string_view.
void deref_after_assignment() {
std::string s = "llvm";
const char *c = s.data(); // note: pointer to inner buffer of 'std::string' obtained here
s = "clang"; // note: inner buffer of 'std::string' reallocated by call to 'operator='
consume(c); // warn: inner pointer of container used after re/deallocation
}
const char *return_temp(int x) {
return std::to_string(x).c_str(); // warn: inner pointer of container used after re/deallocation
// note: pointer to inner buffer of 'std::string' obtained here
// note: inner buffer of 'std::string' deallocated by call to destructor
}
1.1.2.3. cplusplus.Move (C++)¶
Find use-after-move bugs in C++. This includes method calls on moved-from objects, assignment of a moved-from object, and repeated move of a moved-from object.
struct A {
void foo() {}
};
void f1() {
A a;
A b = std::move(a); // note: 'a' became 'moved-from' here
a.foo(); // warn: method call on a 'moved-from' object 'a'
}
void f2() {
A a;
A b = std::move(a);
A c(std::move(a)); // warn: move of an already moved-from object
}
void f3() {
A a;
A b = std::move(a);
b = a; // warn: copy of moved-from object
}
The checker option WarnOn controls on what objects the use-after-move is
checked:
The most strict value is
KnownsOnly, in this mode only objects are checked whose type is known to be move-unsafe. These include most STL objects (but excluding move-safe ones) and smart pointers.With option value
KnownsAndLocalslocal variables (of any type) are additionally checked. The idea behind this is that local variables are usually not tempting to be re-used so an use after move is more likely a bug than with member variables.With option value
Allany use-after move condition is checked on all kinds of variables, excluding global variables and known move-safe cases.
Default value is KnownsAndLocals.
Calls of methods named empty() or isEmpty() are allowed on moved-from
objects because these methods are considered as move-safe. Functions called
reset(), destroy(), clear(), assign, resize, shrink are
treated as state-reset functions and are allowed on moved-from objects, these
make the object valid again. This applies to any type of object (not only STL
ones).
1.1.2.4. cplusplus.NewDelete (C++)¶
Check for double-free and use-after-free problems. Traces memory managed by new/delete.
void f(int *p);
void testUseMiddleArgAfterDelete(int *p) {
delete p;
f(p); // warn: use after free
}
class SomeClass {
public:
void f();
};
void test() {
SomeClass *c = new SomeClass;
delete c;
c->f(); // warn: use after free
}
void test() {
int *p = (int *)__builtin_alloca(sizeof(int));
delete p; // warn: deleting memory allocated by alloca
}
void test() {
int *p = new int;
delete p;
delete p; // warn: attempt to free released
}
void test() {
int i;
delete &i; // warn: delete address of local
}
void test() {
int *p = new int[1];
delete[] (++p);
// warn: argument to 'delete[]' is offset by 4 bytes
// from the start of memory allocated by 'new[]'
}
1.1.2.5. cplusplus.NewDeleteLeaks (C++)¶
Check for memory leaks. Traces memory managed by new/delete.
void test() {
int *p = new int;
} // warn
1.1.2.6. cplusplus.PlacementNew (C++)¶
Check if default placement new is provided with pointers to sufficient storage capacity.
#include <new>
void f() {
short s;
long *lp = ::new (&s) long; // warn
}
1.1.2.7. cplusplus.SelfAssignment (C++)¶
Checks C++ copy and move assignment operators for self assignment.
1.1.2.8. cplusplus.StringChecker (C++)¶
Checks std::string operations.
Checks if the cstring pointer from which the std::string object is
constructed is NULL or not.
If the checker cannot reason about the nullness of the pointer it will assume
that it was non-null to satisfy the precondition of the constructor.
This checker is capable of checking the SEI CERT C++ coding rule STR51-CPP. Do not attempt to create a std::string from a null pointer.
#include <string>
void f(const char *p) {
if (!p) {
std::string msg(p); // warn: The parameter must not be null
}
}
1.1.3. deadcode¶
Dead Code Checkers.
1.1.3.1. deadcode.DeadStores (C)¶
Check for values stored to variables that are never read afterwards.
void test() {
int x;
x = 1; // warn
}
The WarnForDeadNestedAssignments option enables the checker to emit
warnings for nested dead assignments. You can disable with the
-analyzer-config deadcode.DeadStores:WarnForDeadNestedAssignments=false.
Defaults to true.
Would warn for this e.g.: if ((y = make_int())) { }
1.1.4. nullability¶
Checkers (mostly Objective C) that warn for null pointer passing and dereferencing errors.
1.1.4.1. nullability.NullPassedToNonnull (ObjC)¶
Warns when a null pointer is passed to a pointer which has a _Nonnull type.
if (name != nil)
return;
// Warning: nil passed to a callee that requires a non-null 1st parameter
NSString *greeting = [@"Hello " stringByAppendingString:name];
1.1.4.2. nullability.NullReturnedFromNonnull (C, C++, ObjC)¶
Warns when a null pointer is returned from a function that has _Nonnull return type.
- (nonnull id)firstChild {
id result = nil;
if ([_children count] > 0)
result = _children[0];
// Warning: nil returned from a method that is expected
// to return a non-null value
return result;
}
Warns when a null pointer is returned from a function annotated with __attribute__((returns_nonnull))
int global;
__attribute__((returns_nonnull)) void* getPtr(void* p);
void* getPtr(void* p) {
if (p) { // forgot to negate the condition
return &global;
}
// Warning: nullptr returned from a function that is expected
// to return a non-null value
return p;
}
1.1.4.3. nullability.NullableDereferenced (ObjC)¶
Warns when a nullable pointer is dereferenced.
struct LinkedList {
int data;
struct LinkedList *next;
};
struct LinkedList * _Nullable getNext(struct LinkedList *l);
void updateNextData(struct LinkedList *list, int newData) {
struct LinkedList *next = getNext(list);
// Warning: Nullable pointer is dereferenced
next->data = 7;
}
1.1.4.4. nullability.NullablePassedToNonnull (ObjC)¶
Warns when a nullable pointer is passed to a pointer which has a _Nonnull type.
typedef struct Dummy { int val; } Dummy;
Dummy *_Nullable returnsNullable();
void takesNonnull(Dummy *_Nonnull);
void test() {
Dummy *p = returnsNullable();
takesNonnull(p); // warn
}
1.1.4.5. nullability.NullableReturnedFromNonnull (ObjC)¶
Warns when a nullable pointer is returned from a function that has _Nonnull return type.
1.1.5. optin¶
Checkers for portability, performance, optional security and coding style specific rules.
1.1.5.1. optin.core.EnumCastOutOfRange (C, C++)¶
Check for integer to enumeration casts that would produce a value with no corresponding enumerator. This is not necessarily undefined behavior, but can lead to nasty surprises, so projects may decide to use a coding standard that disallows these “unusual” conversions.
Note that no warnings are produced when the enum type (e.g. std::byte) has no enumerators at all.
enum WidgetKind { A=1, B, C, X=99 };
void foo() {
WidgetKind c = static_cast<WidgetKind>(3); // OK
WidgetKind x = static_cast<WidgetKind>(99); // OK
WidgetKind d = static_cast<WidgetKind>(4); // warn
}
Limitations
This checker does not accept the coding pattern where an enum type is used to store combinations of flag values:
enum AnimalFlags
{
HasClaws = 1,
CanFly = 2,
EatsFish = 4,
Endangered = 8
};
AnimalFlags operator|(AnimalFlags a, AnimalFlags b)
{
return static_cast<AnimalFlags>(static_cast<int>(a) | static_cast<int>(b));
}
auto flags = HasClaws | CanFly;
Projects that use this pattern should not enable this optin checker.
1.1.5.2. optin.cplusplus.UninitializedObject (C++)¶
This checker reports uninitialized fields in objects created after a constructor call. It doesn’t only find direct uninitialized fields, but rather makes a deep inspection of the object, analyzing all of its fields’ subfields. The checker regards inherited fields as direct fields, so one will receive warnings for uninitialized inherited data members as well.
// With Pedantic and CheckPointeeInitialization set to true
struct A {
struct B {
int x; // note: uninitialized field 'this->b.x'
// note: uninitialized field 'this->bptr->x'
int y; // note: uninitialized field 'this->b.y'
// note: uninitialized field 'this->bptr->y'
};
int *iptr; // note: uninitialized pointer 'this->iptr'
B b;
B *bptr;
char *cptr; // note: uninitialized pointee 'this->cptr'
A (B *bptr, char *cptr) : bptr(bptr), cptr(cptr) {}
};
void f() {
A::B b;
char c;
A a(&b, &c); // warning: 6 uninitialized fields
// after the constructor call
}
// With Pedantic set to false and
// CheckPointeeInitialization set to true
// (every field is uninitialized)
struct A {
struct B {
int x;
int y;
};
int *iptr;
B b;
B *bptr;
char *cptr;
A (B *bptr, char *cptr) : bptr(bptr), cptr(cptr) {}
};
void f() {
A::B b;
char c;
A a(&b, &c); // no warning
}
// With Pedantic set to true and
// CheckPointeeInitialization set to false
// (pointees are regarded as initialized)
struct A {
struct B {
int x; // note: uninitialized field 'this->b.x'
int y; // note: uninitialized field 'this->b.y'
};
int *iptr; // note: uninitialized pointer 'this->iptr'
B b;
B *bptr;
char *cptr;
A (B *bptr, char *cptr) : bptr(bptr), cptr(cptr) {}
};
void f() {
A::B b;
char c;
A a(&b, &c); // warning: 3 uninitialized fields
// after the constructor call
}
Options
This checker has several options which can be set from command line (e.g.
-analyzer-config optin.cplusplus.UninitializedObject:Pedantic=true):
Pedantic(boolean). If to false, the checker won’t emit warnings for objects that don’t have at least one initialized field. Defaults to false.NotesAsWarnings(boolean). If set to true, the checker will emit a warning for each uninitialized field, as opposed to emitting one warning per constructor call, and listing the uninitialized fields that belongs to it in notes. Defaults to false.CheckPointeeInitialization(boolean). If set to false, the checker will not analyze the pointee of pointer/reference fields, and will only check whether the object itself is initialized. Defaults to false.IgnoreRecordsWithField(string). If supplied, the checker will not analyze structures that have a field with a name or type name that matches the given pattern. Defaults to “”.
1.1.5.3. optin.cplusplus.VirtualCall (C++)¶
Check virtual function calls during construction or destruction.
class A {
public:
A() {
f(); // warn
}
virtual void f();
};
class A {
public:
~A() {
this->f(); // warn
}
virtual void f();
};
1.1.5.4. optin.mpi.MPI-Checker (C)¶
Checks MPI code.
void test() {
double buf = 0;
MPI_Request sendReq1;
MPI_Ireduce(MPI_IN_PLACE, &buf, 1, MPI_DOUBLE, MPI_SUM,
0, MPI_COMM_WORLD, &sendReq1);
} // warn: request 'sendReq1' has no matching wait.
void test() {
double buf = 0;
MPI_Request sendReq;
MPI_Isend(&buf, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &sendReq);
MPI_Irecv(&buf, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &sendReq); // warn
MPI_Isend(&buf, 1, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &sendReq); // warn
MPI_Wait(&sendReq, MPI_STATUS_IGNORE);
}
void missingNonBlocking() {
int rank = 0;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Request sendReq1[10][10][10];
MPI_Wait(&sendReq1[1][7][9], MPI_STATUS_IGNORE); // warn
}
1.1.5.5. optin.osx.cocoa.localizability.EmptyLocalizationContextChecker (ObjC)¶
Check that NSLocalizedString macros include a comment for context.
- (void)test {
NSString *string = NSLocalizedString(@"LocalizedString", nil); // warn
NSString *string2 = NSLocalizedString(@"LocalizedString", @" "); // warn
NSString *string3 = NSLocalizedStringWithDefaultValue(
@"LocalizedString", nil, [[NSBundle alloc] init], nil,@""); // warn
}
1.1.5.6. optin.osx.cocoa.localizability.NonLocalizedStringChecker (ObjC)¶
Warns about uses of non-localized NSStrings passed to UI methods expecting localized NSStrings.
NSString *alarmText =
NSLocalizedString(@"Enabled", @"Indicates alarm is turned on");
if (!isEnabled) {
alarmText = @"Disabled";
}
UILabel *alarmStateLabel = [[UILabel alloc] init];
// Warning: User-facing text should use localized string macro
[alarmStateLabel setText:alarmText];
1.1.5.7. optin.performance.GCDAntipattern¶
Check for performance anti-patterns when using Grand Central Dispatch.
1.1.5.8. optin.performance.Padding (C, C++, ObjC)¶
Check for excessively padded structs.
This checker detects structs with excessive padding, which can lead to wasted memory thus decreased performance by reducing the effectiveness of the processor cache. Padding bytes are added by compilers to align data accesses as some processors require data to be aligned to certain boundaries. On others, unaligned data access are possible, but impose significantly larger latencies.
To avoid padding bytes, the fields of a struct should be ordered by decreasing
by alignment. Usually, its easier to think of the sizeof of the fields, and
ordering the fields by sizeof would usually also lead to the same optimal
layout.
In rare cases, one can use the #pragma pack(1) directive to enforce a packed
layout too, but it can significantly increase the access times, so reordering the
fields is usually a better solution.
// warn: Excessive padding in 'struct NonOptimal' (35 padding bytes, where 3 is optimal)
struct NonOptimal {
char c1;
// 7 bytes of padding
std::int64_t big1; // 8 bytes
char c2;
// 7 bytes of padding
std::int64_t big2; // 8 bytes
char c3;
// 7 bytes of padding
std::int64_t big3; // 8 bytes
char c4;
// 7 bytes of padding
std::int64_t big4; // 8 bytes
char c5;
// 7 bytes of padding
};
static_assert(sizeof(NonOptimal) == 4*8+5+5*7);
// no-warning: The fields are nicely aligned to have the minimal amount of padding bytes.
struct Optimal {
std::int64_t big1; // 8 bytes
std::int64_t big2; // 8 bytes
std::int64_t big3; // 8 bytes
std::int64_t big4; // 8 bytes
char c1;
char c2;
char c3;
char c4;
char c5;
// 3 bytes of padding
};
static_assert(sizeof(Optimal) == 4*8+5+3);
// no-warning: Bit packing representation is also accepted by this checker, but
// it can significantly increase access times, so prefer reordering the fields.
#pragma pack(1)
struct BitPacked {
char c1;
std::int64_t big1; // 8 bytes
char c2;
std::int64_t big2; // 8 bytes
char c3;
std::int64_t big3; // 8 bytes
char c4;
std::int64_t big4; // 8 bytes
char c5;
};
static_assert(sizeof(BitPacked) == 4*8+5);
The AllowedPad option can be used to specify a threshold for the number
padding bytes raising the warning. If the number of padding bytes of the struct
and the optimal number of padding bytes differ by more than the threshold value,
a warning will be raised.
By default, the AllowedPad threshold is 24 bytes.
To override this threshold to e.g. 4 bytes, use the
-analyzer-config optin.performance.Padding:AllowedPad=4 option.
1.1.5.9. optin.portability.UnixAPI¶
Finds implementation-defined behavior in UNIX/Posix functions.
1.1.6. optin.taint¶
Checkers implementing taint analysis.
1.1.6.1. optin.taint.GenericTaint (C, C++)¶
Taint analysis identifies potential security vulnerabilities where the attacker can inject malicious data to the program to execute an attack (privilege escalation, command injection, SQL injection etc.).
The malicious data is injected at the taint source (e.g. getenv() call)
which is then propagated through function calls and being used as arguments of
sensitive operations, also called as taint sinks (e.g. system() call).
One can defend against this type of vulnerability by always checking and sanitizing the potentially malicious, untrusted user input.
The goal of the checker is to discover and show to the user these potential taint source-sink pairs and the propagation call chain.
The most notable examples of taint sources are:
data from network
files or standard input
environment variables
data from databases
Let us examine a practical example of a Command Injection attack.
// Command Injection Vulnerability Example
int main(int argc, char** argv) {
char cmd[2048] = "/bin/cat ";
char filename[1024];
printf("Filename:");
scanf (" %1023[^\n]", filename); // The attacker can inject a shell escape here
strcat(cmd, filename);
system(cmd); // Warning: Untrusted data is passed to a system call
}
The program prints the content of any user specified file. Unfortunately the attacker can execute arbitrary commands with shell escapes. For example with the following input the ls command is also executed after the contents of /etc/shadow is printed. Input: /etc/shadow ; ls /
The analysis implemented in this checker points out this problem.
One can protect against such attack by for example checking if the provided input refers to a valid file and removing any invalid user input.
// No vulnerability anymore, but we still get the warning
void sanitizeFileName(char* filename){
if (access(filename,F_OK)){// Verifying user input
printf("File does not exist\n");
filename[0]='\0';
}
}
int main(int argc, char** argv) {
char cmd[2048] = "/bin/cat ";
char filename[1024];
printf("Filename:");
scanf (" %1023[^\n]", filename); // The attacker can inject a shell escape here
sanitizeFileName(filename);// filename is safe after this point
if (!filename[0])
return -1;
strcat(cmd, filename);
system(cmd); // Superfluous Warning: Untrusted data is passed to a system call
}
Unfortunately, the checker cannot discover automatically that the programmer have performed data sanitation, so it still emits the warning.
One can get rid of this superfluous warning by telling by specifying the sanitation functions in the taint configuration file (see Taint Analysis Configuration).
Filters:
- Name: sanitizeFileName
Args: [0]
The clang invocation to pass the configuration file location:
clang --analyze -Xclang -analyzer-config -Xclang optin.taint.TaintPropagation:Config=`pwd`/taint_config.yml ...
If you are validating your inputs instead of sanitizing them, or don’t want to mention each sanitizing function in our configuration, you can use a more generic approach.
Introduce a generic no-op csa_mark_sanitized(..) function to tell the Clang Static Analyzer that the variable is safe to be used on that analysis path.
// Marking sanitized variables safe.
// No vulnerability anymore, no warning.
// User csa_mark_sanitize function is for the analyzer only
#ifdef __clang_analyzer__
void csa_mark_sanitized(const void *);
#endif
int main(int argc, char** argv) {
char cmd[2048] = "/bin/cat ";
char filename[1024];
printf("Filename:");
scanf (" %1023[^\n]", filename);
if (access(filename,F_OK)){// Verifying user input
printf("File does not exist\n");
return -1;
}
#ifdef __clang_analyzer__
csa_mark_sanitized(filename); // Indicating to CSA that filename variable is safe to be used after this point
#endif
strcat(cmd, filename);
system(cmd); // No warning
}
Similarly to the previous example, you need to define a Filter function in a YAML configuration file and add the csa_mark_sanitized function.
Filters:
- Name: csa_mark_sanitized
Args: [0]
Then calling csa_mark_sanitized(X) will tell the analyzer that X is safe to be used after this point, because its contents are verified. It is the responsibility of the programmer to ensure that this verification was indeed correct. Please note that csa_mark_sanitized function is only declared and used during Clang Static Analysis and skipped in (production) builds.
Further examples of injection vulnerabilities this checker can find.
void test() {
char x = getchar(); // 'x' marked as tainted
system(&x); // warn: untrusted data is passed to a system call
}
// note: compiler internally checks if the second param to
// sprintf is a string literal or not.
// Use -Wno-format-security to suppress compiler warning.
void test() {
char s[10], buf[10];
fscanf(stdin, "%s", s); // 's' marked as tainted
sprintf(buf, s); // warn: untrusted data used as a format string
}
There are built-in sources, propagations and sinks even if no external taint configuration is provided.
- Default sources:
_IO_getc,fdopen,fopen,freopen,get_current_dir_name,getch,getchar,getchar_unlocked,getwd,getcwd,getgroups,gethostname,getlogin,getlogin_r,getnameinfo,gets,gets_s,getseuserbyname,readlink,readlinkat,scanf,scanf_s,socket,wgetch- Default propagations rules:
atoi,atol,atoll,basename,dirname,fgetc,fgetln,fgets,fnmatch,fread,fscanf,fscanf_s,index,inflate,isalnum,isalpha,isascii,isblank,iscntrl,isdigit,isgraph,islower,isprint,ispunct,isspace,isupper,isxdigit,memchr,memrchr,sscanf,getc,getc_unlocked,getdelim,getline,getw,memcmp,memcpy,memmem,memmove,mbtowc,pread,qsort,qsort_r,rawmemchr,read,recv,recvfrom,rindex,strcasestr,strchr,strchrnul,strcasecmp,strcmp,strcspn,strncasecmp,strncmp,strndup,strndupa,strpbrk,strrchr,strsep,strspn,strstr,strtol,strtoll,strtoul,strtoull,tolower,toupper,ttyname,ttyname_r,wctomb,wcwidth- Default sinks:
printf,setproctitle,system,popen,execl,execle,execlp,execv,execvp,execvP,execve,dlopen
Please note that there are no built-in filter functions.
One can configure their own taint sources, sinks, and propagation rules by
providing a configuration file via checker option
optin.taint.TaintPropagation:Config. The configuration file is in
YAML format. The
taint-related options defined in the config file extend but do not override the
built-in sources, rules, sinks. The format of the external taint configuration
file is not stable, and could change without any notice even in a non-backward
compatible way.
For a more detailed description of configuration options, please see the Taint Analysis Configuration. For an example see Example configuration file.
Configuration
Config Specifies the name of the YAML configuration file. The user can define their own taint sources and sinks.
Related Guidelines
SEI Cert STR02-C. Sanitize data passed to complex subsystems
ENV03-C. Sanitize the environment when invoking external programs
Limitations
The taintedness property is not propagated through function calls which are unknown (or too complex) to the analyzer, unless there is a specific propagation rule built-in to the checker or given in the YAML configuration file. This causes potential true positive findings to be lost.
1.1.6.2. optin.taint.TaintedAlloc (C, C++)¶
This checker warns for cases when the size parameter of the malloc ,
calloc, realloc, alloca or the size parameter of the
array new C++ operator is tainted (potentially attacker controlled).
If an attacker can inject a large value as the size parameter, memory exhaustion
denial of service attack can be carried out.
The analyzer emits warning only if it cannot prove that the size parameter is
within reasonable bounds (<= SIZE_MAX/4). This functionality partially
covers the SEI Cert coding standard rule INT04-C.
You can silence this warning either by bound checking the size parameter, or
by explicitly marking the size parameter as sanitized. See the
optin.taint.GenericTaint (C, C++) checker for an example.
void vulnerable(void) {
size_t size = 0;
scanf("%zu", &size);
int *p = malloc(size); // warn: malloc is called with a tainted (potentially attacker controlled) value
free(p);
}
void not_vulnerable(void) {
size_t size = 0;
scanf("%zu", &size);
if (1024 < size)
return;
int *p = malloc(size); // No warning expected as the the user input is bound
free(p);
}
void vulnerable_cpp(void) {
size_t size = 0;
scanf("%zu", &size);
int *ptr = new int[size];// warn: Memory allocation function is called with a tainted (potentially attacker controlled) value
delete[] ptr;
}
1.1.6.3. optin.taint.TaintedDiv (C, C++, ObjC)¶
This checker warns when the denominator in a division operation is a tainted (potentially attacker controlled) value. If the attacker can set the denominator to 0, a runtime error can be triggered. The checker warns when the denominator is a tainted value and the analyzer cannot prove that it is not 0. This warning is more pessimistic than the core.DivideZero (C, C++, ObjC) checker which warns only when it can prove that the denominator is 0.
int vulnerable(int n) {
size_t size = 0;
scanf("%zu", &size);
return n / size; // warn: Division by a tainted value, possibly zero
}
int not_vulnerable(int n) {
size_t size = 0;
scanf("%zu", &size);
if (!size)
return 0;
return n / size; // no warning
}
1.1.7. security¶
Security related checkers.
1.1.7.1. security.cert.env.InvalidPtr¶
Corresponds to SEI CERT Rules ENV31-C and ENV34-C.
ENV31-C: Rule is about the possible problem with
mainfunction’s third argument, environment pointer, “envp”. When environment array is modified using some modification function such asputenv,setenvor others, It may happen that memory is reallocated, however “envp” is not updated to reflect the changes and points to old memory region.ENV34-C: Some functions return a pointer to a statically allocated buffer. Consequently, subsequent call of these functions will invalidate previous pointer. These functions include:
getenv,localeconv,asctime,setlocale,strerror
int main(int argc, const char *argv[], const char *envp[]) {
if (setenv("MY_NEW_VAR", "new_value", 1) != 0) {
// setenv call may invalidate 'envp'
/* Handle error */
}
if (envp != NULL) {
for (size_t i = 0; envp[i] != NULL; ++i) {
puts(envp[i]);
// envp may no longer point to the current environment
// this program has unanticipated behavior, since envp
// does not reflect changes made by setenv function.
}
}
return 0;
}
void previous_call_invalidation() {
char *p, *pp;
p = getenv("VAR");
setenv("SOMEVAR", "VALUE", /*overwrite = */1);
// call to 'setenv' may invalidate p
*p;
// dereferencing invalid pointer
}
The InvalidatingGetEnv option is available for treating getenv calls as
invalidating. When enabled, the checker issues a warning if getenv is called
multiple times and their results are used without first creating a copy.
This level of strictness might be considered overly pedantic for the commonly
used getenv implementations.
To enable this option, use:
-analyzer-config security.cert.env.InvalidPtr:InvalidatingGetEnv=true.
By default, this option is set to false.
When this option is enabled, warnings will be generated for scenarios like the following:
char* p = getenv("VAR");
char* pp = getenv("VAR2"); // assumes this call can invalidate `env`
strlen(p); // warns about accessing invalid ptr
1.1.7.2. security.FloatLoopCounter (C)¶
Warn on using a floating point value as a loop counter (CERT: FLP30-C, FLP30-CPP).
void test() {
for (float x = 0.1f; x <= 1.0f; x += 0.1f) {} // warn
}
1.1.7.3. security.insecureAPI.UncheckedReturn (C)¶
Warn on uses of functions whose return values must be always checked.
void test() {
setuid(1); // warn
}
1.1.7.4. security.insecureAPI.bcmp (C)¶
Warn on uses of the ‘bcmp’ function.
void test() {
bcmp(ptr0, ptr1, n); // warn
}
1.1.7.5. security.insecureAPI.bcopy (C)¶
Warn on uses of the ‘bcopy’ function.
void test() {
bcopy(src, dst, n); // warn
}
1.1.7.6. security.insecureAPI.bzero (C)¶
Warn on uses of the ‘bzero’ function.
void test() {
bzero(ptr, n); // warn
}
1.1.7.7. security.insecureAPI.getpw (C)¶
Warn on uses of the ‘getpw’ function.
void test() {
char buff[1024];
getpw(2, buff); // warn
}
1.1.7.8. security.insecureAPI.gets (C)¶
Warn on uses of the ‘gets’ function.
void test() {
char buff[1024];
gets(buff); // warn
}
1.1.7.9. security.insecureAPI.mkstemp (C)¶
Warn when ‘mkstemp’ is passed fewer than 6 X’s in the format string.
void test() {
mkstemp("XX"); // warn
}
1.1.7.10. security.insecureAPI.mktemp (C)¶
Warn on uses of the mktemp function.
void test() {
char *x = mktemp("/tmp/zxcv"); // warn: insecure, use mkstemp
}
1.1.7.11. security.insecureAPI.rand (C)¶
Warn on uses of inferior random number generating functions (only if arc4random function is available):
drand48, erand48, jrand48, lcong48, lrand48, mrand48, nrand48, random, rand_r.
void test() {
random(); // warn
}
1.1.7.12. security.insecureAPI.strcpy (C)¶
Warn on uses of the strcpy and strcat functions.
void test() {
char x[4];
char *y = "abcd";
strcpy(x, y); // warn
}
1.1.7.13. security.insecureAPI.vfork (C)¶
Warn on uses of the ‘vfork’ function.
void test() {
vfork(); // warn
}
1.1.7.14. security.insecureAPI.DeprecatedOrUnsafeBufferHandling (C)¶
Warn on occurrences of unsafe or deprecated buffer handling functions, which now have a secure variant:
sprintf, fprintf, vsprintf, scanf, wscanf, fscanf, fwscanf, vscanf, vwscanf, vfscanf, vfwscanf, sscanf, swscanf, vsscanf, vswscanf, swprintf, snprintf, vswprintf, vsnprintf, memcpy, memmove, strncpy, strncat, memset
void test() {
char buf [5];
strncpy(buf, "a", 1); // warn
}
1.1.7.15. security.MmapWriteExec (C)¶
Warn on mmap() calls with both writable and executable access.
void test(int n) {
void *c = mmap(NULL, 32, PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANON, -1, 0);
// warn: Both PROT_WRITE and PROT_EXEC flags are set. This can lead to
// exploitable memory regions, which could be overwritten with malicious
// code
}
1.1.7.16. security.PointerSub (C)¶
Check for pointer subtractions on two pointers pointing to different memory chunks. According to the C standard §6.5.6 only subtraction of pointers that point into (or one past the end) the same array object is valid (for this purpose non-array variables are like arrays of size 1). This checker only searches for different memory objects at subtraction, but does not check if the array index is correct. Furthermore, only cases are reported where stack-allocated objects are involved (no warnings on pointers to memory allocated by malloc).
void test() {
int a, b, c[10], d[10];
int x = &c[3] - &c[1];
x = &d[4] - &c[1]; // warn: 'c' and 'd' are different arrays
x = (&a + 1) - &a;
x = &b - &a; // warn: 'a' and 'b' are different variables
}
struct S {
int x[10];
int y[10];
};
void test1() {
struct S a[10];
struct S b;
int d = &a[4] - &a[6];
d = &a[0].x[3] - &a[0].x[1];
d = a[0].y - a[0].x; // warn: 'S.b' and 'S.a' are different objects
d = (char *)&b.y - (char *)&b.x; // warn: different members of the same object
d = (char *)&b.y - (char *)&b; // warn: object of type S is not the same array as a member of it
}
There may be existing applications that use code like above for calculating offsets of members in a structure, using pointer subtractions. This is still undefined behavior according to the standard and code like this can be replaced with the offsetof macro.
1.1.7.17. security.PutenvStackArray (C)¶
Finds calls to the putenv function which pass a pointer to a stack-allocated
(automatic) array as the argument. Function putenv does not copy the passed
string, only a pointer to the data is stored and this data can be read even by
other threads. Content of a stack-allocated array is likely to be overwritten
after exiting from the function.
The problem can be solved by using a static array variable or dynamically
allocated memory. Even better is to avoid using putenv (it has other
problems related to memory leaks) and use setenv instead.
The check corresponds to CERT rule POS34-C. Do not call putenv() with a pointer to an automatic variable as the argument.
int f() {
char env[] = "NAME=value";
return putenv(env); // putenv function should not be called with stack-allocated string
}
There is one case where the checker can report a false positive. This is when the stack-allocated array is used at putenv in a function or code branch that does not return (process is terminated on all execution paths).
Another special case is if the putenv is called from function main. Here the stack is deallocated at the end of the program and it should be no problem to use the stack-allocated string (a multi-threaded program may require more attention). The checker does not warn for cases when stack space of main is used at the putenv call.
1.1.7.18. security.SetgidSetuidOrder (C)¶
When dropping user-level and group-level privileges in a program by using
setuid and setgid calls, it is important to reset the group-level
privileges (with setgid) first. Function setgid will likely fail if
the superuser privileges are already dropped.
The checker checks for sequences of setuid(getuid()) and
setgid(getgid()) calls (in this order). If such a sequence is found and
there is no other privilege-changing function call (seteuid, setreuid,
setresuid and the GID versions of these) in between, a warning is
generated. The checker finds only exactly setuid(getuid()) calls (and the
GID versions), not for example if the result of getuid() is stored in a
variable.
void test1() {
// ...
// end of section with elevated privileges
// reset privileges (user and group) to normal user
if (setuid(getuid()) != 0) {
handle_error();
return;
}
if (setgid(getgid()) != 0) { // warning: A 'setgid(getgid())' call following a 'setuid(getuid())' call is likely to fail
handle_error();
return;
}
// user-ID and group-ID are reset to normal user now
// ...
}
In the code above the problem is that setuid(getuid()) removes superuser
privileges before setgid(getgid()) is called. To fix the problem the
setgid(getgid()) should be called first. Further attention is needed to
avoid code like setgid(getuid()) (this checker does not detect bugs like
this) and always check the return value of these calls.
This check corresponds to SEI CERT Rule POS36-C.
1.1.8. unix¶
POSIX/Unix checkers.
1.1.8.1. unix.API (C)¶
Check calls to various UNIX/Posix functions: open, pthread_once, calloc, malloc, realloc, alloca.
// Currently the check is performed for apple targets only.
void test(const char *path) {
int fd = open(path, O_CREAT);
// warn: call to 'open' requires a third argument when the
// 'O_CREAT' flag is set
}
void f();
void test() {
pthread_once_t pred = {0x30B1BCBA, {0}};
pthread_once(&pred, f);
// warn: call to 'pthread_once' uses the local variable
}
void test() {
void *p = malloc(0); // warn: allocation size of 0 bytes
}
void test() {
void *p = calloc(0, 42); // warn: allocation size of 0 bytes
}
void test() {
void *p = malloc(1);
p = realloc(p, 0); // warn: allocation size of 0 bytes
}
void test() {
void *p = alloca(0); // warn: allocation size of 0 bytes
}
void test() {
void *p = valloc(0); // warn: allocation size of 0 bytes
}
1.1.8.2. unix.BlockInCriticalSection (C, C++)¶
Check for calls to blocking functions inside a critical section.
Blocking functions detected by this checker: sleep, getc, fgets, read, recv.
Critical section handling functions modeled by this checker:
lock, unlock, pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock, mtx_lock, mtx_timedlock, mtx_trylock, mtx_unlock, lock_guard, unique_lock.
void pthread_lock_example(pthread_mutex_t *m) {
pthread_mutex_lock(m); // note: entering critical section here
sleep(10); // warn: Call to blocking function 'sleep' inside of critical section
pthread_mutex_unlock(m);
}
void overlapping_critical_sections(mtx_t *m1, std::mutex &m2) {
std::lock_guard lg{m2}; // note: entering critical section here
mtx_lock(m1); // note: entering critical section here
sleep(10); // warn: Call to blocking function 'sleep' inside of critical section
mtx_unlock(m1);
sleep(10); // warn: Call to blocking function 'sleep' inside of critical section
// still inside of the critical section of the std::lock_guard
}
Limitations
The
trylockandtimedlockversions of acquiring locks are currently assumed to always succeed. This can lead to false positives.
void trylock_example(pthread_mutex_t *m) {
if (pthread_mutex_trylock(m) == 0) { // assume trylock always succeeds
sleep(10); // warn: Call to blocking function 'sleep' inside of critical section
pthread_mutex_unlock(m);
} else {
sleep(10); // false positive: Incorrect warning about blocking function inside critical section.
}
}
1.1.8.3. unix.Chroot (C)¶
Check improper use of chroot described by SEI Cert C recommendation POS05-C.
Limit access to files by creating a jail.
The checker finds usage patterns where chdir("/") is not called immediately
after a call to chroot(path).
void f();
void test_bad() {
chroot("/usr/local");
f(); // warn: no call of chdir("/") immediately after chroot
}
void test_bad_path() {
chroot("/usr/local");
chdir("/usr"); // warn: no call of chdir("/") immediately after chroot
f();
}
void test_good() {
chroot("/usr/local");
chdir("/"); // no warning
f();
}
1.1.8.4. unix.Errno (C)¶
Check for improper use of errno.
This checker implements partially CERT rule
ERR30-C. Set errno to zero before calling a library function known to set errno,
and check errno only after the function returns a value indicating failure.
The checker can find the first read of errno after successful standard
function calls.
The C and POSIX standards often do not define if a standard library function
may change value of errno if the call does not fail.
Therefore, errno should only be used if it is known from the return value
of a function that the call has failed.
There are exceptions to this rule (for example strtol) but the affected
functions are not yet supported by the checker.
The return values for the failure cases are documented in the standard Linux man
pages of the functions and in the POSIX standard.
int unsafe_errno_read(int sock, void *data, int data_size) {
if (send(sock, data, data_size, 0) != data_size) {
// 'send' can be successful even if not all data was sent
if (errno == 1) { // An undefined value may be read from 'errno'
return 0;
}
}
return 1;
}
The checker unix.StdCLibraryFunctions (C) must be turned on to get the
warnings from this checker. The supported functions are the same as by
unix.StdCLibraryFunctions (C). The ModelPOSIX option of that
checker affects the set of checked functions.
Parameters
The AllowErrnoReadOutsideConditionExpressions option allows read of the
errno value if the value is not used in a condition (in if statements,
loops, conditional expressions, switch statements). For example errno
can be stored into a variable without getting a warning by the checker.
int unsafe_errno_read(int sock, void *data, int data_size) {
if (send(sock, data, data_size, 0) != data_size) {
int err = errno;
// warning if 'AllowErrnoReadOutsideConditionExpressions' is false
// no warning if 'AllowErrnoReadOutsideConditionExpressions' is true
}
return 1;
}
Default value of this option is true. This allows save of the errno value
for possible later error handling.
Limitations
Only the very first usage of
errnois checked after an affected function call. Value oferrnois not followed when it is stored into a variable or returned from a function.Documentation of function
lseekis not clear about what happens if the function returns different value than the expected file position but not -1. To avoid possible false-positiveserrnois allowed to be used in this case.
1.1.8.5. unix.Malloc (C)¶
Check for memory leaks, double free, and use-after-free problems. Traces memory managed by malloc()/free().
void test() {
int *p = malloc(1);
free(p);
free(p); // warn: attempt to free released memory
}
void test() {
int *p = malloc(sizeof(int));
free(p);
*p = 1; // warn: use after free
}
void test() {
int *p = malloc(1);
if (p)
return; // warn: memory is never released
}
void test() {
int a[] = { 1 };
free(a); // warn: argument is not allocated by malloc
}
void test() {
int *p = malloc(sizeof(char));
p = p - 1;
free(p); // warn: argument to free() is offset by -4 bytes
}
1.1.8.6. unix.MallocSizeof (C)¶
Check for dubious malloc arguments involving sizeof.
void test() {
long *p = malloc(sizeof(short));
// warn: result is converted to 'long *', which is
// incompatible with operand type 'short'
free(p);
}
1.1.8.7. unix.MismatchedDeallocator (C, C++)¶
Check for mismatched deallocators.
// C, C++
void test() {
int *p = (int *)malloc(sizeof(int));
delete p; // warn
}
// C, C++
void __attribute((ownership_returns(malloc))) *user_malloc(size_t);
void __attribute((ownership_takes(malloc, 1))) *user_free(void *);
void __attribute((ownership_returns(malloc1))) *user_malloc1(size_t);
void __attribute((ownership_takes(malloc1, 1))) *user_free1(void *);
void test() {
int *p = (int *)user_malloc(sizeof(int));
delete p; // warn
}
// C, C++
void test() {
int *p = new int;
free(p); // warn
}
// C, C++
void test() {
int *p = new int[1];
realloc(p, sizeof(long)); // warn
}
// C, C++
void test() {
int *p = user_malloc(10);
user_free1(p); // warn
}
// C, C++
template <typename T>
struct SimpleSmartPointer {
T *ptr;
explicit SimpleSmartPointer(T *p = 0) : ptr(p) {}
~SimpleSmartPointer() {
delete ptr; // warn
}
};
void test() {
SimpleSmartPointer<int> a((int *)malloc(4));
}
// C++
void test() {
int *p = (int *)operator new(0);
delete[] p; // warn
}
// Objective-C, C++
void test(NSUInteger dataLength) {
int *p = new int;
NSData *d = [NSData dataWithBytesNoCopy:p
length:sizeof(int) freeWhenDone:1];
// warn +dataWithBytesNoCopy:length:freeWhenDone: cannot take
// ownership of memory allocated by 'new'
}
1.1.8.8. unix.Vfork (C)¶
Check for proper usage of vfork.
int test(int x) {
pid_t pid = vfork(); // warn
if (pid != 0)
return 0;
switch (x) {
case 0:
pid = 1;
execl("", "", 0);
_exit(1);
break;
case 1:
x = 0; // warn: this assignment is prohibited
break;
case 2:
foo(); // warn: this function call is prohibited
break;
default:
return 0; // warn: return is prohibited
}
while(1);
}
1.1.8.9. unix.cstring.BadSizeArg (C)¶
Check the size argument passed into C string functions for common erroneous patterns. Use -Wno-strncat-size compiler option to mute other strncat-related compiler warnings.
void test() {
char dest[3];
strncat(dest, """""""""""""""""""""""""*", sizeof(dest));
// warn: potential buffer overflow
}
1.1.8.10. unix.cstring.NotNullTerminated (C)¶
Check for arguments which are not null-terminated strings;
applies to the strlen, strcpy, strcat, strcmp family of functions.
Only very fundamental cases are detected where the passed memory block is absolutely different from a null-terminated string. This checker does not find if a memory buffer is passed where the terminating zero character is missing.
void test1() {
int l = strlen((char *)&test1); // warn
}
void test2() {
label:
int l = strlen((char *)&&label); // warn
}
1.1.8.11. unix.cstring.NullArg (C)¶
Check for null pointers being passed as arguments to C string functions:
strlen, strnlen, strcpy, strncpy, strcat, strncat, strcmp, strncmp, strcasecmp, strncasecmp, wcslen, wcsnlen.
int test() {
return strlen(0); // warn
}
1.1.8.12. unix.StdCLibraryFunctions (C)¶
Check for calls of standard library functions that violate predefined argument
constraints. For example, according to the C standard the behavior of function
int isalnum(int ch) is undefined if the value of ch is not representable
as unsigned char and is not equal to EOF.
You can think of this checker as defining restrictions (pre- and postconditions) on standard library functions. Preconditions are checked, and when they are violated, a warning is emitted. Postconditions are added to the analysis, e.g. that the return value of a function is not greater than 255. Preconditions are added to the analysis too, in the case when the affected values are not known before the call.
For example, if an argument to a function must be in between 0 and 255, but the value of the argument is unknown, the analyzer will assume that it is in this interval. Similarly, if a function mustn’t be called with a null pointer and the analyzer cannot prove that it is null, then it will assume that it is non-null.
- These are the possible checks on the values passed as function arguments:
The argument has an allowed range (or multiple ranges) of values. The checker can detect if a passed value is outside of the allowed range and show the actual and allowed values.
The argument has pointer type and is not allowed to be null pointer. Many (but not all) standard functions can produce undefined behavior if a null pointer is passed, these cases can be detected by the checker.
The argument is a pointer to a memory block and the minimal size of this buffer is determined by another argument to the function, or by multiplication of two arguments (like at function
fread), or is a fixed value (for exampleasctime_rrequires at least a buffer of size 26). The checker can detect if the buffer size is too small and in optimal case show the size of the buffer and the values of the corresponding arguments.
#define EOF -1
void test_alnum_concrete(int v) {
int ret = isalnum(256); // \
// warning: Function argument outside of allowed range
(void)ret;
}
void buffer_size_violation(FILE *file) {
enum { BUFFER_SIZE = 1024 };
wchar_t wbuf[BUFFER_SIZE];
const size_t size = sizeof(*wbuf); // 4
const size_t nitems = sizeof(wbuf); // 4096
// Below we receive a warning because the 3rd parameter should be the
// number of elements to read, not the size in bytes. This case is a known
// vulnerability described by the ARR38-C SEI-CERT rule.
fread(wbuf, size, nitems, file);
}
int test_alnum_symbolic(int x) {
int ret = isalnum(x);
// after the call, ret is assumed to be in the range [-1, 255]
if (ret > 255) // impossible (infeasible branch)
if (x == 0)
return ret / x; // division by zero is not reported
return ret;
}
Additionally to the argument and return value conditions, this checker also adds
state of the value errno if applicable to the analysis. Many system
functions set the errno value only if an error occurs (together with a
specific return value of the function), otherwise it becomes undefined. This
checker changes the analysis state to contain such information. This data is
used by other checkers, for example unix.Errno (C).
Limitations
The checker can not always provide notes about the values of the arguments. Without this information it is hard to confirm if the constraint is indeed violated. The argument values are shown if they are known constants or the value is determined by previous (not too complicated) assumptions.
The checker can produce false positives in cases such as if the program has invariants not known to the analyzer engine or the bug report path contains calls to unknown functions. In these cases the analyzer fails to detect the real range of the argument.
Parameters
The ModelPOSIX option controls if functions from the POSIX standard are
recognized by the checker.
With ModelPOSIX=true, many POSIX functions are modeled according to the
POSIX standard. This includes ranges of parameters and possible return
values. Furthermore the behavior related to errno in the POSIX case is
often that errno is set only if a function call fails, and it becomes
undefined after a successful function call.
With ModelPOSIX=false, this checker follows the C99 language standard and
only models the functions that are described there. It is possible that the
same functions are modeled differently in the two cases because differences in
the standards. The C standard specifies less aspects of the functions, for
example exact errno behavior is often unspecified (and not modeled by the
checker).
Default value of the option is true.
1.1.8.13. unix.Stream (C)¶
Check C stream handling functions:
fopen, fdopen, freopen, tmpfile, fclose, fread, fwrite, fgetc, fgets, fputc, fputs, fprintf, fscanf, ungetc, getdelim, getline, fseek, fseeko, ftell, ftello, fflush, rewind, fgetpos, fsetpos, clearerr, feof, ferror, fileno.
The checker maintains information about the C stream objects (FILE *) and
can detect error conditions related to use of streams. The following conditions
are detected:
The
FILE *pointer passed to the function is NULL (the single exception isfflushwhere NULL is allowed).Use of stream after close.
Opened stream is not closed.
Read from a stream after end-of-file. (This is not a fatal error but reported by the checker. Stream remains in EOF state and the read operation fails.)
Use of stream when the file position is indeterminate after a previous failed operation. Some functions (like
ferror,clearerr,fseek) are allowed in this state.Invalid 3rd (”
whence”) argument tofseek.
The stream operations are by this checker usually split into two cases, a success
and a failure case.
On the success case it also assumes that the current value of stdout,
stderr, or stdin can’t be equal to the file pointer returned by fopen.
Operations performed on stdout, stderr, or stdin are not checked by
this checker in contrast to the streams opened by fopen.
In the case of write operations (like fwrite,
fprintf and even fsetpos) this behavior could produce a large amount of
unwanted reports on projects that don’t have error checks around the write
operations, so by default the checker assumes that write operations always succeed.
This behavior can be controlled by the Pedantic flag: With
-analyzer-config unix.Stream:Pedantic=true the checker will model the
cases where a write operation fails and report situations where this leads to
erroneous behavior. (The default is Pedantic=false, where write operations
are assumed to succeed.)
void test1() {
FILE *p = fopen("foo", "r");
} // warn: opened file is never closed
void test2() {
FILE *p = fopen("foo", "r");
fseek(p, 1, SEEK_SET); // warn: stream pointer might be NULL
fclose(p);
}
void test3() {
FILE *p = fopen("foo", "r");
if (p) {
fseek(p, 1, 3); // warn: third arg should be SEEK_SET, SEEK_END, or SEEK_CUR
fclose(p);
}
}
void test4() {
FILE *p = fopen("foo", "r");
if (!p)
return;
fclose(p);
fclose(p); // warn: stream already closed
}
void test5() {
FILE *p = fopen("foo", "r");
if (!p)
return;
fgetc(p);
if (!ferror(p))
fgetc(p); // warn: possible read after end-of-file
fclose(p);
}
void test6() {
FILE *p = fopen("foo", "r");
if (!p)
return;
fgetc(p);
if (!feof(p))
fgetc(p); // warn: file position may be indeterminate after I/O error
fclose(p);
}
Limitations
The checker does not track the correspondence between integer file descriptors
and FILE * pointers.
1.1.9. osx¶
macOS checkers.
1.1.9.1. osx.API (C)¶
Check for proper uses of various Apple APIs.
void test() {
dispatch_once_t pred = 0;
dispatch_once(&pred, ^(){}); // warn: dispatch_once uses local
}
1.1.9.2. osx.NumberObjectConversion (C, C++, ObjC)¶
Check for erroneous conversions of objects representing numbers into numbers.
NSNumber *photoCount = [albumDescriptor objectForKey:@"PhotoCount"];
// Warning: Comparing a pointer value of type 'NSNumber *'
// to a scalar integer value
if (photoCount > 0) {
[self displayPhotos];
}
1.1.9.3. osx.ObjCProperty (ObjC)¶
Check for proper uses of Objective-C properties.
NSNumber *photoCount = [albumDescriptor objectForKey:@"PhotoCount"];
// Warning: Comparing a pointer value of type 'NSNumber *'
// to a scalar integer value
if (photoCount > 0) {
[self displayPhotos];
}
1.1.9.4. osx.SecKeychainAPI (C)¶
Check for proper uses of Secure Keychain APIs.
void test() {
unsigned int *ptr = 0;
UInt32 length;
SecKeychainItemFreeContent(ptr, &length);
// warn: trying to free data which has not been allocated
}
void test() {
unsigned int *ptr = 0;
UInt32 *length = 0;
void *outData;
OSStatus st =
SecKeychainItemCopyContent(2, ptr, ptr, length, outData);
// warn: data is not released
}
void test() {
unsigned int *ptr = 0;
UInt32 *length = 0;
void *outData;
OSStatus st =
SecKeychainItemCopyContent(2, ptr, ptr, length, &outData);
SecKeychainItemFreeContent(ptr, outData);
// warn: only call free if a non-NULL buffer was returned
}
void test() {
unsigned int *ptr = 0;
UInt32 *length = 0;
void *outData;
OSStatus st =
SecKeychainItemCopyContent(2, ptr, ptr, length, &outData);
st = SecKeychainItemCopyContent(2, ptr, ptr, length, &outData);
// warn: release data before another call to the allocator
if (st == noErr)
SecKeychainItemFreeContent(ptr, outData);
}
void test() {
SecKeychainItemRef itemRef = 0;
SecKeychainAttributeInfo *info = 0;
SecItemClass *itemClass = 0;
SecKeychainAttributeList *attrList = 0;
UInt32 *length = 0;
void *outData = 0;
OSStatus st =
SecKeychainItemCopyAttributesAndData(itemRef, info,
itemClass, &attrList,
length, &outData);
SecKeychainItemFreeContent(attrList, outData);
// warn: deallocator doesn't match the allocator
}
1.1.9.5. osx.cocoa.AtSync (ObjC)¶
Check for nil pointers used as mutexes for @synchronized.
void test(id x) {
if (!x)
@synchronized(x) {} // warn: nil value used as mutex
}
void test() {
id y;
@synchronized(y) {} // warn: uninitialized value used as mutex
}
1.1.9.6. osx.cocoa.AutoreleaseWrite¶
Warn about potentially crashing writes to autoreleasing objects from different autoreleasing pools in Objective-C.
1.1.9.7. osx.cocoa.ClassRelease (ObjC)¶
Check for sending ‘retain’, ‘release’, or ‘autorelease’ directly to a Class.
@interface MyClass : NSObject
@end
void test(void) {
[MyClass release]; // warn
}
1.1.9.8. osx.cocoa.Dealloc (ObjC)¶
Warn about Objective-C classes that lack a correct implementation of -dealloc
@interface MyObject : NSObject {
id _myproperty;
}
@end
@implementation MyObject // warn: lacks 'dealloc'
@end
@interface MyObject : NSObject {}
@property(assign) id myproperty;
@end
@implementation MyObject // warn: does not send 'dealloc' to super
- (void)dealloc {
self.myproperty = 0;
}
@end
@interface MyObject : NSObject {
id _myproperty;
}
@property(retain) id myproperty;
@end
@implementation MyObject
@synthesize myproperty = _myproperty;
// warn: var was retained but wasn't released
- (void)dealloc {
[super dealloc];
}
@end
@interface MyObject : NSObject {
id _myproperty;
}
@property(assign) id myproperty;
@end
@implementation MyObject
@synthesize myproperty = _myproperty;
// warn: var wasn't retained but was released
- (void)dealloc {
[_myproperty release];
[super dealloc];
}
@end
1.1.9.9. osx.cocoa.IncompatibleMethodTypes (ObjC)¶
Warn about Objective-C method signatures with type incompatibilities.
@interface MyClass1 : NSObject
- (int)foo;
@end
@implementation MyClass1
- (int)foo { return 1; }
@end
@interface MyClass2 : MyClass1
- (float)foo;
@end
@implementation MyClass2
- (float)foo { return 1.0; } // warn
@end
1.1.9.10. osx.cocoa.Loops¶
Improved modeling of loops using Cocoa collection types.
1.1.9.11. osx.cocoa.MissingSuperCall (ObjC)¶
Warn about Objective-C methods that lack a necessary call to super.
@interface Test : UIViewController
@end
@implementation test
- (void)viewDidLoad {} // warn
@end
1.1.9.12. osx.cocoa.NSAutoreleasePool (ObjC)¶
Warn for suboptimal uses of NSAutoreleasePool in Objective-C GC mode.
void test() {
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
[pool release]; // warn
}
1.1.9.13. osx.cocoa.NSError (ObjC)¶
Check usage of NSError parameters.
@interface A : NSObject
- (void)foo:(NSError """""""""""""""""""""""")error;
@end
@implementation A
- (void)foo:(NSError """""""""""""""""""""""")error {
// warn: method accepting NSError"""""""""""""""""""""""" should have a non-void
// return value
}
@end
@interface A : NSObject
- (BOOL)foo:(NSError """""""""""""""""""""""")error;
@end
@implementation A
- (BOOL)foo:(NSError """""""""""""""""""""""")error {
*error = 0; // warn: potential null dereference
return 0;
}
@end
1.1.9.14. osx.cocoa.NilArg (ObjC)¶
Check for prohibited nil arguments to ObjC method calls.
caseInsensitiveCompare:
compare:
compare:options:
compare:options:range:
compare:options:range:locale:
componentsSeparatedByCharactersInSet:
initWithFormat:
NSComparisonResult test(NSString *s) {
NSString *aString = nil;
return [s caseInsensitiveCompare:aString];
// warn: argument to 'NSString' method
// 'caseInsensitiveCompare:' cannot be nil
}
1.1.9.15. osx.cocoa.NonNilReturnValue¶
Models the APIs that are guaranteed to return a non-nil value.
1.1.9.16. osx.cocoa.ObjCGenerics (ObjC)¶
Check for type errors when using Objective-C generics.
NSMutableArray *names = [NSMutableArray array];
NSMutableArray *birthDates = names;
// Warning: Conversion from value of type 'NSDate *'
// to incompatible type 'NSString *'
[birthDates addObject: [NSDate date]];
1.1.9.17. osx.cocoa.RetainCount (ObjC)¶
Check for leaks and improper reference count management
void test() {
NSString *s = [[NSString alloc] init]; // warn
}
CFStringRef test(char *bytes) {
return CFStringCreateWithCStringNoCopy(
0, bytes, NSNEXTSTEPStringEncoding, 0); // warn
}
1.1.9.18. osx.cocoa.RunLoopAutoreleaseLeak¶
Check for leaked memory in autorelease pools that will never be drained.
1.1.9.19. osx.cocoa.SelfInit (ObjC)¶
Check that ‘self’ is properly initialized inside an initializer method.
@interface MyObj : NSObject {
id x;
}
- (id)init;
@end
@implementation MyObj
- (id)init {
[super init];
x = 0; // warn: instance variable used while 'self' is not
// initialized
return 0;
}
@end
@interface MyObj : NSObject
- (id)init;
@end
@implementation MyObj
- (id)init {
[super init];
return self; // warn: returning uninitialized 'self'
}
@end
1.1.9.20. osx.cocoa.SuperDealloc (ObjC)¶
Warn about improper use of ‘[super dealloc]’ in Objective-C.
@interface SuperDeallocThenReleaseIvarClass : NSObject {
NSObject *_ivar;
}
@end
@implementation SuperDeallocThenReleaseIvarClass
- (void)dealloc {
[super dealloc];
[_ivar release]; // warn
}
@end
1.1.9.21. osx.cocoa.UnusedIvars (ObjC)¶
Warn about private ivars that are never used.
@interface MyObj : NSObject {
@private
id x; // warn
}
@end
@implementation MyObj
@end
1.1.9.22. osx.cocoa.VariadicMethodTypes (ObjC)¶
Check for passing non-Objective-C types to variadic collection initialization methods that expect only Objective-C types.
void test() {
[NSSet setWithObjects:@"Foo", "Bar", nil];
// warn: argument should be an ObjC pointer type, not 'char *'
}
1.1.9.23. osx.coreFoundation.CFError (C)¶
Check usage of CFErrorRef* parameters
void test(CFErrorRef *error) {
// warn: function accepting CFErrorRef* should have a
// non-void return
}
int foo(CFErrorRef *error) {
*error = 0; // warn: potential null dereference
return 0;
}
1.1.9.24. osx.coreFoundation.CFNumber (C)¶
Check for proper uses of CFNumber APIs.
CFNumberRef test(unsigned char x) {
return CFNumberCreate(0, kCFNumberSInt16Type, &x);
// warn: 8 bit integer is used to initialize a 16 bit integer
}
1.1.9.25. osx.coreFoundation.CFRetainRelease (C)¶
Check for null arguments to CFRetain/CFRelease/CFMakeCollectable.
void test(CFTypeRef p) {
if (!p)
CFRetain(p); // warn
}
void test(int x, CFTypeRef p) {
if (p)
return;
CFRelease(p); // warn
}
1.1.9.26. osx.coreFoundation.containers.OutOfBounds (C)¶
Checks for index out-of-bounds when using ‘CFArray’ API.
void test() {
CFArrayRef A = CFArrayCreate(0, 0, 0, &kCFTypeArrayCallBacks);
CFArrayGetValueAtIndex(A, 0); // warn
}
1.1.9.27. osx.coreFoundation.containers.PointerSizedValues (C)¶
Warns if ‘CFArray’, ‘CFDictionary’, ‘CFSet’ are created with non-pointer-size values.
void test() {
int x[] = { 1 };
CFArrayRef A = CFArrayCreate(0, (const void """""""""""""""""""""""")x, 1,
&kCFTypeArrayCallBacks); // warn
}
1.1.10. Fuchsia¶
Fuchsia is an open source capability-based operating system currently being developed by Google. This section describes checkers that can find various misuses of Fuchsia APIs.
1.1.10.1. fuchsia.HandleChecker¶
Handles identify resources. Similar to pointers they can be leaked, double freed, or use after freed. This check attempts to find such problems.
void checkLeak08(int tag) {
zx_handle_t sa, sb;
zx_channel_create(0, &sa, &sb);
if (tag)
zx_handle_close(sa);
use(sb); // Warn: Potential leak of handle
zx_handle_close(sb);
}
1.1.11. WebKit¶
WebKit is an open-source web browser engine available for macOS, iOS and Linux. This section describes checkers that can find issues in WebKit codebase.
Most of the checkers focus on memory management for which WebKit uses custom implementation of reference counted smartpointers.
- Checkers are formulated in terms related to ref-counting:
Ref-counted type is either
Ref<T>orRefPtr<T>.Ref-countable type is any type that implements
ref()andderef()methods asRefPtr<>is a template (i. e. relies on duck typing).Uncounted type is ref-countable but not ref-counted type.
1.1.11.1. webkit.RefCntblBaseVirtualDtor¶
All uncounted types used as base classes must have a virtual destructor.
Ref-counted types hold their ref-countable data by a raw pointer and allow implicit upcasting from ref-counted pointer to derived type to ref-counted pointer to base type. This might lead to an object of (dynamic) derived type being deleted via pointer to the base class type which C++ standard defines as UB in case the base class doesn’t have virtual destructor [expr.delete].
struct RefCntblBase {
void ref() {}
void deref() {}
};
struct Derived : RefCntblBase { }; // warn
1.1.11.2. webkit.NoUncountedMemberChecker¶
Raw pointers and references to uncounted types can’t be used as class members. Only ref-counted types are allowed.
struct RefCntbl {
void ref() {}
void deref() {}
};
struct Foo {
RefCntbl * ptr; // warn
RefCntbl & ptr; // warn
// ...
};
1.1.11.3. webkit.UncountedLambdaCapturesChecker¶
Raw pointers and references to uncounted types can’t be captured in lambdas. Only ref-counted types are allowed.
struct RefCntbl {
void ref() {}
void deref() {}
};
void foo(RefCntbl* a, RefCntbl& b) {
[&, a](){ // warn about 'a'
do_something(b); // warn about 'b'
};
};
1.2. Experimental Checkers¶
These are checkers with known issues or limitations that keep them from being on by default. They are likely to have false positives. Bug reports and especially patches are welcome.
1.2.1. alpha.clone¶
1.2.1.1. alpha.clone.CloneChecker (C, C++, ObjC)¶
Reports similar pieces of code.
void log();
int max(int a, int b) { // warn
log();
if (a > b)
return a;
return b;
}
int maxClone(int x, int y) { // similar code here
log();
if (x > y)
return x;
return y;
}
1.2.2. alpha.core¶
1.2.2.1. alpha.core.BoolAssignment (ObjC)¶
Warn about assigning non-{0,1} values to boolean variables.
void test() {
BOOL b = -1; // warn
}
1.2.2.2. alpha.core.C11Lock¶
Similarly to alpha.unix.PthreadLock, checks for
the locking/unlocking of mtx_t mutexes.
mtx_t mtx1;
void bad1(void)
{
mtx_lock(&mtx1);
mtx_lock(&mtx1); // warn: This lock has already been acquired
}
1.2.2.3. alpha.core.CastSize (C)¶
Check when casting a malloc’ed type T, whether the size is a multiple of the size of T.
void test() {
int *x = (int *) malloc(11); // warn
}
1.2.2.4. alpha.core.CastToStruct (C, C++)¶
Check for cast from non-struct pointer to struct pointer.
// C
struct s {};
void test(int *p) {
struct s *ps = (struct s *) p; // warn
}
// C++
class c {};
void test(int *p) {
c *pc = (c *) p; // warn
}
1.2.2.5. alpha.core.Conversion (C, C++, ObjC)¶
Loss of sign/precision in implicit conversions.
void test(unsigned U, signed S) {
if (S > 10) {
if (U < S) {
}
}
if (S < -10) {
if (U < S) { // warn (loss of sign)
}
}
}
void test() {
long long A = 1LL << 60;
short X = A; // warn (loss of precision)
}
1.2.2.6. alpha.core.DynamicTypeChecker (ObjC)¶
Check for cases where the dynamic and the static type of an object are unrelated.
id date = [NSDate date];
// Warning: Object has a dynamic type 'NSDate *' which is
// incompatible with static type 'NSNumber *'"
NSNumber *number = date;
[number doubleValue];
1.2.2.7. alpha.core.FixedAddr (C)¶
Check for assignment of a fixed address to a pointer.
void test() {
int *p;
p = (int *) 0x10000; // warn
}
1.2.2.8. alpha.core.PointerArithm (C)¶
Check for pointer arithmetic on locations other than array elements.
void test() {
int x;
int *p;
p = &x + 1; // warn
}
1.2.2.9. alpha.core.StackAddressAsyncEscape (ObjC)¶
Check that addresses to stack memory do not escape the function that involves dispatch_after or dispatch_async.
This checker is a part of core.StackAddressEscape, but is temporarily disabled until some false positives are fixed.
dispatch_block_t test_block_inside_block_async_leak() {
int x = 123;
void (^inner)(void) = ^void(void) {
int y = x;
++y;
};
void (^outer)(void) = ^void(void) {
int z = x;
++z;
inner();
};
return outer; // warn: address of stack-allocated block is captured by a
// returned block
}
1.2.2.10. alpha.core.StdVariant (C++)¶
Check if a value of active type is retrieved from an std::variant instance with std::get.
In case of bad variant type access (the accessed type differs from the active type)
a warning is emitted. Currently, this checker does not take exception handling into account.
void test() {
std::variant<int, char> v = 25;
char c = stg::get<char>(v); // warn: "int" is the active alternative
}
1.2.2.11. alpha.core.TestAfterDivZero (C)¶
Check for division by variable that is later compared against 0. Either the comparison is useless or there is division by zero.
void test(int x) {
var = 77 / x;
if (x == 0) { } // warn
}
1.2.3. alpha.cplusplus¶
1.2.3.1. alpha.cplusplus.DeleteWithNonVirtualDtor (C++)¶
Reports destructions of polymorphic objects with a non-virtual destructor in their base class.
class NonVirtual {};
class NVDerived : public NonVirtual {};
NonVirtual *create() {
NonVirtual *x = new NVDerived(); // note: Casting from 'NVDerived' to
// 'NonVirtual' here
return x;
}
void foo() {
NonVirtual *x = create();
delete x; // warn: destruction of a polymorphic object with no virtual
// destructor
}
1.2.3.2. alpha.cplusplus.InvalidatedIterator (C++)¶
Check for use of invalidated iterators.
void bad_copy_assign_operator_list1(std::list &L1,
const std::list &L2) {
auto i0 = L1.cbegin();
L1 = L2;
*i0; // warn: invalidated iterator accessed
}
1.2.3.3. alpha.cplusplus.IteratorRange (C++)¶
Check for iterators used outside their valid ranges.
void simple_bad_end(const std::vector &v) {
auto i = v.end();
*i; // warn: iterator accessed outside of its range
}
1.2.3.4. alpha.cplusplus.MismatchedIterator (C++)¶
Check for use of iterators of different containers where iterators of the same container are expected.
void bad_insert3(std::vector &v1, std::vector &v2) {
v2.insert(v1.cbegin(), v2.cbegin(), v2.cend()); // warn: container accessed
// using foreign
// iterator argument
v1.insert(v1.cbegin(), v1.cbegin(), v2.cend()); // warn: iterators of
// different containers
// used where the same
// container is
// expected
v1.insert(v1.cbegin(), v2.cbegin(), v1.cend()); // warn: iterators of
// different containers
// used where the same
// container is
// expected
}
1.2.3.5. alpha.cplusplus.SmartPtr (C++)¶
Check for dereference of null smart pointers.
void deref_smart_ptr() {
std::unique_ptr<int> P;
*P; // warn: dereference of a default constructed smart unique_ptr
}
1.2.4. alpha.deadcode¶
1.2.4.1. alpha.deadcode.UnreachableCode (C, C++)¶
Check unreachable code.
// C
int test() {
int x = 1;
while(x);
return x; // warn
}
// C++
void test() {
int a = 2;
while (a > 1)
a--;
if (a > 1)
a++; // warn
}
// Objective-C
void test(id x) {
return;
[x retain]; // warn
}
1.2.5. alpha.fuchsia¶
1.2.5.1. alpha.fuchsia.Lock¶
Similarly to alpha.unix.PthreadLock, checks for the locking/unlocking of fuchsia mutexes.
spin_lock_t mtx1;
void bad1(void)
{
spin_lock(&mtx1);
spin_lock(&mtx1); // warn: This lock has already been acquired
}
1.2.6. alpha.llvm¶
1.2.6.1. alpha.llvm.Conventions¶
Check code for LLVM codebase conventions:
A StringRef should not be bound to a temporary std::string whose lifetime is shorter than the StringRef’s.
Clang AST nodes should not have fields that can allocate memory.
1.2.7. alpha.osx¶
1.2.7.1. alpha.osx.cocoa.DirectIvarAssignment (ObjC)¶
Check for direct assignments to instance variables.
@interface MyClass : NSObject {}
@property (readonly) id A;
- (void) foo;
@end
@implementation MyClass
- (void) foo {
_A = 0; // warn
}
@end
1.2.7.2. alpha.osx.cocoa.DirectIvarAssignmentForAnnotatedFunctions (ObjC)¶
Check for direct assignments to instance variables in
the methods annotated with objc_no_direct_instance_variable_assignment.
@interface MyClass : NSObject {}
@property (readonly) id A;
- (void) fAnnotated __attribute__((
annotate("objc_no_direct_instance_variable_assignment")));
- (void) fNotAnnotated;
@end
@implementation MyClass
- (void) fAnnotated {
_A = 0; // warn
}
- (void) fNotAnnotated {
_A = 0; // no warn
}
@end
1.2.7.3. alpha.osx.cocoa.InstanceVariableInvalidation (ObjC)¶
Check that the invalidatable instance variables are invalidated in the methods annotated with objc_instance_variable_invalidator.
@protocol Invalidation <NSObject>
- (void) invalidate
__attribute__((annotate("objc_instance_variable_invalidator")));
@end
@interface InvalidationImpObj : NSObject <Invalidation>
@end
@interface SubclassInvalidationImpObj : InvalidationImpObj {
InvalidationImpObj *var;
}
- (void)invalidate;
@end
@implementation SubclassInvalidationImpObj
- (void) invalidate {}
@end
// warn: var needs to be invalidated or set to nil
1.2.7.4. alpha.osx.cocoa.MissingInvalidationMethod (ObjC)¶
Check that the invalidation methods are present in classes that contain invalidatable instance variables.
@protocol Invalidation <NSObject>
- (void)invalidate
__attribute__((annotate("objc_instance_variable_invalidator")));
@end
@interface NeedInvalidation : NSObject <Invalidation>
@end
@interface MissingInvalidationMethodDecl : NSObject {
NeedInvalidation *Var; // warn
}
@end
@implementation MissingInvalidationMethodDecl
@end
1.2.7.5. alpha.osx.cocoa.localizability.PluralMisuseChecker (ObjC)¶
Warns against using one vs. many plural pattern in code when generating localized strings.
NSString *reminderText =
NSLocalizedString(@"None", @"Indicates no reminders");
if (reminderCount == 1) {
// Warning: Plural cases are not supported across all languages.
// Use a .stringsdict file instead
reminderText =
NSLocalizedString(@"1 Reminder", @"Indicates single reminder");
} else if (reminderCount >= 2) {
// Warning: Plural cases are not supported across all languages.
// Use a .stringsdict file instead
reminderText =
[NSString stringWithFormat:
NSLocalizedString(@"%@ Reminders", @"Indicates multiple reminders"),
reminderCount];
}
1.2.8. alpha.security¶
1.2.8.1. alpha.security.ArrayBound (C)¶
Warn about buffer overflows (older checker).
void test() {
char *s = "";
char c = s[1]; // warn
}
struct seven_words {
int c[7];
};
void test() {
struct seven_words a, *p;
p = &a;
p[0] = a;
p[1] = a;
p[2] = a; // warn
}
// note: requires unix.Malloc or
// alpha.unix.MallocWithAnnotations checks enabled.
void test() {
int *p = malloc(12);
p[3] = 4; // warn
}
void test() {
char a[2];
int *b = (int*)a;
b[1] = 3; // warn
}
1.2.8.2. alpha.security.ArrayBoundV2 (C)¶
Warn about buffer overflows (newer checker).
void test() {
char *s = "";
char c = s[1]; // warn
}
void test() {
int buf[100];
int *p = buf;
p = p + 99;
p[1] = 1; // warn
}
// note: compiler has internal check for this.
// Use -Wno-array-bounds to suppress compiler warning.
void test() {
int buf[100][100];
buf[0][-1] = 1; // warn
}
// note: requires optin.taint check turned on.
void test() {
char s[] = "abc";
int x = getchar();
char c = s[x]; // warn: index is tainted
}
1.2.8.3. alpha.security.ReturnPtrRange (C)¶
Check for an out-of-bound pointer being returned to callers.
static int A[10];
int *test() {
int *p = A + 10;
return p; // warn
}
int test(void) {
int x;
return x; // warn: undefined or garbage returned
}
1.2.9. alpha.security.cert¶
SEI CERT checkers which tries to find errors based on their C coding rules.
1.2.10. alpha.unix¶
1.2.10.1. alpha.unix.PthreadLock (C)¶
Simple lock -> unlock checker.
Applies to: pthread_mutex_lock, pthread_rwlock_rdlock, pthread_rwlock_wrlock, lck_mtx_lock, lck_rw_lock_exclusive
lck_rw_lock_shared, pthread_mutex_trylock, pthread_rwlock_tryrdlock, pthread_rwlock_tryrwlock, lck_mtx_try_lock,
lck_rw_try_lock_exclusive, lck_rw_try_lock_shared, pthread_mutex_unlock, pthread_rwlock_unlock, lck_mtx_unlock, lck_rw_done.
pthread_mutex_t mtx;
void test() {
pthread_mutex_lock(&mtx);
pthread_mutex_lock(&mtx);
// warn: this lock has already been acquired
}
lck_mtx_t lck1, lck2;
void test() {
lck_mtx_lock(&lck1);
lck_mtx_lock(&lck2);
lck_mtx_unlock(&lck1);
// warn: this was not the most recently acquired lock
}
lck_mtx_t lck1, lck2;
void test() {
if (lck_mtx_try_lock(&lck1) == 0)
return;
lck_mtx_lock(&lck2);
lck_mtx_unlock(&lck1);
// warn: this was not the most recently acquired lock
}
1.2.10.2. alpha.unix.SimpleStream (C)¶
Check for misuses of stream APIs. Check for misuses of stream APIs: fopen, fclose
(demo checker, the subject of the demo (Slides ,
Video) by Anna Zaks and Jordan Rose presented at the
2012 LLVM Developers’ Meeting).
void test() {
FILE *F = fopen("myfile.txt", "w");
} // warn: opened file is never closed
void test() {
FILE *F = fopen("myfile.txt", "w");
if (F)
fclose(F);
fclose(F); // warn: closing a previously closed file stream
}
1.2.10.3. alpha.unix.cstring.BufferOverlap (C)¶
Checks for overlap in two buffer arguments. Applies to: memcpy, mempcpy, wmemcpy, wmempcpy.
void test() {
int a[4] = {0};
memcpy(a + 2, a + 1, 8); // warn
}
1.2.10.4. alpha.unix.cstring.OutOfBounds (C)¶
Check for out-of-bounds access in string functions, such as:
memcpy, bcopy, strcpy, strncpy, strcat, strncat, memmove, memcmp, memset and more.
This check also works with string literals, except there is a known bug in that the analyzer cannot detect embedded NULL characters when determining the string length.
void test1() {
const char str[] = "Hello world";
char buffer[] = "Hello world";
memcpy(buffer, str, sizeof(str) + 1); // warn
}
void test2() {
const char str[] = "Hello world";
char buffer[] = "Helloworld";
memcpy(buffer, str, sizeof(str)); // warn
}
1.2.10.5. alpha.unix.cstring.UninitializedRead (C)¶
- Check for uninitialized reads from common memory copy/manipulation functions such as:
memcpy, mempcpy, memmove, memcmp, strcmp, strncmp, strcpy, strlen, strsepand many more.
void test() {
char src[10];
char dst[5];
memcpy(dst,src,sizeof(dst)); // warn: Bytes string function accesses uninitialized/garbage values
}
Limitations:
Due to limitations of the memory modeling in the analyzer, one can likely observe a lot of false-positive reports like this:
void false_positive() { int src[] = {1, 2, 3, 4}; int dst[5] = {0}; memcpy(dst, src, 4 * sizeof(int)); // false-positive: // The 'src' buffer was correctly initialized, yet we cannot conclude // that since the analyzer could not see a direct initialization of the // very last byte of the source buffer. }More details at the corresponding GitHub issue.
1.2.11. alpha.WebKit¶
1.2.11.1. alpha.webkit.MemoryUnsafeCastChecker¶
Check for all casts from a base type to its derived type as these might be memory-unsafe.
Example:
class Base { };
class Derived : public Base { };
void f(Base* base) {
Derived* derived = static_cast<Derived*>(base); // ERROR
}
For all cast operations (C-style casts, static_cast, reinterpret_cast, dynamic_cast), if the source type a Base* and the destination type is Derived*, where Derived inherits from Base, the static analyzer should signal an error.
This applies to:
C structs, C++ structs and classes, and Objective-C classes and protocols.
Pointers and references.
Inside template instantiations and macro expansions that are visible to the compiler.
For types like this, instead of using built in casts, the programmer will use helper functions that internally perform the appropriate type check and disable static analysis.
1.2.11.2. alpha.webkit.NoUncheckedPtrMemberChecker¶
Raw pointers and references to an object which supports CheckedPtr or CheckedRef can’t be used as class members. Only CheckedPtr, CheckedRef, RefPtr, or Ref are allowed.
struct CheckableObj {
void incrementCheckedPtrCount() {}
void decrementCheckedPtrCount() {}
};
struct Foo {
CheckableObj* ptr; // warn
CheckableObj& ptr; // warn
// ...
};
See WebKit Guidelines for Safer C++ Programming for details.
1.2.11.3. alpha.webkit.UncountedCallArgsChecker¶
The goal of this rule is to make sure that lifetime of any dynamically allocated ref-countable object passed as a call argument spans past the end of the call. This applies to call to any function, method, lambda, function pointer or functor. Ref-countable types aren’t supposed to be allocated on stack so we check arguments for parameters of raw pointers and references to uncounted types.
Here are some examples of situations that we warn about as they might be potentially unsafe. The logic is that either we’re able to guarantee that an argument is safe or it’s considered if not a bug then bug-prone.
RefCountable* provide_uncounted(); void consume(RefCountable*); // In these cases we can't make sure callee won't directly or indirectly call `deref()` on the argument which could make it unsafe from such point until the end of the call. void foo1() { consume(provide_uncounted()); // warn } void foo2() { RefCountable* uncounted = provide_uncounted(); consume(uncounted); // warn }
Although we are enforcing member variables to be ref-counted by webkit.NoUncountedMemberChecker any method of the same class still has unrestricted access to these. Since from a caller’s perspective we can’t guarantee a particular member won’t get modified by callee (directly or indirectly) we don’t consider values obtained from members safe.
Note: It’s likely this heuristic could be made more precise with fewer false positives - for example calls to free functions that don’t have any parameter other than the pointer should be safe as the callee won’t be able to tamper with the member unless it’s a global variable.
struct Foo { RefPtr<RefCountable> member; void consume(RefCountable*) { /* ... */ } void bugprone() { consume(member.get()); // warn } };
The implementation of this rule is a heuristic - we define a whitelist of kinds of values that are considered safe to be passed as arguments. If we can’t prove an argument is safe it’s considered an error.
Allowed kinds of arguments:
values obtained from ref-counted objects (including temporaries as those survive the call too)
RefCountable* provide_uncounted(); void consume(RefCountable*); void foo() { RefPtr<RefCountable> rc = makeRef(provide_uncounted()); consume(rc.get()); // ok consume(makeRef(provide_uncounted()).get()); // ok }
forwarding uncounted arguments from caller to callee
void foo(RefCountable& a) { bar(a); // ok }
Caller of
foo()is responsible fora’s lifetime.thispointervoid Foo::foo() { baz(this); // ok }
Caller of
foo()is responsible for keeping the memory pointed to bythispointer safe.constants
foo(nullptr, NULL, 0); // ok
We also define a set of safe transformations which if passed a safe value as an input provide (usually it’s the return value) a safe value (or an object that provides safe values). This is also a heuristic.
constructors of ref-counted types (including factory methods)
getters of ref-counted types
member overloaded operators
casts
unary operators like
&or*
1.2.11.4. alpha.webkit.UncheckedCallArgsChecker¶
The goal of this rule is to make sure that lifetime of any dynamically allocated CheckedPtr capable object passed as a call argument keeps its memory region past the end of the call. This applies to call to any function, method, lambda, function pointer or functor. CheckedPtr capable objects aren’t supposed to be allocated on stack so we check arguments for parameters of raw pointers and references to unchecked types.
The rules of when to use and not to use CheckedPtr / CheckedRef are same as alpha.webkit.UncountedCallArgsChecker for ref-counted objects.
1.2.11.5. alpha.webkit.UncountedLocalVarsChecker¶
The goal of this rule is to make sure that any uncounted local variable is backed by a ref-counted object with lifetime that is strictly larger than the scope of the uncounted local variable. To be on the safe side we require the scope of an uncounted variable to be embedded in the scope of ref-counted object that backs it.
These are examples of cases that we consider safe:
void foo1() { RefPtr<RefCountable> counted; // The scope of uncounted is EMBEDDED in the scope of counted. { RefCountable* uncounted = counted.get(); // ok } } void foo2(RefPtr<RefCountable> counted_param) { RefCountable* uncounted = counted_param.get(); // ok } void FooClass::foo_method() { RefCountable* uncounted = this; // ok }
Here are some examples of situations that we warn about as they might be potentially unsafe. The logic is that either we’re able to guarantee that a local variable is safe or it’s considered unsafe.
void foo1() { RefCountable* uncounted = new RefCountable; // warn } RefCountable* global_uncounted; void foo2() { RefCountable* uncounted = global_uncounted; // warn } void foo3() { RefPtr<RefCountable> counted; // The scope of uncounted is not EMBEDDED in the scope of counted. RefCountable* uncounted = counted.get(); // warn }
1.2.11.6. alpha.webkit.UncheckedLocalVarsChecker¶
The goal of this rule is to make sure that any unchecked local variable is backed by a CheckedPtr or CheckedRef with lifetime that is strictly larger than the scope of the unchecked local variable. To be on the safe side we require the scope of an unchecked variable to be embedded in the scope of CheckedPtr/CheckRef object that backs it.
These are examples of cases that we consider safe:
void foo1() { CheckedPtr<RefCountable> counted; // The scope of uncounted is EMBEDDED in the scope of counted. { RefCountable* uncounted = counted.get(); // ok } } void foo2(CheckedPtr<RefCountable> counted_param) { RefCountable* uncounted = counted_param.get(); // ok } void FooClass::foo_method() { RefCountable* uncounted = this; // ok }
Here are some examples of situations that we warn about as they might be potentially unsafe. The logic is that either we’re able to guarantee that a local variable is safe or it’s considered unsafe.
void foo1() { RefCountable* uncounted = new RefCountable; // warn } RefCountable* global_uncounted; void foo2() { RefCountable* uncounted = global_uncounted; // warn } void foo3() { RefPtr<RefCountable> counted; // The scope of uncounted is not EMBEDDED in the scope of counted. RefCountable* uncounted = counted.get(); // warn }
1.3. Debug Checkers¶
1.3.1. debug¶
Checkers used for debugging the analyzer. Debug Checks page contains a detailed description.
1.3.1.1. debug.AnalysisOrder¶
Print callbacks that are called during analysis in order.
1.3.1.2. debug.ConfigDumper¶
Dump config table.
1.3.1.3. debug.DumpCFG Display¶
Control-Flow Graphs.
1.3.1.4. debug.DumpCallGraph¶
Display Call Graph.
1.3.1.5. debug.DumpCalls¶
Print calls as they are traversed by the engine.
1.3.1.6. debug.DumpDominators¶
Print the dominance tree for a given CFG.
1.3.1.7. debug.DumpLiveVars¶
Print results of live variable analysis.
1.3.1.8. debug.DumpTraversal¶
Print branch conditions as they are traversed by the engine.
1.3.1.9. debug.ExprInspection¶
Check the analyzer’s understanding of expressions.
1.3.1.10. debug.Stats¶
Emit warnings with analyzer statistics.
1.3.1.11. debug.TaintTest¶
Mark tainted symbols as such.
1.3.1.12. debug.ViewCFG¶
View Control-Flow Graphs using GraphViz.
1.3.1.13. debug.ViewCallGraph¶
View Call Graph using GraphViz.
1.3.1.14. debug.ViewExplodedGraph¶
View Exploded Graphs using GraphViz.