From b213ddb515405e3ee66820ff4671413c348cbf57 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 19 Apr 2016 11:57:15 +0300
Subject: [PATCH 01/25] [WebInterface] html - improvements in building the HTML

Fixed issue with multi-line fields.
All javascript-generated HTML is now generated using jquery and not
strings.
---
 kitty/interfaces/web/static/report.html | 165 +++++++++++++++++-------
 1 file changed, 117 insertions(+), 48 deletions(-)

diff --git a/kitty/interfaces/web/static/report.html b/kitty/interfaces/web/static/report.html
index 50ff5f2..f9a08f7 100644
--- a/kitty/interfaces/web/static/report.html
+++ b/kitty/interfaces/web/static/report.html
@@ -35,42 +35,94 @@ <h2 id="report_name"></h2>
 
     <script>
 
-        function toTitleCase(str)
-        {
-            return str.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();}).replace('_', ' ');
+        /* Change a string to title case: 'hEllo wORLD'-> 'Hello World' */
+        function toTitleCase(str) {
+            return str.replace(
+                /\w\S*/g,
+                function(txt) {
+                    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+                }
+            ).replace('_', ' ');
         }
 
-        function sanitizeName(str)
-        {
+        /* Replace "bad" chars with '_' */
+        function sanitizeName(str) {
             return str.replace(/\W+/g, '_');
         }
 
-        function add_to_table(base_name, key, value){
-            if(key != 'sub_reports'){
-                var is_code = false;
-                if((typeof value) == 'string') {
-                    value = window.atob(value);
-                    if(value.indexOf('\n') != -1) {
-                        is_code = true;
-                    }
-                }
-                if(is_code) {
-                    $('<tr>').append($('<td>').text(toTitleCase(key.replace(/_/g, ' '))), $('<td class="textarea-data">').append($('<pre>').text(value))).appendTo($('#' + base_name + '_table'));
-                }
-                else {
-                    $('<tr>').append($('<td>').text(toTitleCase(key.replace(/_/g, ' '))), $('<td class="textarea-data">').text(value)).appendTo($('#' + base_name + '_table'));
-                }
+        /* Decode as base64 if the value is a string */
+        function kunescape(val) {
+            if((typeof val) == 'string') {
+                val = window.atob(val);
             }
+            return val;
         }
-        function fill_table(base_name, report, first_fields){
-            var sub_reports = report.sub_reports;  //JSON.parse(window.atob(report.sub_reports));
-            $.each(first_fields, function(idx, val){
-                v = report[val];
-                if ((typeof v) == 'string') {
-                    v = window.atob(v);
+
+        /* Check if value is a multiline value */
+        function is_multiline(val) {
+            if ((typeof val) == 'string') {
+                if(val.indexOf('\n') != -1) {
+                    return true;
                 }
-                $('#' + base_name + '_' + val).text(v);
-                delete report[val];
+            }
+            return false;
+        }
+
+        /* Generate field id from base name and key */
+        function field_id_from_key(base_name, key) {
+            return base_name + '_' + key;
+        }
+        
+        /* Get field by the table name and the key */
+        function field_by_key(base_name, key) {
+            return $('#' + field_id_from_key(base_name, key));
+        }
+
+        /* Generate table id from base_name */
+        function table_id_from_name(base_name) {
+            return base_name + '_table';
+        }
+
+        /* Get table by the base_name */
+        function table_by_name(base_name) {
+            return $('#' + table_id_from_name(base_name));
+        }
+
+        /* Set a value in a field and return the field */
+        function set_value_in_field(field, value)
+        {
+            value = kunescape(value);
+            if(is_multiline(value)) {
+                field.append($('<pre>').text(value));
+            }
+            else {
+                field.text(value);
+            }
+            return field;
+        }
+        /* Add a field to the table */
+        function add_to_table(base_name, key, value) {
+            if(key != 'sub_reports'){
+                $('<tr>')
+                .append(
+                    $('<td>').text(toTitleCase(key.replace(/_/g, ' '))),
+                    set_value_in_field($('<td class="textarea-data">'), value)
+                )
+                .appendTo(table_by_name(base_name));
+            }
+        }
+
+        /* Set value of existing field in the table */
+        function set_in_table(base_name, key, value) {
+            set_value_in_field(field_by_key(base_name, key), value);
+        }
+
+        /* Fill a table from a report */
+        function fill_table(base_name, report, first_fields) {
+            var sub_reports = report.sub_reports;
+            $.each(first_fields, function(idx, key){
+                set_in_table(base_name, key, report[key]);
+                delete report[key];
             });
             var keys = [];
             for (var prop in report) {
@@ -84,39 +136,56 @@ <h2 id="report_name"></h2>
                     add_to_table(base_name, key, value);
                 }
             }
-            // $.each(report, function(key, val){
-            //     if(sub_reports.indexOf(key) == -1){
-            //         add_to_table(base_name, key, val);
-            //     }                
-            // });
         }
 
+        /* Create a table */
         function create_table(name, title) {
-            var row1 = '<tr><td>Issuer</td><td id="' + name +'_name"></td></tr>';
-            var row2 = '<tr><td>Status</td><td id="' + name +'_status"></td></tr>';
-            var row3 = '<tr><td>Reason</td><td id="' + name +'_reason"></td></tr>';
-            var table = '<table id="' + name + '_table" class="table table-hover table-striped table-bordered info-table">' + row1 + row2 + row3 + '</table>';
-            var heading = '<div class="panel-heading">' + title + '</div>';
-            var panel = '<div class="panel panel-danger">' + heading + table + '</div>';
-            var wrap = '<tr><td>' + panel + '</td></tr>';
-            var tbody = $('#reports_container_table_body');
-            tbody.append(wrap);
-            
+            var new_tr = $('<tr></tr>');
+            new_tr.append(
+                $('<td>').append(
+                    $('<div>')
+                    .append(
+                        $('<div>')
+                        .addClass('panel-heading')
+                        .text(title)
+                    )
+                    .append(
+                        $('<table>', {id:table_id_from_name(name)})
+                        .addClass('table table-hover table-striped table-bordered info-table')
+                        .append(
+                            $('<tr>')
+                            .append($('<td>').text('Issuer'))
+                            .append($('<td>', {id: field_id_from_key(name, 'name')}))
+                        ).append(
+                            $('<tr>')
+                            .append($('<td>').text('Status'))
+                            .append($('<td>', {id: field_id_from_key(name, 'status')}))
+                        ).append(
+                            $('<tr>')
+                            .append($('<td>').text('Reason'))
+                            .append($('<td>', {id: field_id_from_key(name, 'reason')}))
+                        )
+                    )
+                    .addClass('panel panel-danger')
+                )
+            ).appendTo($('#reports_container_table_body'));
         }
 
+        /* Build tables and fill them for all reports */
         function build_tables(response) {
             var report = response.report;
-            var sub_reports = report.sub_reports; //JSON.parse(window.atob(report.sub_reports));
+            var sub_reports = report.sub_reports;
             $('#report_name').text('Report for test #' + report_num);
             fill_table('main_report', report, ['name', 'status', 'reason', 'fuzz_path']);
             sub_reports.sort();
-            $.each(sub_reports, function(idx, val){
-                subrep = report[val]
-                create_table(sanitizeName(val), toTitleCase(val));
-                fill_table(sanitizeName(val), subrep, ['name', 'status', 'reason']);
+            $.each(sub_reports, function(idx, key){
+                subrep = report[key]
+                create_table(sanitizeName(key), toTitleCase(key));
+                fill_table(sanitizeName(key), subrep, ['name', 'status', 'reason']);
             });
         }
 
+        /* Handle failure to fetch report */
         function handle_failure() {
             alert('Failed to load report');
         }

From 650656c37a0a0925be7012d19b484eecce521be8 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 19 Apr 2016 18:44:44 +0300
Subject: [PATCH 02/25] [Docs] Data model documentation

Added a big list of all Kitty's fields to the docs (outside of the API
reference itself)
Put all the data model stuff is a separate dir in docs/source
---
 docs/source/base_structure.rst                |   2 +-
 docs/source/data_model/big_list_of_fields.rst | 363 ++++++++++++++++++
 docs/source/data_model/index.rst              |  21 +
 .../overview.rst}                             |   8 +-
 docs/source/index.rst                         |   2 +-
 5 files changed, 391 insertions(+), 5 deletions(-)
 create mode 100644 docs/source/data_model/big_list_of_fields.rst
 create mode 100644 docs/source/data_model/index.rst
 rename docs/source/{base_data_model_overview.rst => data_model/overview.rst} (74%)

diff --git a/docs/source/base_structure.rst b/docs/source/base_structure.rst
index 08d1a7e..b6852a2 100644
--- a/docs/source/base_structure.rst
+++ b/docs/source/base_structure.rst
@@ -44,7 +44,7 @@ that the order in which messages are sent itself be fuzzed.
 The data model is constructed using the classes defined in the
 `model <https://github.com/cisco-sas/kitty/tree/master/kitty/model>`_ source folder.
 
-For more information, visit the data model :doc:`documentation </base_data_model_overview>`,
+For more information, visit the data model :doc:`documentation </data_model/overview>`,
 :doc:`reference </kitty.model>` and :doc:`tutorials </tutorials/index>`.
 
 Target
diff --git a/docs/source/data_model/big_list_of_fields.rst b/docs/source/data_model/big_list_of_fields.rst
new file mode 100644
index 0000000..08af58b
--- /dev/null
+++ b/docs/source/data_model/big_list_of_fields.rst
@@ -0,0 +1,363 @@
+Data Model Syntax
+=================
+
+A big part of generation based fuzzing is the data modeling.
+It provides guidance to the fuzzer on how the data is supposed to be structured.
+This allows the fuzzer to perform a more precise and faster fuzzing,
+and to keep the state of the payload as similar as possible to a valid while performing mutations on very specific fields.
+
+This chapter is composed of three parts.
+We start by listing the :ref:`available fields <fields>`,
+these fields compose kitty's syntax.
+After that, we list the :ref:`available encoders <encoders>`.
+The :ref:`last part<examples>` of this chapter provides examples on
+how to use the fields, containers and encoders
+that are listed in the first two part
+to compose a full template.
+
+
+
+.. _fields:
+
+Fields
+------
+
+A basic overview of the data model can be found in the :doc:`overview`,
+and you can also take a look at the :doc:`API reference<../kitty.model.low_level>`.
+
+There are a few types of fields in Kitty's data model, and all of them are derived from :class:`~kitty.model.low_level.field.BaseField`.
+
+- :ref:`atomic-fields`
+- :ref:`calculated-fields`
+- :ref:`containers`
+- :ref:`mutation-fields`
+
+The field type defines the type of value that will be rendered by this field,
+as well of the type of mutations that will be performed.
+The type of field instructs the fuzzer *what* data to render in the payload,
+but not *how* to render it. For that, we have encoders (see :ref:`encoders`).
+
+:example:
+
+    If we want to fuzz an integer, we will use a field like ``UInt16``,
+    which is used to represent an unsigned integer number with values
+    between 0 and 65535 ``(2 ** 16 - 1)``.
+
+    This number may be rendered as Little endian binary or a string of ASCII values,
+    or something else.
+    
+    The use of ``UInt16`` provides the type of the value,
+    but an encoder will encode it in the approriate "encoding" during its generation.
+
+.. _atomic-fields:
+
+Atomic Fields
+~~~~~~~~~~~~~
+
+The atomic fields are the very basic building blocks of a data model.
+Each of this fields is self-contained and discrete.
+
+The following atomic fields are available in Kitty (some of them are aliases for other fields):
+
+- :class:`~kitty.model.low_level.field.BitField`
+    :class:`~kitty.model.low_level.aliases.U8`
+    :class:`~kitty.model.low_level.aliases.UInt8`
+    :class:`~kitty.model.low_level.aliases.BE8`
+    :class:`~kitty.model.low_level.aliases.LE8`
+    :class:`~kitty.model.low_level.aliases.Byte`
+    :class:`~kitty.model.low_level.aliases.U16`
+    :class:`~kitty.model.low_level.aliases.UInt16`
+    :class:`~kitty.model.low_level.aliases.Word`
+    :class:`~kitty.model.low_level.aliases.BE16`
+    :class:`~kitty.model.low_level.aliases.WordBE`
+    :class:`~kitty.model.low_level.aliases.LE16`
+    :class:`~kitty.model.low_level.aliases.WordLE`
+    :class:`~kitty.model.low_level.aliases.S16`
+    :class:`~kitty.model.low_level.aliases.SInt16`
+    :class:`~kitty.model.low_level.aliases.U32`
+    :class:`~kitty.model.low_level.aliases.UInt32`
+    :class:`~kitty.model.low_level.aliases.Dword`
+    :class:`~kitty.model.low_level.aliases.BE32`
+    :class:`~kitty.model.low_level.aliases.DwordBE`
+    :class:`~kitty.model.low_level.aliases.LE32`
+    :class:`~kitty.model.low_level.aliases.DwordLE`
+    :class:`~kitty.model.low_level.aliases.S32`
+    :class:`~kitty.model.low_level.aliases.SInt32`
+    :class:`~kitty.model.low_level.aliases.U64`
+    :class:`~kitty.model.low_level.aliases.UInt64`
+    :class:`~kitty.model.low_level.aliases.Qword`
+    :class:`~kitty.model.low_level.aliases.BE64`
+    :class:`~kitty.model.low_level.aliases.QwordBE`
+    :class:`~kitty.model.low_level.aliases.LE64`
+    :class:`~kitty.model.low_level.aliases.QwordLE`
+    :class:`~kitty.model.low_level.aliases.S64`
+    :class:`~kitty.model.low_level.aliases.SInt64`
+- :class:`~kitty.model.low_level.field.Delimiter`
+- :class:`~kitty.model.low_level.field.Dynamic`
+- :class:`~kitty.model.low_level.field.Group`
+- :class:`~kitty.model.low_level.field.RandomBits`
+- :class:`~kitty.model.low_level.field.RandomBytes`
+- :class:`~kitty.model.low_level.field.Static`
+- :class:`~kitty.model.low_level.field.String`
+
+.. _calculated-fields:
+
+Calculated (dependant) Fields
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Calculated fields are fields that their value is calculated
+from properties that are outside of their scope by default,
+for example, the length or the checksum of another fields.
+
+These fields give Kitty's syntax much of its power.
+It allows the user to get into deeper layer of the parsing.
+
+These fields can be fuzzed as well, but when they are not fuzzed,
+they will be calculated each time,
+to ensure that they render into a valid value.
+
+The following calculated fields are available in Kitty (again, some of them are aliases for other fields):
+
+- :class:`~kitty.model.low_level.calculated.AbsoluteOffset`
+- :class:`~kitty.model.low_level.calculated.Checksum`
+- :class:`~kitty.model.low_level.calculated.Clone`
+- :class:`~kitty.model.low_level.calculated.ElementCount`
+- :class:`~kitty.model.low_level.calculated.Hash`
+    :class:`~kitty.model.low_level.aliases.Md5`
+    :class:`~kitty.model.low_level.aliases.Sha1`
+    :class:`~kitty.model.low_level.aliases.Sha224`
+    :class:`~kitty.model.low_level.aliases.Sha256`
+    :class:`~kitty.model.low_level.aliases.Sha384`
+    :class:`~kitty.model.low_level.aliases.Sha512`
+- :class:`~kitty.model.low_level.calculated.IndexOf`
+- :class:`~kitty.model.low_level.calculated.Offset`
+- :class:`~kitty.model.low_level.calculated.Size`
+    :class:`~kitty.model.low_level.aliases.SizeInBytes`
+
+.. _containers:
+
+Containers
+~~~~~~~~~~
+
+Containers, as is pretty obvious from their name, contain other fields.
+There is no limit on how many fields a container can hold,
+nor on the nesting level of containers.
+
+Containers can be used to perform encoding on multiple fields at once,
+or to use some property of multiple rendered fields to perform some calculation.
+But the most important property of containers, IMHO,
+is the logical separation and grouping of units in the model.
+
+In general, containers treat the contained field in the order they were added
+and in most cases will mutate each of the contained fields when in turn.
+However, in addition to the mutations of the internal fields,
+some container may add some mutations that are a property
+of the container itself
+(although they depend on the value of the contained fields)
+
+The following containers are available in Kitty:
+
+- :class:`~kitty.model.low_level.container.Conditional`
+    :class:`~kitty.model.low_level.container.If`
+    :class:`~kitty.model.low_level.container.IfNot`
+- :class:`~kitty.model.low_level.container.Container`
+- :class:`~kitty.model.low_level.container.ForEach`
+- :class:`~kitty.model.low_level.container_mutator.List`
+- :class:`~kitty.model.low_level.container.Meta`
+- :class:`~kitty.model.low_level.container.OneOf`
+- :class:`~kitty.model.low_level.container.Pad`
+- :class:`~kitty.model.low_level.container.Repeat`
+- :class:`~kitty.model.low_level.container.TakeFrom`
+- :class:`~kitty.model.low_level.container.Template`
+- :class:`~kitty.model.low_level.container.Trunc`
+
+.. _mutation-fields:
+
+Mutation Based Fields
+~~~~~~~~~~~~~~~~~~~~~
+
+While Kitty uses a data model,
+and expects the user to be familiar with the structure of the payload,
+in some cases the user might not have this information,
+only a sample payload.
+
+In this cases, a mutation fuzzing might come in handy, and the Mutation based fields can be used to perform a tests on the target
+without an accurate data model.
+
+some of the fields are wrappers around other fields, specifically,
+:class:`~kitty.model.low_level.mutated_field.MutableField`
+is a combination of all other mutation based fields.
+
+
+The following mutation-based fields are available in Kitty:
+
+- :class:`~kitty.model.low_level.mutated_field.BitFlip`
+- :class:`~kitty.model.low_level.mutated_field.BitFlips`
+- :class:`~kitty.model.low_level.mutated_field.BlockDuplicate`
+- :class:`~kitty.model.low_level.mutated_field.BlockDuplicates`
+- :class:`~kitty.model.low_level.mutated_field.BlockOperation`
+- :class:`~kitty.model.low_level.mutated_field.BlockRemove`
+- :class:`~kitty.model.low_level.mutated_field.BlockSet`
+- :class:`~kitty.model.low_level.mutated_field.ByteFlip`
+- :class:`~kitty.model.low_level.mutated_field.ByteFlips`
+- :class:`~kitty.model.low_level.mutated_field.MutableField`
+
+.. _encoders:
+
+Encoders
+--------
+
+The encoders receive data from the field they are assigned to,
+and return a sequence of bits, which is the rendered data.
+
+There are 3 types of encoders:
+
+- Encoders of strings (python2.7's str), receiving a string and returning Bits.
+- Encoders of Bits, receiving Bits object and returning Bits.
+- Encoders of numbers, receiving int value, length in bits and sign and returning Bits.
+
+Encoders are objects, but since most common encoders are stateless,
+and don't change state, the same instance can be used in multple fields,
+kitty provides many default instances of encoders that can be used directly.
+
+These instances are listed in the :doc:`API reference<../kitty.model.low_level.encoder>`.
+
+- :class:`~kitty.model.low_level.encoder.BitFieldEncoder`
+
+    - :class:`~kitty.model.low_level.encoder.BitFieldAsciiEncoder`
+    - :class:`~kitty.model.low_level.encoder.BitFieldBinEncoder`
+    - :class:`~kitty.model.low_level.encoder.BitFieldMultiByteEncoder`
+
+- :class:`~kitty.model.low_level.encoder.BitsEncoder`
+
+    - :class:`~kitty.model.low_level.encoder.ByteAlignedBitsEncoder`
+    - :class:`~kitty.model.low_level.encoder.ReverseBitsEncoder`
+    - :class:`~kitty.model.low_level.encoder.BitsFuncEncoder`
+
+- :class:`~kitty.model.low_level.encoder.StrEncoder`
+
+    - :class:`~kitty.model.low_level.encoder.StrBase64NoNewLineEncoder`
+    - :class:`~kitty.model.low_level.encoder.StrEncodeEncoder`
+    - :class:`~kitty.model.low_level.encoder.StrEncoderWrapper`
+    - :class:`~kitty.model.low_level.encoder.StrFuncEncoder`
+    - :class:`~kitty.model.low_level.encoder.StrNullTerminatedEncoder`
+
+.. _examples:
+
+Using the syntax
+----------------
+
+In this part, we'll take a look at a few examples on how to use
+Kitty's data modeling syntax to model some data or protocol.
+
+It's important to note that Kitty has no capability of modeling
+the data automatically.
+This is really out-of-scope, although,
+if you developed a tool that can infer the structure of a message
+from some (or many) samples, or if you know of such a tool,
+we'd really like to know about that.
+
+Anyway... Kitty's data model syntax is inspired by the syntax of
+`Construct <https://construct.readthedocs.org/en/latest/>`_.
+In the sense that the entire model of a payload (e.g. template)
+can be constructed in a single -- nested -- constructur.
+Using the standard alignment of python,
+this results in a very readable data model,
+although it is 100% python code.
+
+Unlike Construct,
+the resulted data model is not designed to pacrse payloads
+or be modified from outside (although it is possible to a certain level),
+instead, it is designed to generate mutations internally,
+(when ``mutate()`` is called)
+and provide the resulted payloads (when ``render()`` is called).
+
+Example 1 - Sized String
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+The following template describes an ascii string (not null terminated),
+prepended by a 16bit int that holds its size (in bytes):
+
+    ::
+
+        sized_string = Template(name='sized string', fields=[
+            SizeInBytes(name='size', sized_field='the string', length=16),
+            String(name='the string', value='')
+        ])
+
+Example 2 - Count Elements in a List
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The following template describe a List
+of 32bit little endian encoded integers,
+preprended by the number of element in the list
+(field of 16bit, little endian encoded).
+
+    ::
+
+        counted_list = Template(name='counted list', fields=[
+            ElementCount(name='element count', depends_on='the list', length=16, encoder=ENC_INT_LE),
+            List(name='the list', fields=[
+                LE32(name='element 1', value=0x00010203),
+                LE32(name='element 2', value=0x0a050607),
+                LE32(name='element 3', value=0x08090a0b),
+                LE32(name='element 4', value=0x0c0d0e0f),
+                LE32(name='element 5', value=0x10111213),
+                LE32(name='element 6', value=0x1a151617),
+                LE32(name='element 7', value=0x18191a1b),
+                LE32(name='element 8', value=0x1c1d1e1f),
+            ])
+        ])
+
+Here's the default rendered payload (hex encoded),
+see how it matchs the description
+
+    ::
+
+        0800030201000706050a0b0a09080f0e0d0c131211101716151a1b1a19181f1e1d1c
+
+        0800 -> element count: 8 (16 bits, little endian encoded)
+        03020100 -> element 1: 0x00010203 (32 bits, little endian encoded)
+        0706050a -> element 2: 0x0a050607 (32 bits, little endian encoded)
+        0b0a0908 -> element 3: 0x08090a0b (32 bits, little endian encoded)
+        0f0e0d0c -> element 4: 0x0c0d0e0f (32 bits, little endian encoded)
+        13121110 -> element 5: 0x10111213 (32 bits, little endian encoded)
+        1716151a -> element 6: 0x1a151617 (32 bits, little endian encoded)
+        1b1a1918 -> element 7: 0x18191a1b (32 bits, little endian encoded)
+        1f1e1d1c -> element 8: 0x1c1d1e1f (32 bits, little endian encoded)
+
+        
+Example 3 - Base64 Encoded Container
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+As mentioned, a container may be encoded as a whole,
+this comes quite handy in HTTP authorization,
+where the clients sends the username and password as:
+``base64encode(USERNAME:PASSWORD)``.
+Of course, encoding each string (``USERNAME``, ``:`` and ``PASSWORD``)
+separately will result in a different base64 string
+then if they were encoded together.
+
+    ::
+
+        http_user_pass = Container(
+            name='userpass header',
+            fields=[
+                String(name='username', value='some user'),
+                String(name='delimiter', value=':'),
+                String(name='password', value='some password')
+            ],
+            encoder=ENC_BITS_BASE64_NO_NL
+        )
+
+The default result of such a container is
+
+    ::
+
+        'c29tZSB1c2VyOnNvbWUgcGFzc3dvcmQ='
+
+Which is the base64 encoded version of
+
+    ::
+
+        'some user:some password'
diff --git a/docs/source/data_model/index.rst b/docs/source/data_model/index.rst
new file mode 100644
index 0000000..903e210
--- /dev/null
+++ b/docs/source/data_model/index.rst
@@ -0,0 +1,21 @@
+.. Data model index file
+
+The Data Model
+==============
+
+Contents:
+
+.. toctree::
+   :maxdepth: 1
+
+   overview
+   big_list_of_fields
+   Data Model API Reference<../kitty.model>
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
+
diff --git a/docs/source/base_data_model_overview.rst b/docs/source/data_model/overview.rst
similarity index 74%
rename from docs/source/base_data_model_overview.rst
rename to docs/source/data_model/overview.rst
index 72e0ad1..75fa966 100644
--- a/docs/source/base_data_model_overview.rst
+++ b/docs/source/data_model/overview.rst
@@ -20,15 +20,17 @@ Template is the only low-level interface to the high-level of the data
 model.
 
 A full documentation of the low level data model can be found in the API
-reference.
+:doc:`reference <../kitty.model.low_level>`.
+
+A full list of the fields in the Kitty data model syntax can be found in the :doc:`big_list_of_fields`.
 
 High Level Model
 ----------------
 
 The high level model describe how a sequence of messages (Templates)
 looks like to the fuzzer. There are two main models for this part,
-``GraphModel`` and ``StagedSequenceModel``. An additional model -
-``RandomSequenceModel`` is a naive case of ``StagedSequenceModel`` and is
+:class:`~kitty.model.high_level.graph.GraphModel` and :class:`~kitty.model.high_level.staged_sequence.StagedSequenceModel`. An additional model -
+:class:`~kitty.model.high_level.random_sequence.RandomSequenceModel` is a naive case of :class:`~kitty.model.high_level.staged_sequence.StagedSequenceModel` and is
 more convenient, when the order of messages really doesn't matter.
 
 During the fuzzing session, the fuzzer queries the data model for a
diff --git a/docs/source/index.rst b/docs/source/index.rst
index 33a7c21..4c19cde 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -14,7 +14,7 @@ Contents:
    base_introduction
    base_structure
    tutorials/index
-   base_data_model_overview
+   data_model/index
    tools
    modules
    controller

From faf77b48c36a82b31b56888ded68fea77eadabc9 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 19 Apr 2016 18:46:30 +0300
Subject: [PATCH 03/25] [DataModel] bugfix: rendering of default values in
 containers

When setting default value, the container class (and subclasses) did not
encode the default value using the container's encoder at all.
Not any more :)
---
 kitty/model/low_level/container.py         | 6 ++++--
 kitty/model/low_level/container_mutator.py | 3 +--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/kitty/model/low_level/container.py b/kitty/model/low_level/container.py
index 1efd711..7f9d1a0 100644
--- a/kitty/model/low_level/container.py
+++ b/kitty/model/low_level/container.py
@@ -212,7 +212,8 @@ def _initialize_default_buffer(self):
             rendered = Bits()
             for field in self._fields:
                 rendered += field._initialize_default_buffer()
-            self._default_rendered = rendered
+            self._default_value = rendered
+            self._default_rendered = self._encode_value(self._default_value)
         return self._default_rendered
 
     def _mutate(self):
@@ -754,7 +755,8 @@ def get_rendered_fields(self, ctx=None):
         return res
 
     def _initialize_default_buffer(self):
-        self._default_rendered = self._fields[self._field_idx]._initialize_default_buffer()
+        self._default_value = self._fields[self._field_idx]._initialize_default_buffer()
+        self._default_rendered = self._encode_value(self._default_value)
         return self._default_rendered
 
     def _calculate_mutations(self, num):
diff --git a/kitty/model/low_level/container_mutator.py b/kitty/model/low_level/container_mutator.py
index 4deb346..539707b 100644
--- a/kitty/model/low_level/container_mutator.py
+++ b/kitty/model/low_level/container_mutator.py
@@ -204,7 +204,7 @@ def _first_mutated_field_index(self):
 class List(OneOf):
 
     '''
-    Describe a list of elements in the template
+    Describe a list of elements in the template.
     In addition to the standard mutations of its element,
     a List also performs mutation of full elements,
     by reordering, duplicating and omitting them.
@@ -285,4 +285,3 @@ def _get_rotations(self, fields):
                     )
                 )
         return res
-

From 13085106dffdb834300985738af5a4d284e3ea2e Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Mon, 25 Apr 2016 18:46:08 +0300
Subject: [PATCH 04/25] Added CONTRIBUTING file

---
 CONTRIBUTING.rst | 105 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 CONTRIBUTING.rst

diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst
new file mode 100644
index 0000000..c79a0fb
--- /dev/null
+++ b/CONTRIBUTING.rst
@@ -0,0 +1,105 @@
+Contributing to Kitty
+=====================
+
+If you look here - thanks!
+
+This document describes the guidelines for contribution for Kitty.
+This is not to discourage you from contributing -
+we only benefit from contribution.
+However, we want to keep Kitty stable, documented and easy to read.
+
+At this point, this guide is rather short, so please read it from start to end.
+it will 
+
+Code
+----
+
+- **Python 3 compatibility**
+
+  Kitty is written in Python 2.7, we do plan to add python3 compatibility
+  at some point, so please make any new addition python 2 and python 3
+  compatible.
+
+- **Coding conventions**
+
+  We do try to make the pass pylint checks (although it is still far from it)
+  don't make it harder for us, check your code with pylint before you issue
+  a pull request.
+  Specifically, you should not have redundant spaces/line breaks in your code,
+  nor lines longer than 160 characters.
+
+- **Comments**
+
+  We do try not to comment the code, in most cases, comments tell us that the
+  code is not clear enough to begin with.
+  If this is the case - please refactor your code.
+  Of course, if the code is unclear but there's no way to make it better,
+  put a comment there.
+
+- **logging**
+
+  There should be no calls to ``print()`` in your code.
+  Kitty uses python's logging infrastructure,
+  and every object that derives from ``KittyObject`` have a member ``self.logger``
+  just for you.
+  Kitty's default logging level is ``INFO``,
+  and in this mode there shouldn't be too much logging to the terminal,
+  Please use the appropriate logger functions.
+
+Tests
+-----
+
+We try to keep Kitty tested, tests run on each push and pull request.
+The tests are located at the **tests** directory,
+and ``python runner.py`` should run all of them.
+We have two requests:
+
+- Run the tests before you open a pull requests.
+- Add tests for every new module, feature, class or code that you create.
+  if your pull request is meant to fix a bug in Kitty,
+  it means that we are missing a test there.
+  Add such a test with your fix.
+- If you create a new test file, add it to the runner,
+  so it will run with the rest of the tests.
+
+Documentation
+-------------
+
+We also try to keep Kitty documented.
+We use Sphinx to generate the documentation.
+Sphinx generates documentation from both code and documentation files.
+So we require a few things in pull requests.
+
+- **Docstrings**
+
+  Add docstrings to your code - modules, classes and public methods.
+  Take a look at other modules (mainly in **kitty/model/low_level**)
+  to get an idea of how we document the code.
+
+- **New modules**
+
+  If you add a new file to kitty, you should:
+
+  - Add a class description file to **docs/source**.
+    Take a look at **kitty.model.low_level.aliases.rst**
+    as an example.
+
+    Your file name should match the ``import`` of this file,
+    for example,
+    if you add the file **kitty/model/low_level/mymodule.py**
+    the documentation file will be called **kitty.model.low_level.mymodule.rst**
+
+  - Add this description file to the TOC of the package.
+    If we keep the example from the last bullet,
+    Open the file **kitty.model.low_level.rst** and add
+    the line **kitty.model.low_level.mymodule** to the TOC tree.
+
+- **New features**
+
+  If you add a new feature to kitty,
+  consider adding a more thorough documentation and a tutorial.
+  Add them to the TOC tree of **index.rst** and **tutorials/index.rst**
+  (respectively).
+
+
+That's it, and thanks for your help!
\ No newline at end of file

From 16b7392f613e9892b36f2ca40d7fa0b4e5f7fe70 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Mon, 25 Apr 2016 19:17:10 +0300
Subject: [PATCH 05/25] [DataModel] removed get_offset() function

---
 kitty/model/low_level/calculated.py | 4 ++--
 kitty/model/low_level/field.py      | 6 ------
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/kitty/model/low_level/calculated.py b/kitty/model/low_level/calculated.py
index a9774b2..d4d3cb7 100644
--- a/kitty/model/low_level/calculated.py
+++ b/kitty/model/low_level/calculated.py
@@ -494,8 +494,8 @@ def _calculate(self, field):
         '''
         base_offset = 0
         if self.base_field is not None:
-            base_offset = self.base_field.get_offset()
-        target_offset = self._field.get_offset()
+            base_offset = self.base_field.offset
+        target_offset = self._field.offset
         if (target_offset is None) or (base_offset is None):
             return 0
         return target_offset - base_offset
diff --git a/kitty/model/low_level/field.py b/kitty/model/low_level/field.py
index 1a5dbe9..f6054f9 100644
--- a/kitty/model/low_level/field.py
+++ b/kitty/model/low_level/field.py
@@ -74,12 +74,6 @@ def set_offset(self, offset):
         '''
         self.offset = offset
 
-    def get_offset(self):
-        '''
-        :return: absolute offset of this field (in bits)
-        '''
-        return self.offset
-
     def _mutating(self):
         return self._current_index != -1
 

From 67cee7ce8b7fc97b2413d128cb7f638432c385b5 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Mon, 25 Apr 2016 21:30:52 +0300
Subject: [PATCH 06/25] [DataModel] removed get_current_value() function

---
 kitty/model/low_level/condition.py | 4 ++--
 kitty/model/low_level/field.py     | 6 ------
 2 files changed, 2 insertions(+), 8 deletions(-)

diff --git a/kitty/model/low_level/condition.py b/kitty/model/low_level/condition.py
index 9d4c7dc..3f43e26 100644
--- a/kitty/model/low_level/condition.py
+++ b/kitty/model/low_level/condition.py
@@ -134,7 +134,7 @@ class InList(ListCondition):
     '''
 
     def _applies(self, container, ctx):
-        value = self._field.get_current_value()
+        value = self._field._current_value
         return value in self._value_list
 
 
@@ -193,7 +193,7 @@ def __init__(self, field, comp_type, comp_value):
         self._comp_value = comp_value
 
     def _applies(self, container, ctx):
-        value = self._field.get_current_value()
+        value = self._field._current_value
         return self._comp_fn(value, self._comp_value)
 
     def hash(self):
diff --git a/kitty/model/low_level/field.py b/kitty/model/low_level/field.py
index f6054f9..53d159c 100644
--- a/kitty/model/low_level/field.py
+++ b/kitty/model/low_level/field.py
@@ -88,12 +88,6 @@ def set_current_value(self, value):
         self._current_rendered = self._encode_value(self._current_value)
         return self._current_rendered
 
-    def get_current_value(self):
-        '''
-        :return: current value
-        '''
-        return self._current_value
-
     def _last_index(self):
         '''
         :return: last mutation index of this field

From 57c21438754963eb831b615378b15066bb54e79b Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Mon, 25 Apr 2016 21:43:29 +0300
Subject: [PATCH 07/25] [DataModel] removed some info from get_info()

---
 kitty/model/low_level/container.py | 5 ++---
 kitty/model/low_level/field.py     | 4 +---
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/kitty/model/low_level/container.py b/kitty/model/low_level/container.py
index 7f9d1a0..5f774d3 100644
--- a/kitty/model/low_level/container.py
+++ b/kitty/model/low_level/container.py
@@ -900,9 +900,8 @@ def get_info(self):
         res = {'field/%s' % k: v for (k, v) in info.items()}
         res['name'] = self.get_name()
         res['mutation/current index'] = self._current_index
-        res['mutation/total number'] = self._last_index()
-        res['value/rendered/hex'] = self._current_rendered.tobytes().encode('hex')
-        res['value/rendered/base64'] = self._current_rendered.tobytes().encode('base64')
+        res['mutation/total number'] = self.num_mutations()
+        res['value/rendered/base64'] = self._current_rendered.tobytes().encode('base64').replace('\n', '')
         res['value/rendered/len'] = len(self._current_rendered.tobytes())
         res['tree'] = self.get_tree().encode('base64')
         res['hash'] = self.hash()
diff --git a/kitty/model/low_level/field.py b/kitty/model/low_level/field.py
index 53d159c..0597453 100644
--- a/kitty/model/low_level/field.py
+++ b/kitty/model/low_level/field.py
@@ -195,11 +195,9 @@ def get_info(self):
         info['path'] = info['name']
         info['field type'] = type(self).__name__
         info['value/raw'] = repr(self._current_value)
-        info['value/rendered/hex'] = self._current_rendered.tobytes().encode('hex')
-        info['value/rendered/base64'] = self._current_rendered.tobytes().encode('base64')[:-1]
+        info['value/rendered/base64'] = self._current_rendered.tobytes().encode('base64').replace('\n', '')
         info['value/rendered/length/bits'] = len(self._current_rendered)
         info['value/rendered/length/bytes'] = len(self._current_rendered.tobytes())
-        info['value/default'] = repr(self._default_value)
         info['mutation/total number'] = self._num_mutations
         info['mutation/current index'] = self._current_index
         info['mutation/mutating'] = self._mutating()

From 49555b30af080a60584e18a6a13607ac6a8ad982 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Mon, 25 Apr 2016 21:52:25 +0300
Subject: [PATCH 08/25] [DataModel] fields -  _enclosing a public member
 (enclosing) and remove _get_enclosing()

---
 kitty/model/low_level/calculated.py      |  2 +-
 kitty/model/low_level/container.py       |  4 ++--
 kitty/model/low_level/field.py           | 24 +++++++-----------------
 tests/test_model_low_level_calculated.py |  2 +-
 4 files changed, 11 insertions(+), 21 deletions(-)

diff --git a/kitty/model/low_level/calculated.py b/kitty/model/low_level/calculated.py
index d4d3cb7..cd61e4e 100644
--- a/kitty/model/low_level/calculated.py
+++ b/kitty/model/low_level/calculated.py
@@ -380,7 +380,7 @@ def _calculate(self, field):
         We want to avoid trouble, so if the field is not enclosed by any other field,
         we just return 0.
         '''
-        encloser = field._enclosing
+        encloser = field.enclosing
         if encloser:
             rendered = encloser.get_rendered_fields(RenderContext(self))
             if field not in rendered:
diff --git a/kitty/model/low_level/container.py b/kitty/model/low_level/container.py
index 5f774d3..ba5ed30 100644
--- a/kitty/model/low_level/container.py
+++ b/kitty/model/low_level/container.py
@@ -75,7 +75,7 @@ def copy(self):
             idx = self._fields.index(container)
             dup._containers.append(dup._fields[idx])
         for field in dup._fields:
-            field._set_enclosing(dup)
+            field.enclosing = dup
         return dup
 
     def hash(self):
@@ -326,7 +326,7 @@ def push(self, field):
         '''
         kassert.is_of_types(field, BaseField)
         container = self._container()
-        field._set_enclosing(self)
+        field.enclosing = self
         if isinstance(field, Container):
             self._containers.append(field)
         if container:
diff --git a/kitty/model/low_level/field.py b/kitty/model/low_level/field.py
index 0597453..2f9887d 100644
--- a/kitty/model/low_level/field.py
+++ b/kitty/model/low_level/field.py
@@ -62,7 +62,7 @@ def __init__(self, value, encoder=ENC_BITS_DEFAULT, fuzzable=True, name=None):
         self._current_value = value
         self._current_rendered = self._default_rendered
         self._current_index = -1
-        self._enclosing = None
+        self.enclosing = None
         self._initialized = False
         self._hash = None
         self._need_second_pass = False
@@ -178,8 +178,8 @@ def _get_enclosing_list(self):
         :return: list of fields from the top of the path to current field
         '''
         alist = [self]
-        if self._enclosing:
-            alist = self._enclosing._get_enclosing_list() + alist
+        if self.enclosing:
+            alist = self.enclosing._get_enclosing_list() + alist
         return alist
 
     def get_structure(self):
@@ -223,7 +223,7 @@ def resolve_field(self, field):
             return self.resolve_absolute_name(name)
         resolved_field = self.scan_for_field(name)
         if not resolved_field:
-            container = self._enclosing
+            container = self.enclosing
             if container:
                 resolved_field = container.resolve_field(name)
         if not resolved_field:
@@ -240,7 +240,9 @@ def resolve_absolute_name(self, name):
         :return: field with this absolute name
         :raises: KittyException if field could not be resolved
         '''
-        current = self._get_root()
+        current = self
+        while current.enclosing:
+            current = current.enclosing
         components = name.split('/')[2:]
         for component in components:
             current = current.get_field_by_name(component)
@@ -253,18 +255,6 @@ def get_field_by_name(self, name):
         '''
         raise KittyException('Basic field (%s) does not contain any fields inside (looked for "%s")' % (self, name))
 
-    def _get_root(self):
-        root = self
-        while root._enclosing:
-            root = root._enclosing
-        return root
-
-    def _set_enclosing(self, container):
-        '''
-        Set the enclosing field of this field
-        '''
-        self._enclosing = container
-
     def copy(self):
         '''
         :return: a copy of the field
diff --git a/tests/test_model_low_level_calculated.py b/tests/test_model_low_level_calculated.py
index 7325dd5..9b203d6 100644
--- a/tests/test_model_low_level_calculated.py
+++ b/tests/test_model_low_level_calculated.py
@@ -214,7 +214,7 @@ def get_default_field(self, fuzzable=False):
         return self.cls(self.depends_on_name, length=self.length, fuzzable=fuzzable, name=self.uut_name)
 
     def calculate(self, field):
-        rendered = field._enclosing.get_rendered_fields()
+        rendered = field.enclosing.get_rendered_fields()
         if field in rendered:
             value = rendered.index(field)
         else:

From 802141b43de93d861ba5c98b9a83a2aebea84211 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 26 Apr 2016 01:10:38 +0300
Subject: [PATCH 09/25] Changed data model info representation and fixed web
 clients (html + kitty-web-client)

---
 bin/kitty_web_client.py                   | 72 +++++++++++++++++------
 examples/01_file_generator/runner.py      |  1 +
 kitty/fuzzers/base.py                     | 17 +++++-
 kitty/interfaces/web.py                   |  2 +-
 kitty/interfaces/web/static/index.html    | 46 ++++++++-------
 kitty/interfaces/web/static/report.html   | 14 ++---
 kitty/model/high_level/base.py            |  9 ++-
 kitty/model/high_level/graph.py           | 11 ++--
 kitty/model/high_level/staged_sequence.py |  8 ++-
 kitty/model/low_level/container.py        | 21 ++++---
 kitty/model/low_level/field.py            | 43 +++++++++-----
 11 files changed, 164 insertions(+), 80 deletions(-)

diff --git a/bin/kitty_web_client.py b/bin/kitty_web_client.py
index def68a3..5f21be3 100755
--- a/bin/kitty_web_client.py
+++ b/bin/kitty_web_client.py
@@ -35,7 +35,7 @@
 import types
 
 
-class KittyWebApi(object):
+class KittyWebClientApi(object):
 
     def __init__(self, host, port):
         '''
@@ -102,14 +102,23 @@ def cmd_report_show(options):
             print_report(report, depth=0)
 
 
+def _pad(depth, with_key):
+    if depth > 0:
+        if with_key:
+            return '    ' * (depth - 1) + '+---'
+        else:
+            return '    ' * (depth)
+    return ''
+
+
 def indent_print(depth, key, val=None):
     if val is None:
-        print(('    ' * depth) + key)
+        print(_pad(depth, True) + key)
     else:
         pre_len = len(key)
         first = True
         for line in val.split('\n'):
-            print(('    ' * depth) + key + line)
+            print(_pad(depth, with_key=first) + key + line)
             if first:
                 key = ' ' * pre_len
                 first = False
@@ -119,49 +128,78 @@ def format_key(k):
     return k.replace('_', ' ')
 
 
+def print_entry(k, v, depth, decode_str):
+    if isinstance(v, list):
+        indent_print(depth, '%-20s' % (k + ':'))
+        for i in range(len(v)):
+            print_entry('%s' % i, v, depth + 1, decode_str)
+    elif isinstance(v, dict):
+        indent_print(depth, '%-20s' % (k + ':'))
+        for subk in sorted(v):
+            print_entry(subk, v[subk], depth + 1, decode_str)
+    else:
+        print_key_val(k, v, depth, decode_str)
+
+
+def print_key_val(k, val, depth, decode_str):
+    if isinstance(val, types.StringTypes) and decode_str:
+        try:
+            val = val.decode('base64')
+        except:
+            pass
+    key = format_key(k)
+    try:
+        indent_print(depth, '%-20s' % (key + ':'), '%s' % val)
+    except UnicodeDecodeError:
+        indent_print(depth, '%-20s' % (key + ':'), '%s' % val.encode('hex'))
+
+
 def print_report(report, depth):
+    # next two fields should not be printed as normal fields
     name = report['name'].decode('base64')
     del report['name']
     sub_reports = report['sub_reports']
     del report['sub_reports']
+    # print report header
     indent_print(depth, '***** Report: %s *****' % name)
+    # print entries (excluding sub-reports)
     for k in sorted(report.keys()):
         if k not in sub_reports:
             val = report[k]
-            if isinstance(val, types.StringTypes):
-                val = val.decode('base64')
-            key = format_key(k)
-            try:
-                indent_print(depth + 1, '%-20s' % (key + ':'), '%s' % val)
-            except UnicodeDecodeError:
-                indent_print(depth + 1, '%-20s' % (key + ':'), '%s' % val.encode('hex'))
+            print_entry(k, val, depth, True)
+    print('')
+    # print sub-reports
     for sr in sorted(sub_reports):
-        print_report(report[sr], depth + 1)
+        print_report(report[sr], depth)
 
 
 def cmd_info(options, web):
     resp = web.get_stats()
+
     print('--- Stats ---')
     stats = resp['stats']
     for k, v in stats.items():
         print('%s: %s' % (k, v))
-    print
+    print('')
+
     print('--- Current Test Info ---')
     info = resp['current_test']
-    max_len = max(len(k) for k in info.keys())
+    # max_len = max(len(k) for k in info.keys())
     for k, v in sorted(info.items()):
-        pad = ' ' * (max_len - len(k))
-        print('%s:%s %s' % (k, pad, v))
+        print_entry(k, v, 0, False)
+        # pad = ' ' * (max_len - len(k))
+        # print('%s:%s %s' % (k, pad, v))
+
     if options['--verbose']:
         reports = resp['reports_extended']
-        print
+        print('')
         print('--- Report list ---')
         print('\n'.join('%-10s %-10s %s' % tuple(report) for report in reports))
 
 
 def _main():
     options = docopt.docopt(__doc__)
-    web = KittyWebApi(options['--host'], int(options['--port']))
+    web = KittyWebClientApi(options['--host'], int(options['--port']))
     if options['reports']:
         if options['store']:
             cmd_report_store(options, web)
diff --git a/examples/01_file_generator/runner.py b/examples/01_file_generator/runner.py
index e068765..a45c766 100644
--- a/examples/01_file_generator/runner.py
+++ b/examples/01_file_generator/runner.py
@@ -38,6 +38,7 @@
 opts = docopt.docopt(__doc__)
 t1 = Template(name='T1', fields=[
     String('The default string', name='S1_1'),
+    String('Another string', name='S1_2'),
 ])
 
 # Writes content to files
diff --git a/kitty/fuzzers/base.py b/kitty/fuzzers/base.py
index 2d0482a..6ea550f 100644
--- a/kitty/fuzzers/base.py
+++ b/kitty/fuzzers/base.py
@@ -34,6 +34,19 @@
 from pkg_resources import get_distribution
 
 
+def _flatten_dict_entry(orig_key, v):
+    entries = []
+    if isinstance(v, list):
+        for i in range(len(v)):
+            entries.extend(_flatten_dict_entry('%s[%s]' % (orig_key, i), v[i]))
+    elif isinstance(v, dict):
+        for k in v:
+            entries.extend(_flatten_dict_entry('%s/%s' % (orig_key, k), v[k]))
+    else:
+        entries.append((orig_key, v))
+    return entries
+
+
 class _Configuration(object):
 
     def __init__(self, delay_secs, store_all_reports, session_file_name, max_failures):
@@ -436,7 +449,9 @@ def _store_report(self, report):
         test_info = self.model.get_test_info()
         data_model_report = Report(name='Data Model')
         for k, v in test_info.items():
-            data_model_report.add(k, v)
+            new_entries = _flatten_dict_entry(k, v)
+            for (k_, v_) in new_entries:
+                data_model_report.add(k_, v_)
         report.add(data_model_report.get_name(), data_model_report)
         payload = self._last_payload
         if payload is not None:
diff --git a/kitty/interfaces/web.py b/kitty/interfaces/web.py
index 13d70b4..67164fa 100644
--- a/kitty/interfaces/web.py
+++ b/kitty/interfaces/web.py
@@ -181,7 +181,7 @@ def _handle_api_request(self):
         data_type = 'text/json'
         if path == 'stats.json':
             response = self._get_stats()
-        elif path == 'template_description.json':
+        elif path == 'template_info.json':
             response = json.dumps(self.dataman.get('template_info'))
         elif path == 'stages.json':
             response = json.dumps(self.dataman.get('stages'))
diff --git a/kitty/interfaces/web/static/index.html b/kitty/interfaces/web/static/index.html
index c97996d..d0451ec 100644
--- a/kitty/interfaces/web/static/index.html
+++ b/kitty/interfaces/web/static/index.html
@@ -134,7 +134,7 @@ <h1>Kitty Fuzzer <div id="kitty_version"></div> - <div id="fuzzer_name">Name Not
 <!-- update the stages graph -->
 <script type="text/javascript">
     var state = {};
-    state.template_description = {};
+    state.template_info = {};
 
     function renderStageGraph(elements){
         var cy = cytoscape({
@@ -324,7 +324,7 @@ <h1>Kitty Fuzzer <div id="kitty_version"></div> - <div id="fuzzer_name">Name Not
 
     function updateCurrentPayload(test_details)
     {
-        var curr = test_details['node/value/rendered/base64'];
+        var curr = test_details.node.value.rendered.base64;
         if(state.current_payload != curr)
         {
             $('#current_payload_hexdump').html(convertToHtml(Hexdump.dump(atob(curr))));
@@ -342,19 +342,17 @@ <h1>Kitty Fuzzer <div id="kitty_version"></div> - <div id="fuzzer_name">Name Not
 
     function updateTemplateStructure(test_details)
     {
-        var hash  = test_details['node/hash'];
-        if(state.waiting_for_template_structure)
+        var hash  = test_details['node']['hash'];
+        if(!state.waiting_for_template_structure)
         {
-
-        }
-        else
-        {
-            if(hash != state.template_description['node/hash'])
+            if(hash != state.template_info.hash)
             {
-                $.getJSON('api/template_description.json', function (data)
+                $.getJSON('api/template_info.json', function (data)
                 {
-                    state.template_description = data;
-                    state.template_description['node/hash'] = hash;
+                    console.log(data);
+                    console.log(state.template_info);
+                    state.template_info = data;
+                    state.template_info.hash = hash;
                     state.waiting_for_template_structure = false;
                     setTimeout(performUpdate, 10);
                 });
@@ -370,28 +368,32 @@ <h1>Kitty Fuzzer <div id="kitty_version"></div> - <div id="fuzzer_name">Name Not
 
     function updateTemplateWithCurrentState(test_details)
     {
-        var tree_string = buildTree(state.template_description, test_details, 0, test_details['node/mutation/current index']);
+        var tree_string = buildTree(state.template_info, test_details, 0, test_details.node.mutation.current_index);
         $('#template_structure').html(tree_string);
     }
 
     function buildTree(node, test_details, depth, relative_mutation_index)
     {
         var res = '';
-        var node_total_number = node['mutation/total number'];
+        var node_total_number = node.mutation.total_number;
         var mutating = relative_mutation_index < node_total_number && relative_mutation_index > 0;
         res += '&nbsp;'.repeat(depth * 2);
-        res += '<b>' + node['name'] + '</b>';
-        res += ' (' + node['field type'] + ')';
+        res += '<b>' + node.name + '</b>';
+        res += ' (' + node.field_type + ')';
         if(mutating)
         {
-            res += '(' + relative_mutation_index.toString() + '/' + node_total_number.toString() + ')';
+            if(node_total_number > 0)
+            {
+                node_total_number -= 1;
+            }
+            res += '(' + relative_mutation_index.toString() + '/' + (node_total_number).toString() + ')';
             res = '<span class="mutation-highlight">' + res + '</span>'; 
         }
         res += '<br>';
-        if(node['fields'])
-            $.each(node['fields'], function(index, value){
+        if(node.fields)
+            $.each(node.fields, function(index, value){
                 res += buildTree(value, test_details, depth + 1, relative_mutation_index);
-                relative_mutation_index -= value['mutation/total number'];
+                relative_mutation_index -= value.mutation.total_number;
             });
 
         return res;
@@ -425,9 +427,9 @@ <h1>Kitty Fuzzer <div id="kitty_version"></div> - <div id="fuzzer_name">Name Not
     }
 
     function updateFuzzingStage(test_details){
-        if(test_details['sequence/current'] != state.current_sequence)
+        if(test_details.sequence.current != state.current_sequence)
         {
-            test_details['sequence/current'] = state.current_sequence;
+            test_details.sequence.current = state.current_sequence;
             triggerStageGraphUpdate();
         }
     }
diff --git a/kitty/interfaces/web/static/report.html b/kitty/interfaces/web/static/report.html
index f9a08f7..aac5fc5 100644
--- a/kitty/interfaces/web/static/report.html
+++ b/kitty/interfaces/web/static/report.html
@@ -35,14 +35,14 @@ <h2 id="report_name"></h2>
 
     <script>
 
-        /* Change a string to title case: 'hEllo wORLD'-> 'Hello World' */
+        /* Change a string to title case: 'hello world'-> 'Hello World' */
         function toTitleCase(str) {
-            return str.replace(
-                /\w\S*/g,
-                function(txt) {
-                    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+            return str.replace(/_/g, ' ').replace(
+                /(\s|^|\/)([a-zA-Z])/g,
+                function(txt, a, b) {
+                    return a + b.toUpperCase();
                 }
-            ).replace('_', ' ');
+            );
         }
 
         /* Replace "bad" chars with '_' */
@@ -105,7 +105,7 @@ <h2 id="report_name"></h2>
             if(key != 'sub_reports'){
                 $('<tr>')
                 .append(
-                    $('<td>').text(toTitleCase(key.replace(/_/g, ' '))),
+                    $('<td>').text(toTitleCase(key)),
                     set_value_in_field($('<td class="textarea-data">'), value)
                 )
                 .appendTo(table_by_name(base_name));
diff --git a/kitty/model/high_level/base.py b/kitty/model/high_level/base.py
index 4c293c1..e4e0e9d 100644
--- a/kitty/model/high_level/base.py
+++ b/kitty/model/high_level/base.py
@@ -127,8 +127,13 @@ def get_test_info(self):
         '''
         self._get_ready()
         res = {
-            'sequence/current': self.get_sequence_str(),
-            'current mutation index': '%s/%s' % (self._current_index, self.last_index())
+            'sequence': {
+                'current': self.get_sequence_str()
+            },
+            'mutation': {
+                'current_index': self._current_index,
+                'total_number': self.num_mutations()
+            }
         }
         return res
 
diff --git a/kitty/model/high_level/graph.py b/kitty/model/high_level/graph.py
index f70883f..be00585 100644
--- a/kitty/model/high_level/graph.py
+++ b/kitty/model/high_level/graph.py
@@ -197,17 +197,16 @@ def hash(self):
 
     def get_model_info(self):
         info = {}
-        info['model name'] = self.name
-        info['sequence count'] = len(self._sequences)
+        info['model_name'] = self.name
+        info['sequence_count'] = len(self._sequences)
         return info
 
     def get_test_info(self):
         info = super(GraphModel, self).get_test_info()
         node_info = self._get_node().get_info()
-        for k, v in node_info.items():
-            info['node/%s' % k] = v
-        info['sequence/index'] = self._sequence_idx
-        info['duplicate (skipped) test count'] = self._duplication_count
+        info['node'] = node_info
+        info['sequence']['index'] = self._sequence_idx
+        info['duplicated'] = self._duplication_count
         return info
 
     def get_template_info(self):
diff --git a/kitty/model/high_level/staged_sequence.py b/kitty/model/high_level/staged_sequence.py
index 87481e3..fab24bf 100644
--- a/kitty/model/high_level/staged_sequence.py
+++ b/kitty/model/high_level/staged_sequence.py
@@ -233,9 +233,11 @@ def get_model_info(self):
         :return: dictionary of information about this model
         '''
         info = {}
-        info['model name'] = self.name
+        info['model_name'] = self.name
         info['stages'] = '->'.join([repr(s) for s in self._stages])
-        info['sequence index'] = '%s/%s' % (self._current_index, self._num_mutations)
+        info['sequence'] = {
+            'index': self._current_index
+        }
         return info
 
     def get_test_info(self):
@@ -244,7 +246,7 @@ def get_test_info(self):
         '''
         info = super(StagedSequenceModel, self).get_test_info()
         seq = self._sequence
-        info['sequence length'] = len(seq)
+        info['sequence']['length'] = len(seq)
         return info
 
     def hash(self):
diff --git a/kitty/model/low_level/container.py b/kitty/model/low_level/container.py
index ba5ed30..834c5f4 100644
--- a/kitty/model/low_level/container.py
+++ b/kitty/model/low_level/container.py
@@ -265,7 +265,7 @@ def get_rendered_fields(self, ctx=None):
         return result
 
     def get_structure(self):
-        mine = super(Container, self).get_info()
+        mine = super(Container, self).get_structure()
         fields = []
         for field in self._fields:
             fields.append(field.get_structure())
@@ -897,14 +897,21 @@ def get_info(self):
         '''
         self.render()
         info = super(Template, self).get_info()
-        res = {'field/%s' % k: v for (k, v) in info.items()}
+        res = {}
         res['name'] = self.get_name()
-        res['mutation/current index'] = self._current_index
-        res['mutation/total number'] = self.num_mutations()
-        res['value/rendered/base64'] = self._current_rendered.tobytes().encode('base64').replace('\n', '')
-        res['value/rendered/len'] = len(self._current_rendered.tobytes())
-        res['tree'] = self.get_tree().encode('base64')
+        res['mutation'] = {
+            'current_index': self._current_index,
+            'total_number': self.num_mutations()
+        }
+        res['value'] = {
+            'rendered': {
+                'base64': self._current_rendered.tobytes().encode('base64'),
+                'length_in_bytes': len(self._current_rendered.tobytes()),
+            }
+        }
+        res['tree'] = self.get_tree()
         res['hash'] = self.hash()
+        res['field'] = info
         return res
 
     def copy(self):
diff --git a/kitty/model/low_level/field.py b/kitty/model/low_level/field.py
index 2f9887d..6044ab0 100644
--- a/kitty/model/low_level/field.py
+++ b/kitty/model/low_level/field.py
@@ -183,25 +183,40 @@ def _get_enclosing_list(self):
         return alist
 
     def get_structure(self):
-        return self.get_info()
+        info = {
+            'field_type': type(self).__name__,
+            'mutation': {
+                'current_index': self._current_index,
+                'total_number': self._num_mutations,
+            },
+            'name': self.name if self.name else '<no name>',
+        }
+        return info
 
     def get_info(self):
         '''
         :rtype: dictionary
         :return: field information
         '''
-        info = {}
-        info['name'] = self.name if self.name else '<no name>'
-        info['path'] = info['name']
-        info['field type'] = type(self).__name__
-        info['value/raw'] = repr(self._current_value)
-        info['value/rendered/base64'] = self._current_rendered.tobytes().encode('base64').replace('\n', '')
-        info['value/rendered/length/bits'] = len(self._current_rendered)
-        info['value/rendered/length/bytes'] = len(self._current_rendered.tobytes())
-        info['mutation/total number'] = self._num_mutations
-        info['mutation/current index'] = self._current_index
-        info['mutation/mutating'] = self._mutating()
-        info['mutation/fuzzable'] = self._fuzzable
+        info = {
+            'name': self.name if self.name else '<no name>',
+            'path':  self.name if self.name else '<no name>',
+            'field_type': type(self).__name__,
+            'value': {
+                'raw': repr(self._current_value),
+                'rendered': {
+                    'base64': self._current_rendered.tobytes().encode('base64'),
+                    'length_in_bits': len(self._current_rendered),
+                    'length_in_bytes': len(self._current_rendered.tobytes()),
+                }
+            },
+            'mutation': {
+                'total_number': self._num_mutations,
+                'current_index': self._current_index,
+                'mutating': self._mutating(),
+                'fuzzable': self._fuzzable,
+            },
+        }
         return info
 
     def _encode_value(self, value):
@@ -403,7 +418,7 @@ def get_info(self):
         if idx >= 0 and idx < self._lib.size():
             current = self._lib.get(idx)
             if current:
-                info['mutation/description'] = current[1]
+                info['mutation']['description'] = current[1]
         return info
 
     def _filter_lib(self):

From 8c2c99000f5c1705182d7770cc3af776c1b665e3 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 26 Apr 2016 02:04:16 +0300
Subject: [PATCH 10/25] [DataModel] fixed condition - added copy function and
 fixed invalidate function

---
 kitty/model/low_level/condition.py | 27 ++++++++++++++++++++++++++-
 kitty/model/low_level/container.py |  4 +++-
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/kitty/model/low_level/condition.py b/kitty/model/low_level/condition.py
index 3f43e26..362e3f8 100644
--- a/kitty/model/low_level/condition.py
+++ b/kitty/model/low_level/condition.py
@@ -23,6 +23,7 @@
 In future versions, they will probably be used to make other decisions, not only basic rendering decisions.
 '''
 import types
+import copy
 from kitty.core import KittyException, khash
 
 
@@ -40,8 +41,24 @@ def applies(self, container, ctx):
         raise NotImplementedError('applies')
 
     def hash(self):
+        '''
+        :rtype: int
+        :return: hash of the condition
+        '''
         return khash(type(self).__name__)
 
+    def copy(self):
+        '''
+        :return: a copy of the condition
+        '''
+        return copy.copy(self)
+
+    def invalidate(self, container):
+        '''
+        :param container: the container that tries to invalidate the condition
+        '''
+        pass
+
 
 class FieldCondition(Condition):
     '''
@@ -61,7 +78,11 @@ def __init__(self, field):
             self._field_name = None
             self._field = field
 
-    def invalidate(self):
+    def invalidate(self, container):
+        '''
+        :param container: the container that tries to invalidate the condition
+        '''
+        self._get_ready(container)
         field_name = self._field.get_name()
         if field_name is None:
             raise KittyException('Cannot invalidate field without name')
@@ -197,5 +218,9 @@ def _applies(self, container, ctx):
         return self._comp_fn(value, self._comp_value)
 
     def hash(self):
+        '''
+        :rtype: int
+        :return: hash of the condition
+        '''
         hashed = super(Compare, self).hash()
         return khash(hashed, self._comp_value, self._comp_type)
diff --git a/kitty/model/low_level/container.py b/kitty/model/low_level/container.py
index 834c5f4..36e1842 100644
--- a/kitty/model/low_level/container.py
+++ b/kitty/model/low_level/container.py
@@ -493,7 +493,7 @@ def copy(self):
         '''
         dup = super(Conditional, self).copy()
         condition = self._condition.copy()
-        condition.invalidate()
+        condition.invalidate(self)
         dup._condition = condition
         return dup
 
@@ -917,6 +917,8 @@ def get_info(self):
     def copy(self):
         '''
         We might want to change it in the future, but for now...
+
+        :raises: :class:`~kitty.core.KittyException`, as it should not be copied
         '''
         raise KittyException('Template should NOT be copied')
 

From 21c099c4d6eb1a2323e6e18a64afa19f41345e07 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 26 Apr 2016 02:05:30 +0300
Subject: [PATCH 11/25] [Tests] added tests for Template and container's copy

---
 tests/test_model_low_level_container.py | 41 ++++++++++++++++++++-----
 1 file changed, 34 insertions(+), 7 deletions(-)

diff --git a/tests/test_model_low_level_container.py b/tests/test_model_low_level_container.py
index b3d2368..cb2bc36 100644
--- a/tests/test_model_low_level_container.py
+++ b/tests/test_model_low_level_container.py
@@ -21,15 +21,16 @@
 from common import metaTest, BaseTestCase
 from bitstring import Bits
 from kitty.model.low_level.field import String, Static, Group
-from kitty.model.low_level.container import Container, ForEach, If, IfNot, Repeat
+from kitty.model.low_level.container import Container, ForEach, If, IfNot, Repeat, Template
 from kitty.model.low_level.container import Meta, Pad, Trunc
 from kitty.model.low_level.condition import Condition
 from kitty.model.low_level.aliases import Equal, NotEqual
+from kitty.core import KittyException
 
 
 class ContainerTest(BaseTestCase):
 
-    __meta__ = False
+    __meta__ = True
 
     def setUp(self, cls=Container):
         super(ContainerTest, self).setUp(cls)
@@ -233,11 +234,18 @@ def testGetRenderedFieldsCorrect(self):
                 self.assertEqual(container.get_rendered_fields(), [])
 
     @metaTest
-    def _testSetOffsetPersist(self):
-        offset = 1000
-        uut = Container(name=self.uut_name, fields=[String('abc'), String('def')])
-        uut.set_offset(offset)
-        self.assertEqual(uut.get_offset(), offset)
+    def testCopy(self):
+        fields = [
+            String('test_string', name='field1'),
+            If(Equal('test_group_5', 'A'), String('if', name='if_field3'), name='if2'),
+            IfNot(Equal('test_group_5', 'A'), String('ifnot', name='ifnot_field5'), name='ifnot4'),
+            Group(name='test_group_5', values=['A', 'B', 'C'])
+        ]
+        uut = self.get_default_container(fields)
+        uut_copy = uut.copy()
+        uut_mutations = self.get_all_mutations(uut, reset=False)
+        copy_mutations = self.get_all_mutations(uut_copy, reset=False)
+        self.assertEqual(uut_mutations, copy_mutations)
 
 
 class RealContainerTest(ContainerTest):
@@ -293,6 +301,7 @@ def testlways(self):
         while condition_container.mutate():
             rendered = condition_container.render()
             self.assertEqual(rendered, Bits())
+        del enclosing
 
     @metaTest
     def testConditionAppliesFirst(self):
@@ -312,6 +321,8 @@ def testConditionAppliesFirst(self):
         while condition_container.mutate():
             self.assertEqual(condition_container.render(), Bits())
 
+        del enclosing
+
     @metaTest
     def testConditionNotAppliesFirst(self):
         field = self.get_condition_field()
@@ -330,6 +341,8 @@ def testConditionNotAppliesFirst(self):
         while condition_container.mutate():
             self.assertEqual(condition_container.render(), inner_field.render())
 
+        del enclosing
+
 
 class IfTest(ConditionTest):
 
@@ -701,3 +714,17 @@ def testDifferentHashIfPadLengthIsDifferend(self):
         trunc1 = Trunc(11 * 8, fields=String('abc'))
         trunc2 = Trunc(10 * 8, fields=String('abc'))
         self.assertNotEqual(trunc1.hash(), trunc2.hash())
+
+
+class TemplateTest(ContainerTest):
+
+    __meta__ = False
+
+    def setUp(self, cls=Template):
+        super(TemplateTest, self).setUp(cls)
+        self.uut_name = 'uut'
+
+    def testCopy(self):
+        uut = self.get_default_container()
+        with self.assertRaises(KittyException):
+            uut.copy()

From 69fd8d8af4bc130024729fd484c9a5878f8bd3eb Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 26 Apr 2016 14:32:53 +0300
Subject: [PATCH 12/25] [DataModel] new field - Switch

---
 kitty/model/low_level/container.py      |  95 +++++++++++-
 kitty/model/low_level/field.py          |   3 +-
 tests/test_model_low_level_container.py | 187 +++++++++++++++++++++++-
 3 files changed, 279 insertions(+), 6 deletions(-)

diff --git a/kitty/model/low_level/container.py b/kitty/model/low_level/container.py
index 36e1842..bc33f26 100644
--- a/kitty/model/low_level/container.py
+++ b/kitty/model/low_level/container.py
@@ -198,7 +198,6 @@ def _init(self):
         Prepare to run (if not ready)
         '''
         num = 0
-        self._need_second_pass = False
         for field in self._fields:
             field._initialize()
             self._need_second_pass |= field._need_second_pass
@@ -424,7 +423,8 @@ def _mutate(self):
             self._current_index = idx
             # if done internal mutation, mutate the "for-each" field and than start mutating the fields again
             self._mutated_field.mutate()
-            self._mutate()
+            return self._mutate()
+        return True
 
     def reset(self, reset_mutated=True):
         '''
@@ -677,7 +677,8 @@ def _calculate_mutations(self, num):
 
     def _mutate(self):
         if not self._in_repeat_stage():
-            super(Repeat, self)._mutate()
+            return super(Repeat, self)._mutate()
+        return True
 
     def render(self, ctx=None):
         '''
@@ -774,6 +775,94 @@ def _mutate(self):
         return super(OneOf, self)._mutate()
 
 
+class Switch(OneOf):
+    '''
+    When switch is not mutating, it will render one of the fields,
+    choosing the one with a key that matchs the value of key_field.
+    When switch is mutating, it will mutate and render one of its fields each time,
+    setting the value of the key_field field to the mutated field key.
+    '''
+
+    def __init__(self, field_dict, key_field, default_key, encoder=ENC_BITS_DEFAULT, fuzzable=True, name=None):
+        '''
+        :param field_dict: dictionary of key:field
+        :param key_field: (name of) field that switch takes the key from
+        :param default_key: key to use if the key_field's value doesn't match any key
+        :type encoder: BitsEncoder
+        :param encoder: encoder for the container (default: ENC_BITS_DEFAULT)
+        :param fuzzable: is container fuzzable (default: True)
+        :param name: (unique) name of the container (default: None)
+
+        :example:
+
+            ::
+
+                Container(fields=[
+                    BE16(name='opcode', value=1),
+                    Switch(name='opcode_params', key_field='opcode', default_key=1, field_dict={
+                        1: Container(name='opcode_1_params', fields=[
+                            BE32(name='param1', value=3),
+                        ]),
+                        2: Container(name='opcode_2_params', fields=[
+                            BE32(name='param1', value=4),
+                            BE32(name='param2', value=5),
+                        ]),
+                    })
+                ])
+        '''
+        if default_key not in field_dict:
+            raise KittyException('default_key(%s) is not a key in field_dict' % (default_key))
+        self._field_dict = field_dict
+        self._key_field = key_field
+        self._default_key = default_key
+        self._key_idx = 0
+        self._keys = sorted(self._field_dict)
+        self._keys.remove(default_key)
+        self._keys.insert(0, default_key)
+        fields = [field_dict[k] for k in self._keys]
+        super(Switch, self).__init__(fields=fields, encoder=encoder, fuzzable=fuzzable, name=name)
+
+    def _init(self):
+        super(Switch, self)._init()
+        key_field = self.resolve_field(self._key_field)
+        key_field._controlled = True
+
+    def _mutate(self):
+        res = super(Switch, self)._mutate()
+        key = self._keys[self._field_idx]
+        key_field = self.resolve_field(self._key_field)
+        key_field.set_current_value(key)
+        return res
+
+    def render(self, ctx=None):
+        '''
+        Render only a single field (see class docstring for more details)
+
+        :param ctx: rendering context in which the method was called
+        :rtype: `Bits`
+        :return: rendered value of the container
+        '''
+        if ctx is None:
+            ctx = RenderContext()
+        ctx.push(self)
+        self._initialize()
+        offset = self.offset if self.offset else 0
+        if self._mutating():
+            field_idx = self._field_idx
+        else:
+            key_field = self.resolve_field(self._key_field)
+            key_from_key_field = key_field._current_value
+            if key_from_key_field in self._keys:
+                field_idx = self._keys.index(key_from_key_field)
+            else:
+                field_idx = 0  # default value
+        self._fields[field_idx].set_offset(offset)
+        rendered = self._fields[field_idx].render(ctx)
+        self.set_current_value(rendered)
+        ctx.pop()
+        return self._current_rendered
+
+
 class TakeFrom(OneOf):
     '''
     Render to only part of the enclosed fields, performing all mutations on them
diff --git a/kitty/model/low_level/field.py b/kitty/model/low_level/field.py
index 6044ab0..08f50b9 100644
--- a/kitty/model/low_level/field.py
+++ b/kitty/model/low_level/field.py
@@ -67,6 +67,7 @@ def __init__(self, value, encoder=ENC_BITS_DEFAULT, fuzzable=True, name=None):
         self._hash = None
         self._need_second_pass = False
         self.offset = None
+        self._controlled = False
 
     def set_offset(self, offset):
         '''
@@ -302,7 +303,7 @@ def is_default(self):
 
         :return: True if field is in default form
         '''
-        return not self._mutating()
+        return not self._mutating() and not self._controlled
 
     def __str__(self):
         data = []
diff --git a/tests/test_model_low_level_container.py b/tests/test_model_low_level_container.py
index cb2bc36..760ede5 100644
--- a/tests/test_model_low_level_container.py
+++ b/tests/test_model_low_level_container.py
@@ -20,8 +20,9 @@
 '''
 from common import metaTest, BaseTestCase
 from bitstring import Bits
-from kitty.model.low_level.field import String, Static, Group
-from kitty.model.low_level.container import Container, ForEach, If, IfNot, Repeat, Template
+from struct import unpack
+from kitty.model.low_level import String, Static, Group, BE32
+from kitty.model.low_level.container import Container, ForEach, If, IfNot, Repeat, Template, Switch
 from kitty.model.low_level.container import Meta, Pad, Trunc
 from kitty.model.low_level.condition import Condition
 from kitty.model.low_level.aliases import Equal, NotEqual
@@ -716,6 +717,188 @@ def testDifferentHashIfPadLengthIsDifferend(self):
         self.assertNotEqual(trunc1.hash(), trunc2.hash())
 
 
+class SwitchTest(BaseTestCase):
+
+    __meta__ = False
+
+    def setUp(self, cls=Switch):
+        super(SwitchTest, self).setUp(cls)
+        self.uut_name = 'uut'
+        self.key_field_name = 'key_field'
+        self.key_field_default_value = 0
+
+    def get_uut(self, field_dict=[], default_key=0, fuzzable=True):
+        return self.cls(field_dict, self.key_field_name, default_key, name=self.uut_name, fuzzable=fuzzable)
+
+    def get_default_key_field(self, fuzzable=True):
+        key_field = BE32(name=self.key_field_name, value=self.key_field_default_value, fuzzable=fuzzable)
+        return key_field
+
+    def testNumMutationsMatchesMutateCount(self):
+        field_dict = {
+            1: String('1'),
+            2: String('2'),
+            3: String('3'),
+        }
+        uut = self.get_uut(field_dict, 2)
+        key_field = self.get_default_key_field()
+        container = Container([uut, key_field])
+        num_mutations = uut.num_mutations()
+        actual_num_mutations = len(self.get_all_mutations(uut))
+        self.assertEqual(num_mutations, actual_num_mutations)
+        del container
+
+    def testNumMutationsIsAtLeastSumOfFieldsNumMutations(self):
+        field_dict = {
+            1: String('1'),
+            2: String('2'),
+            3: String('3'),
+        }
+        uut = self.get_uut(field_dict, 2)
+        key_field = self.get_default_key_field()
+        container = Container([uut, key_field])
+        num_mutations = uut.num_mutations()
+        actual_num_mutations = sum(v.num_mutations() for k, v in field_dict.items())
+        self.assertGreaterEqual(num_mutations, actual_num_mutations)
+        del container
+
+    def testZeroMutationsIfNotFuzzable(self):
+        field_dict = {
+            1: String('1'),
+            2: String('2'),
+            3: String('3'),
+        }
+        uut = self.get_uut(field_dict, 2, fuzzable=False)
+        key_field = self.get_default_key_field()
+        container = Container([uut, key_field])
+        num_mutations = uut.num_mutations()
+        actual_num_mutations = len(self.get_all_mutations(uut))
+        self.assertEqual(num_mutations, actual_num_mutations)
+        self.assertEqual(num_mutations, 0)
+        del container
+
+    def testSwitchFieldSetByKeyFieldWhenNotMutating(self):
+        field_dict = {
+            1: String('1'),
+            2: String('2'),
+            3: String('3'),
+        }
+        default_key = 2
+        uut = self.get_uut(field_dict, default_key)
+        key_field = self.get_default_key_field()
+        container = Container([uut, key_field])
+        while key_field.mutate():
+            key = key_field._current_value
+            uut_rendered = uut.render()
+            uut_key = key if key in field_dict else default_key
+            field_rendred = field_dict[uut_key].render()
+            self.assertEqual(uut_rendered, field_rendred)
+        del container
+
+    def testKeyFieldValueSetBySwitchWhenMutating(self):
+        field_dict = {
+            1: String('1'),
+            2: String('2'),
+            3: String('3'),
+        }
+        uut = self.get_uut(field_dict, 2)
+        key_field = self.get_default_key_field()
+        container = Container([uut, key_field])
+        while uut.mutate():
+            key_rendered = key_field.render().tobytes()
+            key_value = key_field._current_value
+            self.assertEqual(key_value, unpack('>I', key_rendered)[0])
+            self.assertEqual(key_value, uut._keys[uut._field_idx])
+        del container
+
+    def testContainerRenderingKeyBeforeSwitch(self):
+        field_dict = {
+            1: Static('\x00\x00\x00\x01'),
+            2: Static('\x00\x00\x00\x02'),
+            3: Static('\x00\x00\x00\x03'),
+        }
+        default_key = 2
+        uut = self.get_uut(field_dict, default_key)
+        key_field = self.get_default_key_field(fuzzable=False)
+        container = Container([key_field, uut])
+        mutations = self.get_all_mutations(container)
+        for mutation in mutations:
+            mutation = mutation.tobytes()
+            self.assertEqual(len(mutation), 8)
+            key = unpack('>I', mutation[:4])[0]
+            case = unpack('>I', mutation[4:])[0]
+            if key in field_dict:
+                self.assertEqual(key, case)
+            else:
+                self.assertEqual(case, 2)
+
+    def testContainerRenderingKeyAfterSwitch(self):
+        field_dict = {
+            1: Static('\x00\x00\x00\x01'),
+            2: Static('\x00\x00\x00\x02'),
+            3: Static('\x00\x00\x00\x03'),
+        }
+        default_key = 2
+        uut = self.get_uut(field_dict, default_key)
+        key_field = self.get_default_key_field(fuzzable=False)
+        container = Container([uut, key_field])
+        mutations = self.get_all_mutations(container)
+        for mutation in mutations:
+            mutation = mutation.tobytes()
+            self.assertEqual(len(mutation), 8)
+            key = unpack('>I', mutation[:4])[0]
+            case = unpack('>I', mutation[4:])[0]
+            if key in field_dict:
+                self.assertEqual(key, case)
+            else:
+                self.assertEqual(case, 2)
+
+    def testSwitchWithStringKey(self):
+        field_dict = {
+            '1': String('1'),
+            '2': String('2'),
+            '3': String('3'),
+        }
+        default_key = '3'
+        uut = self.get_uut(field_dict, default_key)
+        key_field = String(name=self.key_field_name, value='someval')
+        container = Container([uut, key_field])
+        while key_field.mutate():
+            key = key_field._current_value
+            uut_rendered = uut.render()
+            uut_key = key if key in field_dict else default_key
+            field_rendred = field_dict[uut_key].render()
+            self.assertEqual(uut_rendered, field_rendred)
+        del container
+
+    def testSwitchWithStaticKeyField(self):
+        field_dict = {
+            '1': String('1'),
+            '2': String('2'),
+            '3': String('3'),
+        }
+        default_key = '3'
+        uut = self.get_uut(field_dict, default_key)
+        key_field = Static(name=self.key_field_name, value='someval')
+        container = Container([uut, key_field])
+        while key_field.mutate():
+            key = key_field._current_value
+            uut_rendered = uut.render()
+            uut_key = key if key in field_dict else default_key
+            field_rendred = field_dict[uut_key].render()
+            self.assertEqual(uut_rendered, field_rendred)
+        del container
+
+    def testExceptionIfDefaultKeyNotInDict(self):
+        with self.assertRaises(KittyException):
+            field_dict = {
+                1: String('1'),
+                2: String('2'),
+                3: String('3'),
+            }
+            self.get_uut(field_dict, 0)
+
+
 class TemplateTest(ContainerTest):
 
     __meta__ = False

From 63081ba3c8195bc38ec78785e3456f3aec162738 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 26 Apr 2016 14:36:32 +0300
Subject: [PATCH 13/25] [Docs] added Switch to big list of fields

---
 docs/source/data_model/big_list_of_fields.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/source/data_model/big_list_of_fields.rst b/docs/source/data_model/big_list_of_fields.rst
index 08af58b..23960a9 100644
--- a/docs/source/data_model/big_list_of_fields.rst
+++ b/docs/source/data_model/big_list_of_fields.rst
@@ -167,6 +167,7 @@ The following containers are available in Kitty:
 - :class:`~kitty.model.low_level.container.OneOf`
 - :class:`~kitty.model.low_level.container.Pad`
 - :class:`~kitty.model.low_level.container.Repeat`
+- :class:`~kitty.model.low_level.container.Switch`
 - :class:`~kitty.model.low_level.container.TakeFrom`
 - :class:`~kitty.model.low_level.container.Template`
 - :class:`~kitty.model.low_level.container.Trunc`

From ccdacd7055574fc78fc716c4d247689a2a8e76e2 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 26 Apr 2016 14:45:00 +0300
Subject: [PATCH 14/25] [DataModel] removed tree from Template's get_info()

---
 kitty/model/low_level/container.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/kitty/model/low_level/container.py b/kitty/model/low_level/container.py
index bc33f26..efe94e5 100644
--- a/kitty/model/low_level/container.py
+++ b/kitty/model/low_level/container.py
@@ -998,7 +998,6 @@ def get_info(self):
                 'length_in_bytes': len(self._current_rendered.tobytes()),
             }
         }
-        res['tree'] = self.get_tree()
         res['hash'] = self.hash()
         res['field'] = info
         return res

From e7be1c9090fde9b76921fe022e174925453c111c Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 26 Apr 2016 15:36:43 +0300
Subject: [PATCH 15/25] [tools] kitty-template-tester now builds the tempalte
 based on get_structure and not get_tree

---
 bin/kitty_template_tester.py | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/bin/kitty_template_tester.py b/bin/kitty_template_tester.py
index fff3014..1428f84 100755
--- a/bin/kitty_template_tester.py
+++ b/bin/kitty_template_tester.py
@@ -50,9 +50,21 @@ def process(self, t):
 
 class TemplateTreePrinter(TemplateProcessor):
 
+    def _pad(self):
+        return '  ' * self.depth
+
+    def _print_structure(self, structure):
+        print('%s%s(name="%s")' % (self._pad(), structure['field_type'], structure['name']))
+        if 'fields' in structure:
+            self.depth += 1
+            for field in structure['fields']:
+                self._print_structure(field)
+            self.depth -= 1
+
     def process(self, t):
-        t.num_mutations()
-        print(t.get_tree())
+        self.depth = 0
+        structure = t.get_structure()
+        self._print_structure(structure)
 
 
 class TemplateTester(TemplateProcessor):

From 8ce715f08504cf4697a12e21f5261862db3eb270 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 26 Apr 2016 15:37:35 +0300
Subject: [PATCH 16/25] [DataModel] removed get_tree method

---
 kitty/model/low_level/container.py | 22 ----------------------
 1 file changed, 22 deletions(-)

diff --git a/kitty/model/low_level/container.py b/kitty/model/low_level/container.py
index efe94e5..7a0c09e 100644
--- a/kitty/model/low_level/container.py
+++ b/kitty/model/low_level/container.py
@@ -285,28 +285,6 @@ def get_info(self):
             info = super(Container, self).get_info()
         return info
 
-    def get_tree(self, depth=0):
-        '''
-        Get a string representation of the field tree
-
-        :param depth: current depth in the tree (default:0)
-        :return: string representing the field tree
-        '''
-        s = ''
-        s += '%(pad)s%(desc)s\n' % {
-                'pad': '  ' * depth,
-                'desc': self
-                }
-        for field in self._fields:
-            if isinstance(field, Container):
-                s += field.get_tree(depth + 1)
-            else:
-                s += '%(pad)s%(desc)s\n' % {
-                    'pad': '  ' * (depth + 1),
-                    'desc': field
-                    }
-        return s
-
     def pop(self):
         '''
         Remove a the top container from the container stack

From b421fc3862fafdc196c9dcaea0b4f8c96cecccc1 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 26 Apr 2016 15:44:03 +0300
Subject: [PATCH 17/25] [WebInterface] html - added report number to title

---
 kitty/interfaces/web/static/report.html | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/kitty/interfaces/web/static/report.html b/kitty/interfaces/web/static/report.html
index aac5fc5..7efd9f2 100644
--- a/kitty/interfaces/web/static/report.html
+++ b/kitty/interfaces/web/static/report.html
@@ -2,7 +2,7 @@
 <html lang="en">
 
 <head>
-    <title>Kitty Fuzzer 0.2 - Report</title>
+    <title>Kitty Fuzzer Report</title>
     <link href="css/bootstrap.min.css" rel="stylesheet">
     <link rel="stylesheet" type="text/css" href="static/style.css">
 </head>
@@ -195,7 +195,8 @@ <h2 id="report_name"></h2>
             return document.URL.split('=').slice(-1)[0];
         }
 
-        report_num = get_report_num();
+        var report_num = get_report_num();
+        document.title += ' #' + report_num;
         $.getJSON('../api/report?report_id=' + report_num, build_tables).fail(handle_failure);
     </script>
 </body>

From a46fcfe8c88a3e2a157cdec4a99a90ec6ebb6b44 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Sun, 1 May 2016 12:39:59 +0300
Subject: [PATCH 18/25] [WebInterface] some order in htmls

---
 kitty/interfaces/web/static/index.html  | 2 +-
 kitty/interfaces/web/static/report.html | 7 ++++---
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/kitty/interfaces/web/static/index.html b/kitty/interfaces/web/static/index.html
index d0451ec..9e4697d 100644
--- a/kitty/interfaces/web/static/index.html
+++ b/kitty/interfaces/web/static/index.html
@@ -4,7 +4,7 @@
     <meta charset="utf-8">
     <meta http-equiv="X-UA-Compatible" content="IE=edge">
     <meta name="viewport" content="width=device-width, initial-scale=1">
-    <link href="css/bootstrap.min.css" rel="stylesheet">
+    <link rel="stylesheet" type="text/css" href="css/bootstrap.min.css">
     <link rel="stylesheet" type="text/css" href="static/style.css">
     <link rel="shortcut icon" href="data:image/x-icon;," type="image/x-icon"> 
     <title>Kitty Fuzzer</title>
diff --git a/kitty/interfaces/web/static/report.html b/kitty/interfaces/web/static/report.html
index 7efd9f2..c4eb9bb 100644
--- a/kitty/interfaces/web/static/report.html
+++ b/kitty/interfaces/web/static/report.html
@@ -2,9 +2,10 @@
 <html lang="en">
 
 <head>
-    <title>Kitty Fuzzer Report</title>
-    <link href="css/bootstrap.min.css" rel="stylesheet">
-    <link rel="stylesheet" type="text/css" href="static/style.css">
+        <link rel="stylesheet" type="text/css" href="css/bootstrap.min.css">
+        <link rel="stylesheet" type="text/css" href="static/style.css">
+        <link rel="shortcut icon" href="data:image/x-icon;," type="image/x-icon">
+        <title>Kitty Fuzzer Report</title>
 </head>
 
 <body>

From 092d3ac8378648e90398c5d8ad2081ee2e05532f Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Sun, 1 May 2016 16:34:55 +0300
Subject: [PATCH 19/25] [WebInterface] html - improvements in index and reports

---
 kitty/interfaces/web/static/index.html  |  74 ++++++------
 kitty/interfaces/web/static/report.html | 153 +++++++++++++++++-------
 kitty/interfaces/web/static/style.css   |  39 +++++-
 3 files changed, 189 insertions(+), 77 deletions(-)

diff --git a/kitty/interfaces/web/static/index.html b/kitty/interfaces/web/static/index.html
index 9e4697d..15b7b73 100644
--- a/kitty/interfaces/web/static/index.html
+++ b/kitty/interfaces/web/static/index.html
@@ -87,16 +87,14 @@ <h1>Kitty Fuzzer <div id="kitty_version"></div> - <div id="fuzzer_name">Name Not
                             <div class="panel-heading">
                                 Reports (<span id="failure_count" style="align:right;"></span>)
                             </div>
-                            <!-- TODO: replace with actual implementation -->
                             <div class="unknown-data-size" id="report-table">
-                                <table id="reports" class="table table-bordered table-striped">
+                                <table id="reports" class="table table-bordered table-striped table-responsive">
                                     <colgroup>
                                         <col class="col-lg-2"/>
                                     </colgroup>
                                     <tbody>
                                     </tbody>
                                 </table>
-                                <!--<lu id="reports" class="list-group"></lu>-->
                             </div>
                             <button id="export_all" type="button" class="btn btn-danger" onclick="exportAllReports()">Export All reports</button>
                         </div>
@@ -136,7 +134,7 @@ <h1>Kitty Fuzzer <div id="kitty_version"></div> - <div id="fuzzer_name">Name Not
     var state = {};
     state.template_info = {};
 
-    function renderStageGraph(elements){
+    function renderStageGraph(elements) {
         var cy = cytoscape({
             container: $('#stages-graph'),
 
@@ -182,6 +180,32 @@ <h1>Kitty Fuzzer <div id="kitty_version"></div> - <div id="fuzzer_name">Name Not
     function triggerStageGraphUpdate() {
         $.getJSON('../api/stages.json', updateStageGraph);
     }
+
+    function is_edge_in_path(curr_path, src, dst) {
+        return (
+            (curr_path.indexOf(dst) != -1) &&
+            (curr_path.indexOf(src) != -1) &&
+            ((curr_path.indexOf(src) + 1) == curr_path.indexOf(dst))
+        )
+    }
+
+    function get_edge_classes(curr_path, src, dst) {
+        if(is_edge_in_path(curr_path, src, dst))
+            return 'highlighted';
+        else
+            return '';
+    }
+
+    function has_node(elements, node) {
+        return elements.nodes.indexOf(node) != -1;
+    }
+
+    function add_node_if_missing(elements, node) {
+        if(has_node(elements, node) == false)
+        {
+            elements.nodes.push({data: {id: node}});
+        }
+    }
     
     function updateStageGraph(resp) {
         var curr_path = resp.current;
@@ -194,46 +218,29 @@ <h1>Kitty Fuzzer <div id="kitty_version"></div> - <div id="fuzzer_name">Name Not
         elements.nodes = new Array();
         elements.edges = new Array();
         curr_path.unshift('Start');
-        $.each(curr_path, function(idx, value){
+        $.each(curr_path, function(idx, value) {
             elements.nodes.push({data: {id: value}, classes: 'highlighted'});
         });
         /*
         build all the edges, each entry in all_stages holds a
         list of destinations from the key
         */
-        $.each(all_stages, function(k, v){
+        $.each(all_stages, function(src, v) {
             /* don't set the same edge twice, even if it occurs twice */
             var cache = new Array();
-            $.each(v, function(idx, value){
+            $.each(v, function(idx, dst) {
                 /* highlight the edge if it is in current path */
-                var classes = '';
-                if(
-                    (curr_path.indexOf(value) != -1) &&
-                    (curr_path.indexOf(k) != -1) &&
-                    ((curr_path.indexOf(k) + 1) == curr_path.indexOf(value))
-                )
-                {
-                    classes = 'highlighted';
-                }
-                if(cache.indexOf(value) == - 1)
-                {
+                var classes = get_edge_classes(curr_path, src, dst);
+                if(cache.indexOf(dst) == - 1) {
                     elements.edges.push({
-                        data: {
-                            source: k,
-                            target: value,
-                            id: k + '--' + value,
-                        },
+                        data: {source: src, target: dst, id: src + '--' + dst},
                         classes:classes,
                     });
-                    if(elements.nodes.indexOf(value) == -1){
-                        elements.nodes.push({data: {id: value}});
-                    }
-                    cache.push(value);
+                    add_node_if_missing(elements, dst);
+                    cache.push(dst);
                 }
             });
-            if(elements.nodes.indexOf(k) == -1){
-                elements.nodes.push({data: {id: k}});
-            }
+            add_node_if_missing(elements, src);
         });
         renderStageGraph(elements);
     }
@@ -253,14 +260,15 @@ <h1>Kitty Fuzzer <div id="kitty_version"></div> - <div id="fuzzer_name">Name Not
                         .append($('<td>').text(entry[2]))
                         .attr('onclick', "document.location = '" + "static/report.html?report_id=" + test_number +"';")
                         .attr('style', 'cursor: pointer;')
+                        .attr('title', 'Show report ' + test_number)
                     );
                 });    
             }
         }
     }
 
+    /* Fetch all reports, return a dictionary - testname/report */
     function getAllReports() {
-        /* Fetch all reports, return a dictionary - testname/report */
         var res = {};
         $.each(state.reports, function(index, entry){
             var test_number = entry[0];
@@ -274,10 +282,8 @@ <h1>Kitty Fuzzer <div id="kitty_version"></div> - <div id="fuzzer_name">Name Not
         return res;
     }
 
+    /* Store all reports into a single zip file */
     function exportAllReports() {
-        /*
-        Store all reports into a single zip file
-        */
         var zip = new JSZip();
         var filename = 'kitty_' + state.start_time.toString() + '_reports.zip';
         var report_dir = zip.folder('reports');
diff --git a/kitty/interfaces/web/static/report.html b/kitty/interfaces/web/static/report.html
index c4eb9bb..7198b1c 100644
--- a/kitty/interfaces/web/static/report.html
+++ b/kitty/interfaces/web/static/report.html
@@ -2,10 +2,10 @@
 <html lang="en">
 
 <head>
-        <link rel="stylesheet" type="text/css" href="css/bootstrap.min.css">
-        <link rel="stylesheet" type="text/css" href="static/style.css">
-        <link rel="shortcut icon" href="data:image/x-icon;," type="image/x-icon">
-        <title>Kitty Fuzzer Report</title>
+    <link rel="stylesheet" type="text/css" href="css/bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="static/style.css">
+    <link rel="shortcut icon" href="data:image/x-icon;," type="image/x-icon">
+    <title>Kitty Report</title>
 </head>
 
 <body>
@@ -17,22 +17,38 @@
         <h2 id="report_name"></h2>
     </div>
 
-    <table id="reports_container_table" class="table table-main-layout">
-        <tbody id="reports_container_table_body">
-            <tr><td>
-                <div class="panel panel-danger">
-                    <div class="panel-heading">Main Report</div>
-                    <table id="main_report_table" class="table table-hover table-striped table-bordered info-table">
-                        <tr><td>Issuer</td><td id="main_report_name"></td></tr>
-                        <tr><td>Status</td><td id="main_report_status"></td></tr>
-                        <tr><td>Reason</td><td id="main_report_reason"></td></tr>
-                        <tr><td>Fuzz Path</td><td id="main_report_fuzz_path"></td></tr>
-                    </table>
+
+    <div class="container" id="reports_container_table">
+        <div class="table" id="reports_container_table_body">
+            <!-- Main report -->
+            <div class="row">
+                <div class="container report-single-table">
+                    <div class="panel panel-danger">
+                        <div class="panel-heading">Main Report</div>
+                        <div class="table table-hover table-striped table-bordered" id="main_report_table">
+                            <div class="row report-row">
+                                <div class="report-cell-key col-sm-3">Issuer</div>
+                                <div class="report-cell-value col-sm-9" id="main_report_name"></div>
+                            </div>
+                            <div class="row report-row">
+                                <div class="report-cell-key col-sm-3">Status</div>
+                                <div class="report-cell-value col-sm-9" id="main_report_status"></div>
+                            </div>
+                            <div class="row report-row">
+                                <div class="report-cell-key col-sm-3">Reason</div>
+                                <div class="report-cell-value col-sm-9" id="main_report_reason"></div>
+                            </div>
+                            <div class="row report-row">
+                                <div class="report-cell-key col-sm-3">Fuzz Path</div>
+                                <div class="report-cell-value col-sm-9" id="main_report_fuzz_path"></div>
+                            </div>
+                        </div>
+                    </div>
                 </div>
-            </td></tr>
-        </tbody>
-        
-    </table>
+            </div>
+
+        </div>
+    </div>
 
     <script>
 
@@ -101,30 +117,52 @@ <h2 id="report_name"></h2>
             }
             return field;
         }
+
         /* Add a field to the table */
         function add_to_table(base_name, key, value) {
             if(key != 'sub_reports'){
-                $('<tr>')
+                $('<div>')
                 .append(
-                    $('<td>').text(toTitleCase(key)),
-                    set_value_in_field($('<td class="textarea-data">'), value)
+                    $('<div>').addClass('report-cell-key col-sm-3').text(toTitleCase(key)),
+                    set_value_in_field(
+                        $('<div>').addClass('report-cell-value col-sm-9'),
+                        value
+                    )
                 )
+                .addClass('row report-row')
                 .appendTo(table_by_name(base_name));
             }
         }
 
         /* Set value of existing field in the table */
-        function set_in_table(base_name, key, value) {
+        function set_in_table(base_name, key, value)
+        {
             set_value_in_field(field_by_key(base_name, key), value);
         }
 
+        function highlight_failed_row(base_name, key)
+        {
+            var status_row = field_by_key(base_name, key);
+            status_row.parent().css('background', '#dc9696');
+        }
+
         /* Fill a table from a report */
         function fill_table(base_name, report, first_fields) {
             var sub_reports = report.sub_reports;
+            var passed = false;
             $.each(first_fields, function(idx, key){
                 set_in_table(base_name, key, report[key]);
+                if((key == 'status') && (window.atob(report[key]) == 'passed'))
+                {
+                    passed = true;
+                }
                 delete report[key];
             });
+            if(passed == false)
+            {
+                highlight_failed_row(base_name, 'status');
+                highlight_failed_row(base_name, 'reason');
+            }
             var keys = [];
             for (var prop in report) {
                 keys.push(prop);
@@ -141,42 +179,73 @@ <h2 id="report_name"></h2>
 
         /* Create a table */
         function create_table(name, title) {
-            var new_tr = $('<tr></tr>');
-            new_tr.append(
-                $('<td>').append(
+            $('<div class="row">')
+            .append(
+                $('<div>')
+                .addClass('container-fluid report-single-table')
+                .append(
                     $('<div>')
+                    .addClass('panel panel-danger')
                     .append(
                         $('<div>')
                         .addClass('panel-heading')
                         .text(title)
                     )
                     .append(
-                        $('<table>', {id:table_id_from_name(name)})
-                        .addClass('table table-hover table-striped table-bordered info-table')
+                        $('<div>', {id:table_id_from_name(name)})
+                        .addClass(
+                            'table table-hover table-striped table-bordered info-table'
+                        )
                         .append(
-                            $('<tr>')
-                            .append($('<td>').text('Issuer'))
-                            .append($('<td>', {id: field_id_from_key(name, 'name')}))
-                        ).append(
-                            $('<tr>')
-                            .append($('<td>').text('Status'))
-                            .append($('<td>', {id: field_id_from_key(name, 'status')}))
-                        ).append(
-                            $('<tr>')
-                            .append($('<td>').text('Reason'))
-                            .append($('<td>', {id: field_id_from_key(name, 'reason')}))
+                            $('<div>')
+                            .addClass('row report-row')
+                            .append(
+                                $('<div>')
+                                .addClass('report-cell-key col-sm-3')
+                                .text('Issuer')
+                            )
+                            .append(
+                                $('<div>', {id: field_id_from_key(name, 'name')})
+                                .addClass('report-cell-value col-sm-9')
+                            )
+                        )
+                        .append(
+                            $('<div>')
+                            .addClass('row report-row')
+                            .append(
+                                $('<div>')
+                                .addClass('report-cell-key col-sm-3')
+                                .text('Status')
+                            )
+                            .append(
+                                $('<div>', {id: field_id_from_key(name, 'status')})
+                                .addClass('report-cell-value col-sm-9')
+                            )
+                        )
+                        .append(
+                            $('<div>')
+                            .addClass('row report-row')
+                            .append(
+                                $('<div>')
+                                .addClass('report-cell-key col-sm-3')
+                                .text('Reason')
+                            )
+                            .append(
+                                $('<div>', {id: field_id_from_key(name, 'reason')})
+                                .addClass('report-cell-value col-sm-')
+                            )
                         )
                     )
-                    .addClass('panel panel-danger')
                 )
-            ).appendTo($('#reports_container_table_body'));
+            )
+            .appendTo($('#reports_container_table_body'));
         }
 
         /* Build tables and fill them for all reports */
         function build_tables(response) {
             var report = response.report;
             var sub_reports = report.sub_reports;
-            $('#report_name').text('Report for test #' + report_num);
+            $('#report_name').text('Report #' + report_num);
             fill_table('main_report', report, ['name', 'status', 'reason', 'fuzz_path']);
             sub_reports.sort();
             $.each(sub_reports, function(idx, key){
diff --git a/kitty/interfaces/web/static/style.css b/kitty/interfaces/web/static/style.css
index 4b22c6a..843741f 100644
--- a/kitty/interfaces/web/static/style.css
+++ b/kitty/interfaces/web/static/style.css
@@ -95,7 +95,6 @@ td {
 }
 
 #stages-graph {
-  /*height: 320px;*/
   height: 100%;
   width: 100%;
   position: absolute;
@@ -126,4 +125,42 @@ position: relative;
   overflow: hidden;
   max-height: 90%;
   max-width: 100%;
+}
+
+div[class^="report-"] {
+}
+
+div[class^="report-cell"] {
+/*  display: table-cell;
+  vertical-align: top;*/
+}
+
+.report-cell-key {
+  overflow: hidden;
+  /*max-width: 25%;*/
+  border-right: 1px dashed;
+  border-right-color: #e1bebe;
+}
+
+.report-cell-value {
+  overflow: auto;
+  /*max-width: 75%;*/
+}
+
+.report-row {
+  width: 100%;
+  border: 1px solid;
+  border-color: #f2dede;
+  margin: 0px;
+  padding: 2px;
+}
+
+.report-row:hover{
+  background: #f2dede;
+}
+
+.report-single-table {
+  margin-left: 0px;
+  margin-right: 0px;
+  margin-bottom: 20px;
 }
\ No newline at end of file

From 67655901b00605a505d6ffe2efc12416c373cfc3 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Sun, 1 May 2016 16:41:32 +0300
Subject: [PATCH 20/25] [docs] updated readthedocs links from .org to .io

---
 README.rst                                    | 4 ++--
 docs/source/base_structure.rst                | 2 +-
 docs/source/data_model/big_list_of_fields.rst | 2 +-
 kitty/remote/rpc.py                           | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.rst b/README.rst
index 81fbb24..dd294db 100644
--- a/README.rst
+++ b/README.rst
@@ -101,7 +101,7 @@ What's Next?
 
         pip install kittyfuzzer
 
-- Read some of the documentation at `ReadTheDocs <https://kitty.readthedocs.org>`_.
+- Read some of the documentation at `ReadTheDocs <https://kitty.readthedocs.io>`_.
 - Build your fuzzer :-)
 - Need some help - ask at our google group: kitty-fuzzer@googlegroups.com
 
@@ -126,7 +126,7 @@ Contribution FAQ
 .. |docs| image:: https://readthedocs.org/projects/kitty/badge/?version=latest
     :alt: Documentation Status
     :scale: 100%
-    :target: https://kitty.readthedocs.org/en/latest/?badge=latest
+    :target: https://kitty.readthedocs.io/en/latest/?badge=latest
 
 .. |travis| image:: https://travis-ci.org/cisco-sas/kitty.svg?branch=master
     :alt: Build Status
diff --git a/docs/source/base_structure.rst b/docs/source/base_structure.rst
index b6852a2..25dcf85 100644
--- a/docs/source/base_structure.rst
+++ b/docs/source/base_structure.rst
@@ -10,7 +10,7 @@ Relation Between Modules
 
 .. note::
 
-   Need to generate UML, look here... https://build-me-the-docs-please.readthedocs.org/en/latest/Using_Sphinx/UsingGraphicsAndDiagramsInSphinx.html
+   Need to generate UML, look here... https://build-me-the-docs-please.readthedocs.io/en/latest/Using_Sphinx/UsingGraphicsAndDiagramsInSphinx.html
 
 ::
 
diff --git a/docs/source/data_model/big_list_of_fields.rst b/docs/source/data_model/big_list_of_fields.rst
index 23960a9..96299a9 100644
--- a/docs/source/data_model/big_list_of_fields.rst
+++ b/docs/source/data_model/big_list_of_fields.rst
@@ -259,7 +259,7 @@ from some (or many) samples, or if you know of such a tool,
 we'd really like to know about that.
 
 Anyway... Kitty's data model syntax is inspired by the syntax of
-`Construct <https://construct.readthedocs.org/en/latest/>`_.
+`Construct <https://construct.readthedocs.io/en/latest/>`_.
 In the sense that the entire model of a payload (e.g. template)
 can be constructed in a single -- nested -- constructur.
 Using the standard alignment of python,
diff --git a/kitty/remote/rpc.py b/kitty/remote/rpc.py
index d15b434..bc6d0d0 100644
--- a/kitty/remote/rpc.py
+++ b/kitty/remote/rpc.py
@@ -17,7 +17,7 @@
 
 '''
 RPC implementation, based on jsonrpc
-https://json-rpc.readthedocs.org/
+https://json-rpc.readthedocs.io/
 '''
 import requests
 import json

From 3d1c55b0340ee2a07827633f2dcb8083525795c6 Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Sun, 1 May 2016 18:41:11 +0300
Subject: [PATCH 21/25] [kitty-tool] improvements, more TBD

---
 bin/kitty_tool.py | 32 ++++++++++++++------------------
 1 file changed, 14 insertions(+), 18 deletions(-)

diff --git a/bin/kitty_tool.py b/bin/kitty_tool.py
index 5277fad..1736661 100755
--- a/bin/kitty_tool.py
+++ b/bin/kitty_tool.py
@@ -19,12 +19,11 @@
 Tools for testing and manipulating kitty templates.
 
 Usage:
-    kitty-tool generate [--verbose] [-s SKIP] [-c COUNT] [-o OUTDIR] [-f FORMAT] <FILE> <TEMPLATE> ...
+    kitty-tool generate [options] <FILE> <TEMPLATE> ...
     kitty-tool list <FILE>
     kitty-tool --version
 
 Commands:
-
     generate    generate files with mutated payload
     list        list templates in a file
 
@@ -34,6 +33,7 @@
     --out -o OUTDIR         output directory for the generated mutations [default: out]
     --skip -s SKIP          how many mutations to skip [default: 0]
     --count -c COUNT        end index to generate
+    --path -p FIELDPATH     generate mutations only for the field with the given path
     --verbose -v            verbose output
     --filename-format -f FORMAT  format for generated file names [default: %(template)s.%(index)s.bin]
     --version               print version and exit
@@ -114,31 +114,31 @@ def handle(self, template):
 
 class FileGeneratorHandler(Handler):
 
-    def __init__(self, outdir, skip, count, template_names, filename_template, logger):
+    def __init__(self, opts, logger):
         super(FileGeneratorHandler, self).__init__(logger)
-        self.outdir = outdir or 'out'
-        if skip is not None:
+        self.outdir = opts['--out'] or 'out'
+        if opts['--skip'] is not None:
             try:
-                self.skip = int(skip)
+                self.skip = int(opts['--skip'])
             except:
                 raise Exception('skip should be a number')
         else:
             self.skip = 0
-        self.count = count
+        self.count = opts['--count']
         if self.count:
             try:
-                self.count = int(count)
+                self.count = int(self.count)
             except:
                 raise Exception('count should be a number')
-        self.template_names = template_names
-        self.filename_template = filename_template
+        self.template_names = opts['<TEMPLATE>']
+        self.filename_format = opts['--filename-format']
         try:
-            self.filename_template % {
+            self.filename_format % {
                 'template': 'hello',
                 'index': 1
             }
         except:
-            raise Exception('invalid filename template: %s' % (self.filename_template))
+            raise Exception('invalid filename template: %s' % (self.filename_format))
 
     def start(self):
         if os.path.exists(self.outdir):
@@ -162,7 +162,7 @@ def handle(self, template):
 #            step = max(step, 2)
             max_line_length = 0
             while template.mutate():
-                template_filename = self.filename_template % {'template': template_name, 'index': template._current_index}
+                template_filename = self.filename_format % {'template': template_name, 'index': template._current_index}
                 with open(os.path.join(self.outdir, template_filename), 'wb') as f:
                     f.write(template.render().tobytes())
                 metadata_filename = template_filename + '.metadata'
@@ -200,11 +200,7 @@ def _main():
             file_iter = FileIterator(
                 opts['<FILE>'],
                 FileGeneratorHandler(
-                    outdir=opts['--out'],
-                    skip=opts['--skip'],
-                    count=opts['--count'],
-                    template_names=opts['<TEMPLATE>'],
-                    filename_template=opts['--filename-format'],
+                    opts,
                     logger=logger
                 ),
                 logger

From b8da272ec651daf10663950e229f83ac3ead8dbc Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 3 May 2016 21:51:08 +0300
Subject: [PATCH 22/25] [DataModel] bugfix - Delimiter field's __init__ didn't
 receive nor passed an encoder

---
 kitty/model/low_level/field.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/kitty/model/low_level/field.py b/kitty/model/low_level/field.py
index 08f50b9..53aff32 100644
--- a/kitty/model/low_level/field.py
+++ b/kitty/model/low_level/field.py
@@ -660,7 +660,7 @@ class Delimiter(String):
     _encoder_type_ = StrEncoder
     lib = None
 
-    def __init__(self, value, max_size=None, fuzzable=True, name=None):
+    def __init__(self, value, max_size=None, encoder=ENC_STR_DEFAULT, fuzzable=True, name=None):
         '''
         :type value: str
         :param value: default value
@@ -676,7 +676,7 @@ def __init__(self, value, max_size=None, fuzzable=True, name=None):
 
                 Delimiter('=', max_size=30, encoder=ENC_STR_BASE64)
         '''
-        super(Delimiter, self).__init__(value=value, max_size=max_size, fuzzable=fuzzable, name=name)
+        super(Delimiter, self).__init__(value=value, max_size=max_size, encoder=encoder, fuzzable=fuzzable, name=name)
 
     def _get_class_lib(self):
         lib = []

From e680e7e557b3513929facc164f47d1000133b2eb Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Tue, 3 May 2016 23:44:23 +0300
Subject: [PATCH 23/25] [DataModel] new field - Float

Float is a field that represents an IEEE 754 floating point number.
At this point, the mutation library for it only contains special cases
(e.g. negative and positives of inf, Nan and 0).
A set of Float encoders was added as well, based on struct (for binary32
and binary64) and format strings (for decimal*).
---
 docs/source/data_model/big_list_of_fields.rst |   9 +-
 kitty/model/low_level/encoder.py              | 108 +++++++++++++++++-
 kitty/model/low_level/field.py                |  43 +++++++
 tests/test_model_low_level_encoders.py        |   1 -
 tests/test_model_low_level_fields.py          |  21 +++-
 5 files changed, 172 insertions(+), 10 deletions(-)

diff --git a/docs/source/data_model/big_list_of_fields.rst b/docs/source/data_model/big_list_of_fields.rst
index 96299a9..6907e8c 100644
--- a/docs/source/data_model/big_list_of_fields.rst
+++ b/docs/source/data_model/big_list_of_fields.rst
@@ -94,6 +94,7 @@ The following atomic fields are available in Kitty (some of them are aliases for
     :class:`~kitty.model.low_level.aliases.SInt64`
 - :class:`~kitty.model.low_level.field.Delimiter`
 - :class:`~kitty.model.low_level.field.Dynamic`
+- :class:`~kitty.model.low_level.field.Float`
 - :class:`~kitty.model.low_level.field.Group`
 - :class:`~kitty.model.low_level.field.RandomBits`
 - :class:`~kitty.model.low_level.field.RandomBytes`
@@ -211,11 +212,12 @@ Encoders
 The encoders receive data from the field they are assigned to,
 and return a sequence of bits, which is the rendered data.
 
-There are 3 types of encoders:
+There are 4 types of encoders:
 
 - Encoders of strings (python2.7's str), receiving a string and returning Bits.
 - Encoders of Bits, receiving Bits object and returning Bits.
 - Encoders of numbers, receiving int value, length in bits and sign and returning Bits.
+- Encoders of floating point numbers, receiving float and returning Bits.
 
 Encoders are objects, but since most common encoders are stateless,
 and don't change state, the same instance can be used in multple fields,
@@ -243,6 +245,11 @@ These instances are listed in the :doc:`API reference<../kitty.model.low_level.e
     - :class:`~kitty.model.low_level.encoder.StrFuncEncoder`
     - :class:`~kitty.model.low_level.encoder.StrNullTerminatedEncoder`
 
+- :class:`~kitty.model.low_level.encoder.FloatEncoder`
+
+    - :class:`~kitty.model.low_level.encoder.FloatAsciiEncoder`
+    - :class:`~kitty.model.low_level.encoder.FloatBinEncoder`
+
 .. _examples:
 
 Using the syntax
diff --git a/kitty/model/low_level/encoder.py b/kitty/model/low_level/encoder.py
index 5175e6f..4277f13 100644
--- a/kitty/model/low_level/encoder.py
+++ b/kitty/model/low_level/encoder.py
@@ -20,7 +20,7 @@
 The encoders are passed as an argument to the fields/container, during the field rendering,
 the encoder's `encode` method is called.
 
-There are three families of encoders:
+There are four families of encoders:
 
 :Bits Encoders: Used to encode fields/containers that their value is of type *Bits* (Container, ForEach etc.)
 
@@ -29,9 +29,14 @@
 :BitField Encoders:
     Used to encode fields that inherit from BitField or contain BitField (UInt8, Size, Checksum etc.)
     Those encoders are also refferred to as Int Encoders.
+
+:FloatingPoint Encoders:
+    Used to encode fields that inherit from FloatingPoint field (Float, Double)
+    Those encoders are also refferred to as Float Encoders
 '''
 from bitstring import Bits, BitArray
 from kitty.core import kassert, KittyException
+from struct import pack
 
 
 # ################### String Encoders ####################
@@ -176,8 +181,8 @@ class BitFieldEncoder(object):
     | Singleton Name    | Encoding                              | Class                 |
     +===================+=======================================+=======================+
     | ENC_INT_BIN       | Encode as binary bits                 | BitFieldBinEncoder    |
-    +-------------------+---------------------------------------+-----------------------+
-    | ENC_INT_LE        | Encode as a little endian binary bits | BitFieldBinEncoder    |
+    +-------------------+---------------------------------------+                       +
+    | ENC_INT_LE        | Encode as a little endian binary bits |                       |
     +-------------------+---------------------------------------+                       |
     | ENC_INT_BE        | Encode as a big endian binary bits    |                       |
     +-------------------+---------------------------------------+-----------------------+
@@ -187,7 +192,7 @@ class BitFieldEncoder(object):
     +-------------------+---------------------------------------+                       |
     | ENC_INT_HEX_UPPER | Encode as an upper case hex value     |                       |
     +-------------------+---------------------------------------+-----------------------+
-    | ENC_INT_DEFAULT   | Same as ENC_INT_BIN                   |                       |
+    | ENC_INT_DEFAULT   | Same as ENC_INT_BIN                   | BitFieldBinEncoder    |
     +-------------------+---------------------------------------+-----------------------+
     '''
 
@@ -423,3 +428,98 @@ def encode(self, value):
 ENC_BITS_HEX = StrEncoderWrapper(StrEncodeEncoder('hex'))
 
 ENC_BITS_DEFAULT = ENC_BITS_NONE
+
+
+# ################### BitField (int) Encoders ####################
+
+class FloatEncoder(object):
+    '''
+    Base encoder class for FloatingPoint values
+
+    +-------------------+---------------------------------------+-----------------------------------------------------------+
+    | Singleton Name    | Encoding                              | Class                                                     |
+    +===================+=======================================+===========================================================+
+    | ENC_FLT_LE        | Encode as a little endian 32 bit      | :class:`~kitty.model.low_level.encoder.FloatBinEncoder`   |
+    +-------------------+---------------------------------------+                                                           |
+    | ENC_FLT_BE        | Encode as a big endian 32 bit         |                                                           |
+    +-------------------+---------------------------------------+                                                           |
+    | ENC_DBL_LE        | Encode as a little endian 64 bit      |                                                           |
+    +-------------------+---------------------------------------+                                                           |
+    | ENC_DBL_BE        | Encode as a big endian 64 bit         |                                                           |
+    +-------------------+---------------------------------------+-----------------------------------------------------------+
+    | ENC_FLT_FP        | Fixed point                           | :class:`~kitty.model.low_level.encoder.FloatAsciiEncoder` |
+    +-------------------+---------------------------------------+                                                           |
+    | ENC_FLT_EXP       | Exponent notation                     |                                                           |
+    +-------------------+---------------------------------------+                                                           |
+    | ENC_FLT_EXP_UPPER | Exponent notation, with upper case E  |                                                           |
+    +-------------------+---------------------------------------+                                                           |
+    | ENC_FLT_GEN       | General format                        |                                                           |
+    +-------------------+---------------------------------------+                                                           |
+    | ENC_FLT_GEN_UPPER | General format, with upper case       |                                                           |
+    +-------------------+---------------------------------------+-----------------------------------------------------------+
+    | ENC_FLT_DEFAULT   | Same as ENC_FLT_BE                    | :class:`~kitty.model.low_level.encoder.FloatBinEncoder`   |
+    +-------------------+---------------------------------------+-----------------------------------------------------------+
+    '''
+
+    def encode(self, value):
+        '''
+        :type value: ``float``
+        :param value: value to encode
+        :rtype: ``Bits``
+        :return: encoded value in bits
+        '''
+        raise NotImplementedError('should be implemented in sub classes')
+
+
+class FloatBinEncoder(FloatEncoder):
+    '''
+    Encode a floating point number in binary format as described by IEEE 754 (binary32 and binary64)
+    '''
+
+    def __init__(self, fmt):
+        '''
+        :type fmt: str
+        :param fmt: format of binary encoding (see floating point encoding in struct docs.)
+        '''
+        super(FloatBinEncoder, self).__init__()
+        self.fmt = fmt
+
+    def encode(self, value):
+        '''
+        :param value: value to encode
+        '''
+        packed = pack(self.fmt, value)
+        return Bits(bytes=packed)
+
+
+class FloatAsciiEncoder(FloatEncoder):
+    '''
+    Encode a floating point number in ascii as described by IEEE 754 (decimal*)
+    '''
+
+    def __init__(self, fmt):
+        '''
+        :type fmt: str
+        :param fmt: format of ascii encoding (see floating point encoding in string docs.)
+        '''
+        super(FloatAsciiEncoder, self).__init__()
+        self.fmt = fmt
+
+    def encode(self, value):
+        '''
+        :param value: value to encode
+        '''
+        packed = self.fmt % (value)
+        return Bits(bytes=packed)
+
+
+ENC_FLT_LE = FloatBinEncoder('<f')
+ENC_FLT_BE = FloatBinEncoder('>f')
+ENC_DBL_LE = FloatBinEncoder('<d')
+ENC_DBL_BE = FloatBinEncoder('>d')
+ENC_FLT_FP = FloatAsciiEncoder('%f')
+ENC_FLT_EXP = FloatAsciiEncoder('%e')
+ENC_FLT_EXP_UPPER = FloatAsciiEncoder('%E')
+ENC_FLT_GEN = FloatAsciiEncoder('%g')
+ENC_FLT_GEN_UPPER = FloatAsciiEncoder('%G')
+ENC_FLT_DEFAULT = ENC_FLT_BE
diff --git a/kitty/model/low_level/field.py b/kitty/model/low_level/field.py
index 53aff32..71d15ec 100644
--- a/kitty/model/low_level/field.py
+++ b/kitty/model/low_level/field.py
@@ -29,6 +29,7 @@
 from kitty.model.low_level.encoder import ENC_STR_DEFAULT, StrEncoder
 from kitty.model.low_level.encoder import ENC_INT_DEFAULT, BitFieldEncoder
 from kitty.model.low_level.encoder import ENC_BITS_DEFAULT, BitsEncoder
+from kitty.model.low_level.encoder import ENC_FLT_DEFAULT, FloatEncoder
 
 
 empty_bits = Bits()
@@ -689,6 +690,48 @@ def _get_class_lib(self):
         return lib
 
 
+class Float(_LibraryField):
+    '''
+    Represent a floating point number.
+    The mutations target edge cases and invalid floating point numbers.
+    '''
+    _encoder_type_ = FloatEncoder
+    lib = None
+
+    def __init__(self, value, encoder=ENC_FLT_DEFAULT, fuzzable=True, name=None):
+        '''
+        :type value: float
+        :param value: default value
+        :type encoder: :class:`~kitty.model.low_levele.encoder.FloatEncoder`
+        :param encoder: encoder for the field (default: ENC_FLT_DEFAULT)
+        :param fuzzable: is field fuzzable (default: True)
+        :param name: name of the object (default: None)
+
+        :example:
+
+            ::
+
+                Float(0.3)
+        '''
+        super(Float, self).__init__(value=value, encoder=encoder, fuzzable=fuzzable, name=name)
+
+    def _get_local_lib(self):
+        return []
+
+    def _get_class_lib(self):
+        lib = []
+        lib.append((float('NaN'), 'positive NaN'))
+        lib.append((float('-NaN'), 'negative NaN'))
+        lib.append((float('inf'), 'positive infinity'))
+        lib.append((float('-inf'), 'negative infinity'))
+        lib.append((float(0.), 'positive zero'))
+        lib.append((float(-0.), 'negative zero'))
+        #
+        # what else?
+        #
+        return lib
+
+
 class BitField(_LibraryField):
     '''
     Represents a fixed-length sequence of bits, the mutations target common integer related vulnerabilities
diff --git a/tests/test_model_low_level_encoders.py b/tests/test_model_low_level_encoders.py
index e280a4b..6d84adb 100644
--- a/tests/test_model_low_level_encoders.py
+++ b/tests/test_model_low_level_encoders.py
@@ -183,4 +183,3 @@ def _encode_func(self, s):
 
     def get_default_encoder(self):
         return self.cls()
-
diff --git a/tests/test_model_low_level_fields.py b/tests/test_model_low_level_fields.py
index b7081d1..ce37d3c 100644
--- a/tests/test_model_low_level_fields.py
+++ b/tests/test_model_low_level_fields.py
@@ -22,7 +22,8 @@
 from common import metaTest, BaseTestCase
 from bitstring import Bits
 import types
-from kitty.model import String, Delimiter, RandomBits, RandomBytes, Dynamic, Static, Group
+import struct
+from kitty.model import String, Delimiter, RandomBits, RandomBytes, Dynamic, Static, Group, Float
 from kitty.model import BitField, UInt8, UInt16, UInt32, UInt64, SInt8, SInt16, SInt32, SInt64
 from kitty.core import KittyException
 import os
@@ -97,18 +98,18 @@ def testNotFuzzable(self):
         self.assertEqual(num_mutations, 0)
         rendered = field.render()
         as_val = self.bits_to_value(rendered)
-        self.assertEqual(as_val, self.default_value)
+        self.assertAlmostEqual(as_val, self.default_value, places=5)
         mutated = field.mutate()
         self.assertFalse(mutated)
         rendered = field.render()
         as_val = self.bits_to_value(rendered)
-        self.assertEqual(as_val, self.default_value)
+        self.assertAlmostEqual(as_val, self.default_value, places=5)
         field.reset()
         mutated = field.mutate()
         self.assertFalse(mutated)
         rendered = field.render()
         as_val = self.bits_to_value(rendered)
-        self.assertEqual(as_val, self.default_value)
+        self.assertAlmostEqual(as_val, self.default_value, places=5)
 
     @metaTest
     def testNumMutations(self):
@@ -715,6 +716,18 @@ def testMutations(self):
         self.assertListEqual([Bits(bytes=x) for x in self.default_values], mutations)
 
 
+class FloatTests(ValueTestCase):
+    __meta__ = False
+    default_value = 15.3
+    default_value_rendered = Bits(bytes=struct.pack('>f', default_value))
+
+    def setUp(self):
+        super(FloatTests, self).setUp(Float)
+
+    def bits_to_value(self, bits):
+        return struct.unpack('>f', bits.tobytes())[0]
+
+
 class BitFieldTests(ValueTestCase):
 
     __meta__ = False

From 1fb38ab13857e89aab7e3f41b928024d882745ce Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Wed, 4 May 2016 00:15:32 +0300
Subject: [PATCH 24/25] version 0.6.8

---
 CHANGELOG           | 36 +++++++++++++++++++++++-------------
 README.rst          |  1 +
 docs/source/conf.py |  4 ++--
 setup.py            |  2 +-
 4 files changed, 27 insertions(+), 16 deletions(-)

diff --git a/CHANGELOG b/CHANGELOG
index c745362..7d76ee4 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,24 +1,34 @@
+Version 0.6.8 (2016-05-03)
+==========================
+
+* bugfix: [DataModel] Delimiter field's __init__ didn't receive nor passed an encoder
+* bugfix: [DataModel] condition - added copy function and fixed invalidate function
+* bugfix: [DataModel] rendering of default values in containers
+* enhancement: [WebInterface] html - improvements in index and reports display
+* new feature: [DataModel] new field - Float
+* new feature: [DataModel] new field - Switch
+
 Version 0.6.7 (2016-04-18)
 ==========================
 
-* new feature: [KittyActor] a new class, KittyActor, is now the base class for monitors and controllers
-* new feature: [KittyActor] a new API is_victim_alive can be used to check if the victim is alive, it is called in a loop in pre-test
-* enhancement: [BaseFuzzer] default logging level is now INFO, hence less messages are printed, can be controlled from cmd line args
 * bugfix: [BaseFuzzer] update test info before the calling target's pre_test
-* new feature: [Report] use 'status' field instead of 'failed' field in the report. currently support FAILED, PASSED and ERROR.
-* enhancement: [WebInterface] html - improvements of caching, window size, cell overflow
-* new feature: [WebInterface] html - report table now shows test status and reason
-* bugfix: [kitty-tool] fixed command line option parsing
-* new feature: [kitty-tool] added checks for mutation indices in "generate"
-* new feature: [kitty-tool] print progress and current field path in "generate"
 * bugfix: [DataModel] fixed "field path" in field info
-* new feature: [DataModel] new fields - Offset & AbsoluteOffset - can hold the offset of a specific field inside the template
-* new feature: [DataModel] new conditions - BitMaskSet and BitMaskNotSet
-* new feature: [DataModel] absolute name resolution of fields
+* bugfix: [kitty-tool] fixed command line option parsing
+* enhancement: [BaseFuzzer] default logging level is now INFO, hence less messages are printed, can be controlled from cmd line args
 * enhancement: [DataModel] perform render in two passes when needed, avoid (some) redundant rendering in between
-* new feature: [DataModel] new container - List - will perform the standard mutations of each of the internal fields, but will also perform mutations on the order and existence of its elements.
 * enhancement: [DataModel] reduce number of mutations for BitField & String field. This cuts the mutation count to about half of the previous count.
+* enhancement: [WebInterface] html - improvements of caching, window size, cell overflow
+* new feature: [DataModel] new conditions - BitMaskSet and BitMaskNotSet
+* new feature: [DataModel] new container - List - will perform the standard mutations of each of the internal fields, but will also perform mutations on the order and existence of its elements.
+* new feature: [DataModel] new fields - Offset & AbsoluteOffset - can hold the offset of a specific field inside the template
+* new feature: [DataModel] absolute name resolution of fields
 * new feature: [DataModel] now String and BitField have a human friendly mutation description in the info
+* new feature: [KittyActor] a new class, KittyActor, is now the base class for monitors and controllers
+* new feature: [KittyActor] a new API is_victim_alive can be used to check if the victim is alive, it is called in a loop in pre-test
+* new feature: [kitty-tool] added checks for mutation indices in "generate"
+* new feature: [kitty-tool] print progress and current field path in "generate"
+* new feature: [Report] use 'status' field instead of 'failed' field in the report. currently support FAILED, PASSED and ERROR.
+* new feature: [WebInterface] html - report table now shows test status and reason
 
 Version 0.6.6 (2016-04-03)
 ==========================
diff --git a/README.rst b/README.rst
index dd294db..6f8c52d 100644
--- a/README.rst
+++ b/README.rst
@@ -104,6 +104,7 @@ What's Next?
 - Read some of the documentation at `ReadTheDocs <https://kitty.readthedocs.io>`_.
 - Build your fuzzer :-)
 - Need some help - ask at our google group: kitty-fuzzer@googlegroups.com
+- You can also find us on freenode #kittyfuzzer
 
 Contribution FAQ
 ----------------
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 564ee2d..1f26748 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -63,9 +63,9 @@
 # built documents.
 #
 # The short X.Y version.
-version = '0.6.7'
+version = '0.6.8'
 # The full version, including alpha/beta/rc tags.
-release = '0.6.7'
+release = '0.6.8'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
diff --git a/setup.py b/setup.py
index 443ab0c..a36b81c 100644
--- a/setup.py
+++ b/setup.py
@@ -7,7 +7,7 @@ def read(fname):
     return open(os.path.join(os.path.dirname(__file__), fname)).read()
 
 
-VERSION = '0.6.7'
+VERSION = '0.6.8'
 AUTHOR = 'Cisco SAS team'
 EMAIL = 'kitty-fuzzer@googlegroups.com'
 URL = 'https://github.com/cisco-sas/kitty.git'

From afe797d10796e52e97d5ac44fe9fddf54841e80d Mon Sep 17 00:00:00 2001
From: Binyamin Sharet <s.binyamin@gmail.com>
Date: Wed, 4 May 2016 00:17:09 +0300
Subject: [PATCH 25/25] fixed date in changelog

---
 CHANGELOG | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG b/CHANGELOG
index 7d76ee4..9b7f3a6 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,4 +1,4 @@
-Version 0.6.8 (2016-05-03)
+Version 0.6.8 (2016-05-04)
 ==========================
 
 * bugfix: [DataModel] Delimiter field's __init__ didn't receive nor passed an encoder