crash.software
Projects
Pull Requests
Issues
Builds
bearer
Code
Files
Commits
Branches
Tags
Pull Requests
Code Comments
Code Compare
Issues
Builds
Statistics
Child Projects
‹cra.sh›
RESTful API
Projects STRLCPY bearer Commits 35d2060d
🤬
  • ■ ■ ■ ■ ■ ■
    new/detector/implementation/custom/custom.go
    skipped 9 lines
    10 10   "github.com/bearer/bearer/pkg/ast/idgenerator"
    11 11   "github.com/bearer/bearer/pkg/commands/process/settings"
    12 12   soufflequery "github.com/bearer/bearer/pkg/souffle/query"
    13  - "github.com/bearer/bearer/pkg/util/output"
    14 13  )
    15 14   
    16 15  type Data struct {
    skipped 70 lines
    87 86   
    88 87   for _, result := range results {
    89 88   if queryContext != nil {
    90  - output.StdErrLogger().Msgf("match node %s %#v", idgenerator.PatternId(detector.detectorType, i), result.MatchNode)
    91  - output.StdErrLogger().Msgf("match captures %#v", result)
    92  - output.StdErrLogger().Msgf("found pattern: %s", result.MatchNode.Content())
     89 + // output.StdErrLogger().Msgf("match node %s %#v", idgenerator.PatternId(detector.detectorType, i), result.MatchNode)
     90 + // output.StdErrLogger().Msgf("match captures %#v", result)
     91 + // output.StdErrLogger().Msgf("found pattern: %s", result.MatchNode.Content())
    93 92   }
    94 93   filtersMatch, datatypeDetections, err := matchAllFilters(result, evaluator, pattern.Filters)
    95 94   if err != nil {
    skipped 1 lines
    97 96   }
    98 97   
    99 98   if queryContext != nil {
    100  - output.StdErrLogger().Msgf("filter match: %t", filtersMatch)
     99 + // output.StdErrLogger().Msgf("filter match: %t", filtersMatch)
    101 100   }
    102 101   
    103 102   if !filtersMatch {
    skipped 19 lines
  • ■ ■ ■ ■ ■ ■
    new/language/implementation/implementation.go
    skipped 73 lines
    74 74   // end
    75 75   // it is natural for `$<ARG>`` to only match the first argument, but
    76 76   // we wouldn't expect `other_call` to be the first expression in the block
    77  - PatternIsAnchored(node *tree.Node) (bool, bool)
     77 + PatternIsAnchored(node *sitter.Node) (bool, bool)
    78 78   // PatternNodeTypes returns the types to use for a given node. This allows us
    79 79   // to match using equivalent syntax without having to enumerate all the
    80 80   // combinations in rules.
    skipped 59 lines
  • ■ ■ ■ ■ ■ ■
    new/language/implementation/javascript/javascript.go
    skipped 219 lines
    220 220   }
    221 221  }
    222 222   
    223  -func (implementation *javascriptImplementation) PatternIsAnchored(node *tree.Node) (bool, bool) {
     223 +func (implementation *javascriptImplementation) PatternIsAnchored(node *sitter.Node) (bool, bool) {
    224 224   if node.Type() == "pair" {
    225 225   return false, false
    226 226   }
    skipped 36 lines
  • ■ ■ ■ ■ ■ ■
    new/language/implementation/ruby/ruby.go
    skipped 168 lines
    169 169   return patternMatchNodeContainerTypes
    170 170  }
    171 171   
    172  -func (*rubyImplementation) PatternIsAnchored(node *tree.Node) (bool, bool) {
     172 +func (*rubyImplementation) PatternIsAnchored(node *sitter.Node) (bool, bool) {
    173 173   if slices.Contains(unanchoredPatternNodeTypes, node.Type()) {
    174 174   return false, false
    175 175   }
    skipped 14 lines
    190 190   
    191 191   // Block body
    192 192   if parent.Type() == "do_block" || parent.Type() == "block" {
    193  - if node.Equal(parent.ChildByFieldName("parameters")) {
     193 + if parameters := parent.ChildByFieldName("parameters"); parameters != nil && node.Equal(parameters) {
    194 194   return true, false
    195 195   }
    196 196   
    skipped 2 lines
    199 199   
    200 200   // Method body
    201 201   if parent.Type() == "method" {
    202  - if node.Equal(parent.ChildByFieldName("name")) || node.Equal(parent.ChildByFieldName("parameters")) {
     202 + name := parent.ChildByFieldName("name")
     203 + parameters := parent.ChildByFieldName("parameters")
     204 + if (name != nil && node.Equal(name)) || (parameters != nil && node.Equal(parameters)) {
    203 205   return true, false
    204 206   }
    205 207   
    skipped 55 lines
  • ■ ■ ■ ■ ■ ■
    new/language/patternquery/builder/builder.go
    skipped 118 lines
    119 119   )
    120 120   }
    121 121   
    122  - nodeAnchoredBefore, nodeAnchoredAfter := builder.langImplementation.PatternIsAnchored(node)
     122 + nodeAnchoredBefore, nodeAnchoredAfter := builder.langImplementation.PatternIsAnchored(node.SitterNode())
    123 123   anchored := !isRoot && node.IsNamed() && nodeAnchoredBefore
    124 124   
    125 125   if anchored && !slices.Contains(builder.inputParams.UnanchoredOffsets, node.StartByte()) {
    skipped 177 lines
  • ■ ■ ■ ■ ■ ■
    pkg/ast/languages/ruby/patterns/patterns.go
    1 1  package patterns
    2 2   
    3 3  import (
     4 + "errors"
    4 5   "fmt"
    5 6   "log"
    6 7   
    7 8   sitter "github.com/smacker/go-tree-sitter"
     9 + "golang.org/x/exp/slices"
    8 10   
     11 + "github.com/bearer/bearer/new/language/implementation"
    9 12   builderinput "github.com/bearer/bearer/new/language/patternquery/builder/input"
    10 13   querytypes "github.com/bearer/bearer/new/language/patternquery/types"
    11 14   "github.com/bearer/bearer/pkg/ast/idgenerator"
    skipped 33 lines
    45 48   
    46 49  type patternWriter struct {
    47 50   *filewriter.Writer
    48  - inputParams *builderinput.InputParams
    49  - input []byte
    50  - literals []writerbase.Literal
    51  - childIndex uint32
    52  - rootElement writerbase.LiteralElement
    53  - parentElement writerbase.LiteralElement
    54  - nodeVariableGenerator *nodeVariableGenerator
    55  - tempIdGenerator *idgenerator.Generator
    56  - handled set.Set[*sitter.Node]
    57  - variableNodes map[string][]writerbase.Identifier
     51 + inputParams *builderinput.InputParams
     52 + input []byte
     53 + literals []writerbase.Literal
     54 + childIndex uint32
     55 + rootElement writerbase.LiteralElement
     56 + parentElement writerbase.LiteralElement
     57 + nodeVariableGenerator *nodeVariableGenerator
     58 + tempIdGenerator *idgenerator.Generator
     59 + handled set.Set[*sitter.Node]
     60 + variableNodes map[string][]writerbase.Identifier
     61 + langImplementation implementation.Implementation
     62 + lastChildIndexVariable writerbase.LiteralElement
    58 63  }
     64 + 
     65 +var Skipped = errors.New("skipped")
    59 66   
    60 67  func CompileRule(
    61 68   walker *walker.Walker,
    62 69   inputParams *builderinput.InputParams,
     70 + langImplementation implementation.Implementation,
    63 71   patternId string,
    64 72   input []byte,
    65 73   rootNode *sitter.Node,
    skipped 7 lines
    73 81   tempIdGenerator: idgenerator.NewGenerator(),
    74 82   handled: set.New[*sitter.Node](),
    75 83   variableNodes: make(map[string][]writerbase.Identifier),
     84 + langImplementation: langImplementation,
    76 85   }
    77 86   
     87 + matchNode := findMatchNode(
     88 + walker,
     89 + inputParams.MatchNodeOffset,
     90 + langImplementation.PatternMatchNodeContainerTypes(),
     91 + rootNode,
     92 + )
     93 + 
    78 94   err := walker.Walk(rootNode, w.visitNode)
    79 95   if err != nil {
    80 96   return err
    skipped 24 lines
    105 121   }
    106 122   
    107 123   if len(w.literals) > 20 {
    108  - log.Printf("rule too large, skipping")
    109  - return nil
     124 + log.Printf("rule too large %d, skipping %s", len(w.literals), patternId)
     125 + return Skipped
    110 126   }
    111  - log.Printf("#literals: %d", len(w.literals))
     127 + // log.Printf("#literals: %d", len(w.literals))
    112 128   
    113 129   writer.WriteRelation(
    114 130   fmt.Sprintf("Rule_Match_%s", patternId),
    skipped 4 lines
    119 135   if err := writer.WriteRule(
    120 136   []writerbase.Predicate{writer.Predicate(
    121 137   fmt.Sprintf("Rule_Match_%s", patternId),
    122  - append([]writerbase.LiteralElement{w.rootElement}, variableElements...)...,
     138 + append(
     139 + []writerbase.LiteralElement{w.Identifier(w.nodeVariableGenerator.Get(matchNode))},
     140 + variableElements...,
     141 + )...,
    123 142   )},
    124 143   append(w.literals, variableConstraints...),
    125 144   ); err != nil {
    126 145   return err
     146 + }
     147 + 
     148 + if patternId == "blowfish_init_0" {
     149 + log.Printf("RULE: %s", matchNode.String())
    127 150   }
    128 151   
    129 152   return nil
    skipped 25 lines
    155 178   writer.Predicate("AST_NodeField", writer.parentElement, nodeElement, writer.Symbol(fname)),
    156 179   )
    157 180   } else {
     181 + childIndexVariable := writer.Identifier(fmt.Sprintf("tmp%d", writer.tempIdGenerator.Get()))
     182 + nodeAnchoredBefore, _ := writer.langImplementation.PatternIsAnchored(node)
     183 + 
     184 + // Anchored before
     185 + if node.IsNamed() && nodeAnchoredBefore && !slices.Contains(writer.inputParams.UnanchoredOffsets, int(node.StartByte())) {
     186 + if writer.lastChildIndexVariable != nil {
     187 + writer.literals = append(
     188 + writer.literals,
     189 + // FIXME: constraint hack!
     190 + writer.Constraint(childIndexVariable, "= 1+", writer.lastChildIndexVariable),
     191 + )
     192 + } else {
     193 + writer.literals = append(
     194 + writer.literals,
     195 + writer.Constraint(childIndexVariable, "=", writer.Unsigned(writer.childIndex)),
     196 + )
     197 + 
     198 + }
     199 + } else {
     200 + if writer.lastChildIndexVariable != nil {
     201 + writer.literals = append(
     202 + writer.literals,
     203 + writer.Constraint(childIndexVariable, ">", writer.lastChildIndexVariable),
     204 + )
     205 + } else {
     206 + writer.literals = append(
     207 + writer.literals,
     208 + writer.Constraint(childIndexVariable, ">=", writer.Unsigned(0)),
     209 + )
     210 + }
     211 + }
     212 + 
     213 + // FIXME: end anchoring
     214 + // if node.IsNamed() && isLastChild && nodeAnchoredAfter && !slices.Contains(writer.inputParams.UnanchoredOffsets, int(node.EndByte())) {
     215 + // // Last anchored
     216 + // }
     217 + 
    158 218   writer.literals = append(
    159 219   writer.literals,
    160  - writer.Predicate("AST_ParentChild", writer.parentElement, writer.Unsigned(writer.childIndex), nodeElement),
     220 + writer.Predicate("AST_ParentChild", writer.parentElement, childIndexVariable, nodeElement),
    161 221   )
    162 222   
    163 223   writer.childIndex++
     224 + writer.lastChildIndexVariable = childIndexVariable
    164 225   }
    165 226   }
    166 227   
    skipped 60 lines
    227 288   oldParentElement := writer.parentElement
    228 289   oldChildIndex := writer.childIndex
    229 290   writer.childIndex = 0
     291 + writer.lastChildIndexVariable = nil
    230 292   writer.parentElement = nodeElement
    231 293   err := visitChildren()
    232 294   writer.childIndex = oldChildIndex
    skipped 61 lines
    294 356   return nil
    295 357  }
    296 358   
     359 +func findMatchNode(
     360 + walker *walker.Walker,
     361 + offset int,
     362 + containerTypes []string,
     363 + rootNode *sitter.Node,
     364 +) (matchNode *sitter.Node) {
     365 + err := walker.Walk(rootNode, func(node *sitter.Node, visitChildren func() error) error {
     366 + // FIXME: do this generically!
     367 + if node.Type() != "program" {
     368 + if node.StartByte() == uint32(offset) && !slices.Contains(containerTypes, node.Type()) {
     369 + matchNode = node
     370 + return nil
     371 + }
     372 + }
     373 + 
     374 + return visitChildren()
     375 + })
     376 + 
     377 + // walk itself shouldn't trigger an error, and we aren't creating any
     378 + if err != nil {
     379 + panic(err)
     380 + }
     381 + 
     382 + return
     383 +}
     384 + 
  • ■ ■ ■ ■ ■ ■
    pkg/ast/languages/ruby/ruby.go
    skipped 2 lines
    3 3  import (
    4 4   "context"
    5 5   "fmt"
     6 + "log"
    6 7   
    7 8   sitter "github.com/smacker/go-tree-sitter"
    8 9   sitterruby "github.com/smacker/go-tree-sitter/ruby"
    skipped 44 lines
    53 54  func (language *Language) WriteRules(rules []*settings.Rule, writer *filewriter.Writer) error {
    54 55   for _, rule := range rules {
    55 56   writer.WriteComment(fmt.Sprintf("rule %s", rule.Id))
     57 + ruleSkipped := false
    56 58   
    57 59   for patternIndex, pattern := range rule.Patterns {
    58 60   patternId := idgenerator.PatternId(rule.Id, patternIndex)
    59 61   
    60 62   if err := language.WriteRule(patternId, pattern.Pattern, writer); err != nil {
     63 + if err == patterns.Skipped {
     64 + ruleSkipped = true
     65 + continue
     66 + }
    61 67   return fmt.Errorf("pattern error (%s)': %w", pattern.Pattern, err)
    62 68   }
    63 69   }
     70 + 
     71 + if !ruleSkipped {
     72 + log.Printf("full rule available: %s", rule.Id)
     73 + }
    64 74   }
    65 75   
    66 76   return nil
    skipped 15 lines
    82 92   if err := patterns.CompileRule(
    83 93   language.walker,
    84 94   inputParams,
     95 + language.langImplementation,
    85 96   patternId,
    86 97   processedInputBytes,
    87 98   rootNode,
    88 99   writer,
    89 100   ); err != nil {
     101 + if err == patterns.Skipped {
     102 + return err
     103 + }
    90 104   return fmt.Errorf("error compiling rule: %w", err)
    91 105   }
    92 106   
    skipped 7 lines
  • ■ ■ ■ ■ ■ ■
    pkg/commands/process/settings/rules/ruby/third_parties/segment.yml
    skipped 16 lines
    17 17   - id: segment_init
    18 18   patterns:
    19 19   - |
    20  - Segment::Analytics.new()
     20 + Segment::Analytics.new($<...>$<_>$<...>)
    21 21  languages:
    22 22   - ruby
    23 23  skip_data_types:
    skipped 18 lines
  • ■ ■ ■ ■ ■ ■
    pkg/souffle/query/query.go
    skipped 60 lines
    61 61  }
    62 62   
    63 63  func (context *QueryContext) put(nodeId uint32, patternId string, result *languagetypes.PatternQueryResult) {
    64  - log.Error().Msgf("putting result for %d: %#v", patternId, result)
     64 + // log.Error().Msgf("putting result for %d: %#v", patternId, result)
    65 65   
    66 66   nodeCache, ruleExists := context.cache[patternId]
    67 67   if !ruleExists {
    skipped 89 lines
Please wait...
Page is in error, reload to recover