Nsnam - User contributions [en]

GSoC2018:Trust-based routing protocols framework

2018-07-15T04:43:38Z

Jude.niroshan: /* Trust calculation algorithm */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)'' or routing metrics''(bandwidth, cost, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets. Eventually trust value can be considered as a security factor for making the routing decision.

== Administer trust values ==
There is a separate new table to hold the trust values in each node within the network. Trust values in ad-hoc networks will have no affect on the routing table.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has a trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>trust-table.h</code> is represented by <code>trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust table.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework has allowed any trust calculation algorithm to work by simply defining how the calculation should work.

<code>simple-aodv-trust-handler</code> is proper example usage of trust calculation of the trust framework. <code>trust-handler</code> is the abstract class which has <code>CalcuateTrust()</code> method. This method must be implemented in a concrete class.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

# Documentation and added more description about the trust framework
# Modified the aodv-routing-protocol.cc to collect metrics for the trust calculation

== Week 7 (June 25 - July 02) ==

# Re-designed the architecture for the trust framework as we have concerns about changing the protocol classes
# New promiscuous callback function considered to collect the metrics for trust value calculation

== Week 8 (July 03 - July 10) ==

# Created a simple simulation with a simple promiscuous callback to collect the metrics for trust calculation
# Removed the boolean flag which is unnecessary code. (We will decide whether to switch to trust tables if we have a trust table for a given node)

== Week 9 (July 10 - July 17) ==

# Re-designed the trust framework architecture as follows:
[[File:Updated_trust_framework_uml.jpeg|1000px]]

GSoC2018:Trust-based routing protocols framework

2018-07-15T04:39:15Z

Jude.niroshan: /* Trust Table */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)'' or routing metrics''(bandwidth, cost, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets. Eventually trust value can be considered as a security factor for making the routing decision.

== Administer trust values ==
There is a separate new table to hold the trust values in each node within the network. Trust values in ad-hoc networks will have no affect on the routing table.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has a trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>trust-table.h</code> is represented by <code>trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust table.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

# Documentation and added more description about the trust framework
# Modified the aodv-routing-protocol.cc to collect metrics for the trust calculation

== Week 7 (June 25 - July 02) ==

# Re-designed the architecture for the trust framework as we have concerns about changing the protocol classes
# New promiscuous callback function considered to collect the metrics for trust value calculation

== Week 8 (July 03 - July 10) ==

# Created a simple simulation with a simple promiscuous callback to collect the metrics for trust calculation
# Removed the boolean flag which is unnecessary code. (We will decide whether to switch to trust tables if we have a trust table for a given node)

== Week 9 (July 10 - July 17) ==

# Re-designed the trust framework architecture as follows:
[[File:Updated_trust_framework_uml.jpeg|1000px]]

GSoC2018:Trust-based routing protocols framework

2018-07-15T04:38:52Z

Jude.niroshan: /* Trust Table */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)'' or routing metrics''(bandwidth, cost, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets. Eventually trust value can be considered as a security factor for making the routing decision.

== Administer trust values ==
There is a separate new table to hold the trust values in each node within the network. Trust values in ad-hoc networks will have no affect on the routing table.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has a trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>trust-table.h</code> is represented by <code>trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust table.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

# Documentation and added more description about the trust framework
# Modified the aodv-routing-protocol.cc to collect metrics for the trust calculation

== Week 7 (June 25 - July 02) ==

# Re-designed the architecture for the trust framework as we have concerns about changing the protocol classes
# New promiscuous callback function considered to collect the metrics for trust value calculation

== Week 8 (July 03 - July 10) ==

# Created a simple simulation with a simple promiscuous callback to collect the metrics for trust calculation
# Removed the boolean flag which is unnecessary code. (We will decide whether to switch to trust tables if we have a trust table for a given node)

== Week 9 (July 10 - July 17) ==

# Re-designed the trust framework architecture as follows:
[[File:Updated_trust_framework_uml.jpeg|1000px]]

GSoC2018:Trust-based routing protocols framework

2018-07-15T03:48:01Z

Jude.niroshan: /* What is Trust value */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)'' or routing metrics''(bandwidth, cost, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets. Eventually trust value can be considered as a security factor for making the routing decision.

== Administer trust values ==
There is a separate new table to hold the trust values in each node within the network. Trust values in ad-hoc networks will have no affect on the routing table.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

# Documentation and added more description about the trust framework
# Modified the aodv-routing-protocol.cc to collect metrics for the trust calculation

== Week 7 (June 25 - July 02) ==

# Re-designed the architecture for the trust framework as we have concerns about changing the protocol classes
# New promiscuous callback function considered to collect the metrics for trust value calculation

== Week 8 (July 03 - July 10) ==

# Created a simple simulation with a simple promiscuous callback to collect the metrics for trust calculation
# Removed the boolean flag which is unnecessary code. (We will decide whether to switch to trust tables if we have a trust table for a given node)

== Week 9 (July 10 - July 17) ==

# Re-designed the trust framework architecture as follows:
[[File:Updated_trust_framework_uml.jpeg|1000px]]

File:Updated trust framework uml.jpeg

2018-07-15T03:40:36Z

Jude.niroshan:

GSoC2018:Trust-based routing protocols framework

2018-07-15T03:39:50Z

Jude.niroshan:

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)'' or routing metrics''(bandwidth, cost, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets. Eventually trust value can be considered as a security factor for making the routing decision.

'''Default trust calculation''' in the framework has only considered ''interaction count.'' If someone wants to consider more parameters''(rreq, rply, err, etc)'' for trust calculation, trust table can be modified accordingly.

== Administer trust values ==
There is a separate new table to hold the trust values in each node within the network. Trust values in ad-hoc networks will have no affect on the routing table.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

# Documentation and added more description about the trust framework
# Modified the aodv-routing-protocol.cc to collect metrics for the trust calculation

== Week 7 (June 25 - July 02) ==

# Re-designed the architecture for the trust framework as we have concerns about changing the protocol classes
# New promiscuous callback function considered to collect the metrics for trust value calculation

== Week 8 (July 03 - July 10) ==

# Created a simple simulation with a simple promiscuous callback to collect the metrics for trust calculation
# Removed the boolean flag which is unnecessary code. (We will decide whether to switch to trust tables if we have a trust table for a given node)

== Week 9 (July 10 - July 17) ==

# Re-designed the trust framework architecture as follows:
[[File:Updated_trust_framework_uml.jpeg|1000px]]

GSoC2018:Trust-based routing protocols framework

2018-07-09T09:21:58Z

Jude.niroshan: Updated weekly progress

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)'' or routing metrics''(bandwidth, cost, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets. Eventually trust value can be considered as a security factor for making the routing decision.

'''Default trust calculation''' in the framework has only considered ''interaction count.'' If someone wants to consider more parameters''(rreq, rply, err, etc)'' for trust calculation, trust table can be modified accordingly.

== Administer trust values ==
There is a separate new table to hold the trust values in each node within the network. Trust values in ad-hoc networks will have no affect on the routing table.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Scheduler task ===
There will be a new scheduler task to update the trust values in the trust table. This will involve the trust table attributes and feed them into the trust calculation algorithm and finally '''update the trust value''' in the trust table. Users can change the '''scheduler timer value'''. By default the timer value is set to 5 seconds.

=== Broadcasting malicious nodes ===
Identifying malicious nodes''(for e.g.: black hole nodes, grey hole nodes, etc.)'' in the network is a fundamental requirement in any trust based protocols. This will increase the security of the network as well as the reliability of the routes. Scheduler task is capable of identifying the malicious nodes by scanning the trust table.

Once a malicious node is identified, it should notify it to the network. This will reflect that all nodes in the network are synchronized about the malicious nodes within the network. It will be helpful when making the best route to forward the packet.

There will be a new broadcast message define in the framework''(trust framework)''. This will be used to notify the malicious nodes within the network.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

# Documentation and added more description about the trust framework
# Modified the aodv-routing-protocol.cc to collect metrics for the trust calculation

== Week 7 (June 25 - July 02) ==

# Re-designed the architecture for the trust framework as we have concerns about changing the protocol classes
# New promiscuous callback function considered to collect the metrics for trust value calculation

== Week 8 (July 03 - July 10) ==

# Created a simple simulation with a simple promiscuous callback to collect the metrics for trust calculation
# Removed the boolean flag which is unnecessary code. (We will decide whether to switch to trust tables if we have a trust table for a given node)

GSoC2018:Trust-based routing protocols framework

2018-06-26T12:03:04Z

Jude.niroshan: /* Week 6 (June 18 - June 24) */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)'' or routing metrics''(bandwidth, cost, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets. Eventually trust value can be considered as a security factor for making the routing decision.

'''Default trust calculation''' in the framework has only considered ''interaction count.'' If someone wants to consider more parameters''(rreq, rply, err, etc)'' for trust calculation, trust table can be modified accordingly.

== Administer trust values ==
There is a separate new table to hold the trust values in each node within the network. Trust values in ad-hoc networks will have no affect on the routing table.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Scheduler task ===
There will be a new scheduler task to update the trust values in the trust table. This will involve the trust table attributes and feed them into the trust calculation algorithm and finally '''update the trust value''' in the trust table. Users can change the '''scheduler timer value'''. By default the timer value is set to 5 seconds.

=== Broadcasting malicious nodes ===
Identifying malicious nodes''(for e.g.: black hole nodes, grey hole nodes, etc.)'' in the network is a fundamental requirement in any trust based protocols. This will increase the security of the network as well as the reliability of the routes. Scheduler task is capable of identifying the malicious nodes by scanning the trust table.

Once a malicious node is identified, it should notify it to the network. This will reflect that all nodes in the network are synchronized about the malicious nodes within the network. It will be helpful when making the best route to forward the packet.

There will be a new broadcast message define in the framework''(trust framework)''. This will be used to notify the malicious nodes within the network.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

# Documentation and added more description about the trust framework

GSoC2018:Trust-based routing protocols framework

2018-06-23T11:37:23Z

Jude.niroshan:

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)'' or routing metrics''(bandwidth, cost, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets. Eventually trust value can be considered as a security factor for making the routing decision.

'''Default trust calculation''' in the framework has only considered ''interaction count.'' If someone wants to consider more parameters''(rreq, rply, err, etc)'' for trust calculation, trust table can be modified accordingly.

== Administer trust values ==
There is a separate new table to hold the trust values in each node within the network. Trust values in ad-hoc networks will have no affect on the routing table.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Scheduler task ===
There will be a new scheduler task to update the trust values in the trust table. This will involve the trust table attributes and feed them into the trust calculation algorithm and finally '''update the trust value''' in the trust table. Users can change the '''scheduler timer value'''. By default the timer value is set to 5 seconds.

=== Broadcasting malicious nodes ===
Identifying malicious nodes''(for e.g.: black hole nodes, grey hole nodes, etc.)'' in the network is a fundamental requirement in any trust based protocols. This will increase the security of the network as well as the reliability of the routes. Scheduler task is capable of identifying the malicious nodes by scanning the trust table.

Once a malicious node is identified, it should notify it to the network. This will reflect that all nodes in the network are synchronized about the malicious nodes within the network. It will be helpful when making the best route to forward the packet.

There will be a new broadcast message define in the framework''(trust framework)''. This will be used to notify the malicious nodes within the network.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T11:25:12Z

Jude.niroshan: /* What is Trust value */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)'' or routing metrics''(bandwidth, cost, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets. Eventually trust value can be considered as a security factor for making the routing decision.

'''Default trust calculation''' in the framework has only considered ''interaction count.'' If someone wants to consider more parameters''(rreq, rply, err, etc)'' for trust calculation, trust table can be modified accordingly.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Scheduler task ===
There will be a new scheduler task to update the trust values in the trust table. This will involve the trust table attributes and feed them into the trust calculation algorithm and finally '''update the trust value''' in the trust table. Users can change the '''scheduler timer value'''. By default the timer value is set to 5 seconds.

=== Broadcasting malicious nodes ===
Identifying malicious nodes''(for e.g.: black hole nodes, grey hole nodes, etc.)'' in the network is a fundamental requirement in any trust based protocols. This will increase the security of the network as well as the reliability of the routes. Scheduler task is capable of identifying the malicious nodes by scanning the trust table.

Once a malicious node is identified, it should notify it to the network. This will reflect that all nodes in the network are synchronized about the malicious nodes within the network. It will be helpful when making the best route to forward the packet.

There will be a new broadcast message define in the framework''(trust framework)''. This will be used to notify the malicious nodes within the network.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T11:08:51Z

Jude.niroshan: /* What is Trust value */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets.

'''Default trust calculation''' in the framework has only considered ''interaction count.'' If someone wants to consider more parameters''(rreq, rply, err, etc)'' for trust calculation, trust table can be modified accordingly.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Scheduler task ===
There will be a new scheduler task to update the trust values in the trust table. This will involve the trust table attributes and feed them into the trust calculation algorithm and finally '''update the trust value''' in the trust table. Users can change the '''scheduler timer value'''. By default the timer value is set to 5 seconds.

=== Broadcasting malicious nodes ===
Identifying malicious nodes''(for e.g.: black hole nodes, grey hole nodes, etc.)'' in the network is a fundamental requirement in any trust based protocols. This will increase the security of the network as well as the reliability of the routes. Scheduler task is capable of identifying the malicious nodes by scanning the trust table.

Once a malicious node is identified, it should notify it to the network. This will reflect that all nodes in the network are synchronized about the malicious nodes within the network. It will be helpful when making the best route to forward the packet.

There will be a new broadcast message define in the framework''(trust framework)''. This will be used to notify the malicious nodes within the network.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T11:03:46Z

Jude.niroshan: /* What is Trust value */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets.

'''Default trust calculation''' in the framework has only considered ''interaction count.'' If someone wants to consider more parameters''(rreq, rply, err, etc)'' for trust calculation, trust table can be modified accordingly.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Scheduler task ===
There will be a new scheduler task to update the trust values in the trust table. This will involve the trust table attributes and feed them into the trust calculation algorithm and finally '''update the trust value''' in the trust table. Users can change the '''scheduler timer value'''. By default the timer value is set to 5 seconds.

=== Broadcasting malicious nodes ===
Identifying malicious nodes''(for e.g.: black hole nodes, grey hole nodes, etc.)'' in the network is a fundamental requirement in any trust based protocols. This will increase the security of the network as well as the reliability of the routes. Scheduler task is capable of identifying the malicious nodes by scanning the trust table.

Once a malicious node is identified, it should notify it to the network. This will reflect that all nodes in the network are synchronized about the malicious nodes within the network. It will be helpful when making the best route to forward the packet.

There will be a new broadcast message define in the framework''(trust framework)''. This will be used to notify the malicious nodes within the network.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T11:01:24Z

Jude.niroshan: /* What is Trust value */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters''(rreq, rply, err, etc)''. Therefore, trust will become a routing metric which can be used to determine the optimal route for forwarding packets.

For example, '''default trust calculation''' has only considered ''interaction count.'' If someone wants to consider more parameters for trust calculation, trust table can be modified accordingly.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Scheduler task ===
There will be a new scheduler task to update the trust values in the trust table. This will involve the trust table attributes and feed them into the trust calculation algorithm and finally '''update the trust value''' in the trust table. Users can change the '''scheduler timer value'''. By default the timer value is set to 5 seconds.

=== Broadcasting malicious nodes ===
Identifying malicious nodes''(for e.g.: black hole nodes, grey hole nodes, etc.)'' in the network is a fundamental requirement in any trust based protocols. This will increase the security of the network as well as the reliability of the routes. Scheduler task is capable of identifying the malicious nodes by scanning the trust table.

Once a malicious node is identified, it should notify it to the network. This will reflect that all nodes in the network are synchronized about the malicious nodes within the network. It will be helpful when making the best route to forward the packet.

There will be a new broadcast message define in the framework''(trust framework)''. This will be used to notify the malicious nodes within the network.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T10:27:45Z

Jude.niroshan: /* What is Trust value */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

Trust value will be calculated based on different routing parameters. These parameters configured based on the requirement. For example, default trust calculation has only considered for

A routing metric is calculated by routing algorithms when determining the optimal route for sending network traffic.

Metrics are assigned to each different route available in the routing table and are calculated using many different techniques and methods based on the routing algorithms in use.

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Scheduler task ===
There will be a new scheduler task to update the trust values in the trust table. This will involve the trust table attributes and feed them into the trust calculation algorithm and finally '''update the trust value''' in the trust table. Users can change the '''scheduler timer value'''. By default the timer value is set to 5 seconds.

=== Broadcasting malicious nodes ===
Identifying malicious nodes''(for e.g.: black hole nodes, grey hole nodes, etc.)'' in the network is a fundamental requirement in any trust based protocols. This will increase the security of the network as well as the reliability of the routes. Scheduler task is capable of identifying the malicious nodes by scanning the trust table.

Once a malicious node is identified, it should notify it to the network. This will reflect that all nodes in the network are synchronized about the malicious nodes within the network. It will be helpful when making the best route to forward the packet.

There will be a new broadcast message define in the framework''(trust framework)''. This will be used to notify the malicious nodes within the network.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T05:44:23Z

Jude.niroshan: /* Technical Approach */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Scheduler task ===
There will be a new scheduler task to update the trust values in the trust table. This will involve the trust table attributes and feed them into the trust calculation algorithm and finally '''update the trust value''' in the trust table. Users can change the '''scheduler timer value'''. By default the timer value is set to 5 seconds.

=== Broadcasting malicious nodes ===
Identifying malicious nodes''(for e.g.: black hole nodes, grey hole nodes, etc.)'' in the network is a fundamental requirement in any trust based protocols. This will increase the security of the network as well as the reliability of the routes. Scheduler task is capable of identifying the malicious nodes by scanning the trust table.

Once a malicious node is identified, it should notify it to the network. This will reflect that all nodes in the network are synchronized about the malicious nodes within the network. It will be helpful when making the best route to forward the packet.

There will be a new broadcast message define in the framework''(trust framework)''. This will be used to notify the malicious nodes within the network.

=== Architecture ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T05:37:51Z

Jude.niroshan: /* Technical Approach */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Scheduler task ===
There will be a new scheduler task to update the trust values in the trust table. This will involve the trust table attributes and feed them into the trust calculation algorithm and finally '''update the trust value''' in the trust table. Users can change the '''scheduler timer value'''. By default the timer value is set to 5 seconds.

=== Bird's eye view ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T05:31:57Z

Jude.niroshan: /* Bird's eye view */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Bird's eye view ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simply extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T05:31:02Z

Jude.niroshan: /* Technical Approach */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table.h</code> is represented by <code>abstract-trust-entry.h</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Bird's eye view ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simple extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T05:30:26Z

Jude.niroshan: /* Trust calculation algorithm */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table</code> is represented by <code>abstract-trust-entry</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published have different algorithms for trust calculation. Therefore, the framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Bird's eye view ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simple extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T05:28:55Z

Jude.niroshan: /* Technical Approach */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table</code> is represented by <code>abstract-trust-entry</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Trust calculation algorithm ===
Almost all the research papers published within the domain of trust based routing protocols have different algorithms for trust calculation. Therefore, trust framework will allow the users to define their own algorithm for the trust calculation.

By default, there is a generic trust calculation defined in <code>abstract-trust-calculation.h</code>. Users can extend that class and define their own algorithm.

=== Bird's eye view ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simple extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T05:24:55Z

Jude.niroshan: /* Trust Table */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table</code> is represented by <code>abstract-trust-entry</code> object.
 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]
 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Bird's eye view ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simple extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-23T05:24:14Z

Jude.niroshan: /* Technical Approach */

{{TOC}}

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* '''Project name:''' Trust-based routing protocols framework
* '''Student:''' Jude Niroshan
* '''Mentor:''' Tommaso Pecorella
* '''Abstract:''' ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience vs routing attacks, it would be useful to have a general approach for trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, ''making it difficult to export the solution to other routing schemes.'' Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* '''Code:''' [https://github.com/JudeNiroshan/ns-3-dev-git/tree/gsoc2018 Github repository]
* '''About me:''' I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

== Introduction ==
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Usually, routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, ''finding a trusted route'' is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a '''trust value''' by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

== What is Trust value ==
''Trust is a relationship established between two entities for a specific action. In particular, one entity trusts the other entity to perform an action. In this work, the first entity is called the subject, the second entity is called the agent.''' [1]

''Trust is a function of uncertainty. In particular, if the subject believes that the agent will perform the action for sure, the subject fully “trusts” the agent to perform the action and there is no uncertainty; if the subject believes that the agent will not perform the action for sure, the subject “trusts” the agent not to perform the action, and there is no uncertainty either; if the subject does not have any idea of whether the agent will perform the action or not, the subject does not have trust in the agent. In this case, the subject has the highest uncertainty.''[1]

''Trust value should represent uncertainty.''[1] Uncertainly always stick to the probability which always has the value ranging from 0 - 1. Therefore, trust value will also be ranging from 0 - 1 by denoting the trust between nodes in the network.

:[1] Sun, Y.L., Yu, W., Han, Z. and Liu, K.R., 2006. Information theoretic framework of trust modeling and evaluation for ad hoc networks. ''IEEE Journal on Selected Areas in Communications, 24(2), pp.305-317.''

== Why need a trust based framework ==
Trust is a subjective measurement. There are many research papers have published which has '''various methodologies of calculating the trust value''' for the same routing protocol.

''For e.g.:'' If we consider AODV routing protocol; following papers have came up with different approaches for trust value calculation.

:[2] Li, X., Lyu, M.R. and Liu, J., 2004, March. A trust model based routing protocol for secure ad hoc networks. ''In Aerospace Conference, 2004. Proceedings. 2004 IEEE (Vol. 2, pp. 1286-1295). IEEE.''

:[3] Marchang, N. and Datta, R., 2012. Light-weight trust-based routing protocol for mobile ad hoc networks. ''IET information security, 6(2), pp.77-83.''

:[4] Pushpa, A.M., 2009, December. Trust based secure routing in AODV routing protocol. ''In Internet Multimedia Services Architecture and Applications (IMSAA), 2009 IEEE International Conference on (pp. 1-6). IEEE.''

Current NS-3 version''(ns-3.28)'' does not welcome trust based routing protocols by default. If someone wants to simulate a trust based protocol in NS-3, there are lot of changes needs to be done in many concrete level classes. This is cumbersome and it's against the conventions that we follow from the maintenance point of view. NS-3 cannot define only one way of calculating trust value as each of the above mentioned methods/approaches have written to serve specific concerns/issues. Therefore, it's clear that ''allowing any custom trust calculation run through a framework'' is a better move from NS-3. This will help the developers to try out trust based frameworks in NS-3 with ''minimal amount of coding''.

== Technical Approach ==

=== Trust Table ===
Similar to routing table, there will an additional table called ''trust table.'' It is required to have a trust table per each node within the network. Trust framework has an abstract trust table which has columns of ''Address, Trust value, Timestamp''. Each row in the trust table represent a trust record for directly connected ''(1 hop)'' nodes for a considering node. One row in <code>abstract-trust-table</code> is represented by <code>abstract-trust-entry</code> object.

 
[[File:Trust_based_framework_abstract_trusttable.jpg |frame|left|400px|alt=Alt text|Trust table with abstract-trust-entry type records]]
[[File:Trust_based_framework_concrete_trusttable.jpg |frame|right|400px|alt=Alt text|Trust table with entries of extending abstract-trust-entry and added additional columns]]

 
Users can extend <code>abstract-trust-entry</code> object and add additional columns as they wish. This will give great flexibility over adding more attributes for the trust calculation algorithm.

=== Bird's eye view ===
There will be a new '''trust module''' consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the <code>abstract-trust-calculation</code> class and implement their own logic to calculate the trust value.

[[File:Trust_based_framework_uml.jpeg|1000px]]

<code>trust-table</code> is a new table which is similar to ''routing table.'' Trust table contains trust value related information for '''directly connected nodes'''. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can see in UML, any user can define the trust calculation algorithm by simple extending the ''AbstractTrustCalculation'' class.

= Project Timeline =
== Week 1 (May 14 - May 20) ==
* Clone appropriate git repository
* Investigate on the internal and external network attack types

== Week 2 (May 21 - May 27) ==
* Create a well structured UML diagram
* Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
* Create the Abstract trust table class

== Week 3 (May 28 - June 3) ==
* Create a new ns-3 module called 'trust'
* Move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 (June 3 - June 10) ==
* Write up a trust implementation before making a abstract module
''Note:'' It has decided to remove the trust module until we have a fully working trust framework. Therefore, all classes planned to go to new trust module has been moved to internet module.
* Test the AODV specific implementation

== Week 5 (June 11 - June 17) ==
* Write doxygen documentation for abstract classes implemented inside internet module
<pre> abstract-trust-entry.h
abstract-trust-calculation.h
trust-table.h
ipv4-routing-helper.h</pre>
* Modify the helper classes to place the main boolean flag to turn on or off the trust based framework

Ipv4RoutingHelper::Ipv4RoutingHelper (bool enableTrust)
{
this->enableTrust = enableTrust;
}

== Week 6 (June 18 - June 24) ==

GSoC2018:Trust-based routing protocols framework

2018-06-22T16:02:12Z

Jude.niroshan: /* Technical Approach */

GSoC2018:Trust-based routing protocols framework

2018-06-22T09:31:18Z

Jude.niroshan: /* Technical Approach */

File:Trust based framework concrete trusttable.jpg

2018-06-22T09:21:09Z

Jude.niroshan:

GSoC2018:Trust-based routing protocols framework

2018-06-22T09:10:35Z

Jude.niroshan: /* Technical Approach */

GSoC2018:Trust-based routing protocols framework

2018-06-22T09:09:08Z

Jude.niroshan: /* Technical Approach */

File:Trust based framework abstract trusttable.jpg

2018-06-22T09:04:18Z

Jude.niroshan:

GSoC2018:Trust-based routing protocols framework

2018-06-22T08:44:48Z

Jude.niroshan: /* What is the Trust value */

GSoC2018:Trust-based routing protocols framework

2018-06-22T04:40:23Z

Jude.niroshan: /* Why need a trust based framework */

GSoC2018:Trust-based routing protocols framework

2018-06-22T04:35:58Z

Jude.niroshan: /* Introduction */

GSoC2018:Trust-based routing protocols framework

2018-06-22T04:35:18Z

Jude.niroshan:

GSoC2018:Trust-based routing protocols framework

2018-06-22T04:26:20Z

Jude.niroshan: /* Technical Approach */

GSoC2018:Trust-based routing protocols framework

2018-06-22T02:08:59Z

Jude.niroshan: /* Project Overview */

GSoC2018:Trust-based routing protocols framework

2018-06-22T02:02:54Z

Jude.niroshan: /* Week 4 (June 3 - June 10) */

GSoC2018:Trust-based routing protocols framework

2018-06-22T01:59:58Z

Jude.niroshan: /* Week 5 (June 11 - June 17) */

GSoC2018:Trust-based routing protocols framework

2018-06-22T01:57:50Z

Jude.niroshan: /* Week 5 (June 11 - June 17) */

GSoC2018:Trust-based routing protocols framework

2018-06-22T01:55:40Z

Jude.niroshan: /* Week 5 (June 11 - June 17) */

GSoC2018:Trust-based routing protocols framework

2018-06-22T01:25:53Z

Jude.niroshan: /* Why need a trust based framework */

GSoC2018:Trust-based routing protocols framework

2018-06-22T01:23:32Z

Jude.niroshan: /* What is the Trust value */

GSoC2018:Trust-based routing protocols framework

2018-06-22T01:22:54Z

Jude.niroshan: /* Project Overview */

GSoC2018:Trust-based routing protocols framework

2018-06-22T00:58:26Z

Jude.niroshan: Added reference for trust value definition

GSoC2018:Trust-based routing protocols framework

2018-06-21T18:46:47Z

Jude.niroshan: /* Project Timeline */

GSoC2018:Trust-based routing protocols framework

2018-06-21T18:45:50Z

Jude.niroshan: Added project timeline

GSoC2018:Trust-based routing protocols framework

2018-06-21T18:39:14Z

Jude.niroshan: Added what is trust factor

GSoC2018:Trust-based routing protocols framework

2018-06-21T18:31:46Z

Jude.niroshan: /* Why a Trust based framework? */

GSoC2018:Trust-based routing protocols framework

2018-06-21T18:29:00Z

Jude.niroshan: Added the purpose of a trust framework

GSoC2018:Trust-based routing protocols framework

2018-06-21T17:10:05Z

Jude.niroshan: refactored the introduction section

Return to [https://www.nsnam.org/wiki/Summer_Projects#Google_Summer_of_Code_2018 GSoC 2018 Accepted Projects] page.

== Project Overview ==

* Project name: Trust-based routing protocols framework
* Student: Jude Niroshan
* Mentor: Tommaso Pecorella
* Abstract: ns-3 contains different routing modules, both for IPv4 and for IPv6. None of them are trust-based routing protocols. Given the increasing interest on trust-based routing schemes to increase and improve the network resilience Vs routing attacks, it would be useful to have a general approach for Trust-based schemes. As a matter of fact, there are multiple trust-based extensions for well known protocol (e.g., AODV), but each one modifies in a particular way the single routing protocol, making it difficult to export the solution to other routing schemes. Therefore, it would be beneficial for many developers to have a generic trust-based framework which accommodates the alteration of well-known protocols to work as trust based protocols.
* Code: [https://github.com/JudeNiroshan/ns-3-dev-git Github repository]
* About me: I am an undergraduate student at the Sri Lanka Institute of Information Technology(SLIIT), Sri Lanka. I'm so excited to work with ns-3 community during the summer of 2018. You can find more about me on [https://www.linkedin.com/in/jude-niroshan-92693086/ LinkedIn]

=== Introduction ===
Networks are susceptible to attacks by '''malicious nodes''' that could easily bring down the whole network. Therefore, it is important to have a reliable mechanism for ''detecting and isolating malicious nodes before they can do any harm to the network.'' Routing protocols discover usable multi-hop routes between source and destination nodes. However, some of the routes found and used may not be as reliable or trust-worthy as expected. Thus, finding a trusted route is an important component for ''enhancing the security of communication''. Enhanced trust and security are achieved by the maintenance of a trust factor by the nodes in the network. This factor is established and refined over time and it increases for each node when it participates successfully in data transmissions.

=== Technical Approach ===
As of now NS-3 does not support to simulate the above mentioned trust based routing protocols. If somebody wants to simulate such an environment, there are lot of changes needs to be done in many concrete classes. This is cumbersome and it is against the conventions that we follow from the maintainence point of view. Therefore, this project is aimed to facilitate a new trust module which enables the capability of implementing a trust based algorithm to NS-3 and let the users to tryout the simulations based upon them.

New trust module consists of abstract classes which can be extended and implemented as the user's preferences. Users can extend the AbstractTrustCalculation class and implement their own logic to calculate the trust measurement.

[[File:Trust_based_framework_uml.jpeg|1000px]]

TrustTable is a new table which is similar to ''routing table.'' Trust table contains trust value related information for directly connected nodes. Users will be able to add new properties to trust table as they wish. At the same time, trust calculation logic is also feasible to change according to the above framework structure. As you can in UML, any user can define the trust calculation algorithm by simple extending the ''AbstractTrustCalculation'' class.

Talk:GSoC2018:Trust-based routing protocols framework

2018-06-04T16:47:40Z

Jude.niroshan:

== Week 1 Goals ==
''Skype call with mentor on Monday, April 30, 2018''
# Clone appropriate git repo (Done)
# Investigate on the internal and external network attack types (Done)

== Week 2 Goals ==
''Skype call with mentor on Monday, May 7, 2018''
# Create a well structured UML (Done)
# Create a simple simulation with 2 network nodes. Analyze the data packets that transfer between those nodes.
# Create the Abstract trust table class (Done)

== Week 3 Goals ==
# Create a new ns-3 module called 'trust' (Done)
# move abstract classes into that new module and test (Done, but raised dependency issues)

== Week 4 Goals ==
# Write up a trust implementation before making a abstract module
# Test the aodv specific implementation

Talk:GSoC2018:Trust-based routing protocols framework

2018-06-04T16:45:15Z

Jude.niroshan: /* Week 2 Goals */