1

CHAPTER 1
INTRODUCTION

1.1 OBJECTIVE

The aim of the project is to provide a secure platform for the interaction
between the nodes in a Mobile Ad Hoc Grid. This is achieved by means of
providing a reputation based trust model that evaluates the trust value of the service
requesting node every time a request is received. This value is calculated by taking
into account the history of transactions that have taken place involving the node.
This provides for a secure environment where the resources in the system are
protected from malicious nodes. In addition there is also an encryption mechanism
for the secure communication of messages in the system.

1.2 SCOPE
Mobile ad hoc Grid can be constructed at the places where people have a
routine life with mobile devices. Such an environment comprises of a
heterogeneous mixture of high capacity nodes and low capacity nodes. The low
capacity nodes may request high capacity nodes to provide service to them forming
a good platform for grid. Now in this grid environment, the services should be
provided only to the deserving nodes that are trustworthy and the malicious nodes
should be prevented access to these resources for the effective functioning of the
system. Here comes the necessity of reputation based trust model in the mobile ad
hoc grid environment.
 2

1.3 PROBLEM DEFINITION

To build a reputation based trust model that provides for a secure mobile ad
hoc grid environment where the resources of the environment are protected from
the malicious entities in the network and thereby increasing the performance of the
system.

1.4. OUTLINE OF THE THESIS

This thesis is organized as follows. Chapter 2 discusses background and

related work. Chapter 3 deals with the proposed architecture of a mobile ad hoc
network. Chapter 4 discusses about the modeling and implementation of mobile ad
hoc grid. Chapter 5 evaluates the proposed mobile ad hoc grid and shows the
results. Chapter 6 concludes the thesis.
 3

CHAPTER 2
LITERATURE SURVEY

In an ad-hoc environment, the network will consist of nodes with diverse

capabilities. They are organised as clusters or Grids based on their capabilities,
according to which they are classified as Consumer Nodes ( CNs ) and Service
Provider Nodes ( SPNs ) . This classification and organisation as a grid structure
has been discussed in detail by Vetriselvi et al [1]. Service provider nodes have a
list of several services at their disposal. The consumer nodes might need access to
these services and request the SPNs for the same.

Elvis Papalilo et al [7] discuss about the direct experiences being established
every time a trustor collaborates with a trustee. The output of the collaboration is
called direct trust and is calculated entirely based on the behavior elements under
observation. Direct trust between the participants X as trustor and Y as trustee is
expressed as the product of the behavior trust elements under observation. Each of
the behavior trust elements is calculated as the average of the ratio of the “positive”
observed experiences and the total number of observations during the
collaboration.

Baolin Ma et al [2] discuss about the creation of a domain agent for every
domain to maintain domain transaction table that contains transaction records of all
the entities. Every record saves the request entity, the services provider (denoted as
“providee”) and the service evaluation provided by request entity. At the same
time, every entity in the domain maintains an evaluation table used to record the
 4

reliability of other entities having direct transaction experiences with the entity.
Corresponding record items contain other entities’ name and reliability.

S. D. Kamvar [6] propose an Eigen trust model that collects the local trust
values of all peers to calculate the global trust value of a given peer. Eigen Trust
relies on good choice of some pre trusted peers, which are supposed to be trusted
by all peers. Additionally, Eigen Trust adopts a binary rating function, interpreted
as one (positive or satisfactory), or zero or negative one (unsatisfactory or
complaint).

ISSUES IN EXISTING WORK

As described above the existing models rely on good choice of only some
pre trusted peers and not all the nodes in the network. This assumption may be
over optimistic in a distributed computing environment and can lead to a situation
where the malicious entities start cheating cooperatively with the other peers and
lead to the degradation of the system.
Also the trust models adopt a binary rating function. This might lead to very
high rating for a node after few successful transactions or very low after a few
failure transactions. So even if a node genuinely requests for a service after some
time it is very difficult to get access to these resources. Hence binary rating is not a
solution for the determination of the trust values in a grid environment where
services hold the key.
 5

Another key problem with the existing system is the unequal distribution of
weights to the calculated direct and indirect trust values. This leads to a
miscalculated trust value that acts detrimental to the performance of the system.
The proposed model plans to overcome all of the above said shortcomings in an
effective manner.

The next chapter discusses the implementation details of the project.

 6

CHAPTER 3
BUILD RESOURCE
SYSTEM DESIGN LIST

ENCRYPTION
MODULE INITIALISE
CONSUMER
NODES

RESOURCE
GRID AVAILABILITY
SIMULATION

SERVICES FOR
GRID

BUILD
TRUST CALCULATE DIRECT
EVALUATION AND
MODEL TRUST VALUE
DOMAIN TABLE

EVALUATION DOMAIN CALCULATE INDIRECT

TABLE TABLE TRUST VALUE

CUMULATIVE TRUST VALUE CREDIBILITY

CALCULATION EVALUATION

Fig. 3.1. ARCHITECTURE DIAGRAM

 7

3.1 GRID ARCHITECTURE

In any ad hoc network, the nodes are in the form of Clusters with the
powers and capabilities of nodes varying heavily. So to make it easier for the low
power nodes to share the resources of the high power nodes we propose a Grid
architecture. A grid consists of two nodes set, one which contains the nodes of
lower power and computational capability and the other with higher power and
thus possess necessary resources with them to share it with low power systems.
The group of such high power nodes generates a list with the possible
resources available with them .So, when a low power node needs a request to be
executed and it does not possesses necessary resources it requests higher power
nodes to share resources and execute the services.
For the service to be executed by the Nodes of higher power it should
necessarily know the list of possible resources that service may need at any point
of time during the execution. Thus a resource table containing the list of available
resources is generated. By building the resource table the architecture keeps track
of the total resources with the system and what is available at any instant of time.
Initializing the consumer nodes that needs the service is a part of Grid
formation procedure. List of all available Grid nodes are initialized and made
available for processing by the system.
Once the Nodes are initialized then the system is ready to get service and go
on with the execution of the same. For a node to share its resources with another
node the trust value is to compared with the permissible value and if the Service
requesting node is found to possess the trust value then it is termed as trust worthy
for communication. Then to check the availability, the total list of resources and
what is needed by the current system are compared. In doing so if the system is
 8

found to possess necessary resources then the system may go on and continue with
the execution of services.
Once the resources available with the system are verified, then the Service
Provider Node starts to identify the type of request made by the system. Once the
type of request or service is identified then the system calls the corresponding
execution function to process the UNIX command, which is a request.

WORKFLOW DIAGRAM

1: GRID SIMULATION

2 : DATA ENCRYPTION

3 : EVALUATION TABLE AND DOMAIN TABLE

CONSTRUCTION

4 : INDIRECT TRUST CALCULATION

5 : CUMULATIVE TRUST CALCULATION

Fig. 3.2 WORKFLOW DIAGRAM

 9

3.2 ELLIPTIC CURVE CRYPTOGRAPHY:

Elliptic curve cryptography (ECC) is an approach to public-key
cryptography based on the algebraic structure of elliptic curves over finite fields. It
involves encrypting the original text based on a generator point taken on the
ellipse.
Public-key cryptography is based on the intractability of certain
mathematical problems. Early public-key systems, such as the RSA algorithm, are
secure assuming that it is difficult to factor a large integer composed of two or
more prime factors. For elliptic-curve-based protocols, it is assumed that finding
the discrete logarithm of a random elliptic curve element with respect to a publicly-
known base point is infeasible. The size of the elliptic curve determines the
difficulty of the problem. It is believed that the same level of security afforded by
an RSA-based system with a large modulus can be achieved with a much smaller
elliptic curve group. Using a small group reduces storage and transmission
requirements.

3.3 DATA ENCRYPTION-SIGNATURE GENERATION:

This is an integral part of the encryption mechanism that has been employed
in the project. In this process a generator point is initially fixed and the plain text
that has to be encrypted is represented as a point on the ellipse generated from the
generator point. After this a random variable is generated and the public and
private keys are formulated. The plain text is then encrypted with the receiver’s
public key and sender’s private key. After this process of encryption the public key
of the sender and cipher text are sent to the receiver.
 10

3.4 DATA DECRYPTION-SIGNATURE VERIFICATION:

Having encrypted the plain text the next step is to convert this plain text into
cipher text at the receiver’s end. In order to decrypt the message the receiver must
have the sender’s public key. Then an evaluation is done to check if the encrypted
text lies within the permissible range. If so, decipher the text using the sender’s
public key and self’s private key.

3.5 EVALUATION TABLE AND DOMAIN TABLE CONSTRUCTION:

The network activity is recorded periodically in a log file. The log file has a
list of all the transactions that have taken place in the network. The evaluation table
and the domain table that are constructed with the help of this log file as input form
an integral part of the trust calculation mechanism.

A separate evaluation table is maintained by each and every node in the

network and the contents of the table include information about the direct
transactions that have taken place between that particular node and the specific
node requesting service. This makes the process of direct trust evaluation less
complex.

There is a single domain table for an entire domain and this includes the
information about all the transactions that have taken place in that particular
domain. However, the information that is of interest to the implementation is the
IDs of the nodes requesting and providing service and the status of that particular
transaction. The domain table plays an integral in indirect trust and credibility
factor calculation.
 11

3.6 DIRECT TRUST CALCULATION:

The direct trust value is calculated based on the information that is available
in the evaluation table. The direct trust value is the estimate how trustworthy the
service requesting node has been to this particular SPN. The number of occasions
when the past transactions have ended successful or failed is taken into account
after which a penalty factor is added to the node. The penalty factor is a measure of
number of successful transactions against those that have been unsuccessful. The
trust value pre calculated is now divided by this penalty factor to get the final direct
trust value.

3.6 INDIRECT TRUST CALCULATION:

Indirect forms an integral part of the trust model that has been implemented
and is the factor that sets this model apart from the traditional ones. The indirect
trust is the estimate of how much trustworthy the service requesting node is in the
opinion of the peers in the system. The first step in the calculation of this indirect
trust is the request to the domain table that has been constructed priorly. In this
process the direct trust between each of the peers and the service requesting node is
first calculated. After this the credibility factor between each of the peers and the
service providing node is calculated and the composite indirect trust value is
computed as the sum of product of the corresponding terms of each of the above
calculated values. The composite trust value is then divided by the number of such
peers in the network to determine the cumulative indirect trust value [2].

Cumulative Indirect Trust Value= Σ (Credibility Factor * Indirect Trust Value) /

(Number of peers in the network)
 12

3.7 CUMULATIVE TRUST CALCULATION:

The above calculated direct and indirect trust values are deployed for the
determination of the cumulative trust value of a particular entity. The key to
appropriate evaluation of the trust value of a node is to balance the weights
awarded to the direct and the indirect trust values to determine the final value. An
important entity to determine the weight is the number of transactions that have
been taken into account to determine the indirect trust value. The cumulative value
[3] is hence determined by

Cumulative Trust Value = (α * Indirect Trust Value + β * Direct Trust Value)

where α + β=1

and α=(1-1/k ^½)

k – the number of transactions between the peers and the service requesting node.

Distributing the weights in the above manner turns out to be an effective

mechanism for the calculation of the trust values of the nodes in the network as is
evident from the simulation results that are to follow.
 13

CHAPTER 4

IMPLEMENTATION

4.1 TECHNOLOGICAL SUPPORT

Global Mobile Information System Simulator (GloMoSim) is a

network protocol simulation software that simulates wireless and wired network
systems. GloMoSim is designed using the parallel discrete event simulation
capability provided by Parsec, a parallel programming language. GloMoSim
currently supports protocols for a purely wireless network. To run GloMoSim, a
latest Parsec compiler would be required. The simple approach to designing a
network simulation would be to initialize each network node in the simulation as a
Parsec entity. It is possible to view different entity initializations as being separate
logical processes in the system. Hence each entity initialization requires its own
stack space in the runtime. In GloMoSim, it is possible to build a simulation that
will scale to thousands of nodes. The node aggregation technique is introduced into
GloMoSim to give significant benefits to the simulation performance. This tool
allows debugging and verifying models, show packet transmissions, show mobility
groups in different colors and showing statistics.
 14

4.2. PSEUDOCODES:

4.2.1 BUILDING RESOURCE LIST:

Void BuildResourceList()

List down the resources used by a System.

spn.rt[0] = (struct resource_table *)

malloc(sizeof(struct resource_table));

strcpy(spn.rt[0]->resource_name,Resource_name);

spn.rt[0]->tot_instances=spn.rt[0]->available=Initial_Resource_Count;

Repeat the above steps for all the resources available.

4.2.2 INITIALIZE CONSUMER NODES:

Void InitValConsumerNodes

Initialise the consumer nodes array

Get the service requesting node it

if(consumers[jts.cpn_id-1]==1)

Approve as valid node

}
 15

4.2.3 RESORUCE AVAILABILITY CHECK:

int Resource(char* Res, int res_count )

if(strcmp(res,spn.rt[i]->resource_name)==0)

if(spn.rt[i]->available >= res_cnt)

spn.rt[i]->available-=res_cnt;

break;

else

f=0;

break;

}
 16

4.2.4 SERVICES FOR GRIDS:

Void spn_Request(struct job_to_spn jts)

Identify the trust value of the nodes in communication

Verify whether the trust value meets the threshold value.

Allocate memory to store the result value

for (i=0,j=0,s=0;i<strlen(jts.cmd);i++)

if(isspace(jts.cmd[i])){s++;j=0;continue;}

if(s==0)comd[j++]=jts.cmd[i],comd[j]='\0';

else if(s==1)file1[j++]=jts.cmd[i],file1[j]='\0';

else file2[j++]=jts.cmd[i],file2[j]='\0';

//Identifying the type of request

if(strcmp(comd,"ls")==0)

//Checks availability of Resources

if(resource(res,2))

{ Approve as resource available

Requested Service is provided

 17

Execute the service requested

4.2.5 DATA ENCRYPTION:

First, decide the equation of the ellipse.

Generate a table of integral points that lie on the ellipse, using the equation given
above.
Fix a point on the ellipse as the generator point.

if(table_filled == false)

compute_table;

get generator point. Compute P, the finite field element over G.

a-> private key of Sender

Pb-> public key of Receiver

cipher_text = original_text * a * Pb;

send(cipher_text,Pa);

//Decryption routine
b-> private key of Receiver
 18

Pa-> Public key of Sender

regenerated_text = decrypt ( cipher_text, Pa , b );
//Eavesdropper routine
j-> Private key of Eavesdropper

Pa-> Public key of Sender

text=decrypt ( cipher_text, Pa, j) // doesnot yield the original text

4.2.6 EVALUATION TABLE AND DOMAIN TABLE CONSTRUCTION:

Procedure Construct Tables()

Initialise all the evaluation table customer Ids to be zero

Initialise all the domain table requester Ids to be zero

Initialise all the domain table provider Ids to be zero

Read the values from the input file specified

Store the values into the DomainTableStructure Specified

 19

if((domaintable provider_id == final_provider_id) and

(domaintable.requester_id==final_requester_id))

{
Evaluation table cn id= domaintable requester id
Evaluation table status=DomainTableStatus

Print the Evaluation Table and DomainTable Values

}

4.2.7 DIRECT TRUST CALCULATION:

Procedure request_service

for(i=0;evaltable[i].cn_id!=0;i++)
{
if(evaltable[i].cn_id==cn_id )
{
if( evaltable[i].status is FAILURE)
{
failure++
final_failure++
}
 20

else if(evaltable[i].status is SUCCESS)

{

success++;
final_success++;
}

if(!((success==0)&&(failure==0)))

local_trust[spn_id][cn_id] = (1.0*success)/(success+failure );

mu[spn_id][cn_id] = (1.0*failure)/success;

penalty[spn_id][cn_id] = 1 + mu[spn_id][cn_id];

return local_trust[spn_id][cn_id]/penalty[spn_id][cn_id];
 21

else if((success==0) &&(failure==0))

{

return the trust value as 1;

else if((success==0) && (failure!=0))

{

return the trust value as 0;

4.2.8 INDIRECT TRUST CALCULATION:

Procedure request_domaintable

Initialise the success and failure array count as zero

For all appropriate values in the domain table

 22

if(domaintable[i].requester_id==cn_id)

{
if((domaintable[i].status is SUCCESS)

success[domaintable[i].provider_id]++;
else

failure[domaintable[i].provider_id]++;
}

Initialize the variable opinion to zero

For all the users that exist in the network

if((!((success[i]==0)&&(failure[i])==0))&&(!(i==cn_id)))

local_trust[i][cn_id] = (1.0 * success[i])/(success[i]+failure[i]);

if(success[i]!=0)
 23

{
mu[i][cn_id] = (1.0*failure[i])/success[i];
}
else
{
mu[i][cn_id]= (1.0 * failure[i]);
}

penalty[i][cn_id] = 1 + mu[i][cn_id];

indirect_trust[i][cn_id] = local_trust[i][cn_id]/penalty[i][cn_id];

increase the opinion count value

if(((success[i]==0) && (failure[i]==0)) && (i!=cn_id))

{
indirect_trust[i][cn_id]=0;
}

}
 24

4.2.9 CUMULATIVE TRUST CALCULATION:

Procedure calculate_trust
{

Construct domain table and evaluation table

Calculate direct trust value between the service requesting node and
service providing node

Initialise all indirect trust array domain values to zero

Compute the indirect trust domain values

For all the users in the network

{

Calculate the credibility factor for each node in the network

Cumulative indirect trust value is calculated as a product of

indirect trust value and the credibility factor computed

cumulative_indirect_trust_value=indirect_trust_value/count;
 25

val=sqrt(opinion);

if(val!=0)
weight=1-(1/val);
else
weight=0;

alpha=1-weight;

beta=(weight);

cumulative_total_trust_value=alpha*direct_trust[spn_id][cn_id]+beta
*cumulative_indirect_trust_value;

if(cumulative_total_trust_value > .4)

{
Node is trustworthy
}
else

{
Malicious node detected :Prevent transaction
}

}
 26

CHAPTER 5
RESULTS

5.1 PERFORMANCE ANALYSIS

Simulation studies have been carried out to analyze the effectiveness of the
trust model developed across several other parameters. The simulation tool used is
GloMoSim.
The implemented trust model is compared against the trust models that
employ only direct trust mechanisms to evaluate the reputation of their peers. The
implemented trust model is observed to have significant advantages over the
existing models as is demonstrated by the results below. Accuracy of evaluation of
the trust model has been chosen as the significant criteria to evaluate its
performance.
The simulation involves a malicious node requesting service to all other
nodes and the trust model helping the service providing nodes to calculate the trust
value of the service requesting node. The accuracy of evaluation is the number of
instances where the trust model comes out with the correct prediction that the node
requesting service is malicious against the total number of instances where the
system evaluates the trust value of a service requesting node.
Accuracy of evaluation (%) = (AE) / (AE+FE)

AE =Accurate evaluations is the number of instances where the trust model

comes out with the correct prediction that the node requesting service is malicious
FE= False evaluations is the number of instances where the trust model fails
to predict that the node requesting service is malicious and allows for a service to
be provided to it.
 27

5.2 RATE OF MALICIOUS ACTIVITY

The performance of the direct trust model and the implemented trust model
is evaluated against the rate of malicious activity. Rate of malicious activity is
chosen as the parameter here because it is an effective measure of the number of
successful transactions against those that are unsuccessful. This in turn is a clear
indication of the trustworthiness of the nodes.

Rate of malicious activity = (ST/ST+FT)

ST=Number of transactions that have been successfully completed
FT=Number of transactions that have failed

5.2.1 ANALYSIS OF ACCURACY OF EVALUATION OF DIRECT TRUST

MODEL-

As it can be seen from Table 5.1 the direct trust model has no false
evaluations when there are no malicious nodes in the network and hence the
accuracy of evaluation of the trust model is 100% as can be seen from the Fig 5.1.
But with the increase in the rate of malicious activity the accuracy of
evaluations drop down significantly as is observed in the Fig 5.1. The reason for
this is because the system takes into account only the direct experiences with the
node under study. So there is a good chance that the transactions that have taken
place with this SPN in the past have resulted in success but the service requesting
node has produced failed transactions with other nodes in the network. But the
SPN does not have any knowledge of these since it does not take into account the
indirect trust value of the service requesting node.
 28

RATE OF MALICIOUS ACCURATE FALSE EVALUATIONS

ACTIVITY EVALUATIONS
0 28 0
0.2 19 9
0.4 20 8
0.6 24 4
0.8 25 3
1.0 28 0

Table 5.1 Accuracy of evaluation of Direct Trust Model

X-AXIS - Rate of malicious activity (units)

Y-AXIS – Accuracy of evaluation (%)

Fig 5.1 Rate of Malicious Activity Vs Accuracy of evaluation of Direct Trust Model
 29

5.2.2 ANALYSIS OF ACCURACY OF EVALUATION OF TRUST MODEL

It can be seen from Table 5.2 that the system is infallible when the rate of
malicious activity is 0 as there are no false evaluations made and the hence the
accuracy of evaluation is 100% as can be seen from the Fig 5.2. The accuracy of
evaluation initially drops when the rate of malicious activity increases. This is
because the system does not have enough of failed transactions in the network to
identify the node to be malicious. But, as the rate of malicious activity increases the
accuracy of evaluation also increases and the system identifies all the malicious
nodes appropriately.

Table 5.2 Accuracy of evaluation of the Trust Model

RATE OF MALICIOUS ACCURATE FALSE EVALUATIONS

ACTIVITY EVALUATIONS
0 28 0
0.2 20 8
0.4 26 2
0.6 28 0
0.8 28 0
1.0 28 0
 30

X-AXIS - Rate of malicious activity

Y-AXIS – Accuracy of evaluation

Fig 5.2 Rate of Malicious Activity Vs Accuracy of evaluation of Trust Model

5.3 NUMBER OF MALICIOUS NODES:

The performance of the direct trust model and the implemented
trust model is evaluated against the number of malicious nodes in the network. The
number of malicious nodes in the network is a direct measure of the malicious
activity in the system and hence an important criteria to study the accuracy of
evaluation.
 31

5.3.1 PERFORMANCE OF DIRECT TRUST MODEL:

The performance of the direct trust model is evaluated in many scenarios by

varying the number of malicious nodes in the network from 0 to 6. First is the
scenario where there are no malicious nodes in the network and hence all the
transactions are successful and hence all the predictions made by the trust model
are accurate as can be seen in Table 5.3 and as a result of which the accuracy of
evaluation is 100% as can be observed from Fig 5.3. But when the number of
malicious nodes in the network increase the direct trust model fails miserably as
not even half the predictions made by this model is correct. This is because the
direct trust model relies only on the direct experiences between the service
requesting node and the service providing node. Therefore there is a good chance
that the node acts trustworthy to some nodes in the system and maliciously to all
other nodes. This problem is overcome in the implemented trust model as the
number of accurate evaluations is twice than in the direct trust model as can be
seen from Table 5.4. Figure 5.4 also reflects the same with the accuracy of
evaluation of the trust model being twice that of the direct trust model. Even when
the number of malicious nodes increases the accuracy of evaluation of the
implemented model remains above 80% (Fig 5.4) which is considerable
improvement over the performance of the direct trust model.
 32

Table 5.3 Performance of direct trust model

NUMBEROF ACCURATE FALSE EVALUATIONS

MALICIOUS NODES EVALUATIONS
0 14 0
1 6 8
2 20 8
3 27 15
4 37 19
5 46 24
6 52 32

X-AXIS – Number of malicious nodes in the network

Y-AXIS – Accuracy of evaluation

Fig 5.3 No of malicious nodes Vs Accuracy of evaluation of Trust Model

 33

5.3.2 PERFORMANCE OF TRUST MODEL:

Table 5.4 Performance of trust model

NUMBEROF ACCURATE FALSE EVALUATIONS

MALICIOUS NODES EVALUATIONS
0 14 0
1 12 2
2 25 3
3 37 5
4 52 4
5 61 9
6 73 11
 34

X-AXIS – Number of malicious nodes in the network

Y-AXIS – Accuracy of evaluation

Fig 5.4 No of malicious nodes Vs Accuracy of evaluation of Trust Model

The next chapter will discuss about the conclusions and the future work that
could be augmented to the existing system.
 35

CHAPTER 6

CONCLUSIONS & FUTURE WORK

The developed model of reputation based trust is found to provide a

significant advantage over the existing systems that evaluate trust value only based
on the direct experiences with other nodes. Another significant advantage is that
the accuracy of evaluation of a system almost remains a constant even when the
number of malicious nodes in the system increases which is a notable improvement
when compared with the existing trust models. The encryption mechanism used as
a part of the model provides options for an increased secure communication
between the nodes.

FUTURE WORK
The security system that has been implemented concentrates more on the
application layer attacks that result in improper resource utilization in the network.
While this forms the major problem in grids, there might also be attacks at the
network layer which might also have a detrimental influence on the system
performance. So the further work can be directed towards identifying and
eliminating such attacks in mobile ad-hoc grids. The system can also be extended
in such a manner that these security features are incorporated and implemented for
web services also.
 36

REFERENCES

1. V.Vetri Selvi, Ranjani Parthasarathi, “Mobile Ad Hoc Grid Architecture using a

Trace Based Mobility Model”, International Journal on Ubiquitous Computing
and Communication, Vol 2, No. 5, pp 47- 57, Oct 2007.
2. Baolin Ma, Jizhou Sun, Ce Yu, “Reputation-based Trust Model in Grid Security
System”, Journal of Communication and Computer, ISSN1548-7709, USA,
Volume 3, No.8 (Serial No.21), August 2006.
3. Yong Zhang, Kewen Wang , Keqiu Li , Wenyu Qu, Yang Xiang , “ A Time-
decay based P2P Trust Model”, International Conference on Networks
Security, Wireless Communications and Trusted Computing ,2009.
4. L. Xiong and L. Liu, “PeerTrust: supporting reputation-based trust for peer-to-
peer electronic communities” , 2004.
5. M. Brown, D. Hankerson, J. Lopez, and A. Menezes, “Software Implementation
of the NIST Elliptic Curves Over Prime Fields”.
6. S. D. Kamvar, M. T. Schlosser, and H. Garcia-Molina, “The Eigentrust
algorithm for reputation management in P2P network”, Proceedings of the 12th
international conference on World Wide Web, May 2003.
7. Elvis Papalilo and Bernd Freisleben, “Managing Behaviour Trust in Grids
Using Statistical Methods of Quality Assurance”, Third International
Symposium on Information Assurance and Security.
8. Xiang Xeng , Rajive Bagrodia and Mario Gerla , “Glomosim: A Library for
Parallel Simulation of Large –Scale Wireless Networks”, In Proceedings of the
12th Workshop on Parallel and Distributed Simulation, May 1998.