wibrfake-brk 0.0.2

data/lib/wibrfake/Process/pkill.rb

@@ -0,0 +1,124 @@
+require_relative 'processes'
+module WibrFake
+    class Pkill
+        def self.kill(process_name)
+            status = false
+            pids = WibrFake::Processes.status(process_name)
+            if(pids.length>1)
+                pids.each{|pid|
+                    puts "Process #{process_name} with PID #{pid} found"
+                }
+                puts "Select the process to kill or press [ENTER] to kill all:"
+                input = gets.chomp
+                if(input.to_i>0) and (pids.include?(input))
+                    puts "Killing #{process_name} with PID: #{input.to_i}"
+                    begin
+                        Process.kill("TERM", input.to_i)
+                        WibrFake::Processes.del(input)
+                    rescue Errno::ESRCH
+                        WibrFake::Processes.del(input)
+                    end
+                    puts "Killed #{process_name}"
+                elsif (input=="")
+                    pids.each{|pid|
+                        puts "Killing #{process_name} with PID: #{pid}"
+                        begin
+                            Process.kill("TERM", pid.to_i)
+                            WibrFake::Processes.del(pid)
+                        rescue Errno::ESRCH
+                            WibrFake::Processes.del(pid)
+                        end
+                        puts "Killed #{process_name} with PID: #{pid}"
+                    }
+                end
+            elsif(pids.length==1)
+                puts "Killing #{process_name} with PID: #{pids[0]}"
+                begin
+                    Process.kill("TERM", pids[0].to_i)
+                    WibrFake::Processes.del(pids[0])
+                rescue Errno::ESRCH
+                    WibrFake::Processes.del(pids[0])
+                end
+                sleep(1)
+                puts "process killed #{process_name}"
+                status = true
+            end
+            return status
+        end
+
+        def self.kill_all()
+            processes_name = %w[hostapd wpa_supplicant web_server dns dhcp]
+            processes_name.each{|process_name|
+                pids = WibrFake::Processes.status(process_name)
+                if(pids.length>1)
+                    pids.each{|pid|
+                        puts "Process #{process_name} with PID #{pid} found"
+                    }
+                    puts "Select the process to kill or press [ENTER] to kill all:"
+                    input = gets.chomp
+                    if(input.to_i>0) and (pids.include?(input))
+                        puts "Killing #{process_name} with PID: #{input.to_i}"
+                        begin
+                            Process.kill("TERM", input.to_i)
+                            WibrFake::Processes.del(input)
+                        rescue Errno::ESRCH
+                            WibrFake::Processes.del(input)
+                        end
+                        puts "Killed #{process_name}"
+                    elsif (input=="")
+                        pids.each{|pid|
+                            puts "Killing #{process_name} with PID: #{pid}"
+                            begin
+                                Process.kill("TERM", pid.to_i)
+                                WibrFake::Processes.del(pid)
+                            rescue Errno::ESRCH
+                                WibrFake::Processes.del(pid)
+                            end
+                            puts "Killed #{process_name} with PID: #{pid}"
+                        }
+                    end
+                elsif(pids.length==1)
+                    puts "Killing #{process_name} with PID: #{pids[0]}"
+                    begin
+                        Process.kill("TERM", pids[0].to_i)
+                        WibrFake::Processes.del(pids[0].to_i)
+                    rescue Errno::ESRCH
+                        WibrFake::Processes.del(pids[0].to_i)
+                    end
+                    sleep(1)
+                    puts "process killed #{process_name}"
+                    status = true
+                end
+            }
+        end
+        def self.kill_silence(process_name)
+            pids = WibrFake::Processes.status(process_name)
+            if(pids.length>=1)
+                pids.each{|pid|
+                    begin
+                        Process.kill("TERM", pid.to_i)
+                        WibrFake::Processes.del(pid.to_i)
+                    rescue Errno::ESRCH
+                        WibrFake::Processes.del(pid)
+                    end
+                }
+            end
+        end
+        def self.kill_all_silence()
+            processes_name = %w[hostapd wpa_supplicant web_server dns dhcp]
+            processes_name.each{|process_name|
+                pids = WibrFake::Processes.status(process_name)
+                if(pids.length>=1)
+                    pids.each{|pid|
+                        begin
+                            Process.kill("TERM", pid)
+                            WibrFake::Processes.del(pid)
+                        rescue Errno::ESRCH
+                            WibrFake::Processes.del(pid)
+                        end
+                    }
+                end
+            }
+        end
+    end
+end

data/lib/wibrfake/Process/processes.rb

@@ -0,0 +1,76 @@
+module WibrFake
+    class Processes
+        def initialize
+            processes = ['wibrfake_hostapd', 'wibrfake_dns', 'wibrfake_dhcp']
+            processes.each{|process|
+                status_proc(process).each{|pid|
+                    if(!pid.empty?)
+                        set(process.split('_')[1], pid)
+                    end
+                }
+            }
+        end
+        def self.status(process, verb=0)
+            pids = []
+            File.foreach(File.join(File.dirname(__FILE__), 'pids.log')){|file|
+                if(file.include?(process))
+                    [file].each{|line|
+                        line.split("\n").each{|pid|
+                            pids << pid.split[1]
+                        }
+                    }
+                end
+            }
+
+            if(pids.empty?)
+                return "\033[38;5;196moff\e[1;37m" if(verb==1)
+                []
+            else
+                return "\033[38;5;46mon\e[1;37m" if(verb==1)
+                return pids
+            end
+        end
+        
+        def self.status_proc(process)
+            pids = Array.new
+            Dir.entries('/proc').each do |entry|
+                next unless entry =~ /^\d+$/ # Solo directorios numéricos (PIDs)
+                comm_path = File.join('/proc', entry, 'comm')
+                begin
+                    cmdline = File.read(comm_path).strip
+                    if cmdline.include?(process)
+                        pids << entry.to_i
+                    end
+                rescue Errno::ENOENT, Errno::EACCES
+                     next
+                end
+            end
+            return pids
+        end
+
+        def self.status_all
+            process = []
+            File.foreach(File.join(File.dirname(__FILE__), 'pids.log')){|line|
+                process << line if(!line.strip.empty?)
+            }
+            process
+        end
+
+        def self.set(process_name, pid)
+            File.open(File.join(File.dirname(__FILE__), 'pids.log'), 'a'){|file|             
+                file.write "\n#{process_name}: #{pid}"
+            }
+            [process_name, pid]
+        end
+
+        def self.del(pid)
+            File.open(File.join(File.dirname(__FILE__), 'pids.log'), 'r+'){|file|
+                lines = file.readlines
+                lines.reject!{|line| line.include?(pid.to_s)}
+                file.rewind
+                file.write(lines.join)
+                file.truncate(file.pos)
+            }
+        end
+    end
+end

data/lib/wibrfake/Rails/login.rb

@@ -0,0 +1,20 @@
+module WibrFake
+    class RailsLogin
+        def self.logins
+            return ['basic', 'nauta_etecsa', 'nauta_hogar', 'facebook', 'instagram', 'google']
+        end
+        def self.validate?(login)
+            logins.each{|log_in|
+                if(log_in==login)
+                    return true
+                end
+            }
+            return false
+        end
+        
+        def self.show(verb = 0)
+            return logins if verb==0
+            puts logins
+        end
+    end
+end

data/lib/wibrfake/Rails/routes.rb

@@ -0,0 +1,76 @@
+module WibrFake
+    class Rails
+        def self.usage(route: nil)
+            routes = {
+                    route: route,
+                    route_about: "#{route}/about",
+                    sessions_get: "sessions#wibrfake",
+                    sessions_get_about: "sessions#wibrfake_about",
+                }
+        end
+        def self.routes(login: nil, route: nil)
+            case login
+            when 'basic'
+                routes = [{sessions_get: "sessions#basic", as_get: :page_index}]
+                routes << {
+                    route_generate_204: 'generate_204/',
+                    route_login: route,
+                    sessions_get: "sessions#basic",
+                    sessions_post: "sessions#basic_login",
+                    as_get: "basic_login",
+                    as_post: "basic_login_post"
+                }
+            when 'nauta_etecsa'
+                routes = [{sessions_get: "sessions#nauta_etecsa", as_get: :page_index}]
+                routes << {
+                    route_generate_204: 'generate_204/',
+                    route_login: route,
+                    sessions_get: "sessions#nauta_etecsa",
+                    sessions_post: "sessions#nauta_etecsa_login",
+                    as_get: "nauta_etecsa_login",
+                    as_post: "nauta_etecsa_login_post"
+                }
+            when 'nauta_hogar'
+                routes = [{sessions_get: "sessions#nauta_hogar", as_get: :page_index}]
+                routes << {
+                    route_generate_204: 'generate_204/',
+                    route_login: route,
+                    sessions_get: "sessions#nauta_hogar",
+                    sessions_post: "sessions#nauta_hogar_login",
+                    as_get: "nauta_hogar_login",
+                    as_post: "nauta_hogar_login_post"
+                }
+            when 'facebook'
+                routes = [{sessions_get: "sessions#facebook", as_get: :page_index}]
+                routes << {
+                    route_generate_204: 'generate_204/',
+                    route_login: route,
+                    sessions_get: "sessions#facebook",
+                    sessions_post: "sessions#facebook_login",
+                    as_get: "facebook_login",
+                    as_post: "facebook_login_post"
+                }
+            when 'instagram'
+                routes = [{sessions_get: "sessions#instagram", as_get: :page_index}]
+                routes << {
+                    route_generate_204: 'generate_204/',
+                    route_login: route,
+                    sessions_get: "sessions#instagram",
+                    sessions_post: "sessions#instagram_login",
+                    as_get: "instagram_login",
+                    as_post: "instagram_login_post"
+                }
+            when 'google'
+                routes = [{sessions_get: "sessions#google", as_get: :page_index}]
+                routes << {
+                    route_generate_204: 'generate_204/',
+                    route_login: route,
+                    sessions_get: "sessions#google",
+                    sessions_post: "sessions#google_login",
+                    as_get: "google_login",
+                    as_post: "google_login_post"
+                }
+            end
+        end
+    end
+end

data/lib/wibrfake/Rails/service.rb

@@ -0,0 +1,58 @@
+module WibrFake
+    class Rails
+        def initialize(host, port, login, route, credential_route, iface, id)
+            begin
+                require 'puma'
+                require_relative '../Rails/routes'
+                require_relative '../../../config/environment'
+            rescue LoadError => e
+                puts "Error al cargar una libreria"
+                puts e.message
+                exit(1)
+            end
+            @host = host
+            @port = port
+            @login = login
+            @route = route
+            ENV['IFACE'] = iface
+            ENV['ID'] = id
+            ENV['CREDENTIAL_ROUTE'] = credential_route
+        end
+        def start
+            status = true
+            begin
+                server_pid = fork {
+                    begin
+                    route_root, route_login = WibrFake::Rails.routes(login: @login, route: @route)
+                    ::Rails.application.routes.clear!
+                    
+                    ::Rails.application.routes.draw {
+                        devise_for :users
+                        if(route_login[:route]=='/')
+                            root to: route_root[:sessions_get], as: route_root[:as_get]
+                        else
+                            get route_login[:route_login], to: route_login[:sessions_get]
+                            
+                        end
+                        get route_login[:route_generate_204], to: route_login[:sessions_get], as: route_login[:as_get]
+                        post route_login[:route_generate_204], to: route_login[:sessions_post], as: route_login[:as_post]
+                    }
+                    Puma::Server.new(::Rails.application).tap {|server|
+                        server.add_tcp_listener @host, @port
+                    }.run
+                    WibrFake::Processes.set("web_server", Process.pid)
+                    sleep
+                    rescue Errno::EADDRINUSE
+                        warn "\n\r\e[1;33m[\e[1;37m!\e[1;33m]\e[1;37m There is already a captive portal web service running on port #{@port}. Run 'pkill web_server' to terminate the web server or set a new port with 'set port [PORT]'."
+                        puts "\n"
+                        print "\r\033[38;5;236m\e[0m\033[48;5;236m \033[38;5;196mwibrfake  #{@iface} \e[0m\033[38;5;236m\e[0m "
+                    end 
+                }
+                
+            rescue => e
+                puts e.message
+            end
+            return {"#{server_pid}_#{@login}" => "http://#{@host}:#{@port}/#{@route}"}
+        end
+    end
+end

data/lib/wibrfake/Rails/service_usage.rb

@@ -0,0 +1,46 @@
+module WibrFake
+    class RailsUsage
+        def initialize
+            begin
+                require 'puma'
+                require_relative '../Rails/routes'
+                require_relative '../../../config/environment'
+            rescue LoadError => e
+                puts "Error al cargar una libreria"
+                puts e.message
+                exit(1)
+            end
+            @host = '0.0.0.0'
+            @port = 1972
+            @route = 'wibrfake/'
+        end
+        def start
+            begin
+                #server_pid = fork {
+                    routes = WibrFake::Rails.usage(route: @route)
+                    ::Rails.application.routes.clear!
+                    
+                    ::Rails.application.routes.draw {
+                        devise_for :users
+                        get routes[:route], to: routes[:sessions_get]
+                        get routes[:route_about], to: routes[:sessions_get_about]
+                    }
+                    Puma::Server.new(::Rails.application).tap {|server|
+                        server.add_tcp_listener @host, @port
+                    }.run
+                #}
+                #WibrFake::Processes.set("web_server", server_pid)
+                puts "\n\033[38;5;196m[\e[1;37m+\033[38;5;196m]\e[1;37m Wibrfake server to learn how to use it is mounted on:"
+                puts "http://#{@host}:#{@port.to_s}/#{@route}"
+                puts 'To exit use Ctrl + C'
+                sleep
+            rescue Interrupt
+                exit(0)
+            rescue => e
+                puts e.message
+            end
+            #return {"#{server_pid}_#{@login}" => "http://#{@host}:#{@port}/#{@route}"}
+
+        end
+    end
+end

data/lib/wibrfake/Sessions/session.rb

@@ -0,0 +1,188 @@
+module WibrFake
+    class Session
+        def initialize(id: nil)
+            begin
+                require_relative '../Listing/sessions'
+                require_relative '../Config/ipaddr.rb'
+
+                @id = id
+                Dir.mkdir(File.join(File.dirname(__FILE__), '..', 'Tmp', @id))
+                config_session = {
+                    'WibrFake' => 'Config',
+                    'session' => {
+                        'session_save' => false,
+                        'session_modified' => false,
+                        'name' => id
+                    }
+                }
+                File.open(File.join(File.dirname(__FILE__), '..', 'Tmp', id, 'config.yml'), 'w'){|file|
+                    file.write(config_session.to_yaml)
+                }
+            rescue LoadError => e
+                puts e.message
+            rescue Errno::EINVAL
+            rescue Errno::EEXIST
+                warn "\e[1;33m[\e[1;37m+\e[1;33m]\e[1;37m Session: #{@id} already exists"
+            end
+        end
+        
+        def rename(number: nil, name: nil, id: nil)
+            sessions = WibrFake::Listing.sessions_list_return
+            status = false
+            verify_session = false
+            if(sessions.empty?)
+                warn "\e[1;33m[\e[1;37m+\e[1;33m]\e[1;37m No active sessions"
+            else
+                sessions.each_with_index{|session, index|
+                    index += 1
+                    if(index==number.to_i)
+                        begin
+                            FileUtils.mv(File.join(File.dirname(__FILE__), '..', 'Tmp', session), File.join(File.dirname(__FILE__), '..', 'Tmp', name))
+                            FileUtils.mv(File.join(File.dirname(__FILE__), '..', 'Tmp', name, 'wkdump', "#{session}.wkdump"), File.join(File.dirname(__FILE__), '..', 'Tmp', name, 'wkdump', "#{name}.wkdump"))
+                        rescue Errno::EINVAL
+                            warn "\e[1;33m[\e[1;37m+\e[1;33m]\e[1;37m The session name already exists"
+                        end
+                        verify_session = "current" if (session==id)
+                        status = true
+                    elsif(session==number)
+                        begin
+                            FileUtils.mv(File.join(File.dirname(__FILE__), '..', 'Tmp', session), File.join(File.dirname(__FILE__), '..', 'Tmp', name))
+                            FileUtils.mv(File.join(File.dirname(__FILE__), '..', 'Tmp', name, 'wkdump', "#{session}.wkdump"), File.join(File.dirname(__FILE__), '..', 'Tmp', name, 'wkdump', "#{name}.wkdump"))
+                            print "\033[38;5;46m[\e[1;37m+\033[38;5;46m]\e[1;37m Session [#{session}] was renamed to: #{name}          "
+                            puts
+                            
+                        rescue Errno::EINVAL
+                            warn "\e[1;33m[\e[1;37m+\e[1;33m]\e[1;37m The session name already exists"
+                        end
+                        verify_session = "current" if (session==id)
+                        status = true
+                    end
+                }
+                if(status)
+                    if(verify_session=='current')
+                        return verify_session
+                    else
+                        return name
+                    end
+                else
+                    warn "\e[1;33m[\e[1;37m+\e[1;33m]\e[1;37m The session index or name was not found"
+                    return status
+                end
+            end
+        end
+        def remove(number: nil, id: nil)
+            status = false
+            eliminated = false
+            sessions = WibrFake::Listing.sessions_list_return
+            if(sessions.empty?)
+                warn "\e[1;33m[\e[1;37m+\e[1;33m]\e[1;37m The specified session does not exist"
+            else
+                sessions.each_with_index{|session, index|
+                    index += 1
+                    if(index==number.to_i)
+                        if(id==session)
+                            status = true
+                        end
+                        eliminated = true
+                        FileUtils.rm_rf(File.join(File.dirname(__FILE__), '..', 'Tmp', session))
+                        print "\033[38;5;46m[\e[1;37m+\033[38;5;46m]\e[1;37m Session: #{session} has been removed"
+                        puts
+                    elsif(session==number)
+                        if(id==session)
+                            status = true
+                        end
+                        eliminated = true
+                        FileUtils.rm_rf(File.join(File.dirname(__FILE__), '..', 'Tmp', session))
+                        print "\033[38;5;46m[\e[1;37m+\033[38;5;46m]\e[1;37m Session: #{session} has been removed"
+                        puts
+                    end
+                }
+            end
+            if(!eliminated)
+                warn "\n\e[1;33m[\e[1;37m+\e[1;33m]\e[1;37m The session '#{number}' does not exist"
+            end
+            return status
+        end
+        def active(id: nil)
+            if(id.nil?)
+                puts
+            else
+                config_session = {
+                    'WibrFake' => 'Config',
+                    'session' => {
+                        'session_save' => true,
+                        'session_modified' => false,
+                    }
+                }
+                File.open(File.join(File.dirname(__FILE__), '..', 'Tmp', id, 'config.yml'), 'w'){|file|
+                    file.write(config_session.to_yaml)
+                }
+                warn "\033[38;5;46m[\e[1;37m+\033[38;5;46m]\e[1;37m Session settings activated and saved successfully"
+            end
+        end
+        def save(id: nil)
+            config_yml = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'Tmp', id, 'config.yml'))
+            if(id.nil?)
+                puts
+            else
+                config_session = {
+                    'WibrFake' => 'Config',
+                    'session' => {
+                        'session_save' => config_yml['session']['session_save'],
+                        'session_modified' => false,
+                    }
+                }
+                File.open(File.join(File.dirname(__FILE__), '..', 'Tmp', id, 'config.yml'), 'w'){|file|
+                    file.write(config_session.to_yaml)
+                }
+            end
+        end
+        def init(number: nil)
+            status = false
+            workspace = String.new
+            sessions = WibrFake::Listing.sessions_list_return
+            if(sessions.empty?)
+                warn "\e[1;33m[\e[1;37m+\e[1;33m]\e[1;37m Session defined does not exist"
+            else
+                sessions.each_with_index{|session, index|
+                    index += 1
+                    if(index==number.to_i)
+                        workspace = session
+                        status = true
+                    elsif(session==number)
+                        workspace = session
+                        status = true
+                    end
+                }
+                if(status)
+                    puts "\033[38;5;46m[\e[1;37m+\033[38;5;46m]\e[1;37m Initializing session: #{workspace}"
+                    return workspace
+                else
+                    warn "\e[1;33m[\e[1;37m+\e[1;33m]\e[1;37m The session index or name was not found"
+                    return status
+                end
+            end
+        end
+        def session_modified(status: false, id: nil)
+            if(id.nil?)
+                warn "\e[1;33m[\e[1;37m+\e[1;33m]\e[1;37m Session ID not found"
+            else
+                #Load config.yml file
+                config_yml = YAML.load_file(File.join(File.dirname(__FILE__), '..', 'Tmp', id, 'config.yml'))
+                if(status)
+                    config_session = {
+                        'WibrFake' => 'Config',
+                        'session' => {
+                            'session_save' => config_yml['session']['session_save'],
+                            'session_modified' => true,
+                            'name' => config_yml['session']['name']
+                        }
+                    }
+                    File.open(File.join(File.dirname(__FILE__), '..', 'Tmp', id, 'config.yml'), 'w'){|file|
+                        file.write(config_session.to_yaml)
+                    }
+                end
+            end
+        end
+    end
+end