include/wipal/filter/anon_policies.hh

/*
 * 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_ANON_POLICIES_HH_
# define FILTER_ANON_POLICIES_HH_

# include <map>
# include <set>

# ifdef HAVE_OPENSSL
#  include <openssl/evp.h>
# endif // HAVE_OPENSSL

# include <boost/array.hpp>
# include <boost/scoped_ptr.hpp>

# include <wipal/tool/mapping.hh>
# include <wipal/wifi/addr.hh>
# include <wipal/wifi/essid.hh>

namespace wpl
{

  namespace wifi
  {

    namespace anon
    {

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

      namespace internals
      {

        struct ppmp_mapping_factory
        {
          typedef std::map<addr, addr>                  mac_map;

          addr                  new_value(const addr&           a,
                                          const mac_map&        );
          void                  value_loaded(const addr&        ,
                                             const addr&        a,
                                             const mac_map&     );

        private:
          std::set<addr>        values_;
        };

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


      struct prefix_preserving_mac_policy:
        public tool::mapping<addr, addr, internals::ppmp_mapping_factory>
      {
        typedef tool::mapping<addr, addr, internals::ppmp_mapping_factory>
                super_type;

        prefix_preserving_mac_policy(const std::string& mapname = "MAC.map");
      };

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

      namespace internals
      {

        struct ppep_mapping_factory
        {
          typedef std::map<essid, essid>        essid_map;

          ppep_mapping_factory();

          essid new_value(const essid&          e,
                          const essid_map&      m);
          void  value_loaded(const essid&       from,
                             const essid&       to,
                             const essid_map&   );
        private:
          // Forward declaration.
          struct node;

          std::pair<std::string, node*>
          longest_anonymized_prefix(const essid& orig_essid);


          /*------.
          | Nodes |
          `------*/

          struct node
          {
            node*                       child(unsigned char c);
            std::pair<char, node*>      add_valued_child(unsigned char c);
            node*                       add_valued_child(unsigned char c,
                                                         unsigned char value);

            virtual                     ~node();

          private:
            static unsigned char        rand_extended();
            static unsigned char        rand_alnum();
            static unsigned char        rand_print();
            static unsigned char        rand_other();
            static unsigned char        rand_same_class(unsigned char c);

          private:
            boost::array<boost::scoped_ptr<node>, 256>  children_;
            std::set<char>                              children_values_;
          };

          struct valued_node: public node
          {
            valued_node(char value);

            char                value;
          };

          /*--------------------------------.
          | ppep_mapping_factory attributes |
          `--------------------------------*/

          boost::shared_ptr<node>       root_;
        };

      } // End of namespace internals.

      struct prefix_preserving_essid_policy:
        public tool::mapping<essid, essid, internals::ppep_mapping_factory>
      {
        typedef tool::mapping<essid, essid, internals::ppep_mapping_factory>
                super_type;

        prefix_preserving_essid_policy(const std::string&
                                         mapname = "ESSID.map");
      };

# ifdef HAVE_OPENSSL

      /*--------------------------------.
      | Base compounds for XOR policies |
      `--------------------------------*/

      namespace internals
      {

        template <class Type, size_t Len>
        struct xor_policy
        {
          xor_policy(const uint8_t* mask, const std::string& seed);
          xor_policy(const xor_policy&);
          ~xor_policy();

          xor_policy&   operator = (const xor_policy&);
          const Type&   operator [] (const Type& x);

        private:
          typedef std::map<Type, Type>          cache_type;

          const uint8_t*        mask_;
          EVP_MD_CTX            seed_ctx_;
          cache_type            cache_;
        };

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

      /*---------------.
      | XOR MAC policy |
      `---------------*/

      struct xor_mac_policy: public internals::xor_policy<addr, sizeof (addr)>
      {
        typedef internals::xor_policy<addr, sizeof (addr)>      super_type;

        xor_mac_policy(const std::string& seed);

        const addr&     operator [] (const addr& x);

      private:
        static const uint8_t    mask_[];
      };

      /*-----------------.
      | XOR ESSID policy |
      `-----------------*/

      struct xor_essid_policy: public internals::xor_policy<essid, 32>
      {
        typedef internals::xor_policy<essid, 32>        super_type;

        xor_essid_policy(const std::string& seed);

      private:
        static const uint8_t    mask_[];
      };

# endif // HAVE_OPENSSL

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

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

# include "anon_policies.hxx"

#endif // ! FILTER_ANON_POLICIES_HH_

---