willow_run 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1b6a01b45bd102244d8f6b96c6d539f9caf6aa89
+  data.tar.gz: a63cec69b7d3966915b1ff3196fa950da412b22c
+SHA512:
+  metadata.gz: 51e635916ad95a6fecfa2e6fc18a819b4020922040510cf44a34640c908eb457251799b943277dcb66c480d4b069acef7a0460c6d9ddd5f4867927b39f0487cf
+  data.tar.gz: cb88db8dd6ce8171db5b2a0e5aaec214e4bc93b0720a89419e7f83f3bfa20d08d13356c8bb2d3c9a955ff1a83b15cfd045870c8a305f1e568b1e6d274a45a026

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.2
+before_install: gem install bundler -v 1.13.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at kgruber1@emich.edu. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in willow_run.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Kent Gruber
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,83 @@
+# Willow Run ✈️ 
+
+## ⚠️  Still in development! Should have working tests though!
+
+#### ⚠️  Note: I've learned that `airport` sometimes dosen't handle BSSID values properly.
+
+Willow Run is a Ruby API to the macOs/OSX `airport` command. The [airport](http://osxdaily.com/2007/01/18/airport-the-little-known-command-line-wireless-utility/) command manages 802.11 interfaces, can perform wireless broadcast scans ( with xml output support ), set arbitrary channels on the interface, and even generate PSKs from specified pass phrase and SSIDs -- all from the command-line, which I really love. 
+
+## Installation
+
+It will be  a [gem](https://rubygems.org/)! So, you'll be able to install it yourself pretty easily:
+
+    $ gem install willow_run
+
+## Purpose
+This gem takes those capabilities provided by the `airpot` command and provides a Ruby API to be able use these functionalities in an [OO](https://en.wikipedia.org/wiki/Object-oriented_programming) manner, which I also really love. This provides better flexibility to build tools ontop of this tool; and can provide greater functionality for scripting or creating applications around various wireless taks this utility provides on macOS or OSX systems in Ruby, which I happen to use sometimes.
+
+I can also just build better command-line applications with this interface, since I really enjoy building command-line application in Ruby. Maybe you'll find it useful too. 
+
+### Why The Name?
+
+[Willow Run](https://en.wikipedia.org/wiki/Willow_Run_Airport) is an airport located in Ypsilanti, Michigan. I go to school at [Eastern Michigan University](https://www.emich.edu/) which is also in Ypsilanti. So, it all works out like that.
+
+![airport](https://upload.wikimedia.org/wikipedia/commons/3/34/Willow_Run_Airport_-_Michigan.jpg)
+
+## Usage
+
+This gem has lots of different functionality!
+
+### Sniffing
+
+You can access the `airport <interface> sniff <channel>` functionality for sniffing 802.11 frames:
+
+```ruby
+require 'willow_run'
+
+# make new sniffer object that sniffs for 10 seconds
+sniffer = WillowRun::Sniffer.new(:timeout => 10)
+
+# get the capture file path that was generated
+sniffer.file
+# => /tmp/airportSniff9wFMP4.cap
+```
+
+### Generate PSKs
+
+You can use the `airport -P` command to generate a PSK:
+
+```ruby
+require 'willow_run'
+
+WillowRun::GeneratePsk.new.generate(:ssid => "cats", :password => "dogs")
+# => "4e471f8d03afeca8a9d27f6a6358294ce0e89543880fad99498ac457e0b09341"
+``` 
+
+### Currect Access Point Information
+
+You can use the `airprot -I` command to get current wireless status, e.g. signal info, BSSID, port type etc:
+
+```ruby
+require 'willow_run'
+
+# get current wireless status
+info = WillowRun::Status.new.getinfo
+
+# note: osx/macOS totally fails and gives invalid/faulty BSSID values for this command
+info.bssid
+# => "6c:b0:ce:0b:ec:56"
+
+# but generally, everything is fine and dandy!
+info.ssid
+# => "NETGEAR52"
+
+# and things should generally be Integers when appropriate
+info.channel
+# => 11
+
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "willow_run"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/all_ssid_strs.rb

@@ -0,0 +1,21 @@
+$: << File.expand_path("../../lib", __FILE__)
+require 'willow_run'
+
+# make new scanner object
+scanner = WillowRun::Scanner.new
+
+# scan with that scanner object
+# but only get the first access point
+# if it exists
+ap_data = scanner.scan
+
+unless ap_data.empty?
+  ap_data.each do |access_point|
+    puts access_point.data.ssid_str
+  end
+else
+  puts "Unable to find any access points!"
+  exit 1  
+end
+
+

data/examples/all_ssid_strs_and_bssids.rb

@@ -0,0 +1,25 @@
+$: << File.expand_path("../../lib", __FILE__)
+require 'willow_run'
+
+# make new scanner object
+scanner = WillowRun::Scanner.new
+
+# scan with that scanner object
+# but only get the first access point
+# if it exists
+ap_data = scanner.scan
+
+unless ap_data.empty?
+  puts "-" * 40
+  puts "%-20s |\t%s" % [ "BSSID", "SSID" ]
+  puts "-" * 40
+  ap_data.each do |access_point|
+    data = access_point.data
+    puts "%-20s |\t%s" % [ data.bssid, data.ssid_str ]
+  end
+else
+  puts "Unable to find any access points!"
+  exit 1  
+end
+
+

data/examples/current_connected_ap_data.rb

@@ -0,0 +1,23 @@
+$: << File.expand_path("../../lib", __FILE__)
+require 'willow_run'
+
+# get current wireless status, e.g. signal info, BSSID, port type etc.
+info = WillowRun::Status.new.getinfo
+
+# print out that information all purtty like
+# closely mimics the `airport -I` command
+puts "agrCtlRSSI      : " + info.agrctlrssi.to_s
+puts "agrExtRSSI      : " + info.agrextrssi.to_s
+puts "agrCtlNoise     : " + info.agrctlnoise.to_s
+puts "agrExtNoise     : " + info.agrextnoise.to_s
+puts "state           : " + info.state.to_s
+puts "op mode         : " + info.op_mode.to_s
+puts "lastTxRate      : " + info.lasttxrate.to_s
+puts "maxRate         : " + info.maxrate.to_s
+puts "lastAssocStatus : " + info.lastassocstatus.to_s
+puts "802.11 auth     : " + info.wifi_auth.to_s
+puts "link auth       : " + info.link_auth.to_s
+puts "BSSID           : " + info.bssid.to_s
+puts "SSID            : " + info.ssid.to_s
+puts "MCS             : " + info.mcs.to_s
+puts "channel         : " + info.channel.to_s

data/examples/example.rb

@@ -0,0 +1,5 @@
+$: << File.expand_path("../../lib", __FILE__)
+require 'willow_run'
+require 'pry'
+
+binding.pry

data/examples/first_ap_data.rb

@@ -0,0 +1,23 @@
+$: << File.expand_path("../../lib", __FILE__)
+require 'willow_run'
+
+# make new scanner object
+scanner = WillowRun::Scanner.new
+
+# scan with that scanner object
+# but only get the first access point
+# if it exists
+ap = scanner.scan[0] || false
+
+# if there is any data to work with
+if ap
+  ap.data.each_pair do |key,value|
+    puts "#{key} : #{value}"
+  end
+else
+  # otherwise just error out
+  puts "Unable to find any access points!"
+  exit 1  
+end
+
+

data/examples/simple_sniffer.rb

@@ -0,0 +1,14 @@
+$: << File.expand_path("../../lib", __FILE__)
+require 'willow_run'
+
+# make new sniffer object
+sniffer = WillowRun::Sniffer.new
+
+# start sniffing
+# The default timeout after 5 seconds
+# has been set to 10 seconds.
+sniffer.sniff(:timeout => 10)
+
+# get the capture file path that was generated
+sniffer.file
+# => /tmp/airportSniff9wFMP4.cap

data/lib/willow_run.rb

@@ -0,0 +1,52 @@
+require 'ostruct'
+require 'plist'
+require 'open3'
+require 'socket'
+require 'packetfu'
+require 'plist'
+require "willow_run/airport"
+require "willow_run/access_point"
+require "willow_run/generate_psk"
+require "willow_run/scanner"
+require "willow_run/sniffer"
+require "willow_run/parser"
+require "willow_run/status"
+require "willow_run/errors"
+require "willow_run/version"
+
+module WillowRun
+ 
+  # find_the_airport?() will help determine if the airport
+  # Mach-O 64-bit executable is avaiable to us or not. 
+  def self.find_the_airport?
+    File.exist?(AIRPORT) ? true : false
+  end
+   
+  # take_off?() can help determine if the airport
+  # command is accessible or not if we run it.
+  def self.take_off?
+    Open3.capture2(AIRPORT).last.success?
+  end
+
+  # set_channel() allows a user to set a
+  # arbitrary channel on the card.
+  def self.set_channel(channel)
+    o, s = Open3.capture2("#{AIRPORT} -c #{channel}")
+    s.success? ? true : false
+  end
+
+  # disassociate() allows a user to simply
+  # disassociate from any network, requiring
+  # root/sudo privilleges
+  def self.disassociate
+    unless Process.uid == 0
+      o, s = Open3.capture2("#{AIRPORT} -z")
+      unless o == "root required to disassociate\n"
+        return true
+      end
+      raise WillowRunError.new(o)
+      false  
+    end
+  end
+
+end

data/lib/willow_run/access_point.rb

@@ -0,0 +1,37 @@
+module WillowRun
+
+  # AccessPoint maintains the logic to do with
+  # the access points found during a scan. Data
+  # asccoiated with an access point is avaiable via
+  # the data attr_accessor associated with it.
+  #
+  # == Example
+  #
+  #  # Typical use
+  #  ap = AccessPoint(xml_pist_data_from_scan)
+  #  # access that access point's data
+  #  ap.data
+  #  # get the bssid of the access point
+  #  ap.data.bssid
+  #  # => "6c:b0:ce:b:ec:56"
+  #  # get the channel of the access point
+  #  ap.data.channel
+  #  # => 11
+  #  # get the ssid string associated with the ap
+  #  ap.data.ssid_str
+  #  # => "NETGEAR53"
+  #
+  class AccessPoint
+    # data contains the OpenStruct data for the AccessPoint
+    attr_accessor :data
+
+    def initialize(xml_plist)
+      # downcase the main keys of the hash to be
+      # able to turn them into methods using OpenStruct
+      struct_data = Hash[xml_plist.map{ |k, v| [k.downcase, v] }]
+      # parse the data by storing data it into an OpenStruct
+      @data = OpenStruct.new(struct_data)
+    end
+  end
+
+end

data/lib/willow_run/airport.rb

@@ -0,0 +1,4 @@
+module WillowRun
+  # path to the airport command
+  AIRPORT='/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport'
+end

data/lib/willow_run/errors.rb

@@ -0,0 +1,18 @@
+module WillowRun
+
+	# WillowRunError handles the custom error handling for this Gem
+  #
+  # == Example
+  #
+  #  # Typical use case
+  #  raise WillowRunError.new("This is a custom error!")
+  #
+	class WillowRunError < StandardError
+    attr_reader :problem
+    def initialize(problem="Willow Run seems to have encountered a problem.")
+      @problem = problem
+      super(@problem)
+    end
+  end
+
+end

data/lib/willow_run/generate_psk.rb

@@ -0,0 +1,36 @@
+module WillowRun
+
+  class GeneratePsk 
+    # contains the generated PSK when avaiable.
+    attr_reader :psk
+    
+    # generate() will generate a PSK from 
+    # a specified pass phrase and SSID passed in
+    # as a hash.
+    #
+    # == Example
+    #
+    #  # Typical use
+    #  WillowRun::GeneratePsk.new.generate(:ssid => "dogs", :password => "cats")
+    #  # => "ddd3da4ed028b81de13ed6ec53238838755bf44e69365cc6453cdcb65d42406f"
+    # 
+    def generate(opts)
+      if opts
+        if opts[:ssid] and opts[:password]
+          o, s = Open3.capture2("#{AIRPORT} -P --ssid #{opts[:ssid]} --password #{opts[:password]}")
+          if s.success?
+            @psk = o.strip
+          else
+            raise WillowRunError.new("Unable to generate psk with SSID: #{opts[:ssid]} and PASSWORD: #{opts[:password]}")
+          end
+        else
+          raise WillowRunError.new("Unable to generate psk, requires both an ssid and password; only got: #{opts}.")
+        end
+      else
+        raise WillowRunError.new("Unable to generate psk, requires both an ssid and password.")
+      end
+      @psk
+    end
+  end
+
+end

data/lib/willow_run/parser.rb

@@ -0,0 +1,61 @@
+module WillowRun
+
+  # Parser contains the logic to do with parsing xml/plist
+  # data for this gem. The parsed data is avaiable via
+  # the data attribute which should contain an array
+  # of AccessPoint objects after parsing. 
+  # 
+  # == Example
+  #
+  #  # Typical use for the Parser class
+  #  parser = WillowRun::Parser.new
+  #  data = parser.parse(plist_xml_data)
+  # 
+  class Parser 
+    # You can either create a parser object with
+    # or without data when it is iniatilized. 
+    def initialize(data=false)
+      parse(data) if data
+    end
+
+    # parse() handles the parsing of the general 
+    # data associated with this gem where appropriate
+    def parse(data)
+      if data.is_a? Sniffer
+        parse_sniffer_data(data) 
+      else
+        # The preferred way to store property lists on
+        # OS X and iOS is as an XML file called an
+        # XML property list or XML plist.
+        parse_plist_xml(data)
+      end
+    end
+
+    private
+
+    # parse_plist_xml() hanldes the plist xml format
+    # that actually is parse behind the seens to make the
+    # parse method prettier really. 
+    def parse_plist_xml(data)
+      # Parse the xml with Plist and iterate over each
+      # access point by creating a new access point.
+      parsed_data = []
+      Plist::parse_xml(data).each do |ap_info|
+        ap = AccessPoint.new(ap_info)
+        parsed_data << ap
+      end
+      parsed_data
+    end
+
+    # parse_sniffer_data() handles the tcpdump format
+    # that is generated by the airport's sniffing 
+    # ability using usual pcap tools.
+    def parse_sniffer_data(data)
+      # note: will not be able to parse every thing...
+      # better than ruby-pcap which just fails for pcap
+      # things it dosen't know how to handle.
+      PacketFu::PcapFile.file_to_array data.file
+    end
+  end
+
+end

data/lib/willow_run/scanner.rb

@@ -0,0 +1,30 @@
+module WillowRun
+
+  class Scanner
+    def initialzie(opts=false)
+      if opts[:scan]
+        if opts[:ssid]
+          scan(opts[:ssid])
+        else
+          scan
+        end
+      end
+      true
+    end
+
+    def scan(ssid="")
+      o, s = Open3.capture2("#{AIRPORT} -x -s '#{ssid}'")
+      manage_output(o, s)
+    end 
+
+    def manage_output(stdout, status)
+      if status.success?
+        Parser.new.parse(stdout)
+      else
+        # custom error?
+        false
+      end 
+    end
+  end
+
+end

data/lib/willow_run/sniffer.rb

@@ -0,0 +1,130 @@
+module WillowRun
+
+  # Sniffing contains the logic to do with sniffing
+  # 802.11 frames on an interface using the airport
+  # command's sniff verb.
+  # 
+  # == Example
+  #
+  #  # Typical use for the Parser class
+  #  sniffer = WillowRun::Sniffer.new
+  #  # sniff for 30 seconds
+  #  sniffer.sniff(:time => 30)
+  #  
+  class Sniffer 
+    # file contains the path to the tcpdump capture file
+    # version 2.4, 802.11 with radiotap header
+    attr_accessor :file
+    # pcap contains the parsed tcpdump data
+    attr_accessor :pcap
+    # interface is the interface to capture on
+    attr_accessor :interface
+
+    # You can either create a parser object with
+    # or without data when it is iniatilized. 
+    def initialize(opts=false)
+      if opts
+        if opts[:file]
+          unless File.exists?(opts[:file])
+            raise WillowRunError.new("#{opts[:file]} doesn't seem to exist!")
+          else
+            @file = opts[:file]
+          end
+          return true
+        end
+        if opts[:sniff]
+          if opts[:channel] and opts[:interface]
+            sniff(opts[:channel],opts[:interface])
+          elsif opts[:interface]
+            sniff("",opts[:interface])
+          elsif opts[:channel]
+            sniff(opts[:channel])
+          else
+            sniff
+          end
+        end
+      end
+      true
+    end
+
+    # sniff() alllows the capturing packets, as long as
+    # the process as the correct privelleges. Optionally,
+    # a set of options can be passed in as a hash to set
+    # custom parameters for the sniffing. A default of 5
+    # seconds has been given to the sniff method, whereafter
+    # the sniffing will stop / the process PID be killed.
+    def sniff(opts=false)
+      if Process.uid == 0
+        if opts
+          interface = opts[:interface] if opts[:interface]
+          channel = opts[:channel] if opts[:channel]
+          timeout = opts[:timeout] if opts[:timeout]
+        end
+        interface = default_interface unless interface
+        channel = "" unless channel
+        timeout = 5 unless timeout
+        stdin, stdout, stderr, wait_thr = Open3.popen3("#{AIRPORT} #{interface} sniff #{channel}")
+        sleep(timeout.to_i)
+        if Process.kill("KILL", wait_thr.pid)
+          @file = determine_cap_file
+          @pcap = Parser.new.parse(self)
+        else
+          raise WillowRunError.new("unable to kill pid #{wait_thr.pid}")
+        end
+      else
+        raise WillowRunError.new("sniffing must be done with root!")
+      end
+      self
+    end
+
+    # Determine the default ip address, taken from packetfu's utils.rb
+    def default_ip
+      begin
+        orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true  # turn off reverse DNS resolution temporarily
+        UDPSocket.open do |s|
+          s.connect rand_routable_daddr.to_s, rand_port
+          s.addr.last
+        end
+      ensure
+        Socket.do_not_reverse_lookup = orig
+      end
+    end
+
+    # Determine the default routeable interface, taken from packetfu's utils.rb
+    def default_interface
+      ip = default_ip
+      Socket.getifaddrs.each do |ifaddr|
+        next unless ifaddr.addr.ip?
+        return ifaddr.name if ifaddr.addr.ip_address == ip
+      end
+      # Fall back to libpcap as last resort
+      return Pcap.lookupdev
+    end
+
+    private
+
+    # Since 177/8 is IANA reserved (for now), this network should
+    # be handled by your default gateway and default interface.
+    # Taken from packetfu's utils.rb logic.
+    def rand_routable_daddr
+      IPAddr.new((rand(16777216) + 2969567232), Socket::AF_INET)
+    end
+
+    # A helper for getting a random port number, taken from packetfu's utils.rb
+    def rand_port
+      rand(0xffff-1024)+1024
+    end
+
+    # Since the airport command on Apple's part has no easy way to access 
+    # the file name/path for the pcap that is generated during
+    # the sniffing process. By default, and without any options, the
+    # pcap file will be generated in /tmp as *.cap file with a random
+    # name associated with it.
+    def determine_cap_file
+      # We use the most recently modified file, best we can really
+      # do in this case.
+      Dir.glob("/tmp/*.cap").max_by {|f| File.mtime(f)}
+    end
+  end
+
+end

data/lib/willow_run/status.rb

@@ -0,0 +1,31 @@
+module WillowRun
+	class Status
+    # data contains information about the wireless status, 
+    # e.g. signal info, BSSID, port type etc. provided 
+    # by the airport command.
+    attr_reader :data
+    
+    # getinfo() get the current information associated
+    # with the access point that the computer is already
+    # connected to. 
+    def getinfo
+      o, s = Open3.capture2("#{AIRPORT} -I")
+      if s.success?
+        data = o.split("\n").map(&:strip)
+        hashed_data = {}
+        data.each do |info|
+          key, value = info.gsub(' ','_').split(":_")
+          key = key.gsub(':','').gsub('.','').downcase
+          key = "wifi_auth" if key == "80211_auth"
+          value = Integer(value) rescue value
+          hashed_data[key] = value
+        end
+        @data = OpenStruct.new(hashed_data) 
+      else
+        # custom error?
+        return false
+      end
+      @data
+    end
+  end
+end

data/lib/willow_run/version.rb

@@ -0,0 +1,3 @@
+module WillowRun
+  VERSION = "1.0.0"
+end

data/willow_run.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'willow_run/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "willow_run"
+  spec.version       = WillowRun::VERSION
+  spec.authors       = ["Kent Gruber"]
+  spec.email         = ["kgruber1@emich.edu"]
+
+  spec.summary       = %q{Willow Run is a Ruby API to the macOS/OSX airport command providing various wireless utilities.}
+  spec.description   = %q{Willow Run is a Ruby API to the macOS/OSX airport command providing various wireless utilities. The airport command manages 802.11 interfaces, can perform wireless broadcast scans ( with xml/plist output support ), set arbitrary channels on the interface, and even generate PSKs from specified pass phrases and SSIDs -- all from the command-line, which I really love. }
+  spec.homepage      = "https://github.com/picatz/Willow-Run"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "plist"
+  spec.add_dependency "packetfu"
+  
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: willow_run
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kent Gruber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: plist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: packetfu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 'Willow Run is a Ruby API to the macOS/OSX airport command providing
+  various wireless utilities. The airport command manages 802.11 interfaces, can perform
+  wireless broadcast scans ( with xml/plist output support ), set arbitrary channels
+  on the interface, and even generate PSKs from specified pass phrases and SSIDs --
+  all from the command-line, which I really love. '
+email:
+- kgruber1@emich.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/all_ssid_strs.rb
+- examples/all_ssid_strs_and_bssids.rb
+- examples/current_connected_ap_data.rb
+- examples/example.rb
+- examples/first_ap_data.rb
+- examples/simple_sniffer.rb
+- lib/willow_run.rb
+- lib/willow_run/access_point.rb
+- lib/willow_run/airport.rb
+- lib/willow_run/errors.rb
+- lib/willow_run/generate_psk.rb
+- lib/willow_run/parser.rb
+- lib/willow_run/scanner.rb
+- lib/willow_run/sniffer.rb
+- lib/willow_run/status.rb
+- lib/willow_run/version.rb
+- willow_run.gemspec
+homepage: https://github.com/picatz/Willow-Run
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Willow Run is a Ruby API to the macOS/OSX airport command providing various
+  wireless utilities.
+test_files: []