include/wipal/filter/anonymizer.hxx

/*
 * WiPal - A library and a set of tools to manipulate wireless traces.
 * Copyright (C) 2008, 2009  Universite Pierre et Marie Curie - Paris 6
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA  02110-1301  USA
 *
 * Author: Thomas Claveirole <thomas.claveirole@lip6.fr>
 */
#ifndef FILTER_ANONYMIZER_HXX_
# define FILTER_ANONYMIZER_HXX_

# include <cassert>
# include <stdexcept>

# include <boost/foreach.hpp>
# include <boost/lexical_cast.hpp>

# include <wipal/wifi/dissector/dissector.hh>

# include "anonymizer.hh"

namespace wpl
{
  namespace wifi
  {

    /*-----------------------.
    | Anonymization policies |
    `-----------------------*/

    namespace anon
    {

      inline
      addr
      dummy_mac_policy::operator [] (const addr& mac_addr) const
      {
        return mac_addr;
      }

      inline
      essid
      dummy_essid_policy::operator [] (const essid& essid) const
      {
        return essid;
      }

      template <class MACAnonPolicy, class ESSIDAnonPolicy>
      generic_policy<MACAnonPolicy, ESSIDAnonPolicy>::
      generic_policy(const MACAnonPolicy&       macp,
                     const ESSIDAnonPolicy&     essidp):
        MACAnonPolicy (macp),
        ESSIDAnonPolicy (essidp)
      {
      }

      template <class MACAnonPolicy, class ESSIDAnonPolicy>
      addr
      generic_policy<MACAnonPolicy, ESSIDAnonPolicy>::
      operator [] (const addr& mac_addr)
      {
        return MACAnonPolicy::operator [] (mac_addr);
      }

      template <class MACAnonPolicy, class ESSIDAnonPolicy>
      essid
      generic_policy<MACAnonPolicy, ESSIDAnonPolicy>::
      operator [] (const essid& essid)
      {
        return ESSIDAnonPolicy::operator [] (essid);
      }

    } // End of namespace wpl::wifi::anon.


    namespace internals
    {

      /*----------------.
      | anonymize_addrs |
      `----------------*/

      template <class AnonPolicy>
      void
      anonymize_addrs(AnonPolicy&                               anon_policy,
                      void* const                               bytes,
                      const std::set<const wifi::addr*>&        addrs)
      {
        uint8_t* const  bytes_u8 = static_cast<uint8_t*> (bytes);

        BOOST_FOREACH(const wifi::addr* a, addrs)
          {
            const uint8_t* const  a_u8 = reinterpret_cast<const uint8_t*> (a);
            const ptrdiff_t       offset = a_u8 - bytes_u8;
            wifi::addr* const     a2 = reinterpret_cast<wifi::addr*> (bytes_u8 +
                                                                      offset);
            *a2 = anon_policy[*a];
          }
      }

      /*---------------.
      | anonymize_ssid |
      `---------------*/

      template <class AnonPolicy>
      size_t
      anonymize_ssid(AnonPolicy&                        anon_policy,
                     const size_t                       anon_caplen,
                     const pkt::metadata&               meta,
                     void* const                        bytes,
                     const wifi::ssid_elt* const        ssid,
                     const std::string* const           pkt_id)
      {
        if (not ssid)
          return anon_caplen;

        const std::string       msg_pfx = pkt_id? *pkt_id + ": ": "";

        if (ssid->elt_id != 0)
          {
            std::cerr << msg_pfx << "SSID element ID not found, skipping ("
                      << unsigned (ssid->elt_id) << " instead of 0)."
                      << std::endl;
            return anon_caplen;
          }

        uint8_t* const          bytes_u8 = static_cast<uint8_t*> (bytes);
        const size_t            caplen = meta.caplen;
        const ptrdiff_t         ssid_offset = ssid->ssid - bytes_u8;
        size_t                  ssid_len = ssid->length;

        if (ssid_offset > ptrdiff_t (anon_caplen))
          return anon_caplen;

        if (ssid_len > 32)
          {
            std::cerr << msg_pfx << "Invalid SSID length of "  << ssid_len
                      << ", truncating frame (should be between 0 and 32)."
                      << std::endl;
            return ssid_offset;
          }

        if (ssid->ssid + ssid_len > bytes_u8 + caplen)
          {
            std::cerr << msg_pfx
                      << "SSID overruns captured bytes, truncating."
                      << std::endl;
            ssid_len = caplen - ssid_offset;
          }

        const essid     ssid_str (*ssid, ssid_len);
        essid           anon_ssid_str = anon_policy[ssid_str];

        if (anon_ssid_str.size() > ssid_len)
          throw std::runtime_error ("Anonymized ESSID is too big");
        anon_ssid_str.append(ssid_len - anon_ssid_str.size(), '\0');

        if (ssid_offset + ssid_len > anon_caplen)
          ssid_len = anon_caplen - ssid_offset;
        memcpy(bytes_u8 + ssid_offset, anon_ssid_str.data(), ssid_len);

        return anon_caplen;
      }

      /*--------------------.
      | Anonymization hooks |
      `--------------------*/

      inline
      anon_hooks::anon_hooks():
        ty (type::reserved),
        end (0),
        ssid (0)
      {
      }

      inline
      void
      anon_hooks::addr_hook(const void* f, size_t, unsigned n, const addr& a)
      {
        if (n == 1)
          ty = type_of(f);

        addrs.insert(&a);
      }

      inline
      void
      anon_hooks::end_of_frame_headers_hook(const void* f, size_t caplen,
                                            const void* eofh)
      {
        const uint8_t* const    eofh_u8 = static_cast<const uint8_t*> (eofh);
        const uint8_t* const    eof = static_cast<const uint8_t*> (f) + caplen;
        const uint8_t*          tmp_ssid = 0;

        switch (ty)
          {
          case type::data:
            end = eofh_u8;
            break;

          case type::management:
            switch (subtype_of(f))
              {
              case mgt::subtype::assoc_req:
                // 4 == sizeof (Caps. + Listen Interv.)
                tmp_ssid = eofh_u8 + 4;
                break;

              case mgt::subtype::reassoc_req:
                // 10 == sizeof (Caps. + Listen Interv. + Current AP addr.)
                tmp_ssid = eofh_u8 + 10;
                break;

              case mgt::subtype::probe_req:
                tmp_ssid = eofh_u8;
                break;

              case mgt::subtype::probe_resp:
              case mgt::subtype::beacon:
                // 12 == sizeof (Timestamp + Beacon Interv. + Caps.)
                tmp_ssid = eofh_u8 + 12;
                break;
              }
            break;

          default:
            break;
          }
        if (tmp_ssid and tmp_ssid + sizeof (ssid_elt) < eof)
          ssid = reinterpret_cast<const ssid_elt*> (tmp_ssid);
      }

    } // End of namespace wpl::wifi::internals.

    template <class Phy, class AnonPolicy, class S>
    void
    anonymize(AnonPolicy&       anon_policy,
              pkt::packet<S>&   frm)
    {
      const std::string  pkt_str = boost::lexical_cast<std::string> (frm);

      return anonymize<Phy>(anon_policy,
                            frm.meta(), frm.bytes(), frm.swapped(), &pkt_str);
    }

    template <class Phy, class AnonPolicy>
    void
    anonymize(AnonPolicy&               anon_policy,
              pkt::metadata&            meta,
              void*                     bytes,
              const bool                swapped,
              const std::string* const  pkt_str)
    {
      const Phy* const          phy = static_cast<const Phy*> (bytes);
      const size_t              caplen = meta.caplen;
      const size_t              phy_len = phy->len(caplen, swapped);
      const uint8_t* const      mac = (static_cast<const uint8_t*>
                                       (phy->decapsulate(caplen, swapped)));

      wifi::dissector<internals::anon_hooks>    d;
      const internals::anon_hooks&              h = d.hooks();

      if (mac) // MAC will be null if PHY header is truncated.
        {
          assert(caplen >= phy_len);
          d(mac, caplen - phy_len);
        }

      const size_t  anon_caplen = h.end? phy_len + (h.end - mac): caplen;

      internals::anonymize_addrs(anon_policy, bytes, h.addrs);
      meta.caplen = internals::anonymize_ssid(anon_policy, anon_caplen,
                                              meta, bytes, h.ssid, pkt_str);
    }

  } // End of namespace wpl::wifi.

  namespace filter
  {

    namespace internals
    {

      /*--------------------.
      | anonymizer_iterator |
      `--------------------*/

      template <class I, class P,  class A, class B1, class B2>
      anonymizer_iterator<I, P, A, B1, B2>::
      anonymizer_iterator(const iterable_type& iterable, bool end):
        A (iterable),
        next_ (end? iterable.last_ : iterable.first_),
        last_ (iterable.last_)
      {
        if (not end)
          increment();
      }

      template <class I, class P,  class A, class B1, class B2>
      bool
      anonymizer_iterator<I, P, A, B1, B2>::
      equal(const anonymizer_iterator& rhs) const
      {
        if (not rhs.value())
          return not this->value();

        return next_ == rhs.next_;
      }

      template <class I, class P,  class A, class B1, class B2>
      void
      anonymizer_iterator<I, P, A, B1, B2>::increment()
      {
        if (next_ == last_)
          this->value() = boost::none_t ();
        else
          {
            boost::optional<value_type>& v = this->value();

            if (not v or not v->unique())
              v = value_type (next_->meta());
            else
              v->meta() = next_->meta();
            memcpy(v->bytes(), next_->bytes(), next_->meta().caplen);
            wifi::anonymize<P, A>(*this, *v);
            ++next_;
          }
      }

    } // End of namespace wpl::filter::internals.


    template <class I, class P, class A, class B>
    anonymizer<I, P, A, B>::anonymizer(const I& first, const I& last,
                                       const A& anon_policy):
      A (anon_policy),
      first_ (first),
      last_ (last)
    {
    }

    template <class I, class P, class A, class B>
    bool
    anonymizer<I, P, A, B>::swapped_impl() const
    {
      if (first_ == last_)
        return false;

      return first_->swapped();
    }


  } // End of namespace wpl::filter.

} // End of namespace wpl.

#endif // ! FILTER_ANONYMIZER_HXX_

---