include/wipal/filter/anon_policies.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 ANON_POLICIES_HXX_
# define ANON_POLICIES_HXX_

# include <cstdlib>
# include <memory>

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

# include "anon_policies.hh"

namespace wpl
{

  namespace wifi
  {

    namespace anon
    {

      namespace internals
      {

        /*-----------------------------.
        | Prefix preserving MAC policy |
        `-----------------------------*/

        inline
        addr
        ppmp_mapping_factory::new_value(const addr&     a,
                                        const mac_map&  )
        {
          addr  r (a);

          if (a != addr::null() and a != addr::broadcast())
            {
              do
                {
                  for (unsigned i = 3; i < 6; ++i)
                    r[i] = rand();
                }
              while (values_.count(r));
            }

          values_.insert(r);
          return r;
        }

        inline
        void
        ppmp_mapping_factory::value_loaded(const addr&          ,
                                           const addr&          a,
                                           const mac_map&       )
        {
          values_.insert(a);
        }

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

      inline
      prefix_preserving_mac_policy::
      prefix_preserving_mac_policy(const std::string& mapname):
        super_type(mapname)
      {
      }

      namespace internals
      {

        /*-------------------------------.
        | Prefix preserving ESSID policy |
        `-------------------------------*/

        inline
        ppep_mapping_factory::ppep_mapping_factory(): root_ (new node)
        {
        }

        inline
        essid
        ppep_mapping_factory::new_value(const essid&            e,
                                        const essid_map&        )
        {
          using boost::ref;

          std::string   r;
          node*         n;

          make_tuple(ref(r), ref(n)) = longest_anonymized_prefix(e);

          assert(r.size() <= e.size());
          for (size_t i = r.size(); i < e.size(); ++i)
            {
              char      c;

              make_tuple(ref(c), ref(n)) = n->add_valued_child(e[i]);
              r.push_back(c);
            }
          return r;
        }

        inline
        void
        ppep_mapping_factory::value_loaded(const essid&         from,
                                           const essid&         to,
                                           const essid_map&     )
        {
          if (from.size() != to.size())
            throw std::invalid_argument ("Invalid ESSID mapping");

          node* n = root_.get();

          for (size_t i = 0; i < from.size(); ++i)
            {
              assert(n);

              const char&       c = from[i];
              node* const       t = n->child(c);

              n = t? t: n->add_valued_child(c, to[i]);
            }
        }

        inline
        std::pair<std::string, ppep_mapping_factory::node*>
        ppep_mapping_factory::
        longest_anonymized_prefix(const essid& orig_essid)
        {
          node*         n = root_.get();
          std::string   r;

          BOOST_FOREACH(char c, orig_essid)
            {
              assert(n);

              node*     t = n->child(c);

              if (not t)
                break;
              {
                const valued_node* const  v =
                  dynamic_cast<const valued_node*>(t);

                assert(v);
                r.push_back(v->value);
              }
              n = t;
            }
          return std::make_pair(r, n);
        }

        inline
        ppep_mapping_factory::node*
        ppep_mapping_factory::node::child(unsigned char c)
        {
          return children_[c].get();
        }

        inline
        std::pair<char, ppep_mapping_factory::node*>
        ppep_mapping_factory::node::add_valued_child(unsigned char c)
        {
          assert(not child(c));

          char  new_c;

          do
            new_c = rand_same_class(c);
          while (children_values_.count(new_c));

          children_[c].reset(new valued_node (new_c));
          children_values_.insert(new_c);
          return std::make_pair(new_c, child(c));
        }

        inline
        ppep_mapping_factory::node*
        ppep_mapping_factory::node::add_valued_child(unsigned char c,
                                                     unsigned char v)
        {
          assert(not child(c));
          assert(not children_values_.count(v));

          children_[c].reset(new valued_node (v));
          children_values_.insert(v);
          return child(c);
        }

        inline
        ppep_mapping_factory::node::~node()
        {
        }

        inline
        unsigned char
        ppep_mapping_factory::node::rand_extended()
        {
          unsigned char r;

          do
            r = rand();
          while (r < 128);
          return r;
        }

        inline
        unsigned char
        ppep_mapping_factory::node::rand_alnum()
        {
          unsigned char r;

          do
            r = rand();
          while (r > 127 or not std::isalnum(r));
          return r;
        }

        inline
        unsigned char
        ppep_mapping_factory::node::rand_print()
        {
          unsigned char r;

          do
            r = rand();
          while (r > 127 or std::isalnum(r) or not std::isprint(r));
          return r;
        }

        inline
        unsigned char
        ppep_mapping_factory::node::rand_other()
        {
          unsigned char r;

          do
            r = rand();
          while (r > 127 or std::isprint(r));
          return r;
        }

        inline
        unsigned char
        ppep_mapping_factory::node::rand_same_class(unsigned char c)
        {
          if (c > 127)
            return rand_extended();
          if (std::isalnum(c))
            return rand_alnum();
          if (std::isprint(c))
            return rand_print();
          return rand_other();
        }

        inline
        ppep_mapping_factory::
        valued_node::valued_node(char value): value (value)
        {
        }

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

      inline
      prefix_preserving_essid_policy::
      prefix_preserving_essid_policy(const std::string& mapname):
        super_type (mapname)
      {
      }

      namespace internals
      {

# ifdef HAVE_OPENSSL

        /*-----------.
        | xor_policy |
        `-----------*/

        template <class T, size_t L>
        xor_policy<T, L>::xor_policy(const uint8_t*     mask,
                                     const std::string& seed): mask_ (mask)
        {
          EVP_DigestInit(&seed_ctx_, EVP_sha1());
          EVP_DigestUpdate(&seed_ctx_, seed.data(), seed.size());
        }

        template <class T, size_t L>
        xor_policy<T, L>::xor_policy(const xor_policy& other):
          mask_ (other.mask_),
          cache_ (other.cache_)
        {
          EVP_MD_CTX_copy(&seed_ctx_, &other.seed_ctx_);
        }

        template <class T, size_t L>
        xor_policy<T, L>::~xor_policy()
        {
          EVP_MD_CTX_cleanup(&seed_ctx_);
        }

        template <class T, size_t L>
        xor_policy<T, L>&
        xor_policy<T, L>::operator = (const xor_policy& other)
        {
          if (this == &other)
            return *this;

          mask_ = other.mask_;
          EVP_MD_CTX_cleanup(&seed_ctx_);
          EVP_MD_CTX_copy(&seed_ctx_, other.seed_ctx_);
          cache_ = other.cache_;
          return *this;
        }

        template <class T, size_t L>
        const T&
        xor_policy<T, L>::operator [] (const T& x)
        {
          typedef typename cache_type::iterator iterator;
          typedef std::pair<iterator, bool>     ins_type;

          const ins_type        ins_ret = cache_.insert(std::make_pair(x, x));
          T&                    ret = ins_ret.first->second;

          if (not ins_ret.second)
            return ret;

          const size_t  x_size = x.size();

          for (size_t i = 0; i < x_size; ++i)
            {
              const uint8_t&    mask = mask_[i];

              if (not mask)
                continue;

              uint8_t           md[EVP_MAX_MD_SIZE];
              unsigned          md_len;
              EVP_MD_CTX        md_ctx;

              EVP_MD_CTX_copy(&md_ctx, &seed_ctx_);
              for (int j = int (i) - 1; j >= 0; --j)
                EVP_DigestUpdate(&md_ctx, &x[j], 1);
              EVP_DigestFinal(&md_ctx, md, &md_len);
              assert(md_len);
              ret[i] = ((x[i] xor md[0]) & mask) | (x[i] & ~mask);
            }
          return ret;
        }

# endif // HAVE_OPENSSL

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

# ifdef HAVE_OPENSSL

      /*---------------.
      | xor_mac_policy |
      `---------------*/

      inline
      xor_mac_policy::xor_mac_policy(const std::string& seed):
        super_type (mask_, seed)
      {
      }

      inline
      const addr&
      xor_mac_policy::operator [] (const addr& x)
      {
        if (x == addr::broadcast() or x == addr::null())
          return x;
        return super_type::operator [] (x);
      }

      /*-----------------.
      | xor_essid_policy |
      `-----------------*/

      inline
      xor_essid_policy::xor_essid_policy(const std::string& seed):
        super_type (mask_, seed)
      {
      }

# endif // HAVE_OPENSSL

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

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

#endif // ! ANON_POLICIES_HXX_

---