nasl 0.3.0 → 0.4.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZWMwMTc1ZTg3N2ZmZDJjYzBkN2U3NDljZWM0MGMxNDUxNzc4ZmI2Yg==
-  data.tar.gz: !binary |-
-    MGZmMWYyMmVkOTA3ZjhlZTUwNGY4YWI3OGJmYzA0YzlmNThlMjg0NQ==
+SHA1:
+  metadata.gz: 199cd9a0ada92765a2e1812786f7b41eb22c3724
+  data.tar.gz: 0b8ff7ebf8d1b4b166dd7ffb4f71fa52d884e1aa
 SHA512:
-  metadata.gz: !binary |-
-    Nzc0ZjcyMTk5ZjZkNzgxZmYxMTVhNzRmNjE0ZDJhOWNlNTEwMTllMzk1NjYz
-    ODBhNTc1NjIxYzhkNmJjZTVmMDJkMGMzMDg5YzViYzBiMjZkZTA1ZmFjM2Q1
-    ZjRhMDFkZDg0ZDFkY2MwYTYwOGM3YWU3MzFiZjMxMmU1NWVhMWM=
-  data.tar.gz: !binary |-
-    MWRhZDY3MjQ4NDg5ZjQ5ZTExOTk3MjIyODJlN2IzNGZhNTliOTAwODA1ZmM4
-    MWM5OWRkNzdmNzgyZDM3Y2JkOTMyNGY0ZTI1YzdlMWUxMTgzMWZmNjAxNzJj
-    NWE2ZDNjZDQzMTI0MWE4M2M5ODY1YzQ2MDhhOTM3M2MyYzIwZjQ=
+  metadata.gz: 1cd9093af658c23660d9d662e3da33ab2ecaf97aececd1402832a92a7d779e245c2a64c7cfe1be8d71793f2f08b2f51388e03de1d2a5be0da7712bc541a6a8ab
+  data.tar.gz: 749a6d9e4fea7edb88eb34113496988d7cba0cfe6baffb00eeabc154a4f81ffddd2d93eccbff44b142f645d2f190f7c88559bf77d892cd9bacd5f2ac42d9801e

data/.travis.yml

@@ -1,17 +1,22 @@
 language: ruby
+sudo: false
 
 rvm: 
   - 1.9.3
   - 2.0.0
   - 2.1.0
+  - 2.2.0
+  - 2.3.0
 
 gemfile:
-  - Gemfile.ci
+  - Gemfile
 
 notifications:
   email:
     - jhammack@tenable.com
     - aweber@tenable.com
+    - mcoumbes@tenable.com
+    - aorr@tenable.com
 
 before_install:
   - gem --version

data/Gemfile

@@ -1,6 +1,3 @@
 source "https://rubygems.org"
 
-gem "racc", '1.4.12'
-gem "rake", '10.3.2'
-gem "builder", '3.2.2'
-gem "rainbow", '2.0.0'
+gemspec

data/README.md

@@ -1,5 +1,8 @@
 # Installation
 
+[![Gem Version](http://img.shields.io/gem/v/nasl.svg?style=flat-square)](https://rubygems.org/gems/nasl)
+[![Build Status](http://img.shields.io/travis/tenable/nasl.svg)](https://travis-ci.org/tenable/nasl)
+
 ## Git
 
 Installing the source from Git is done as follows:
@@ -98,5 +101,28 @@ obviously, and can be used as follows:
 That's all there is to it. If there are any errors, it'll throw an instance of
 `ParseException` that will include as much context about the error as possible.
 
+Development
+-----------
+
+This project uses [Bundler](http://bundler.io/).
+
+If you have a brand-new Debian machine, do this as root:
+
+    apt-get install ruby-dev rubygems git
+    gem install bundler
+
+As your regular user:
+
+    git clone https://github.com/tenable/nasl
+    cd nasl
+    bundle install --path vendor/bundle
+    bundle exec rake grammars
+    bundle exec rake test
+
+All the tests should pass!
+
+To run the nasl-parse command line, do `bundle exec ./bin/nasl-parse`, which should give
+a help message.
+
 [nasldoc]: https://github.com/tenable/nasldoc
 [pedant]: https://github.com/tenable/pedant

data/lib/nasl/grammar.racc

@@ -1,5 +1,5 @@
 ################################################################################
-# Copyright (c) 2011-2014, Tenable Network Security
+# Copyright (c) 2011-2018, Tenable Network Security
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -74,18 +74,40 @@ rule
              { c(*val) }
              | export
              { val[0] }
-             | COMMENT function
-             { c(*val) }
-             | function
-             { val[0] }
+           #  | COMMENT function
+           #  { c(*val) }
+           #  | function
+           #  { val[0] }
              | statement
              { val[0] }
+             | obj_decl
+             { val[0] }
+             | namespace
+             { val[0] }
              ;
 
+  obj_statement : obj_var SEMICOLON
+                { val[0] }
+                | COMMENT obj_function
+                { c(*val) }
+                | obj_function
+                { val[0] }
+                ;
+              #  | obj_function
+              #  { val[0] }
+
   statement : simple
              { val[0] }
              | compound
              { val[0] }
+             | function 
+             { val[0] }
+             | COMMENT function 
+             { c(*val) }
+             | obj_decl
+             { val[0] }
+             | namespace 
+             { val[0] }
              ;
 
   ##############################################################################
@@ -96,10 +118,16 @@ rule
              { n(:Export, *val) }
              ;
 
+  obj_function : obj_func_attr FUNCTION ident LPAREN params RPAREN block
+               { n(:Function, val[0], 'obj', val[1], val[2], val[3], val[4], val[5], val[6]) }
+               | obj_func_attr FUNCTION ident LPAREN RPAREN block
+               { n(:Function, val[0], 'obj', val[1], val[2], val[3], val[4], val[5]) }
+               ;
+
   function   : FUNCTION ident LPAREN params RPAREN block
-             { n(:Function, *val) }
+             { n(:Function, val[0], 'normal', val[1], val[2], val[3], val[4], val[5]) }
              | FUNCTION ident LPAREN RPAREN block
-             { n(:Function, *val) }
+             { n(:Function, val[0], 'normal', val[1], val[2], val[3], val[4]) }
              ;
 
   simple     : assign
@@ -118,6 +146,8 @@ rule
              { c(*val) }
              | global
              { val[0] }
+             | var_def
+             { val[0] }
              | import
              { val[0] }
              | include
@@ -144,8 +174,23 @@ rule
              { val[0] }
              | while
              { val[0] }
+             | switch
+             { val[0] }
+             | case
+             { val[0] }
              ;
 
+  namespace  : NAMESPACE ident LBRACE statements RBRACE 
+             { n(:Namespace, *val) }
+             | NAMESPACE ident LBRACE RBRACE
+             { n(:Namespace, *val) }
+             ;
+
+  obj_decl   : OBJECT ident LBRACE obj_statements RBRACE
+             { n(:Object, *val) }
+             | NAMESPACE ident LBRACE RBRACE
+             { n(:Namespace, *val) }
+             ;
   ##############################################################################
   # Simple Statements
   ##############################################################################
@@ -178,6 +223,10 @@ rule
              { n(:Global, *val) }
              ;
 
+  var_def    : VAR var_decls SEMICOLON
+             { n(:Local, *val) }
+             ;
+
   incr       : incr_exp SEMICOLON
              { val[0] }
              ;
@@ -194,6 +243,10 @@ rule
              { n(:Local, *val) }
              ;
 
+  local      : LOCAL var_decls SEMICOLON
+             { n(:Local, *val) }
+             ;
+
   rep        : call_exp REP expr SEMICOLON
              { n(:Repetition, *val[0..-1]) }
              ;
@@ -206,16 +259,53 @@ rule
              { n(:Return, *val) }
              ;
 
+  obj_func_attr : /* Empty */ 
+                { nil }
+                | PUBLIC 
+                { val[0] }
+                | PRIVATE
+                { val[0] }
+                ;
+                
   ##############################################################################
   # Compound Statements
   ##############################################################################
-
   block      : LBRACE statements RBRACE
              { n(:Block, *val) }
              | LBRACE RBRACE
              { n(:Block, *val) }
              ;
 
+  switch     : SWITCH LPAREN expr RPAREN switch_block
+             { n(:Switch, *val) }
+             | SWITCH LBRACK switch_op RBRACK LPAREN expr RPAREN switch_block
+             { n(:Switch, *val) }
+             ;
+ 
+  case       : CASE case_expr_list COLON
+             { n(:Case, *val) }
+             | CASE LBRACK switch_op RBRACK case_expr_list COLON
+             { n(:Case, *val) }
+             | DEFAULT COLON
+             { n(:Case, *val) }
+             ;
+
+  case_expr  : expr
+             { val[0] }
+             ;
+
+  case_expr_list : case_expr
+                 { val[0] }
+                 | case_expr COMMA case_expr_list
+                 { [val[0]] + val[2] }
+                 ;
+  
+  switch_block  : LBRACE case statements RBRACE
+                { n(:Block, *val) }
+                | LBRACE RBRACE
+                { n(:Block, *val) }
+                ;
+
   for        : FOR LPAREN field SEMICOLON expr SEMICOLON field RPAREN statement
              { n(:For, *val) }
              ;
@@ -364,13 +454,47 @@ rule
              { val[0] }
              ;
 
+  switch_op  : SUBSTR_EQ
+             { val[0] }
+             | SUBSTR_NE
+             { val[0] }
+             | REGEX_EQ
+             { val[0] }
+             | REGEX_NE
+             { val[0] }
+             | CMP_LT 
+             { val[0] }
+             | CMP_GT
+             { val[0] }
+             | CMP_EQ
+             { val[0] }
+             | CMP_NE
+             { val[0] }
+             | CMP_LE
+             { val[0] }
+             | CMP_GE
+             { val[0] }
+             | AMPERSAND
+             { val[0] }
+             | BIT_XOR
+             { val[0] }
+             | BIT_OR
+             { val[0] } 
+             ;
+ 
+ 
+  ident_ex   : ident
+             { val[0] }
+             | VAR 
+             { val[0] }
+
   ##############################################################################
   # Named Components
   ##############################################################################
 
-  arg        : ident COLON expr
+  arg        : ident_ex COLON expr
              { n(:Argument, *val) }
-             | ident COLON ref
+             | ident_ex COLON ref
              { n(:Argument, *val) }
              | expr
              { n(:Argument, *val) }
@@ -480,12 +604,22 @@ rule
              { [val[0]] }
              ;
 
+  obj_statements  : obj_statement obj_statements
+                  { [val[0]] + val[1] }
+                  | obj_statement
+                  { [val[0]] }
+                  ;
+
   statements : statement statements
              { [val[0]] + val[1] }
              | statement
              { [val[0]] }
              ;
 
+  obj_var    : VAR var_decls
+             { n(:ObjVar, *val) }
+             ;
+
   var_decl   : ident ASS_EQ expr
              { n(:Assignment, *val) }
              | ident ASS_EQ ref
@@ -546,6 +680,7 @@ require 'nasl/parser/argument'
 require 'nasl/parser/array'
 require 'nasl/parser/assigment'
 require 'nasl/parser/block'
+require 'nasl/parser/namespace'
 require 'nasl/parser/break'
 require 'nasl/parser/call'
 require 'nasl/parser/comment'
@@ -577,6 +712,10 @@ require 'nasl/parser/return'
 require 'nasl/parser/string'
 require 'nasl/parser/undefined'
 require 'nasl/parser/while'
+require 'nasl/parser/object'
+require 'nasl/parser/switch'
+require 'nasl/parser/case'
+require 'nasl/parser/obj_var'
 
 ---- inner ----
 

data/lib/nasl/parser/block.rb

@@ -35,7 +35,13 @@ module Nasl
     def initialize(tree, *tokens)
       super
 
-      @body = if @tokens.length == 3 then @tokens[1] else [] end
+      if (@tokens.length == 4)
+        @body = [@tokens[1]] + @tokens[2]
+      elsif (@tokens.length == 3)
+        @body = @tokens[1]
+      else
+        @body = []
+      end
 
       @children << :body
     end

data/lib/nasl/parser/case.rb

@@ -0,0 +1,55 @@
+################################################################################
+# Copyright (c) 2011-2018, Tenable Network Security
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+################################################################################
+
+require 'nasl/parser/node'
+
+module Nasl
+  class Case < Node
+    attr_reader :case_val, :case_op, :case_type
+
+    def initialize(tree, *tokens)
+      super
+
+      if @tokens.length == 3
+        @case_op = nil 
+        @case_val = @tokens[1]
+        @case_type = 'normal'
+      elsif @tokens.length == 6
+        @case_op = @tokens[2]
+        @case_val = @tokens[4]
+        @case_type = 'normal_with_op'
+      else
+        @case_op = nil 
+        @case_val = nil
+        @case_type = 'default'
+      end
+
+      @children << :case_val
+      @children << :case_op
+      @children << :case_type
+    end
+  end
+end

data/lib/nasl/parser/function.rb

@@ -28,18 +28,43 @@ require 'nasl/parser/node'
 
 module Nasl
   class Function < Node
-    attr_reader :body, :name, :params
+    attr_reader :body, :name, :params, :attribute, :fn_type
 
     def initialize(tree, *tokens)
       super
 
-      @name = @tokens[1]
-      @params = if @tokens.length == 6 then @tokens[3] else [] end
       @body = @tokens.last
 
+      @fn_type = @tokens[1]
+
+      if @fn_type == "obj"
+        @name = @tokens[3]
+        @attribute = @tokens[0]
+        if @tokens.length == 8 
+          @params = @tokens[5]          
+        else
+          @params = []
+        end
+      else
+        @name = @tokens[2]
+        @attribute = []
+        if @tokens.length == 7
+          @params = @tokens[4]
+        else
+          @params = []
+        end
+      end
+
       @children << :name
+      @children << :attribute
       @children << :params
       @children << :body
+      @children << :fn_type
     end
+
+    def each
+      @body.each{ |stmt| yield stmt }
+    end
+
   end
 end