ronin-code-sql 2.0.0.beta1

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

@@ -0,0 +1,384 @@
+# 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/>.
+#
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Methods for creating SQL expressions.
+      #
+      # @api public
+      #
+      # @see http://sqlite.org/lang_expr.html
+      #
+      module Operators
+        #
+        # Multiplication.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def *(other)
+          BinaryExpr.new(self,:*,other)
+        end
+
+        #
+        # Division.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def /(other)
+          BinaryExpr.new(self,:/,other)
+        end
+
+        #
+        # Modulus.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def %(other)
+          BinaryExpr.new(self,:%,other)
+        end
+
+        #
+        # Addition.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def +(other)
+          BinaryExpr.new(self,:+,other)
+        end
+
+        #
+        # Subtraction.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def -(other)
+          BinaryExpr.new(self,:-,other)
+        end
+
+        #
+        # Bit-wise left shift.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def <<(other)
+          BinaryExpr.new(self,:<<,other)
+        end
+
+        #
+        # Bit-wise right shift.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def >>(other)
+          BinaryExpr.new(self,:>>,other)
+        end
+
+        #
+        # Bit-wise `AND`.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def &(other)
+          BinaryExpr.new(self,:&,other)
+        end
+
+        #
+        # Bit-wise `OR`.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def |(other)
+          BinaryExpr.new(self,:|,other)
+        end
+
+        #
+        # Less than.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def <(other)
+          BinaryExpr.new(self,:<,other)
+        end
+
+        #
+        # Less than or equal to.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def <=(other)
+          BinaryExpr.new(self,:<=,other)
+        end
+
+        #
+        # Greater than.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def >(other)
+          BinaryExpr.new(self,:>,other)
+        end
+
+        #
+        # Greater than or equal to.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def >=(other)
+          BinaryExpr.new(self,:>=,other)
+        end
+
+        #
+        # Equal to.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def ==(other)
+          BinaryExpr.new(self,:"=",other)
+        end
+
+        #
+        # Not equal to.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def !=(other)
+          BinaryExpr.new(self,:!=,other)
+        end
+
+        #
+        # Alias.
+        #
+        # @param [Symbol] name
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def as(name)
+          BinaryExpr.new(self,:AS,name)
+        end
+
+        #
+        # `IS` comparison.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def is(other)
+          BinaryExpr.new(self,:IS,other)
+        end
+
+        #
+        # `IS NOT` comparison.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def is_not(other)
+          BinaryExpr.new(self,[:IS, :NOT],other)
+        end
+
+        #
+        # `LIKE` comparison.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def like(other)
+          BinaryExpr.new(self,:LIKE,other)
+        end
+
+        #
+        # `GLOB` comparison.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def glob(other)
+          BinaryExpr.new(self,:GLOB,other)
+        end
+
+        #
+        # `MATCH` comparison.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def match(other)
+          BinaryExpr.new(self,:MATCH,other)
+        end
+
+        #
+        # `REGEXP` comparison.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def regexp(other)
+          BinaryExpr.new(self,:REGEXP,other)
+        end
+
+        #
+        # `REGEXP` comparison.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def in(other)
+          BinaryExpr.new(self,:IN,other)
+        end
+
+        #
+        # Unary minus.
+        #
+        # @return [UnaryExpr]
+        #   The new binary expression.
+        #
+        def -@
+          UnaryExpr.new(:-,self)
+        end
+
+        #
+        # Unary plus.
+        #
+        # @return [UnaryExpr]
+        #   The new binary expression.
+        #
+        def +@
+          UnaryExpr.new(:+,self)
+        end
+
+        #
+        # Bit-wise negate.
+        #
+        # @return [UnaryExpr]
+        #   The new binary expression.
+        #
+        def ~
+          UnaryExpr.new(:~,self)
+        end
+
+        #
+        # Logical negate.
+        #
+        # @return [UnaryExpr]
+        #   The new binary expression.
+        #
+        def !
+          UnaryExpr.new(:!,self)
+        end
+
+        #
+        # Logical `NOT`.
+        #
+        # @return [UnaryExpr]
+        #   The new binary expression.
+        #
+        def not
+          UnaryExpr.new(:NOT,self)
+        end
+
+        #
+        # `AND`.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def and(other)
+          BinaryExpr.new(self,:AND,other)
+        end
+
+        #
+        # `OR`.
+        #
+        # @param [Object] other
+        #
+        # @return [BinaryExpr]
+        #   The new binary expression.
+        #
+        def or(other)
+          BinaryExpr.new(self,:OR,other)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+# 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/literals'
+require 'ronin/code/sql/clause'
+require 'ronin/code/sql/clauses'
+require 'ronin/code/sql/operators'
+require 'ronin/code/sql/emittable'
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Represents a SQL Statement.
+      #
+      # @api semipublic
+      #
+      class Statement < Struct.new(:keyword,:argument)
+
+        include Literals
+        include Operators
+        include Clauses
+        include Emittable
+
+        #
+        # Initializes a new SQL statement.
+        #
+        # @param [Symbol, Array<Symbol>] keyword
+        #   Name of the statement.
+        #
+        # @param [Object] argument
+        #   Additional argument for the statement.
+        #
+        # @yield [(statement)]
+        #   If a block is given, it will be called.
+        #
+        # @yieldparam [Statement] statement
+        #   If the block accepts an argument, it will be passed the new statement.
+        #   Otherwise the block will be evaluated within the statement.
+        #
+        def initialize(keyword,argument=nil,&block)
+          super(keyword,argument)
+
+          if block
+            case block.arity
+            when 0 then instance_eval(&block)
+            else        block.call(self)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+# 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'
+require 'ronin/code/sql/fields'
+require 'ronin/code/sql/unary_expr'
+require 'ronin/code/sql/binary_expr'
+require 'ronin/code/sql/functions'
+require 'ronin/code/sql/statement'
+require 'ronin/code/sql/statements'
+require 'ronin/code/sql/emittable'
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Represents a list of SQL {Statements Statement}.
+      #
+      # @api public
+      #
+      class StatementList
+
+        include Fields
+        include Functions
+        include Statements
+        include Emittable
+
+        # The list of statements
+        attr_reader :statements
+
+        #
+        # Initializes a new SQL statement list.
+        #
+        # @yield [(statements)]
+        #   If a block is given, it will be evaluated within the statement list.
+        #   If the block accepts an argument, the block will be called with the
+        #   new statement list.
+        #
+        # @yieldparam [StatementList] statements
+        #   The new statement list.
+        #
+        def initialize(&block)
+          @statements = []
+
+          if block
+            case block.arity
+            when 0 then instance_eval(&block)
+            else        block.call(self)
+            end
+          end
+        end
+
+        #
+        # Appends a statement.
+        #
+        # @param [Statement] statement
+        #   The SQL statement.
+        #
+        # @return [self]
+        #
+        def <<(statement)
+          @statements << statement
+          return self
+        end
+
+        #
+        # Appends an arbitrary statement.
+        #
+        # @param [Symbol] keyword
+        #   Name of the statement.
+        #
+        # @param [Object] argument
+        #   Additional argument for the statement.
+        #
+        # @yield [(statement)]
+        #   If a block is given, it will be called.
+        #
+        # @yieldparam [Statement] statement
+        #   If the block accepts an argument, it will be passed the new statement.
+        #   Otherwise the block will be evaluated within the statement.
+        #
+        # @return [Statement]
+        #   The newly created statement.
+        #
+        def statement(keyword,argument=nil,&block)
+          new_statement = super
+
+          self << new_statement
+          return new_statement
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# 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/>.
+#
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Methods for creating common SQL {Statement Statements}.
+      #
+      # @api public
+      #
+      module Statements
+        #
+        # Creates an arbitrary statement.
+        #
+        # @param [Symbol] keyword
+        #   Name of the statement.
+        #
+        # @param [Object] argument
+        #   Additional argument for the statement.
+        #
+        # @yield [(statement)]
+        #   If a block is given, it will be called.
+        #
+        # @yieldparam [Statement] statement
+        #   If the block accepts an argument, it will be passed the new statement.
+        #   Otherwise the block will be evaluated within the statement.
+        #
+        # @return [Statement]
+        #   The new statement.
+        #
+        def statement(keyword,argument=nil,&block)
+          Statement.new(keyword,argument,&block)
+        end
+
+        #
+        # Creates a new `SELECT` statement.
+        #
+        # @param [Array<Field, Symbol>] columns
+        #   The columns to select.
+        #
+        # @return [Statement]
+        #   The new statement.
+        #
+        def select(*columns,&block)
+          statement(:SELECT,columns,&block)
+        end
+
+        #
+        # Creates a new `INSERT` statement.
+        #
+        # @return [Statement]
+        #   The new statement.
+        #
+        def insert(&block)
+          statement(:INSERT,&block)
+        end
+
+        #
+        # Creates a new `UPDATE` statement.
+        #
+        # @param [Field, Symbol] table
+        #   The table to update.
+        #
+        # @return [Statement]
+        #   The new statement.
+        #
+        def update(table,&block)
+          statement(:UPDATE,table,&block)
+        end
+
+        #
+        # Creates a new `DELETE` statement.
+        #
+        # @param [Field, Symbol] table
+        #   The table to delete from.
+        #
+        # @return [Statement]
+        #   The new statement.
+        #
+        def delete(table,&block)
+          statement([:DELETE, :FROM],table,&block)
+        end
+
+        #
+        # Creates a new `DROP TABLE` statement.
+        #
+        # @param [Field, Symbol] table
+        #   The table to drop.
+        #
+        # @return [Statement]
+        #   The new statement.
+        #
+        def drop_table(table,&block)
+          statement([:DROP, :TABLE],table,&block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# 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/emittable'
+
+module Ronin
+  module Code
+    module SQL
+      #
+      # Represents a unary expression in SQL.
+      #
+      # @api semipublic
+      #
+      class UnaryExpr < Struct.new(:operator,:operand)
+
+        include Emittable
+
+      end
+    end
+  end
+end