Class PacketFu::Utils < Object

# File lib/packetfu/utils.rb, line 29
                def self.arp(target_ip,args={})
                        iface = args[:iface] || :eth0
                        args[:config] ||= whoami?(:iface => iface)
                        arp_pkt = PacketFu::ARPPacket.new(:flavor => (args[:flavor] || :none), :config => args[:config])
                        arp_pkt.eth_daddr = "ff:ff:ff:ff:ff:ff"
                        arp_pkt.arp_daddr_mac = "00:00:00:00:00:00"
                        arp_pkt.arp_daddr_ip = target_ip
                        # Stick the Capture object in its own thread.
                        cap_thread = Thread.new do
                                target_mac = nil
                                cap = PacketFu::Capture.new(:iface => iface, :start => true, 
                                :filter => "arp src #{target_ip} and ether dst #{arp_pkt.eth_saddr}")
                                arp_pkt.to_w(iface) # Shorthand for sending single packets to the default interface.
                                timeout = 0
                                while target_mac.nil? && timeout <= (args[:timeout] || 3)
                                        if cap.save > 0
                                                arp_response = PacketFu::Packet.parse(cap.array[0])
                                                target_mac = arp_response.arp_saddr_mac if arp_response.arp_saddr_ip = target_ip
                                        end
                                        timeout += 0.1
                                        sleep 0.1 # Check for a response ten times per second.
                                end
                                target_mac
                        end # cap_thread
                        cap_thread.value
                end

# File lib/packetfu/utils.rb, line 157
                def self.ifconfig(iface='eth0')
                        ret = {}
                        iface = iface.to_s.scan(/[0-9A-Za-z]/).join # Sanitizing input, no spaces, semicolons, etc.
                        case RUBY_PLATFORM
                        when /linux/i
                                ifconfig_data = %x[ifconfig #{iface}]
                                if ifconfig_data =~ /#{iface}/i
                                        ifconfig_data = ifconfig_data.split(/[\s]*\n[\s]*/)
                                else
                                        raise ArgumentError, "Cannot ifconfig #{iface}"
                                end
                                real_iface = ifconfig_data.first
                                ret[:iface] = real_iface.split.first.downcase
                                if real_iface =~ /[\s]HWaddr[\s]+([0-9a-fA-F:]{17})/i
                                        ret[:eth_saddr] = $1.downcase
                                        ret[:eth_src] = EthHeader.mac2str(ret[:eth_saddr])
                                end
                                ifconfig_data.each do |s|
                                        case s
                                        when /inet addr:[\s]*([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+)(.*Mask:([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+))?/i
                                                ret[:ip_saddr] = $1
                                                ret[:ip_src] = [IPAddr.new($1).to_i].pack("N")
                                                ret[:ip4_obj] = IPAddr.new($1)
                                                ret[:ip4_obj] = ret[:ip4_obj].mask($3) if $3
                                        when /inet6 addr:[\s]*([0-9a-fA-F:\x2f]+)/
                                                ret[:ip6_saddr] = $1
                                                ret[:ip6_obj] = IPAddr.new($1)
                                        end
                                end
                        end # linux 
                        ret
                end

# File lib/packetfu/utils.rb, line 129
                def self.lookupdev
                        # XXX cycle through eth0-9 and wlan0-9, and if a cap start throws a RuntimeErorr (and we're
                        # root), it's not a good interface. Boy, really ought to fix lookupdev directly with another
                        # method that returns an array rather than just the first candidate.
                end

# File lib/packetfu/utils.rb, line 79
                def self.whoami?(args={})
                        unless args.kind_of? Hash
                                raise ArgumentError, "Argument to `whoami?' must be a Hash"
                        end
                        if args[:iface].to_s =~ /^lo/ # Linux loopback more or less. Need a switch for windows loopback, too.
                                dst_host = "127.0.0.1"
                        else
                                dst_host = (args[:target] || IPAddr.new((rand(16777216) + 2969567232), Socket::AF_INET).to_s)
                        end

                        dst_port = rand(0xffff-1024)+1024
                        msg = "PacketFu whoami? packet #{(Time.now.to_i + rand(0xffffff)+1)}"
                        iface = (args[:iface] || ENV['IFACE'] || Pcap.lookupdev || :lo ).to_s
                        cap = PacketFu::Capture.new(:iface => iface, :promisc => false, :start => true, :filter => "udp and dst host #{dst_host} and dst port #{dst_port}")
                        udp_sock = UDPSocket.new
                        udp_sock.send(msg,0,dst_host,dst_port)
                        udp_sock = nil
                        cap.save
                        pkt = Packet.parse(cap.array[0]) unless cap.save.zero?
                        timeout = 0
                        while timeout < 1 # Sometimes packet generation can be a little pokey.
                                if pkt
                                        timeout = 1.1 # Cancel the timeout
                                        if pkt.payload == msg
                                        my_data =  {
                                                :iface => (args[:iface] || ENV['IFACE'] || Pcap.lookupdev || "lo").to_s,
                                                :pcapfile => args[:pcapfile] || "/tmp/out.pcap",
                                                :eth_saddr => pkt.eth_saddr,
                                                :eth_src => pkt.eth_src.to_s,
                                                :ip_saddr => pkt.ip_saddr,
                                                :ip_src => pkt.ip_src,
                                                :ip_src_bin => [pkt.ip_src].pack("N"),
                                                :eth_dst => pkt.eth_dst.to_s,
                                                :eth_daddr => pkt.eth_daddr
                                        }
                                        else raise SecurityError, 
                                                "whoami() packet doesn't match sent data. Something fishy's going on."
                                        end
                                else
                                        sleep 0.1; timeout += 0.1
                                        cap.save
                                        pkt = Packet.parse(cap.array[0]) unless cap.save.zero?
                                end
                                raise SocketError, "Didn't receive the whomi() packet, can't automatically configure." if !pkt
                                cap = nil
                        end
                        my_data
                end