access_point.h

Go to the documentation of this file.

#ifndef SNIFF_AP
#define SNIFF_AP
 
#include "channel.h"
#include "decrypter.h"
#include "recording.h"
#include <filesystem>
#include <optional>
#include <tins/ethernetII.h>
#include <tins/tins.h>
#include <vector>
 
namespace yarilo {
 
class AccessPoint {
public:
  enum class NetworkSecurity {
    OPEN,
    WEP,
    WPA,
    WPA2_Personal,
    WPA2_Enterprise,
    WPA3_Personal,
    WPA3_Enterprise,
  };
 
  enum class DecryptionState {
    DECRYPTED,
    NOT_ENOUGH_DATA,
    INCORRECT_PASSWORD,
    ALREADY_DECRYPTED,
  };
 
  /*
   * @brief WiFi standard that is supported by an access point, there can be
   * many of them for a given access point
   */
  enum class WiFiStandard {
    Dot11A,  // Legacy standards
    Dot11B,  // Legacy standards
    Dot11G,  // Legacy standards
    Dot11N,  // Wi-Fi 4 or HT (High Throughput)
    Dot11AC, // Wi-Fi 5 or HVT (Very High Throughput)
    Dot11AX, // Wi-Fi 6 or HE (High Efficiency)
  };
 
  /*
   * @brief WiFi modulation type used
   */
  enum class Modulation {
    CCK,   // Complementary code keying (802.11b)
    BPSK,  // Binary phase shift keying
    QPSK,  // Quadrature phase shift keying
    QAM16, // Quadrature amplitude modulation
    QAM64,
    QAM256,
    QAM1024,
  };
 
  /*
   * @brief WiFi channel width used
   */
  enum class ChannelWidth {
    CHAN20,
    CHAN40,
    CHAN80,
    CHAN80_80,
    CHAN160,
  };
 
  struct wifi_standard_info {
    WiFiStandard std;
    bool single_beamformer_support;
    bool single_beamformee_support;
    bool multi_beamformer_support;
    bool multi_beamformee_support;
    std::set<uint8_t> mcs_supported_idx; // Indices of MCS
    std::set<Modulation> modulation_supported;
    std::set<uint8_t>
        spatial_streams_supported; // Spatial stream configurations for MIMO,
                                   // for example 3 means that the network
                                   // supports 3 spatial streams, or 3x3
    std::set<ChannelWidth> channel_widths_supported;
  };
 
  struct client_info {
    std::string hwaddr;
    std::string hostname;
    std::string ipv4;
    std::string ipv6;
    uint32_t sent_unicast;
    uint32_t sent_total;
    uint32_t received;
    int8_t rrsi;
    int8_t noise;
    int8_t snr;
  };
 
  struct client_security {
    NetworkSecurity security;
    bool is_ccmp = false;
    bool pmf = false;
    std::optional<Tins::RSNInformation::CypherSuites> pairwise_cipher;
  };
 
  AccessPoint(const MACAddress &bssid, const SSID &ssid, int wifi_channel);
 
  bool handle_pkt(Tins::Packet *pkt);
 
  DecryptionState add_password(const std::string &psk);
 
  SSID get_ssid() const;
 
  MACAddress get_bssid() const;
 
  int get_wifi_channel() const;
 
  std::vector<wifi_standard_info> standards_supported() const;
 
  std::shared_ptr<PacketChannel> get_decrypted_channel();
 
  void close_all_channels();
 
  bool send_deauth(const Tins::NetworkInterface &iface, const MACAddress &addr);
 
  bool has_working_password() const;
 
  std::vector<NetworkSecurity> security_supported() const;
 
  bool unicast_decryption_supported() const;
 
  bool group_decryption_supported() const;
 
  bool client_decryption_supported(const MACAddress &client);
 
  /*
   * Get if the network can protect its management frames
   * @return True if 802.11w is in place
   */
  bool protected_management_supported() const;
 
  /*
   * Get if the network must protect its management frames
   * @return True if 802.11w is in place
   */
  bool protected_management_required() const;
 
  /*
   * Get if the network protects its management frames for a specific client
   * @return True if 802.11w is enforced for a client
   */
  bool protected_management(const MACAddress &client);
 
  WPA2Decrypter &get_decrypter();
 
  const std::set<MACAddress> get_clients() {
    std::set<MACAddress> result;
    for (const auto &[addr, _] : clients)
      result.insert(addr);
    return result;
  }
 
  const std::optional<client_info> get_client(MACAddress addr) {
    if (!clients.count(addr))
      return std::nullopt;
    return clients[addr];
  }
 
  const std::optional<client_security> get_client_security(MACAddress addr) {
    if (!clients_security.count(addr))
      return std::nullopt;
    return clients_security[addr];
  }
 
  uint32_t raw_packet_count() const;
 
  uint32_t decrypted_packet_count() const;
 
  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);
 
private:
  bool handle_data(Tins::Packet *pkt);
 
  bool handle_management(Tins::Packet *pkt);
 
  void update_client_metadata(const Tins::Packet &pkt);
 
  std::vector<NetworkSecurity>
  detect_security_modes(const Tins::Dot11ManagementFrame &mgmt) const;
 
  std::vector<wifi_standard_info>
  detect_wifi_capabilities(const Tins::Dot11ManagementFrame &mgmt) const;
 
  bool check_pmf_capable(const Tins::Dot11ManagementFrame &mgmt) const;
 
  bool check_pmf_required(const Tins::Dot11ManagementFrame &mgmt) const;
 
  bool is_ccmp(const Tins::Dot11ManagementFrame &mgmt) const;
 
  uint32_t count = 0;
  uint32_t decrypted_pkt_count = 0;
  std::shared_ptr<spdlog::logger> logger;
  const SSID ssid;
  const MACAddress bssid;
  int wifi_channel = 0;
  std::vector<Tins::Packet *> captured_packets;
  WPA2Decrypter decrypter;
  std::vector<std::shared_ptr<PacketChannel>> converted_channels;
  std::vector<wifi_standard_info> wifi_stds_supported;
 
  // Used for deauth, we need to "copy" the behaviour of the radiotap layer
  uint8_t radio_length = 0;
  uint8_t radio_channel_freq = 0;
  uint8_t radio_channel_type = 0;
  uint8_t radio_antenna = 0;
 
  bool capabilities_detected = false;
  std::vector<NetworkSecurity> security_modes;
  bool pmf_supported = false; // 802.11w
  bool pmf_required = false;  // 802.11w
  bool uses_ccmp = false;
  std::unordered_map<MACAddress, client_info> clients;
  std::unordered_map<MACAddress, client_security> clients_security;
};
 
} // namespace yarilo
 
#endif // SNIFF_AP