sniffer.h

Go to the documentation of this file.

#ifndef SNIFF_SNIFFER
#define SNIFF_SNIFFER
 
#include "access_point.h"
#include "decrypter.h"
#include "net_card_manager.h"
#include "recording.h"
#include "uuid.h"
#include <tins/network_interface.h>
#include <tins/sniffer.h>
#include <unordered_map>
 
namespace yarilo {
 
enum ScanMode {
  FOCUSED, // We are focused on one network and following its channel
  GENERAL  // We are hopping through the spectrum
};
 
class Sniffer {
public:
  typedef std::pair<MACAddress, SSID> network_name;
  static MACAddress NoAddress;
 
  Sniffer(std::unique_ptr<Tins::FileSniffer> sniffer,
          const std::filesystem::path &filepath);
 
  Sniffer(std::unique_ptr<Tins::Sniffer> sniffer,
          const Tins::NetworkInterface &iface);
 
  void start();
 
  std::set<network_name> all_networks();
 
  std::optional<MACAddress> get_bssid(const SSID &ssid);
 
  std::optional<std::shared_ptr<AccessPoint>> get_network(const SSID &ssid);
 
  std::optional<std::shared_ptr<AccessPoint>>
  get_network(const MACAddress &bssid);
 
  void add_ignored_network(const SSID &ssid);
 
  void add_ignored_network(const MACAddress &bssid);
 
  std::unordered_map<MACAddress, SSID> ignored_networks();
 
  void shutdown();
 
  std::optional<std::string> iface();
 
  std::optional<std::filesystem::path> file();
 
  std::optional<uint32_t> focus_network(const SSID &ssid);
 
  std::optional<uint32_t> focus_network(const MACAddress &bssid);
 
  std::optional<std::shared_ptr<AccessPoint>> focused_network();
 
  void stop_focus();
 
  std::optional<Recording::info>
  save_traffic(const std::filesystem::path &save_path, const std::string &name);
 
  std::optional<Recording::info>
  save_decrypted_traffic(const std::filesystem::path &save_path,
                         const std::string &name);
 
  static std::vector<Recording::info>
  available_recordings(const std::filesystem::path &save_path);
 
  static bool recording_exists(const std::filesystem::path &save_path,
                               const uuid::UUIDv4 &uuid);
 
  static std::optional<std::unique_ptr<PacketChannel>>
  get_recording_stream(const std::filesystem::path &save_path,
                       const uuid::UUIDv4 &uuid);
 
  static std::optional<std::string>
  detect_interface(std::shared_ptr<spdlog::logger> log,
                   const std::string &ifname);
 
  ~Sniffer() {
    if (!filemode)
      net_manager.disconnect();
  }
 
private:
  bool handle_pkt(Tins::Packet &pkt);
 
  bool handle_data(Tins::Packet &pkt);
 
  bool handle_management(Tins::Packet &pkt);
 
  Tins::Packet *save_pkt(Tins::Packet &pkt);
 
  void hopper(int phy_idx, const std::vector<uint32_t> &channels);
 
  std::shared_ptr<spdlog::logger> logger;
  std::vector<Tins::Packet> packets;
  std::atomic<ScanMode> scan_mode = GENERAL;
 
  NetCardManager net_manager;
  MACAddress focused;
  bool filemode = true;
  int count = 0;
  int current_channel = 1;
  std::unique_ptr<Tins::Crypto::WPA2Decrypter> decrypter;
  std::unordered_map<MACAddress, std::shared_ptr<AccessPoint>> aps;
  Tins::NetworkInterface send_iface;
  std::string iface_name = "";
  std::filesystem::path filepath;
  std::unordered_map<MACAddress, SSID> ignored_nets;
  std::unique_ptr<Tins::BaseSniffer> sniffer;
  std::atomic<bool> finished;
};
 
} // namespace yarilo
 
#endif // SNIFF_SNIFFER