ronin-support 0.5.2 → 1.0.0.beta1

data/lib/ronin/support/network/unix/mixin.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support 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-support 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-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'socket'
+require 'timeout'
+
+module Ronin
+  module Support
+    module Network
+      module UNIX
+        #
+        # Provides helper methods for communicating with UNIX sockets.
+        #
+        module Mixin
+          #
+          # Tests whether a UNIX socket is open.
+          #
+          # @param [String] path
+          #   The path to the socket.
+          #
+          # @param [Integer] timeout (5)
+          #   The maximum time to attempt connecting.
+          #
+          # @return [Boolean, nil]
+          #   Specifies whether the UNIX socket is open.
+          #   If the connection was not accepted, `nil` will be returned.
+          #
+          # @api public
+          #
+          # @since 0.5.0
+          #
+          def unix_open?(path,timeout=nil)
+            timeout ||= 5
+
+            begin
+              Timeout.timeout(timeout) do
+                socket = unix_connect(path)
+                socket.close
+              end
+              return true
+            rescue Timeout::Error
+              return nil
+            rescue SocketError, SystemCallError
+              return false
+            end
+          end
+
+          #
+          # Connects to a UNIX socket.
+          #
+          # @param [String] path
+          #   The path to the UNIX socket.
+          #
+          # @yield [socket]
+          #   If a block is given, it will be passed an UNIX socket object.
+          #   Once the block has returned, the UNIX socket will be closed.
+          #
+          # @yieldparam [UNIXSocket] socket
+          #   The UNIX socket.
+          #
+          # @return [UNIXSocket, nil]
+          #   The UNIX socket. If a block was given, `nil` will be returned.
+          #
+          # @example
+          #   unix_connect('/tmp/haproxy.stats.socket')
+          #
+          # @example
+          #   unix_connect('/tmp/haproxy.stats.socket') do |socket|
+          #     # ...
+          #   end
+          #
+          # @see https://rubydoc.info/stdlib/socket/UNIXSocket
+          #
+          # @api public
+          #
+          def unix_connect(path)
+            socket = UNIXSocket.new(path)
+
+            if block_given?
+              yield socket
+              socket.close
+            else
+              return socket
+            end
+          end
+
+          #
+          # Connects to a UNIX Socket and sends the given data.
+          #
+          # @param [String] data
+          #   The data to send to the socket.
+          #
+          # @param [String] path
+          #   The path to the socket.
+          #
+          # @yield [socket]
+          #   If a block is given, it will be passed the newly created socket.
+          #
+          # @yieldparam [UNIXSocket] socket
+          #   The newly created UNIXSocket object.
+          #
+          # @return [UNIXSocket]
+          #   The newly created UNIXSocket object.
+          #
+          # @api public
+          #
+          def unix_connect_and_send(data,path)
+            socket = unix_connect(path)
+            socket.write(data)
+
+            yield socket if block_given?
+            return socket
+          end
+
+          #
+          # Connects to a UNIX socket, sends the given data and then closes the
+          # socket.
+          #
+          # @param [String] data
+          #   The data to send to the UNIX socket.
+          #
+          # @param [String] path
+          #   The UNIX socket to connect to.
+          #
+          # @return [true]
+          #   The data was successfully sent.
+          #
+          # @example
+          #   buffer = "GET /" + ('A' * 4096) + "\n\r"
+          #   unix_send(buffer,'/tmp/thin.socket')
+          #   # => true
+          #
+          # @api public
+          #
+          def unix_send(data,path)
+            unix_connect(path) do |socket|
+              socket.write(data)
+            end
+
+            return true
+          end
+
+          #
+          # Opens a UNIX socket.
+          #
+          # @param [String] path
+          #   The path for the new UNIX socket.
+          #
+          # @yield [server]
+          #   If a block is given, it will be passed an UNIX socket object.
+          #
+          # @yieldparam [UNIXServer] server
+          #   The new UNIX socket.
+          #
+          # @return [UNIXServer]
+          #   The new UNIX socket.
+          #
+          # @example
+          #   unix_server('/tmp/test.socket')
+          #
+          # @see https://rubydoc.info/stdlib/socket/UNIXServer
+          #
+          # @api public
+          #
+          def unix_server(path)
+            socket = UNIXServer.new(path)
+
+            yield socket if block_given?
+            return socket
+          end
+
+          #
+          # Temporarily opens a UNIX socket.
+          #
+          # @param [String] path
+          #   The path for the new UNIX socket.
+          #
+          # @yield [server]
+          #   If a block is given, it will be passed an UNIX socket object.
+          #
+          # @yieldparam [UNIXServer] server
+          #   The new UNIX socket.
+          #
+          # @example
+          #   unix_server_session('/tmp/test.socket') do |server|
+          #     # ...
+          #   end
+          #
+          # @api public
+          #
+          def unix_server_session(path,&block)
+            socket = unix_server(path,&block)
+            socket.close
+            return nil
+          end
+
+          #
+          # Opens a UNIX socket, accepts connections in a loop.
+          #
+          # @param [String] path
+          #   The path for the new UNIX socket.
+          #
+          # @yield [client]
+          #   If a block is given, it will be passed each accepted connection.
+          #
+          # @yieldparam [UNIXSocket] client
+          #   An accepted connection to UNIX socket.
+          #
+          # @example
+          #   unix_server_loop('/tmp/test.socket') do |client|
+          #     # ...
+          #   end
+          #
+          # @api public
+          #
+          def unix_server_loop(path)
+            unix_server_session(path) do |server|
+              loop do
+                client = server.accept
+
+                yield client if block_given?
+                client.close
+              end
+            end
+          end
+
+          #
+          # Opens a UNIX socket, accepts a connection, then closes the socket.
+          #
+          # @param [String] path
+          #   The path for the new UNIX socket.
+          #
+          # @yield [client]
+          #   If a block is given, it will be passed the accepted connection.
+          #
+          # @yieldparam [UNIXSocket] client
+          #   The accepted connection to UNIX socket.
+          #
+          # @example
+          #   unix_accept('/tmp/test.socket') do |client|
+          #     # ...
+          #   end
+          #
+          # @api public
+          #
+          def unix_accept(path)
+            unix_server_session(path) do |server|
+              client = server.accept
+
+              yield client if block_given?
+              client.close
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ronin/support/network.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support 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-support 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-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/support/network/asn'
+require 'ronin/support/network/dns'
+require 'ronin/support/network/domain'
+require 'ronin/support/network/email_address'
+require 'ronin/support/network/host'
+require 'ronin/support/network/http'
+require 'ronin/support/network/ip_range'
+require 'ronin/support/network/ip'
+require 'ronin/support/network/packet'
+require 'ronin/support/network/proxy'
+require 'ronin/support/network/public_suffix'
+require 'ronin/support/network/smtp'
+require 'ronin/support/network/ssl'
+require 'ronin/support/network/tcp'
+require 'ronin/support/network/tld'
+require 'ronin/support/network/tls'
+require 'ronin/support/network/udp'
+require 'ronin/support/network/mixin'
+require 'ronin/support/network/core_ext'

data/lib/ronin/support/path.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support 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-support 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-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'pathname'
+
+module Ronin
+  module Support
+    #
+    # The {Path} class extends `Pathname` to allow representing directory
+    # traversal paths.
+    #
+    # @api public
+    #
+    class Path < Pathname
+
+      # The separator to join paths together with
+      #
+      # @return [String]
+      attr_accessor :separator
+
+      #
+      # Initializes a new Path.
+      #
+      # @param [String] path
+      #   The path.
+      #
+      # @param [String] separator
+      #   The directory separator to use.
+      #
+      def initialize(path,separator=File::SEPARATOR)
+        @separator = separator
+
+        super(path)
+      end
+
+      #
+      # The root path.
+      #
+      # @return [Path]
+      #   The root path.
+      #
+      def Path.root
+        Path.new('/')
+      end
+
+      #
+      # Creates a new path object for upward directory traversal.
+      #
+      # @param [Integer, Array, Range] n
+      #   The number of directories to go up.
+      #
+      # @param [String] separator
+      #   Path separator.
+      #
+      # @return [Path]
+      #   The new path object.
+      #
+      # @raise [ArgumentError]
+      #   A negative number was given as the first argument.
+      #
+      # @example Generate a relative path that goes up 7 directories:
+      #   Path.up(7)
+      #   # => #<Ronin::Support::Path:../../../../../../..>
+      #
+      # @example Generate multiple relative paths, going up 1 to 3 directories:
+      #   Path.up(1..3)
+      #   # => [#<Ronin::Support::Path:..>, #<Ronin::Support::Path:../..>,
+      #   #<Ronin::Support::Path:../../..>]
+      #
+      def self.up(n,separator=File::SEPARATOR)
+        case n
+        when Integer
+          if n == 0
+            separator
+          elsif n > 0
+            path = new('..',separator)
+            path.join(*(['..'] * (n-1)))
+          else
+            raise(ArgumentError,"negative argument")
+          end
+        when Enumerable
+          n.map { |i| up(i) }
+        else
+          raise(ArgumentError,"The first argument of Path.up must be either an Integer or Enumerable")
+        end
+      end
+
+      #
+      # Joins directory names together with the path, but does not resolve
+      # the resulting path.
+      #
+      # @param [Array] names
+      #   The names to join together.
+      #
+      # @return [Path]
+      #   The joined path.
+      #
+      # @example
+      #   Path.up(7).join('etc/passwd')
+      #   # => #<Ronin::Support::Path:../../../../../../../etc/passwd>
+      #
+      def join(*names)
+        joined_path = if root? then String.new
+                      else          self.to_s
+                      end
+
+        names.each do |name|
+          name = name.to_s
+
+          joined_path << @separator unless name.start_with?(@separator)
+          joined_path << name       unless name == @separator
+        end
+
+        return self.class.new(joined_path,@separator)
+      end
+
+      alias / join
+
+    end
+  end
+end

data/lib/ronin/{network/extensions/dns/net.rb → support/text/core_ext/regexp.rb}

@@ -1,7 +1,6 @@
+# frozen_string_literal: true
 #
-# Copyright (c) 2006-2021 Hal Brodigan (postmodern.mod3 at gmail.com)
-#
-# This file is part of ronin-support.
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # ronin-support is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published
@@ -17,8 +16,8 @@
 # along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
 #
 
-require 'ronin/network/dns'
+require 'ronin/support/text/patterns'
 
-module Net
-  extend Ronin::Network::DNS
+class Regexp
+  include Ronin::Support::Text::Patterns
 end

data/lib/ronin/support/text/core_ext/string.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support 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-support 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-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/support/text/random'
+
+class String
+
+  #
+  # Creates a new String by randomizing the case of each character in the
+  # String.
+  #
+  # @return [String]
+  #   The new String with randomized case.
+  #
+  # @example
+  #   "a".random_case
+  #   # => "A"
+  #   "ab".random_case
+  #   # => "aB"
+  #   "foo".random_case
+  #   # => "FoO"
+  #   "The quick brown fox jumps over 13 lazy dogs.".random_case
+  #   # => "the quIcK broWn fox Jumps oveR 13 lazY Dogs."
+  #
+  # @api public
+  #
+  def random_case
+    Ronin::Support::Text::Random.swapcase(self)
+  end
+
+end

data/lib/ronin/{formatting.rb → support/text/core_ext.rb}

@@ -1,7 +1,6 @@
+# frozen_string_literal: true
 #
-# Copyright (c) 2006-2021 Hal Brodigan (postmodern.mod3 at gmail.com)
-#
-# This file is part of ronin-support.
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # ronin-support is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published
@@ -17,9 +16,8 @@
 # along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
 #
 
-require 'ronin/formatting/extensions'
-require 'ronin/formatting/digest'
-require 'ronin/formatting/binary'
-require 'ronin/formatting/text'
-require 'ronin/formatting/http'
-require 'ronin/formatting/html'
+require 'ronin/support/text/core_ext/string'
+require 'ronin/support/text/core_ext/regexp'
+require 'ronin/support/text/entropy/core_ext'
+require 'ronin/support/text/homoglyph/core_ext'
+require 'ronin/support/text/typo/core_ext'

data/lib/ronin/support/text/entropy/core_ext/string.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support 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-support 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-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/support/text/entropy'
+
+class String
+
+  #
+  # Calculates the entropy for the given string.
+  #
+  # @param [Hash{Symbol => Object}] kwargs
+  #   Additional keyword arguments.
+  #
+  # @option kwargs [Integer] :base (2)
+  #   The base to calculate the entropy for.
+  #
+  # @return [Float]
+  #   The entropy for the string.
+  #
+  # @see Ronin::Support::Text::Entropy.calculate
+  #
+  # @since 1.0.0
+  #
+  # @api public
+  #
+  def entropy(**kwargs)
+    Ronin::Support::Text::Entropy.calculate(self,**kwargs)
+  end
+
+end

data/lib/ronin/{formatting/http.rb → support/text/entropy/core_ext.rb}

@@ -1,7 +1,6 @@
+# frozen_string_literal: true
 #
-# Copyright (c) 2006-2021 Hal Brodigan (postmodern.mod3 at gmail.com)
-#
-# This file is part of ronin-support.
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
 # ronin-support is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published
@@ -17,4 +16,4 @@
 # along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
 #
 
-require 'ronin/formatting/extensions/http'
+require 'ronin/support/text/entropy/core_ext/string'

data/lib/ronin/support/text/entropy.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support 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-support 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-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+module Ronin
+  module Support
+    module Text
+      #
+      # Implements the [Shanno Entropy] algorithm.
+      #
+      # [Shannon Entropy]: https://en.wikipedia.org/wiki/Entropy_(information_theory)
+      #
+      # @since 1.0.0
+      #
+      # @api public
+      #
+      module Entropy
+        #
+        # Calculates the entropy for the given string.
+        #
+        # @param [String] string
+        #   The given string to calculate the entropy for.
+        #
+        # @param [Integer] base
+        #   The base to calculate the entropy for.
+        #
+        # @return [Float]
+        #   The entropy for the string.
+        #
+        def self.calculate(string, base: 2)
+          char_counts = Hash.new(0)
+
+          string.each_char do |char|
+            char_counts[char] += 1
+          end
+
+          length  = string.length.to_f
+          entropy = 0.0
+
+          char_counts.each do |char,count|
+            freq     = count / length
+            entropy -= freq * Math.log(freq,base)
+          end
+
+          return entropy
+        end
+      end
+    end
+  end
+end
+
+require 'ronin/support/text/entropy/core_ext'