ronin-code-sql 2.0.0.beta1

data/lib/ronin/code/sql/emitter.rb

@@ -0,0 +1,406 @@
+# frozen_string_literal: true
+#
+# ronin-code-sql - A Ruby DSL for crafting SQL Injections.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-sql is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-sql is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-sql.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/support/encoding/sql'
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Generates raw SQL.
+      #
+      # @api private
+      #
+      class Emitter
+
+        # The case to use when emitting keywords
+        attr_reader :case
+
+        # String to use for white-space
+        attr_reader :space
+
+        # Type of String quotes to use
+        attr_reader :quotes
+
+        #
+        # Initializes the SQL Emitter.
+        #
+        # @param [String] space
+        #   String to use for white-space.
+        #
+        # @param [:single, :double] quotes
+        #   Type of quotes to use for Strings.
+        #
+        # @param [Hash{Symbol => Object}] kwargs
+        #   Emitter options.
+        #
+        # @option kwargs [:lower, :upper, :random, nil] :case
+        #   Case for keywords.
+        #
+        def initialize(space: ' ', quotes: :single, **kwargs)
+          @case   = kwargs[:case] # HACK: because `case` is a ruby keyword
+          @space  = space
+          @quotes = quotes
+        end
+
+        #
+        # Emits a SQL keyword.
+        #
+        # @param [Symbol, Array<Symbol>] keyword
+        #   The SQL keyword.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_keyword(keyword)
+          keyword = Array(keyword).join(@space)
+
+          case @case
+          when :upper  then keyword.upcase
+          when :lower  then keyword.downcase
+          when :random
+            keyword.tap do
+              (keyword.length / 2).times do
+                index = rand(keyword.length)
+                keyword[index] = keyword[index].swapcase
+              end
+            end
+          else
+            keyword
+          end
+        end
+
+        #
+        # Emits a SQL operator.
+        #
+        # @param [Array<Symbol>, Symbol] op
+        #   The operator symbol.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_operator(op)
+          case op
+          when /^\W+$/          then op.to_s
+          else                       emit_keyword(op)
+          end
+        end
+
+        #
+        # Emits the `NULL` value.
+        #
+        # @return [String]
+        #
+        def emit_null
+          emit_keyword(:NULL)
+        end
+
+        #
+        # Emits a `false` value.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_false
+          "1=0"
+        end
+
+        #
+        # Emits a `true` value.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_true
+          "1=1"
+        end
+
+        #
+        # Emits a SQL Integer.
+        #
+        # @param [Integer] int
+        #   The Integer.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_integer(int)
+          int.to_s
+        end
+
+        #
+        # Emits a SQL Decimal.
+        #
+        # @param [Float] decimal
+        #   The decimal.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_decimal(decimal)
+          decimal.to_s
+        end
+
+        #
+        # Emits a SQL String.
+        #
+        # @param [String] string
+        #   The String.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_string(string)
+          Support::Encoding::SQL.escape(string, quotes: @quotes)
+        end
+
+        #
+        # Emits a SQL field.
+        #
+        # @param [Field, Symbol, String] field
+        #   The SQL field.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_field(field)
+          name = emit_keyword(field.name)
+
+          if field.parent
+            name = "#{emit_field(field.parent)}.#{name}"
+          end
+
+          return name
+        end
+
+        #
+        # Emits a list of elements.
+        #
+        # @param [#map] list
+        #   The list of elements.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_list(list)
+          '(' + list.map { |element| emit(element) }.join(',') + ')'
+        end
+
+        #
+        # Emits a list of columns and assigned values.
+        #
+        # @param [Hash{Field,Symbol => Object}] values
+        #   The column names and values.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_assignments(values)
+          values.map { |key,value|
+            "#{emit_keyword(key)}=#{emit(value)}"
+          }.join(',')
+        end
+
+        #
+        # Emits a value used in an expression.
+        #
+        # @param [Statement, #to_sql] operand
+        #   The operand to emit.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        # @since 1.1.0
+        #
+        def emit_argument(operand)
+          case operand
+          when Statement then "(#{emit_statement(operand)})"
+          else                emit(operand)
+          end
+        end
+
+        #
+        # Emits a SQL expression.
+        #
+        # @param [BinaryExpr, UnaryExpr] expr
+        #   The SQL expression.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_expression(expr)
+          op = emit_operator(expr.operator)
+
+          case expr
+          when BinaryExpr
+            left, right = emit_argument(expr.left), emit_argument(expr.right)
+
+            case op
+            when /^\W+$/ then "#{left}#{op}#{right}"
+            else              [left, op, right].join(@space)
+            end
+          when UnaryExpr
+            operand = emit_argument(expr.operand)
+
+            case expr.operator
+            when /^\W+$/ then "#{op}#{operand}"
+            else              [op, operand].join(@space)
+            end
+          end
+        end
+
+        #
+        # Emits a SQL function.
+        #
+        # @param [Function] function
+        #   The SQL function.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_function(function)
+          name      = emit_keyword(function.name)
+          arguments = function.arguments.map { |value| emit_argument(value) }
+
+          return "#{name}(#{arguments.join(',')})"
+        end
+
+        #
+        # Emits a SQL object.
+        #
+        # @param [#to_sql] object
+        #   The SQL object.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        # @raise [ArgumentError]
+        #   Could not emit an unknown SQL object.
+        #
+        def emit(object)
+          case object
+          when NilClass              then emit_null
+          when TrueClass             then emit_true
+          when FalseClass            then emit_false
+          when Integer               then emit_integer(object)
+          when Float                 then emit_decimal(object)
+          when String                then emit_string(object)
+          when Literal               then emit(object.value)
+          when Symbol                then emit_keyword(object)
+          when Field                 then emit_field(object)
+          when Array                 then emit_list(object)
+          when Hash                  then emit_assignments(object)
+          when BinaryExpr, UnaryExpr then emit_expression(object)
+          when Function              then emit_function(object)
+          when Clause                then emit_clause(object)
+          when Statement             then emit_statement(object)
+          when StatementList         then emit_statement_list(object)
+          else
+            if object.respond_to?(:to_sql)
+              object.to_sql
+            else
+              raise(ArgumentError,"cannot emit #{object.class}")
+            end
+          end
+        end
+
+        #
+        # Emits a SQL Clause.
+        #
+        # @param [Clause] clause
+        #   The SQL Clause.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_clause(clause)
+          sql = emit_keyword(clause.keyword)
+
+          unless clause.argument.nil?
+            sql << @space << emit_argument(clause.argument)
+          end
+
+          return sql
+        end
+
+        #
+        # Emits multiple SQL Clauses.
+        #
+        # @param [Array<Clause>] clauses
+        #   The clauses to emit.
+        #
+        # @return [String]
+        #   The emitted clauses.
+        #
+        def emit_clauses(clauses)
+          clauses.map { |clause| emit_clause(clause) }.join(@space)
+        end
+
+        #
+        # Emits a SQL Statement.
+        #
+        # @param [Statement] stmt
+        #   The SQL Statement.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_statement(stmt)
+          sql = emit_keyword(stmt.keyword)
+
+          unless stmt.argument.nil?
+            case stmt.argument
+            when Array
+              sql << @space << if stmt.argument.length == 1
+                                 emit_argument(stmt.argument[0])
+                               else
+                                 emit_list(stmt.argument)
+                               end
+            else
+              sql << @space << emit_argument(stmt.argument)
+            end
+          end
+
+          unless stmt.clauses.empty?
+            sql << @space << emit_clauses(stmt.clauses)
+          end
+
+          return sql
+        end
+
+        #
+        # Emits a full SQL statement list.
+        #
+        # @param [StatementList] list
+        #   The SQL statement list.
+        #
+        # @return [String]
+        #   The raw SQL.
+        #
+        def emit_statement_list(list)
+          list.statements.map { |stmt|
+            emit_statement(stmt)
+          }.join(";#{@space}")
+        end
+
+      end
+    end
+  end
+end

data/lib/ronin/code/sql/field.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+#
+# ronin-code-sql - A Ruby DSL for crafting SQL Injections.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-sql is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-sql is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-sql.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/sql/operators'
+require 'ronin/code/sql/emittable'
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Represents a SQL column, table or database name.
+      #
+      # @api semipublic
+      #
+      class Field < Struct.new(:name,:parent)
+
+        include Operators
+        include Emittable
+
+        #
+        # Initializes the new field.
+        #
+        # @param [String] name
+        #   The name of the field.
+        #
+        # @param [Field] parent
+        #   The parent of the field.
+        #
+        def initialize(name,parent=nil)
+          super(name.to_s,parent)
+        end
+
+        #
+        # Parses a field.
+        #
+        # @param [String] name
+        #
+        # @return [Field]
+        #   The parsed field.
+        #
+        def self.parse(name)
+          names = name.to_s.split('.',3)
+          field = nil
+
+          names.each { |name| field = new(name,field) }
+
+          return field
+        end
+
+        alias to_str to_s
+
+        protected
+
+        #
+        # Allows accessing columns from tables or tables from databases.
+        #
+        # @param [Symbol] name
+        #   The sub-field name.
+        #
+        # @param [Array] arguments
+        #   Additional mehtod arguments.
+        #
+        # @return [Field]
+        #   The sub-field for the given name.
+        #
+        # @raise [ArgumentError]
+        #   The method missing call was given additional arguments.
+        #
+        # @raise [NoMethodError]
+        #   Cannot access a column from another column.
+        #
+        # @example
+        #   db.users
+        #
+        # @example
+        #   users.id
+        #
+        def method_missing(name,*arguments)
+          unless arguments.empty?
+            raise(ArgumentError,"canot access columns or tables with arguments")
+          end
+
+          if (self.parent.nil? || self.parent.parent.nil?)
+            Field.new(name,self)
+          else
+            raise(NoMethodError,"cannot access columns from other columns")
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/ronin/code/sql/fields.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+#
+# ronin-code-sql - A Ruby DSL for crafting SQL Injections.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-sql is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-sql is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-sql.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/sql/field'
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Allows creating {Field Fields} via {#method_missing}.
+      #
+      # @api public
+      #
+      module Fields
+        #
+        # Specifies that {#method_missing} will catch all missing methods.
+        #
+        # @param [Symbol] name
+        #   The method name that is being checked.
+        #
+        # @param [Boolean] include_private
+        #
+        # @return [true]
+        #
+        def respond_to_missing?(name,include_private)
+          true
+        end
+
+        #
+        # @return [nil]
+        #
+        def to_ary
+        end
+
+        protected
+
+        #
+        # Allows specifying databases, tables or columns.
+        #
+        # @param [Symbol] name
+        #   The field name to access.
+        #
+        # @param [Array] arguments
+        #   Additional method arguments.
+        #
+        # @return [Field]
+        #   The field object.
+        #
+        # @example
+        #   db.users
+        #
+        # @example
+        #   users.id
+        #
+        def method_missing(name,*arguments,&block)
+          if (arguments.empty? && block.nil?)
+            Field.new(name)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ronin/code/sql/function.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+#
+# ronin-code-sql - A Ruby DSL for crafting SQL Injections.
+#
+# Copyright (c) 2007-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-code-sql is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-code-sql is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-code-sql.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/code/sql/operators'
+require 'ronin/code/sql/emittable'
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Represents a SQL function call.
+      #
+      # @api semipublic
+      #
+      class Function < Struct.new(:name,:arguments)
+
+        include Operators
+        include Emittable
+
+        #
+        # Creates a new Function object.
+        #
+        # @param [Symbol] name
+        #   The name of the function.
+        #
+        # @param [Array] arguments
+        #   The arguments of the function.
+        #
+        def initialize(name,*arguments)
+          super(name,arguments)
+        end
+
+      end
+    end
+  end
+end