weggli is a fast and robust semantic search tool for C and C++ codebases. It is designed to help security researchers identify interesting functionality in large codebases.

Related tags

Miscellaneous weggli
Overview

weggli

weggli example

Introduction

weggli is a fast and robust semantic search tool for C and C++ codebases. It is designed to help security researchers identify interesting functionality in large codebases.

weggli performs pattern matching on Abstract Syntax Trees based on user provided queries. Its query language resembles C and C++ code, making it easy to turn interesting code patterns into queries.

weggli is inspired by great tools like Semgrep, Coccinelle and CodeQL, but makes some different design decisions:

  • C++ support: weggli has first class support for modern C++ constructs, such as lambda expressions, range-based for loops and constexprs.

  • Minimal setup: weggli should work out-of-the box against most software you will encounter. weggli does not require the ability to build the software and can work with incomplete sources or missing dependencies.

  • Interactive: weggli is designed for interactive usage and fast query performance. Most of the time, a weggli query will be faster than a grep search. The goal is to enable an interactive workflow where quick switching between code review and query creation/improvement is possible.

  • Greedy: weggli's pattern matching is designed to find as many (useful) matches as possible for a specific query. While this increases the risk of false positives it simplifies query creation. For example, the query $x = 10; will match both assignment expressions (foo = 10;) and declarations (int bar = 10;).

Usage

Use -h for short descriptions and --help for more details.

Homepage: https://github.com/googleprojectzero/weggli

USAGE: weggli [OPTIONS] 
    
    
     

ARGS:
    
     
          
            A weggli search pattern. weggli's query language closely resembles
            C and C++ with a small number of extra features.
            
            For example, the pattern '{_ $buf[_]; memcpy($buf,_,_);}' will
            find all calls to memcpy that directly write into a stack buffer.
            
            Besides normal C and C++ constructs, weggli's query language
            supports the following features:
            
            _        Wildcard. Will match on any AST node. 
            
            $var     Variables. Can be used to write queries that are independent
                     of identifiers. Variables match on identifiers, types,
                     field names or namespaces. The --unique option
                     optionally enforces that $x != $y != $z. The --regex option can
                     enforce that the variable has to match (or not match) a
                     regular expression.
            
            _(..)    Subexpressions. The _(..) wildcard matches on arbitrary
                     sub expressions. This can be helpful if you are looking for some
                     operation involving a variable, but don't know more about it.
                     For example, _(test) will match on expressions like test+10,
                     buf[test->size] or f(g(&test));
            
            not:     Negative sub queries. Only show results that do not match the
                     following sub query. For example, '{not: $fv==NULL; not: $fv!=NULL *$v;}'
                     would find pointer dereferences that are not preceded by a NULL check.
            
            weggli automatically unwraps expression statements in the query source 
            to search for the inner expression instead. This means that the query `{func($x);}` 
            will match on `func(a);`, but also on `if (func(a)) {..}` or  `return func(a)`. 
            Matching on `func(a)` will also match on `func(a,b,c)` or `func(z,a)`. 
            Similarly, `void func($t $param)` will also match function definitions 
            with multiple parameters. 
            
            Additional patterns can be specified using the --pattern (-p) option. This makes
            it possible to search across functions or type definitions.
    
      
              
            Input directory or file to search. By default, weggli will search inside 
            .c and .h files for the default C mode or .cc, .cpp, .cxx, .h and .hpp files when
            executing in C++ mode (using the --cpp option).
            Alternative file endings can be specified using the --extensions (-e) option.
            
            When combining weggli with other tools or preprocessing steps, 
            files can also be specified via STDIN by setting the directory to '-' 
            and piping a list of filenames.

OPTIONS:
    -A, --after 
       
         Lines to print after a match. Default = 5. -B, --before 
        
          Lines to print before a match. Default = 5. -C, --color Force enable color output. -X, --cpp Enable C++ mode. --exclude 
         
          ... Exclude files that match the given regex. -e, --extensions 
          
           ... File extensions to include in the search. -f, --force Force a search even if the queries contains syntax errors. -h, --help Prints help information. --include 
           
            ... Only search files that match the given regex. -l, --limit Only show the first match in each function. -p, --pattern 
           
          
         
        
       
      
     
    
   

... Specify additional search patterns. -R, --regex ... Filter variable matches based on a regular expression. This feature uses the Rust regex crate, so most Perl-style regular expression features are supported. (see https://docs.rs/regex/1.5.4/regex/#syntax) Examples: Find calls to functions starting with the string 'mem': weggli -R 'func=^mem' '$func(_);' Find memcpy calls where the last argument is NOT named 'size': weggli -R 's!=^size$' 'memcpy(_,_,$s);' -u, --unique Enforce uniqueness of variable matches. By default, two variables such as $a and $b can match on identical values. For example, the query '$x=malloc($a); memcpy($x, _, $b);' would match on both void *buf = malloc(size); memcpy(buf, src, size); and void *buf = malloc(some_constant); memcpy(buf, src, size); Using the unique flag would filter out the first match as $a==$b. -v, --verbose Sets the level of verbosity. -V, --version Prints version information.

Examples

Calls to memcpy that write into a stack-buffer:

weggli '{
    _ $buf[_];
    memcpy($buf,_,_);
}' ./target/src

Potentially vulnerable snprintf() users:

weggli '{
    $ret = snprintf($b,_,_);
    $b[$ret] = _;
}' ./target/src

Potentially uninitialized pointers:

weggli '{ _* $p;
NOT: $p = _;
$func(&$p);
}' ./target/src

Potentially insecure WeakPtr usage:

weggli -X '{
$x = _.GetWeakPtr(); 
DCHECK($x); 
$x->_;}' ./target/src

Debug only iterator validation:

weggli -X 'DCHECK(_!=_.end());' ./target/src

Functions that perform writes into a stack-buffer based on a function argument.

weggli '_ $fn(_ $limit) {
    _ $buf[_];
    for (_; $i<$limit; _) {
        $buf[$i]=_;
    }
}' ./target/src

Functions with the string decode in their name

weggli -R func=decode '_ $func(_) {_;}'

Encoding/Conversion functions

weggli '_ $func($t *$input, $t2 *$output) {
    for (_($i);_;_) {
        $input[$i]=_($output);
    }
}' ./target/src

Build Instruction

# optional: install rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh 

git clone https://github.com/googleprojectzero/weggli.git
cd weggli; cargo build --release
./target/release/wegggli

Implementation details

Weggli is built on top of the tree-sitter parsing library and its C and C++ grammars. Search queries are first parsed using an extended version of the corresponding grammar, and the resulting AST is transformed into a set of tree-sitter queries in builder.rs. The actual query matching is implemented in query.rs, which is a relatively small wrapper around tree-sitter's query engine to add weggli specific features.

Contributing

See CONTRIBUTING.md for details.

License

Apache 2.0; see LICENSE for details.

Disclaimer

This project is not an official Google project. It is not supported by Google and Google specifically disclaims all warranties as to its quality, merchantability, or fitness for a particular purpose.

Issues
  • Unable to match class members

    Unable to match class members

    I have the following example

    int getX() { return 0; }
    
    class Foo {
    	
    
    	Foo(int x, int y)
    	:m_x(x)
    	,m_y(y)
    	{}
    
    	int getX();
    	int getY(){return m_y;};
    
    	int m_x;
    	int m_y;
    };
    
    int Foo::getX() const { return m_x; }
    

    I can match getX with

    _ Foo::getX() const {_;}
    

    but I can't create a query to match getY which is inline. Is this possible?

    opened by bradphelan 4
  • Can't query across files?

    Can't query across files?

    test code:

    test1.cpp

    #include "test2.h"
    static INT64 func1(VOID)
    {
    
        lResult = func2(1, func3, (VOID *)NULL);
    
        return SUCCESS;
    }
    

    test2.cpp

    VOID *func3(VOID *pStr)
    {
        int i = 0;
        (VOID)pthread_detach(pthread_self());
    
        return (VOID *)0;
    } //lint !e715 !e818
    

    my query not work:

    weggli -C --cpp --unique 'func2(_,$fn,_);' -p '_ $fn(_){
    _;
    pthread_detach(pthread_self());
        }' test
    

    When I put it together, the query works. So is it my query worng or weggli not support query across files?

    opened by p1v07 4
  • How do I search for all else {} blocks that contain a return or a throw?

    How do I search for all else {} blocks that contain a return or a throw?

    First of all, thank you for sharing such a useful tool!

    I am trying to find patterns in the code like this:

      if (condition)
      {
          /* do */
          /* many */
          /* things */
      }
      else
      {
          throw PreconditionNotSatisified{};   // or return -ERROR, 
      }
    

    so they can be refactored to return early and reduce code indentation.

    I have tried:

      weggli 'if (_) else { throw }' .
    
      weggli 'if (_) { _ } else { throw $something; }' .
    

    but nothing seems to work. Help!

    Thank you.

    opened by 0x8000-0000 4
  • Mismatch of generic variable name using

    Mismatch of generic variable name using "NOT" statement

    Hello,

    While trying to generate a pattern for matching dangling pointer bugs on a random code-base I run into an issue. Explicitly writing the variable name ==> does result in a match. Using a generic variable name ($data) ==> does not result in a match.

    ie: Needle: {free($data); not: $data = NULL;} - doesnt match ==> expected behavior : MATCH Needle: {free(data); not: data = NULL;} - does match ==> expected behavior : MATCH

    Test file to reproduce the issue (only needle changed):

    #[test]
    fn not_dangling_correct() {
        let needle = "{free(data); not: data = NULL;}";
        let source = r"
        int32_t random_func_name2(random_struct **handle_ptr)
    {
        random_struct_data *data = NULL;
        random_struct *handle = NULL;
    
        if ((handle_ptr != NULL) && (*handle_ptr != NULL)) {
            handle = *handle_ptr;
            data = (random_struct_data*)handle->_data;
    
            if (data != NULL) {
                if (data->name != NULL) {
                   //TODO
                }
                free(data); //bug is here
            }
            if (handle != NULL) {
                free(handle);
            }
            *handle_ptr = NULL;
        }
    
        return 0;
    }";
    
        let matches = parse_and_match(needle, source);
    
        assert_eq!(matches, 1);
    }
    
    
    
    #[test]
    fn not_dangling_wrong() {
        let needle = "{free($data); not: $data = NULL;}";
        let source = r"
        int32_t random_func_name2(random_struct **handle_ptr)
    {
        random_struct_data *data = NULL;
        random_struct *handle = NULL;
    
        if ((handle_ptr != NULL) && (*handle_ptr != NULL)) {
            handle = *handle_ptr;
            data = (random_struct_data*)handle->_data;
    
            if (data != NULL) {
                if (data->name != NULL) {
                   //TODO
                }
                free(data);
            }
            if (handle != NULL) {
                free(handle);
            }
            *handle_ptr = NULL;
        }
    
        return 0;
    }";
    
        let matches = parse_and_match(needle, source);
    
        assert_eq!(matches, 1);
    }
    
    
    opened by AnisBoss 4
  • Added Binary Ninja script

    Added Binary Ninja script

    Hey, super cool tool! I saw this tweet and figured I would give it a shot :)

    I don't have IDA, but I tried to match the functionality the best I could based off the documentation.

    I am also totally new to Rust, so if you could provide some instructions on how to build the Python module so I could test the script, that would be appreciated.

    opened by mmaekr 4
  • result: make captures public

    result: make captures public

    First of all, thanks for weggli!

    This is a small visibility change, making QueryResult.captures public instead of private. It's a handy field to have when using weggli's API.

    opened by woodruffw 3
  • Failure generating query without { }

    Failure generating query without { }

    Hi. This query generates an error with tree sitter: weggli '{ _ $x; for (_;_;_) $x = _; }' .

    Tree sitter query generation failed: Structure
                             (init_declarator declarator:(pointer_declarator declarator: [(identifier) (field_expression) (field_identifier) (scoped_identifier)] @2) value: [(cast_expression value: (_)) (_)])]) )
                            ^
    sexpr: ((declaration type:(_) declarator:[(identifier) (field_expression) (field_identifier) (scoped_identifier)] @0) )((for_statement "for" @1 initializer:(_) condition:(_) update:(_) [(assignment_expression left: [(identifier) (field_expression) (field_identifier) (scoped_identifier)] @2 right: [(cast_expression value: (_)) (_)])
                            (init_declarator declarator: [(identifier) (field_expression) (field_identifier) (scoped_identifier)] @2 value: [(cast_expression value: (_)) (_)])
                            (init_declarator declarator:(pointer_declarator declarator: [(identifier) (field_expression) (field_identifier) (scoped_identifier)] @2) value: [(cast_expression value: (_)) (_)])]) )
    This is a bug! Can't recover :/
    

    With {} it can generate the query. weggli '{ _ $x; for (_;_;_) {$x = _;} }' .

    This is not recognized,

    void main() {
            int i;
            for ( i;i;i ) i = 0;
    }
    

    while this one is recognized

    void main() {
            int i;
            for ( i;i;i ) {i = 0;}
    }
    

    Is the problem with the way tree sitter is used here? If it's with them, I'll forward this issue to them

    bug 
    opened by 82marbag 3
  • can't search for-statement which use class member variable as threshold

    can't search for-statement which use class member variable as threshold

    I tried to use weggli on hexray C output and found some useful cases recently.

    But I encounter a problem today and I think I need some help.

    the problem is, I tried to find some function like below:

    struct StructName *__fastcall ClassName::MethodName(ClassName *this, int a2)
    {
      __int64 i; // r8
      struct StructName *result; // rax
    
      for ( i = 0i64; i < this->dword_80; ++i )
      {
        result = *(this->qword_88 + 8 * i);
        if ( a2 == *(result + 112) )
          return result;
      }
    ..
    }
    

    I could found above function with query below:

    ./target/release/weggli --cpp 'for(_; _ < this->dword_80; _) { _; }' ~/hexray_output.cpp
    

    But, above query is using fixed member variable name so I couldn't exapand it to find another variant.

    I tried following queries but none of them working as I want.

    Queries with no-output

    ./target/release/weggli --cpp '_ $func(_* $thisptr) { for(_; _ < $thisptr->_; _) { _; } }' ~/hexray_output.cpp
    ./target/release/weggli --cpp '_ $func(_* $thisptr) { for(_; _ < $thisptr->dword_80; _) { _; } }' ~/hexray_output.cpp
    
    ./target/release/weggli -R 'thisptr=this|a1' --cpp '_ $func(_) { for(_; _ < $thisptr->dword_80; _) { _; } }' ~/hexray_output.cpp
    
    ./target/release/weggli --cpp '_ $func(_* $thisptr) { for(_; _ < _($thisptr)->_; _) { _; } }' ~/hexray_output.cpp
    
    

    Queries with output

    ./target/release/weggli --cpp '_ $func(_* $thisptr) { for(_; _ < _($thisptr); _) { _; } }' ~/hexray_output.cpp
    
    • Output example:
    __int64 __fastcall Func1(..., struct Struct1 *a2, ...)
    {
      int v4; // er14
      int v7; // eax
      int v8; // ebx
      int v9; // ebx
    
    // ...
        if ( v8 >= 0 )
        {
          if ( *(*(this + 932) + 112i64) )
          {
            for ( i = 0; i < *(a2 + 10); ++i ) // <- here
            {
             // ...
    
    __int64 __fastcall Func2(
            struct Struct2 *a1,
            ....)
    {
      __int64 v4; // rdi
    ...
    
      v4 = *(a1 + 5);
      v6 = a3;
      v7 = a2;
      updated = 0;
      for ( i = 0; i < *(*(a1 + 3) + 6i64); ++i ) // <- here
      {
        ...
    }
    
    

    only found i < (a1 + ...) , no output like i < a1->dword_80

    ./target/release/weggli -R 'thisptr=this|a1' --cpp '_ $func(_) { for(_; _ < _($thisptr); _) { _; } }' ~/hexray_output.cpp
    

    This one found i < a1->dword_80 and similar member variable reference. But as you can see, it just use regex match instead of using this argument of class method. I want to find data flow from this argument to for-loop.

    If you have any free time, I will really appreciate to let me know what I am doing wrong.


    FYI, my host OS is macOS BigSur.

    > sw_vers
    ProductName:	macOS
    ProductVersion:	11.4
    BuildVersion:	20F71
    
    opened by y0ny0ns0n 3
  • Grammar source

    Grammar source

    In implementation details it says that

    Search queries are first parsed using an extended version of the corresponding grammar

    However, third_party/grammars/{c,cpp}/* only contains the tree-sitter-generated C and C++ code. Can the modified tree-sitter js grammar file be added to the repository?

    opened by arlencox 3
  • sizeof subexpression not matching

    sizeof subexpression not matching

    In the circumstance that a query containing a subexpression is surrounded by two adjacent expressions, it appears that any sizeof subexpression matches get dropped. For example, for the following code:

    int test_sizeof() {
        int b;
        a = sizeof(a) + b;
    }
    int test_deref() {
        int b;
        void* a = *a + b;
    }
    int test_call(void* c) {
        int b;
        void* a = test_call(a) + b;
    }
    

    The following behavior is observed:

    $ weggli '{ _(a) + _; }' test.c
    ./test.c:1
    int test_sizeof() {
        int b;
        a = sizeof(a) + b;
    }
    ./test.c:5
    int test_deref() {
        int b;
        void* a = *a + b;
    }
    ./test.c:9
    int test_call(void* c) {
        int b;
        void* a = test_call(a) + b;
    }
    $ weggli '{ _ = _(a); }' test.c
    ./test.c:1
    int test_sizeof() {
        int b;
        a = sizeof(a) + b;
    }
    ./test.c:5
    int test_deref() {
        int b;
        void* a = *a + b;
    }
    ./test.c:9
    int test_call(void* c) {
        int b;
        void* a = test_call(a) + b;
    }
    $ weggli '{ _ = _(a) + _; }' test.c
    ./test.c:5
    int test_deref() {
        int b;
        void* a = *a + b;
    }
    ./test.c:9
    int test_call(void* c) {
        int b;
        void* a = test_call(a) + b;
    }
    

    It's this final query that appears to return incorrect results. I would have expected the sizeof function to have been included in the query results, but it is not. It is only included if there are less than 2 adjacent expressions in the query itself.

    opened by Roguebantha 2
  • Inner blocks

    Inner blocks

    Hi @felixwilhelm,

    One of my colleagues discovered the following issue. When you uncomment the inner function blocks, you will observe an abnormal increasing number of matches:

    • 1 bloc = 1 match
    • 2 blocs = 657 matches
    • 3 blocs = 3404 matches
    • 4 blocs = 10446 matches
    % cat test.pat
    {
      _* $p = _;
      free($p);
      _;
      free($p);
    }
    
    % cat test.c
    void double_free_multiple_blocks()
    {
        {
    	char *s = malloc(10);
    	free(s);
    	for (int i = 0; i < 10; i++) {
    	    // do stuff
    	}
    	free(s);
        }
        {
    	char *s = malloc(10);
    	free(s);
    	for (int i = 0; i < 10; i++) {
    	    // do stuff
    	}
    	free(s);
        }
        //{
        //	char *s = malloc(10);
        //	free(s);
        //	for (int i = 0; i < 10; i++) {
        //	    // do stuff
        //	}
        //	free(s);
        //}
        //{
        //	char *s = malloc(10);
        //	free(s);
        //	for (int i = 0; i < 10; i++) {
        //	    // do stuff
        //	}
        //	free(s);
        //}
    }
    
    % weggli "$(<test.pat)" test.c | grep test.c | wc -l
       657
    
    opened by sduverger 2
  • Match the size of an array

    Match the size of an array

    Hey, thanks for weggli, it's so awesome ;)

    I ran into an issue and wanted to see if you had a solution for it:

    Given this pattern: weggli -u '{char $buf[$len];snprintf($buf, $len2,_);}' test.c

    I expect the following lines to be matched:

    char buffer[80];
    snprintf(buffer, 256, "aaaaaaaa%s", somevar);
    

    By minimalizing the pattern, I found that a pattern like $buf[$a] won't match char buffer[80]; but $buf[_] will. Am I doing something wrong?

    enhancement 
    opened by plowsec 1
  • Finding function declarations

    Finding function declarations

    I would like to find function declarations only but it seems that weggli does not support this at the moment.

    What I have tried: $ weggli -R func=myFoo '_ $func(_);' .

    If this is indeed not supported, an enhancement would be nice even though this may be a little out of scope for the tool (based on its description).

    opened by iulian3144 0
  • Create a script that runs common test cases against a codebase

    Create a script that runs common test cases against a codebase

    It would be nice if there were a script file that ran weggli using various test cases, such as the ones in the README, for quick use. Thus developers could integrate this with their CI/CD pipeline and have a template to build on.

    opened by AlvinKuruvilla 1
  • Both C and C++

    Both C and C++

    I would like to have a config file where I can specify command line options. In particular I have a mixed code base here, both C and C++ and half a dozen of other languages. I would like weggli to search in all of them.

    By default it will look in C only. If I turn on C++ mode, it will look in C++ only and not in C. So currently I'm using a ton of -e options at the end, which is pretty unwieldly and inelegant.

    An easier solution would be to give me an --all option.

    EDIT: I can work around for now by piping a list of filenames into weggli. So treat as low prio.

    opened by fefe17 0
  • Incorrect cross-function match identified

    Incorrect cross-function match identified

    Hello - when I run this query:

    weggli -X '{
    const _ $a = _;
    std::move($a);
    }' /tmp/x.cc
    

    On this code:

    MACRO
    
    namespace {
    
    void func() {
        const auto g = f2();
    }
    
    void func2() {
        auto g = f2();
        std::move(g);
    }
    
    }
    

    I get this:

    /tmp/x.cc:1
    MACRO
    
    namespace {
    
    void func() {
        const auto g = f2();
    }
    
    void func2() {
        auto g = f2();
        std::move(g);
    }
    
    }
    

    It seems weggli is unaware of the function boundary here. Both the macro and namespace are necessary for the bug.

    Adding a ; after MACRO fixes it, but that's not something I can change in my codebase.

    Thanks!

    opened by offlinemark 0
Releases(v0.2.4)
  • v0.2.4(May 31, 2022)

    What's Changed

    • python: Fix missing argument from build_query_tree by @fabianfreyer in https://github.com/googleprojectzero/weggli/pull/30
    • python: Use setuptools to build python library by @fabianfreyer in https://github.com/googleprojectzero/weggli/pull/31
    • python: Add python files to gitignore by @fabianfreyer in https://github.com/googleprojectzero/weggli/pull/33
    • python: Add unit tests by @fabianfreyer in https://github.com/googleprojectzero/weggli/pull/34
    • Run tests on github actions by @fabianfreyer in https://github.com/googleprojectzero/weggli/pull/35
    • Python: Expose C++ argument to python bindings by @fabianfreyer in https://github.com/googleprojectzero/weggli/pull/36
    • ci: Improve github actions by @felixwilhelm in https://github.com/googleprojectzero/weggli/pull/41
    • result: make captures public by @woodruffw in https://github.com/googleprojectzero/weggli/pull/49

    New Contributors

    • @fabianfreyer made their first contribution in https://github.com/googleprojectzero/weggli/pull/30
    • @woodruffw made their first contribution in https://github.com/googleprojectzero/weggli/pull/49

    Full Changelog: https://github.com/googleprojectzero/weggli/compare/v0.2.3...v0.2.4

    Source code(tar.gz)
    Source code(zip)
  • v0.2.3(Nov 11, 2021)

  • v0.2.2(Oct 8, 2021)

    Changes since v0.2.1:

    • Support strict:
    • Improved matching for number literals
    • Better semantic matching for comparisons and commutative expressions.
    Source code(tar.gz)
    Source code(zip)
Owner
Google Project Zero
Projects by Google Project Zero
Google Project Zero
OpenDCDiag is an open-source project designed to identify defects and bugs in CPUs.

OpenDCDiag is an open-source project designed to identify defects and bugs in CPUs. It consists of a set of tests built around a sophisticated CPU testing framework. OpenDCDiag is primarily intended for, but not limited to, Data Center CPUs.

OpenDCDiag 21 Jun 20, 2022
Typesense is a fast, typo-tolerant search engine for building delightful search experiences.

Fast, typo tolerant, fuzzy search engine for building delightful search experiences ⚡ ??

Typesense 10.2k Jun 27, 2022
Unix pager (with very rich functionality) designed for work with tables. Designed for PostgreSQL, but MySQL is supported too. Works well with pgcli too. Can be used as CSV or TSV viewer too. It supports searching, selecting rows, columns, or block and export selected area to clipboard.

Unix pager (with very rich functionality) designed for work with tables. Designed for PostgreSQL, but MySQL is supported too. Works well with pgcli too. Can be used as CSV or TSV viewer too. It supports searching, selecting rows, columns, or block and export selected area to clipboard.

Pavel Stehule 1.8k Jun 21, 2022
RRxIO - Robust Radar Visual/Thermal Inertial Odometry: Robust and accurate state estimation even in challenging visual conditions.

RRxIO - Robust Radar Visual/Thermal Inertial Odometry RRxIO offers robust and accurate state estimation even in challenging visual conditions. RRxIO c

Christopher Doer 53 Jun 17, 2022
Identify I2C devices from a database of the most popular I2C sensors and other devices

I2C Detective Identify I2C devices from a database of the most popular I2C sensors and other devices. For more information see http://www.technoblogy.

David Johnson-Davies 19 Jun 11, 2022
An implementation of the SZZ algorithm, i.e., an approach to identify bug-introducing commits.

SZZ Unleashed SZZ Unleashed is an implementation of the SZZ algorithm, i.e. an approach to identify bug-introducing commits, introduced by Śliwerski e

Oscar Svensson 80 Jun 22, 2022
Gunyah is a Type-1 hypervisor designed for strong security, performance and modularity.

Gunyah is a Type-1 hypervisor, meaning that it is independent of any high-level OS kernel, and runs in a higher CPU privilege level. It does not depend on any lower-privileged OS kernel/code for its core functionality. This increases its security and can support a much smaller trusted computing base than a Type-2 hypervisor.

Qualcomm Innovation Center 65 Jun 27, 2022
Program your micro-controllers in a fast and robust high-level language.

Toit language implementation This repository contains the Toit language implementation. It is fully open source and consists of the compiler, virtual

Toit language 919 Jun 23, 2022
mimikatz is a tool I've made to learn C and make somes experiments with Windows security

mimikatz is a tool I've made to learn C and make somes experiments with Windows security

Benjamin DELPY 15.5k Jun 24, 2022
macOS Endpoint Security Message Analysis Tool

Endpoint Security Message Analysis Tool - esmat esmat is a command line tool for macOS that allows you to explore the behavior of Apple's Endpoint Sec

vast limits GmbH 33 May 3, 2022
Phage-Host Interaction Search Tool

PHIST Phage-Host Interaction Search Tool A tool to predict prokaryotic hosts for phage (meta)genomic sequences. PHIST links viruses to hosts based on

REFRESH Bioinformatics Group 18 Jun 26, 2022
Tool to search system for log4j-*.jar files

find_log4j Searches all disks for log4j-*.jar files and writes the matching paths to .txt in the same folder as the executable Description This comman

Brecht Sanders 2 Dec 23, 2021
C/C++ language server supporting multi-million line code base, powered by libclang. Emacs, Vim, VSCode, and others with language server protocol support. Cross references, completion, diagnostics, semantic highlighting and more

Archived cquery is no longer under development. clangd and ccls are both good replacements. cquery cquery is a highly-scalable, low-latency language s

Jacob Dufault 2.3k Jun 28, 2022
C/C++/ObjC language server supporting cross references, hierarchies, completion and semantic highlighting

ccls ccls, which originates from cquery, is a C/C++/Objective-C language server. code completion (with both signature help and snippets) definition/re

Fangrui Song 3k Jun 30, 2022
BAAF-Net - Semantic Segmentation for Real Point Cloud Scenes via Bilateral Augmentation and Adaptive Fusion (CVPR 2021)

Semantic Segmentation for Real Point Cloud Scenes via Bilateral Augmentation and Adaptive Fusion (CVPR 2021) This repository is for BAAF-Net introduce

null 82 Jun 5, 2022
Semantic version library written in ANSI C

semver.c Semantic version v2.0 parser and render written in ANSI C with zero dependencies. Features Standard compliant (otherwise, open an issue) Vers

Tom 169 May 16, 2022
Semantic Edge Detection with Diverse Deep Supervision

Semantic Edge Detection with Diverse Deep Supervision This repository contains the code for our IJCV paper: "Semantic Edge Detection with Diverse Deep

Yun Liu 11 May 15, 2022
Semantic Versioning for modern C++

_____ _ _ / ____| | | (_) | (___ ___ _ __ ___ __ _ _ __ | |_ _ ___ \

Daniil Goncharov 193 Jun 27, 2022