decrypter.h

Go to the documentation of this file.

#ifndef SNIFF_DECRYPTER
#define SNIFF_DECRYPTER
 
#include <optional>
#include <set>
#include <spdlog/logger.h>
#include <tins/crypto.h>
#include <tins/dot11.h>
#include <tins/eapol.h>
#include <tins/hw_address.h>
#include <tins/packet.h>
#include <tins/pdu.h>
#include <tins/snap.h>
#include <tins/timestamp.h>
#include <vector>
 
namespace yarilo {
 
typedef std::string SSID;
typedef Tins::HWAddress<6> MACAddress;
 
class WPA2Decrypter {
public:
  typedef std::vector<uint8_t> ptk_type;
  typedef std::vector<uint8_t> gtk_type;
 
  struct client_window {
    Tins::Timestamp start;
    Tins::Timestamp end;
    bool ended = false;
    bool decrypted = false;
    MACAddress client;
    std::vector<Tins::Packet *> packets;
    std::vector<Tins::Packet *> auth_packets;
    ptk_type ptk;
  };
 
  struct group_window {
    Tins::Timestamp start;
    Tins::Timestamp end;
    bool ended = false;
    bool decrypted = false;
    std::vector<Tins::Packet *> packets;
    std::vector<Tins::Packet *> auth_packets;
    gtk_type gtk;
  };
 
  WPA2Decrypter(const MACAddress &bssid, const SSID &ssid);
 
  bool decrypt(Tins::Packet *pkt);
 
  bool can_generate_keys() const;
 
  void add_password(const std::string &psk);
 
  bool has_working_password() const;
 
  std::optional<std::string> get_password() const;
 
  std::set<MACAddress> get_clients() const;
 
  std::optional<client_window>
  get_current_client_window(const MACAddress &client);
 
  std::optional<std::vector<client_window>>
  get_all_client_windows(const MACAddress &client);
 
  group_window get_current_group_window() const;
 
  std::vector<group_window> get_all_group_windows() const;
 
  std::optional<std::string> extract_hc22000(const client_window &client);
 
  static std::string readable_hex(const std::vector<uint8_t> &vec);
 
private:
  bool decrypt_unicast(Tins::Packet *pkt, const MACAddress &client);
 
  bool handle_pairwise_eapol(Tins::Packet *pkt, const MACAddress &client);
 
  bool handle_group_eapol(Tins::Packet *pkt, const MACAddress &client);
 
  void try_generate_keys(client_window &window);
 
  bool decrypt_group(Tins::Packet *pkt);
 
  void try_insert_gtk(const gtk_type &gtk, const Tins::Timestamp &ts);
 
  Tins::SNAP *decrypt_group_data(const Tins::Dot11Data &data, Tins::RawPDU &raw,
                                 const gtk_type &gtk) const;
 
  std::optional<gtk_type> exctract_key_data(const Tins::RSNEAPOL &eapol,
                                            const ptk_type &ptk) const;
 
  static std::optional<uint8_t>
  eapol_pairwise_hs_num(const Tins::RSNEAPOL &eapol);
 
  static std::optional<uint8_t> eapol_group_hs_num(const Tins::RSNEAPOL &eapol);
 
  std::shared_ptr<spdlog::logger> logger;
  std::unordered_map<MACAddress, Tins::Packet *> group_rekey_first_messages;
  std::unordered_map<MACAddress, std::vector<Tins::Packet *>> client_handshakes;
  const SSID ssid;
  const MACAddress bssid;
  std::string psk = "";
  bool working_psk = false;
  std::unordered_map<MACAddress, std::vector<client_window>> client_windows;
  std::vector<group_window> group_windows;
  Tins::Crypto::WPA2Decrypter unicast_decrypter;
};
 
} // namespace yarilo
 
#endif // SNIFF_DECRYPTER