netd_mngr 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a1ec00680bcc40cc8eb18f09b108a04c26c7a7f0cbee12659bf4b503636bd724
+  data.tar.gz: 6c9b2fb762ef9fa0f5a204207df63eccb86a41c2f8ce018c418c19d89cab5938
+SHA512:
+  metadata.gz: 5cae0e347c02a7c1e265a3e1fe4d059b4a8e2dbb58debab4c8ab7dbe80532c205d74b4b6d2bef036e91c930d63ed9fdc6caee9f8272414e463d542d68193e6ff
+  data.tar.gz: '0817719f7dcb0ff40f0d7f869b488b20e07ad3590814c2c34710a29ac54310e601a7d4f4c0f7481062bfae069068f0cbec9fe8196a84bab5095889cc0ac2ead1'

data/bin/netc

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'netd_core'
+require 'logger'
+require 'zlib'
+require 'base64'
+require 'json'
+
+require 'dry/cli'
+require 'awesome_print'
+
+module NetC
+  # convention for dry/cli
+  module Command
+    # required to implement a cli command
+    extend Dry::CLI::Registry
+
+    # install the service file
+    class Install < Dry::CLI::Command
+      desc 'Install service file to systemd user directory'
+      def call(**)
+        # base64(zlib(netd.service))
+        service_file_data = 'eJwljLEKgzAURfd8RZaueUJnl2KHLl1EOohDjFcNvMby8pT69xW7He65nLZJUT' \
+                            'tTIQeJH41LKpsMsYwNbA/aYoAdF7FPaGVMW/+nzty/CLV60ZLWLNTHRLL2u73M5HgJninPXkAT3qegqy' \
+                            'tccf4SdDhSj5TVM3fm5ZNiuO3lgNGvrO7ITlDzAyzzNxM='
+
+        # reverse the encoding process for the systemd service file
+        service_file = Zlib::Inflate.inflate(Base64.decode64(service_file_data))
+        # path to install the file to
+        fname = "#{Dir.home}/.config/systemd/user/netd.service"
+        # write the decoded data to the file
+        File.write(fname, service_file)
+
+        # print install info
+        puts "Wrote service file to #{fname}"
+        puts "To enable the service, execute the following:\n"
+        puts 'systemctl --user enable netd.service'
+        puts 'systemctl --user start netd.service'
+      end
+    end
+
+    # list current forwards
+    class List < Dry::CLI::Command
+      # list current forwards
+      desc 'List the currently registered port forwards'
+      def call(**)
+        # open connection to server and
+        # dispatch the list command
+        NetDSvr.connect_to_netd do |socket|
+          socket.puts 'list|'
+          puts JSON.generate(NetDSvr.parse_list(socket))
+        end
+      end
+    end
+
+    module PortFwd
+      # Local port forward
+      class Local < Dry::CLI::Command
+        desc 'Create a new local port forward'
+        option :host, type: :String, default: '127.0.0.1', desc: 'Host address to bind to', required: true
+        option :bind, type: :String, default: '127.0.0.1:8000', desc: 'Host address to bind to in <ip>:<port> format'
+        option :remote, type: :String, desc: 'Remote address to connect to'
+        option :del, default: false, desc: 'Delete the specified forward'
+
+        def call(host:, bind:, remote:, del:, **)
+          # decode the bind host host_port pair
+          bind_addr, bind_port = bind.split(':')
+          # decode the remote host host_port pair
+          remote_addr, remote_port = remote.split(':')
+          # connect to server and send local forward request
+          NetDSvr.connect_to_netd do |socket|
+            if !del
+              socket.puts NetD::OperationRequest.local_port_forward(
+                host, bind_port.to_i, bind_addr, remote_port.to_i, remote_addr
+              )
+            else
+              socket.puts NetD::OperationRequest.delete_local_port_forward(host, remote_port.to_i, remote_addr)
+            end
+            puts socket.readline
+          end
+        end
+      end
+
+      # Remote port forward
+      class Remote < Dry::CLI::Command
+        desc 'Create a new remote port forward'
+        option :host, type: :String, default: '127.0.0.1', desc: 'Host address to bind to', required: true
+        option :bind, type: :String, default: '127.0.0.1:8000', desc: 'Remote address to bind to in <ip>:<port> format'
+        option :local, type: :String, desc: 'Local address to connect to'
+        option :del, default: false, desc: 'Delete the specified forward'
+
+        def call(host:, bind:, local:, del:, **)
+          # decode the remote bind host host_port pair
+          bind_addr, bind_port = bind.split(':')
+          # decode the local host host_port pair
+          local_addr, local_port = local.split(':')
+          # connect to server and send remote forward request
+          NetDSvr.connect_to_netd do |socket|
+            if !del
+              socket.puts NetD::OperationRequest.remote_port_forward(
+                host, bind_port.to_i, bind_addr, local_port.to_i, local_addr
+              )
+            else
+              socket.puts NetD::OperationRequest.delete_remote_port_forward(host, local_port.to_i, local_addr)
+            end
+            puts socket.readline
+          end
+        end
+      end
+    end
+    register 'install', Install
+    register 'list', List
+    register 'pfwd', aliases: ['p'] do |prefix|
+      prefix.register 'local', PortFwd::Local
+      prefix.register 'remote', PortFwd::Remote
+    end
+  end
+end
+
+def main
+  Dry::CLI.new(NetC::Command).call
+end
+
+main

data/bin/netd

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'netd_core'
+require 'logger'
+require 'socket'
+
+def detect_already_running(socket_path, logger)
+  # if the file does not exist, the server
+  # cannot be running
+  return unless File.exist?(socket_path)
+
+  # attempt to detect crash
+  logger.warn('Socket path exists, detecting crash')
+  # if the connection does not except,
+  # a server is running
+  begin
+    UNIXSocket.open(socket_path).close
+  # connection refused means server is not running
+  # so clean-up the old socket file
+  rescue Errno::ECONNREFUSED
+    logger.info('crash detected, cleaning up')
+    File.unlink(socket_path)
+    return
+  end
+  logger.fatal('Server appears to be running already')
+end
+
+def main
+  # setup logger
+  logger = Logger.new("#{Dir.home}/.local/share/netd.log")
+  logger.level = Logger::INFO
+
+  # setup and validate the unix socket path
+  socket_path = "#{Dir.home}/.local/run/"
+  Dir.mkdir(socket_path) unless Dir.exist?(socket_path)
+  socket_path += 'netd.socket'
+
+  detect_already_running(socket_path, logger)
+
+  # setup the server
+  server = NetDSvr.new(socket_path, logger)
+  server.server_main
+end
+
+main

data/lib/netd_core/netop.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'net/ssh'
+require 'socket'
+
+# netd namespace
+module NetD
+  # encapsulates a currently running network operation
+  # Base Class
+  class NetworkOperation
+    attr_reader :request
+    attr_accessor :thread
+
+    def initialize(_request); end
+
+    def to_s
+      @request.values.join('|')
+    end
+
+    def close
+      @thread.thread_variable_set('stop', true)
+    end
+  end
+
+  # encapsulates a local port_forward
+  class LocalPortForward < NetworkOperation
+    def initialize(request)
+      super
+      @request = request
+      @thread = Thread.new(request) do |req|
+        stop = false
+        Net::SSH.start(req[:host], nil, keys_only: true) do |ssh|
+          ssh.forward.local(req[:bind_addr], req[:bind_port], req[:remote_addr], req[:remote_port])
+          ssh.loop(0.1) { true unless stop }
+          ssh.forward.cancel_local(req[:bind_port], req[:bind_addr])
+        end
+      end
+    end
+  end
+
+  # encapsulates a remote port_forward
+  class RemotePortForward < NetworkOperation
+    def initialize(request)
+      super
+      @request = request
+      @thread = Thread.new(request) do |req|
+        stop = false
+        Net::SSH.start(req[:host], nil, keys_only: true) do |ssh|
+          ssh.forward.remote(req[:bind_port], req[:bind_addr], req[:local_port], req[:local_addr])
+          ssh.loop(0.1) { true unless stop }
+          ssh.forward.cancel_remote(req[:bind_port], req[:bind_addr])
+        end
+      end
+    end
+  end
+
+  def test_forward
+    data = 'HELLO'
+    # create the server
+    TCPServer.open('127.0.0.1', 2224) do |svr|
+      # create the client
+      TCPSocket.open('127.0.0.1', 2222) do |c|
+        # accept the connection
+        s = svr.accept
+        # send a hello
+        c.puts data
+        # validate the data sent through
+        raise 'Forward test failed!!!' unless s.readline(chomp: true) == data
+      end
+    end
+    sleep(1) # let the threads complete
+  end
+
+  def test_setup_port_forwards
+    lpfwd = LocalPortForward.new({  'request': 'lpfwd',
+                                    'host': 'localhost',
+                                    'bind_port': 2222, 'bind_addr': 'localhost',
+                                    'remote_port': 2223, 'remote_addr': 'localhost' })
+    rpfwd = RemotePortForward.new({ 'request': 'rpfwd',
+                                    'host': 'localhost',
+                                    'bind_port': 2224, 'bind_addr': 'localhost',
+                                    'local_port': 2223, 'local_addr': 'localhost' })
+    sleep(1) # let the threads finish setting up
+    [lpfwd, rpfwd]
+  end
+
+  def test
+    puts 'testing forwards'
+    # setup the ssh-agent connector
+    Net::SSH::Authentication::Agent.connect(nil, nil, '/home/shellspawn/.1password/agent.sock')
+    # create the port forwards
+    lpfwd, rpfwd = test_setup_port_forwards
+    puts lpfwd, rpfwd
+    # send some data through the tunnel
+    test_forward
+    # close both forwards
+    [lpfwd, rpfwd].map(&:close)
+    puts 'all cleaned up'
+  end
+end
+
+# if ran independently, run tests
+test if __FILE__ == $PROGRAM_NAME

data/lib/netd_core/request.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# parse requests from a pipe delimited line
+module NetD
+  # encapsulate a request
+  class OperationRequest
+    LOCAL_PORT_FORWARD  = 'lpfwd'
+    REMOTE_PORT_FORWARD = 'rpfwd'
+    DELETE_LOCAL_PORT_FORWARD  = 'delete_lpfwd'
+    DELETE_REMOTE_PORT_FORWARD = 'delete_rpfwd'
+    LIST_FORWARDS = 'list'
+
+    def initialize(request_str)
+      malformed_request unless request_str.include? '|'
+
+      blocks = request_str.split('|')
+      @command = blocks[0]
+      @args = blocks[1..] if blocks.length > 1
+    end
+
+    def parse
+      case @command
+      when LOCAL_PORT_FORWARD
+        pfwd_fmt(@command, 'local')
+      when REMOTE_PORT_FORWARD
+        pfwd_fmt(@command, 'remote')
+      when DELETE_LOCAL_PORT_FORWARD
+        del_pfwd_fmt(@command, 'local')
+      when DELETE_REMOTE_PORT_FORWARD
+        del_pfwd_fmt(@command, 'remote')
+      when LIST_FORWARDS
+        { 'request': LIST_FORWARDS }
+      else
+        raise 'wat'
+      end
+    end
+
+    def pfwd_fmt(command, direction)
+      malformed_request unless @args.length == 5
+      lorr = direction == 'remote' ? 'local' : 'remote'
+      {
+        'request': command,
+        'host': @args[0],
+        'bind_addr': @args[1],
+        'bind_port': @args[2].to_i,
+        "#{lorr}_addr": @args[3],
+        "#{lorr}_port": @args[4].to_i
+      }
+    end
+
+    def del_pfwd_fmt(command, direction)
+      lorr = direction == 'remote' ? 'local' : 'remote'
+      {
+        'request': command,
+        'host': @args[0],
+        "#{lorr}_addr": @args[1],
+        "#{lorr}_port": @args[2].to_i
+      }
+    end
+
+    def self.local_port_forward(host, bind_port, bind_addr, remote_port, remote_addr)
+      "#{LOCAL_PORT_FORWARD}|#{host}|#{bind_addr}|#{bind_port}|#{remote_addr}|#{remote_port}"
+    end
+
+    def self.remote_port_forward(host, bind_port, bind_addr, local_port, local_addr)
+      "#{REMOTE_PORT_FORWARD}|#{host}|#{bind_addr}|#{bind_port}|#{local_addr}|#{local_port}"
+    end
+
+    def self.delete_local_port_forward(host, remote_port, remote_addr)
+      "#{DELETE_LOCAL_PORT_FORWARD}|#{host}|#{remote_addr}|#{remote_port}"
+    end
+
+    def self.delete_remote_port_forward(host, local_port, local_addr)
+      "#{DELETE_REMOTE_PORT_FORWARD}|#{host}|#{local_addr}|#{local_port}"
+    end
+
+    def malformed_request
+      raise 'malformed request'
+    end
+  end
+end

data/lib/netd_core.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'netd_core/request'
+require 'netd_core/netop'
+
+# the server class of netd
+class NetDSvr
+  # the server class of netd
+  def initialize(socket_path, logger)
+    @path = socket_path
+    @net_ops = []
+    @logger = logger
+  end
+
+  # standard connection to the netd.socket unix server
+  def self.connect_to_netd(&block)
+    # open the socket and execute the block
+    UNIXSocket.open("#{Dir.home}/.local/run/netd.socket", &block)
+  # if failed, print error
+  rescue Errno::ECONNREFUSED => e
+    puts "NetD server does not appear to be running #{e}"
+  end
+
+  # if local then the field is 'remote' if remote the command requires 'local'
+  def self.get_direction(command)
+    command == NetD::OperationRequest::LOCAL_PORT_FORWARD ? 'remote' : 'local'
+  end
+
+  def self.parse_line(line)
+    tokens = line.split('|')
+    # common to both commands
+    req = { 'request': tokens[0], 'host': tokens[1], 'bind_addr': tokens[2], 'bind_port': tokens[3] }
+    # detect last line
+    return if tokens[0] == 'OKAY'
+
+    # add the fields to the output
+    direction = NetDSvr.get_direction(tokens[0])
+    req["#{direction}_addr"] = tokens[4]
+    req["#{direction}_port"] = tokens[5]
+    req
+  end
+
+  def self.parse_list(sock)
+    # parse the first line (number of entries)
+    entries = []
+    number_of_lines = sock.readline.chomp[0..-2].to_i
+    number_of_lines.times do
+      # pretty print the hash result from parse_line
+      entries << NetDSvr.parse_line(sock.readline.chomp)
+    end
+    entries
+  end
+
+  def current_net_ops
+    # get a list of the commands used
+    # to dispatch the network operations
+    @net_ops.map(&:request).map { |v| v.values.join('|') }
+  end
+
+  def del_request(request_args)
+    @net_ops.each do |n|
+      case request_args[:request]
+      when NetD::OperationRequest::DELETE_LOCAL_PORT_FORWARD
+        if (n.request[:remote_addr] == request_args[:remote_addr]) && (n.request[:remote_port] == request_args[:remote_port])
+          n.close
+          @net_ops.delete(n)
+          return true
+        end
+      when NetD::OperationRequest::DELETE_REMOTE_PORT_FORWARD
+        if (n.request[:local_addr] == request_args[:local_addr]) && (n.request[:local_port] == request_args[:local_port])
+          n.close
+          @net_ops.delete(n)
+          return true
+        end
+      end
+    end
+    false
+  end
+
+  def dispatch_command(request_args, server_socket)
+    # switch on the request type, dispatch the request,
+    # and add the object to the tracking list
+    case request_args[:request]
+    when NetD::OperationRequest::LOCAL_PORT_FORWARD
+      @net_ops << NetD::LocalPortForward.new(request_args)
+    when NetD::OperationRequest::REMOTE_PORT_FORWARD
+      @net_ops << NetD::RemotePortForward.new(request_args)
+    when NetD::OperationRequest::DELETE_LOCAL_PORT_FORWARD
+      del_request(request_args)
+    when NetD::OperationRequest::DELETE_REMOTE_PORT_FORWARD
+      del_request(request_args)
+    when NetD::OperationRequest::LIST_FORWARDS
+      server_socket.puts("#{current_net_ops.length}|\n#{current_net_ops.join("\n")}")
+    else
+      raise 'how did you get here?'
+    end
+  end
+
+  def server_main
+    UNIXServer.open(@path) do |serv|
+      # accept, dispatch, respond for all connections
+      loop do
+        # accept new connection
+        server_socket = serv.accept
+        # read command, parse it, and dispatch it
+        dispatch_command(NetD::OperationRequest.new(server_socket.readline).parse, server_socket)
+        # respond with success
+        server_socket.puts 'OKAY|'
+      rescue EOFError, Errno::EPIPE, RuntimeError => e
+        # if connection fails or bad data is sent, report error
+        @logger.error("Malformed Request: #{e.message}\n#{e.backtrace} ")
+        server_socket.puts 'ERR|' unless server_socket.closed?
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: netd_mngr
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- shellspawn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-01-29 00:00:00.000000000 Z
+dependencies: []
+description: cnetd is a small userspace server that allows for cnet to request port
+  forwards and other services
+email: shellspawn@protonmail.com
+executables:
+- netd
+- netc
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/netc
+- bin/netd
+- lib/netd_core.rb
+- lib/netd_core/netop.rb
+- lib/netd_core/request.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key: 
+specification_version: 4
+summary: Server used for background port fwds
+test_files: []