外文翻译

毕业论文（设计）外文翻译

题目：基于C++局域网聊天系统

学院：数理与信息学院

学生姓名：陈霆

专业：计算机科学与技术

班级： A07计算机

指导教师：管林挺

起止日期： 2011.3.29至2011.6.18

2011年4月6日

Paper1

P2P trust model

Summary of the P2P network problems are analyzed, described the establishment of P2P network trust model needs.P2P network on the existing trust models are summarized, pointing out the direction of future research.

Introduction

With the Internet's widespread popularity, the rich end user's system resources, as well as the rapid increase in network bandwidth, the traditional Client / Server Network Application Mode server performance bottlenecks and single point of failure issue is not only limited the full use of end system resources,also increasingly unable to meet the new distributed applications.The P2P networks to work together, distributed information sharing, large-scale parallel computing such as showing the unique advantages of the new development to make it hot.

P2P networks are willing to share resources on the node the basic assumption that each node share its own resources and from other nodes where the resources for their own needs.However, such individuals to provide resources for the public, and node behavior result in unconstrained mode of P2P network there are three problems.

(1) ride (Free-Riding) problem

Free-Rriding consumption of other nodes that node only contribution to the resources without sharing their own resources.To Gnutella P2P file sharing system, for example, 70% of the nodes is the Free-Rider.The latest monitoring also shows that in the eDonkey file-sharing network, about 80% of the nodes is the Free-Rider.

(2) "Public Goods and sorrow" (the Tragedy of the Commons) problem

"Public Goods and sorrow" means the network resources as a non-exclusive public resources are most uncontrolled use of P2P nodes, according to statistics, P2P traffic accounted for 60% of Internet Zong traffic flow, and the user is not the total number of significant growthcases, P2P traffic is still growing rapidly.In fact, P2P network users of its fundamental purpose is rational to maximize their utility, but does not consider the network's overall effectiveness.

(3) not reliable services, and fraud

P2P network, there are a large number of unreliable service quality, and fraud.To the many

file-sharing application, for example, 25% of the documents were forged documents (Faked Files).This is similar to eBay in e-commerce, this is not a reliable service and fraud to the user impact is more serious.

Therefore, effective mechanisms must be designed to regulate the behavior of nodes in P2P networks to address these three issues, to improve the availability of P2P services to promote effective collaboration node and the rational use of network resources.

Why is the trust model

Nodes that have their own rights, self-organizing P2P network, how to regulate the behavior of the node? In fact, P2P networks provide real-world network environment of human communication, human-centered networks, and social networks with the same configurationsex.The trust as an integral part of social existence, is the social network in the core of relations between

people.Human society, reputation-based trust relationship with the incentive mechanism to restrict people's daily behavior.Trust-based P2P network and the similarity of human social networks embodied in the P2P network between individuals interact with each other for each other left sporadic "credit" information; individual objects on the interaction with the full right to choose; individuals are often not the absolute valuereliability or quality of service that individuals can tolerate a small amount of damage caused by the wrong choice, such as file-sharing application; individual obligation to the network to provide recommended information to other individuals.Therefore, we can describe P2P networks using the trust relationship between nodes, and to take trust-based incentive mechanisms to address these issues.

(1) to provide differentiated services based on trust values

In file sharing P2P network, nodes on the network resources according to the contribution level, to provide differentiated services.For example, Kazaa nodes provide the resources and the ratio of consumption of resources into the system as a node in the level of participation and access to services as a priority of the node.BitTorrent nodes upload rate under each other to determine their own upload rate.EDonkey network node in accordance with the request of local trust values to set the node in the download queue priority.

Malicious use of network resources on the node to punish.For example, proposed incentives RTBMa focus on the Gnutella network file transfer type when the bandwidth allocation problem, according to the contribution of the node on the network for distribution of bandwidth resources.When a node share data, contribute to stimulate nodes to increase share value.When the node from the node overload to download a file, contribution to reducing the value of the node to suppress the consumption of public resources.

Differentiated services based incentives to encourage cooperation between nodes, and the rational use of network resources, in order to address free-riding and the "tragedy of public goods" problem.

(2) According to the trust value of node selection service provider

Node can be based on trust values to choose to trade with each other.For example, in the eBay network, high trust value to buy the products business, which encourage businesses to maintain good sales practices and improve reliability of products.Effectively inhibit the P2P network is not reliable services, and fraud.

The concept of trust

Trust is a multidisciplinary concept, describes specific situations, an individual may have adverse consequences in the circumstances, want to believe that another individual has some ability to complete a task or a subjective belief.Close contact with the concept of trust the credibility of credit from the individual's social network, is based on observed past behavior or past behavior of individual information and expectations on individual behavior.The difference between reputation and trust can I trust you because you have good credit or I trust you despite your credit is not good to show.This shows that the credibility of the stress that a group of individuals or groups to a common level of reliability and trust more to emphasize that trust in the individual's subjective trust trusted party.Mentioned in this article refers to the trust the trust side of the trusted party's subjective trust, that trust in parties according to their own experience or to both the trusted party's reputation and resulting reliability of trusted parties.In resource sharing in P2P networks, reflecting the extent of not only the reliable nodes such as computing nodes, storage, network bandwidth and other aspects of the objective ability, and participate in P2P networks with nodes in

the behavior traits, such as duration of the node-line, friendly, and so on.P2P networks in

e-commerce category, the seller's trustworthiness and product description, communication with the buyer, delivery time, delivery and related charges.In practical applications, the nodes will affect the credibility of all the factors that quantify the confidence and credibility of integrated reached node is not feasible.Therefore, under normal circumstances, the trust model in P2P networks, according to the node between satisfaction with the transaction to determine credibility. credibility, trust and mutually beneficial relationship

Shown in Figure 1, if node A has a reciprocal behavior of other nodes, then A will have a good reputation, so node A will be other nodes in the trust, and transaction reciprocal behavior by other nodes.The plan involves a trusted network of reciprocity, or you can call it incentive mechanism.As the social field, only when the behavior of the past affect the future (for sociology as "the future of the shadow (Shadow of Future)" phenomenon), people have incentive to build mutual trust.Therefore, the trust model and the incentive mechanism of interaction between the good, P2P networks can effectively promote the cooperation between nodes.

Figure 1 credit, trust and mutually beneficial relationship between a simple model

Trust Model classification

In P2P network, there are all kinds of attack models, including: fraud, counterfeiting, defamation, fraud combined with a front-end node (head-end node generally provide reliable service, the cooperative nodes give a fair evaluation. However, these front-end nodetrying to give a high internal malicious nodes to disguise malicious node positive behavior) of the joint fraud, change the ID to re-enter the network node and the nodes intermittently to provide credible information and services, or the accumulation of credit to a certain height, the use ofits high trust value, fraud, slander or joint fraud attacks.Most of the current trust model focused on solving the problem of certain types of attacks, according to the method to establish trust relationships can be broadly divided into the trust model based on trusted third parties, and based on the feedback / evaluation of two types of trust model.

Trust Model based on trusted third party

Such trust model in the traditional PKI security system technology, a small number of leaders through the network node to monitor the operation of the whole network, and regularly circular

nodes or to punish violations.The legitimacy of these leaders node certificates issued by CA to be guaranteed.

Such systems often rely on a small central node, so there is a single point of failure, and scalability issues.

Based on feedback / evaluation of the trust model

Trust model for P2P networks generally fall into this category, according to the different objects to be trusted, there is as resources to build the credibility and the credibility of the transaction nodes in two categories.The former focuses on P2P networks can access the information's credibility, and credibility of information providers do not establish direct contact.In this type of trust model, the nodes determine the reliability of the information, and gives a positive or negative feedback rating, and further calculate the trust value.For example, in file-sharing application Kazaa, only consider the positive feedback to the data signature way to build credibility, that is, if the user accepted the authenticity of the information, then the signature, the information obtained more signatures, the authenticity of the morehigh.Such as resources, limited trust model to establish the credibility of information sharing applications, does not have broad applicability.Below the node for the transaction to establish the credibility of the trust model are explained.

(1) global trust model

Trust model of such a network analysis and feedback of all transactions for each node to establish a unique credibility.

The world's largest auction site eBay by the end of trading, trading parties are given a positive, negative or neutral feedback rating, and use the number of positive minus the number of negative rating reached a certain individual's credibility.The method is simple and easy to understand, but can not deal with the unfair trader is given feedback.S. Kamvar global trust model EigenTrust proposed transaction history according to the node to calculate the local trust, and trust information to consider the recommendation of the node, through the iterative trust between nodes to achieve the spread of the trust, thus calculated for each node in the globalcredibility.W. Dou and EigenTrust similar to the proposed global trust model, to solve the EigenTrust credibility in solving global problems when the existence of solutions.A. Yamamoto proposed a distributed trust model for P2P networks of trust between the nodes are modeled as Web page links, Pagerank

algorithm using a distributed approach to calculating the trust value of nodes.But this model neglects the nodes and relations of trust between the different nodes differ, their rationality is questionable.L. Xiong proposed PeerTrust to more effectively assess the trustworthiness of peers and describes a variety of malicious acts P2P community will not only deal satisfaction feedback for evaluating the parameters of the trust, taking the total number of transactions, feedbackcredibility, the transaction context factor, the community context factor.Simulation results show that the trust model can effectively inhibit the malicious node attacks.L. Mekouar made part of the distributed P2P network (such as KaZaa) the credibility of the management mechanism RMS_PDN.Super nodes in RMS_PDN passed between nodes in the trust evaluation, so that each super-node to its leaf node record of effective contribution to the system and the credibility as a leaf node.However, all the nodes directly RMS_PDN feedback vulnerable to malicious nodes of joint fraud attacks.

Global trust model ignores the private trust of features for a particular node, other nodes on the trust of his values are the same.Simple global trust model vulnerable to malicious nodes joint fraud attacks.And complex needs of global trust model of cooperation between the processing nodes trust the information, computing and communication costs are higher.In addition,

large-scale P2P network, each node in the global trust value computing the necessity and feasibility of further study.

(2) the local trust model

On P2P networks have mostly focused on the trust model provides a mechanism which nodes can share information for a given node, the local trust value calculation.Y. Wang proposed a P2P environment based on Bayesian network trust model.The trust model describes the main focus on different aspects of trust, which nodes can be based on different scenarios for on-demand access to different aspects of the performance of the node.The trust model can be adapted to smaller scale Gnutella network, or nodes of the Gnutella network interactive focus.S. Lee proposed a fully distributed way to store the user's credit information.And other trust system is different in the NICE system, the node i trust information stored in other nodes of the services provided i satisfied with feedback, so trust in the information storage node motivated.L-Xiong PeerTrust proposed mechanism allows nodes to provide feedback according to the node with its own individual choices similar feedback to calculate a given node of the subjective reliability of this method to

prevent fraud attacks the joint node, but in largescale P2P networks because of the sparsity of the transaction, there is not necessarily sufficient similarity with the individual nodes.

Share information based on local trust model, shared access to information in two ways: first, to the other nodes by flooding a request for trust, poor scalability of the method; the other is the mechanism through the use of P2P DHT storage systems such asChord and other access, this method is not suitable for frequent node join and leave the system P2P system.Moreover, such sharing of information based on local trust model is not suitable for management information between nodes can not directly interact with some of the distributed P2P network. Conclusion

In the absence of an effective management mechanism in P2P networks, the establishment can suppress all the attack patterns of the trust model is very difficult, apart from the node to be able to suppress the attacks, the time of the establishment of trust model, trust model to fully consider whether the scale can be extendednature of trust in the trusted computing and information storage scalability, and trust in the process of information transmission bandwidth overhead problems.In addition, dynamic access to the network node frequent cases, the trust model of fault tolerance or robustness also needs to be stressed.

In fact, in the P2P network trust model, the community should be fully learn the true reputation management system, different scenarios for the transaction to establish credibility for the node, and nodes into a particular group to restrict and regulate the nodes Xing Wei.Therefore, based on group reputation mechanism is the direction of future research, research work has been useful in the exploration of aspects, but still not mature.In addition, the model of incentive mechanisms based on trust, not only to consider the P2P networks of cooperation between the internal nodes should also be considered P2P applications and networks of cooperation between other applications.For example, in P2P file sharing applications, when the network bandwidth utilization reaches a certain threshold, still predatory on the node using the network resources to punish.P2P applications and networks in harmony with other applications, P2P applications is the development of long-term solution.

《Journal of Harbin Institute of Technology》

Paper2

Object landscapes and lifetimes

Technically, OOP is just about abstract data typing, inheritance, and polymorphism, but other issues can be at least as important. The remainder of this section will cover these issues.

One of the most important factors is the way objects are created and destroyed. Where is the data for an object and how is the lifetime of the object controlled? There are different philosophies at work here. C++ takes the approach that control of efficiency is the most important issue, so it gives the programmer a choice. For maximum run-time speed, the storage and lifetime can be determined while the program is being written, by placing the objects on the stack (these are sometimes called automatic or scoped variables) or in the static storage area. This places a priority on the speed of storage allocation and release, and control of these can be very valuable in some situations. However, you sacrifice flexibility because you must know the exact quantity, lifetime, and type of objects while you're writing the program. If you are trying to solve a more general problem such as computer-aided design, warehouse management, or air-traffic control, this is too restrictive.

The second approach is to create objects dynamically in a pool of memory called the heap. In this approach, you don't know until run-time how many objects you need, what their lifetime is, or what their exact type is. Those are determined at the spur of the moment while the program is running. If you need a new object, you simply make it on the heap at the point that you need it. Because the storage is managed dynamically, at run-time, the amount of time required to allocate storage on the heap is significantly longer than the time to create storage on the stack. (Creating storage on the stack is often a single assembly instruction to move the stack pointer down, and another to move it back up.) The dynamic approach makes the generally logical assumption that objects tend to be complicated, so the extra overhead of finding storage and releasing that storage will not have an important impact on the creation of an object. In addition, the greater flexibility is essential to solve the general programming problem.

Java uses the second approach, exclusively]. Every time you want to create an object, you use the new keyword to build a dynamic instance of that object.

There's another issue, however, and that's the lifetime of an object. With languages that allow objects to be created on the stack, the compiler determines how long the object lasts and can automatically destroy it. However, if you create it on the heap the compiler has no knowledge of its lifetime. In a language like C++, you must determine programmatically when to destroy the object, which can lead to memory leaks if you don’t do it correctly (and this is a common problem in C++ programs). Java provides a feature called a garbage collector that automatically discovers when an object is no longer in use and destroys it. A garbage collector is much more convenient because it reduces the number of issues that you must track and the code you must write. More important, the garbage collector provides a much higher level of insurance against the insidious problem of memory leaks (which has brought many a C++ project to its knees).

The rest of this section looks at additional factors concerning object lifetimes and landscapes. Collections and iterators

If you don’t know how many objects you’re going to need to solve a particular problem, or how long they will last, you also don’t know how to store those objects. How can you know how much space to create for those objects? You can’t, since that information isn’t known until run-time.

The solution to most problems in object-oriented design seems flippant: you create another type of object. The new type of object that solves this particular problem holds references to other objects. Of course, you can do the same thing with an array, which is available in most languages. But there’s more. This new object, generally called a container (also called a coll ection, but the Java library uses that term in a different sense so this book will use “container”), will expand itself whenever necessary to accommodate everything you place inside it. So you don’t need to know how manyobjects you’re going to hold in a co ntainer. Just create a container object and let it take care of the details.

Fortunately, a good OOP language comes with a set of containers as part of the package. In C++, it’s part of the Standard C++ Library and is sometimes called the Standard Templat e Library (STL). Object Pascal has containers in its Visual Component Library (VCL). Smalltalk has a very complete set of containers. Java also has containers in its standard library. In some libraries, a generic container is considered good enough for all needs, and in others (Java, for example) the library has different types of containers for different needs: a vector (called an ArrayList in Java) for consistent access to all elements, and a linked list for consistent insertion at all elements, for example, so you can choose the particular type that fits your needs. Container libraries may also include sets, queues, hash tables, trees, stacks, etc.

All containers have some way to put things in and get things out; there are usually functions to add elements to a container, and others to fetch those elements back out. But fetching elements can be more problematic, because a single-selection function is restrictive. What if you want to manipulate or compare a set of elements in the container instead of just one?

The solution is an iterator, which is an object whose job is to select the elements within a container and present them to the user of the iterator. As a class, it also provides a level of abstraction. This abstraction can be used to separate the details of the container from the code that’s accessing that container. The container, via the iterator, is abstracted to be simply a sequence. The iterator allows you to traverse that sequence without worrying about the underlying structure—that is, whether it’s an ArrayList, a LinkedList, a Stack, or something else. This gives you the flexibility to easily change the underlying data structure without disturbing the code in your program. Java began (in version 1.0 and 1.1) with a standard iterator, called Enumeration, for all of its container classes. Java 2 has added a much more complete container library that contains an iterator called Iterator that does more than the older Enumeration.

From a design standpoint, all you really want is a sequence that can be manipulated to solve your problem. If a single type of sequence satisfied all of your needs, there’d be no reason to have different kinds. There are two reasons that you need a choice of containers. First, containers provide different types of interfaces and external behavior. A stack has a different interface and behavior than that of a queue, which is different from that of a set or a list. One of these might

provide a more flexible solution to your problem than the other. Second, different containers have different efficiencies for certain operations. The best example is an ArrayList and a LinkedList. Both are simple sequences that can have identical interfaces and external behaviors. But certain operations can have radically different costs. Randomly accessing elements in an ArrayList is a constant-time operation; it takes the same amount of time regardless of the element you select. However, in a LinkedList it is expensive to move through the list to randomly select an element, and it takes longer to find an element that is further down the list. On the other hand, if you want to insert an element in the middle of a sequence, it’s much cheaper in a LinkedLis t than in an ArrayList. These and other operations have different efficiencies depending on the underlying structure of the sequence. In the design phase, you might start with a LinkedList and, when tuning for performance, change to an ArrayList. Because of the abstraction via iterators, you can change from one to the other with minimal impact on your code.

In the end, remember that a container is only a storage cabinet to put objects in. If that cabinet solves all of your needs, it doesn’t really matter how it is implemented (a basic concept with most types of objects). If you’re working in a programming environment that has built-in overhead due to other factors, then the cost difference between an ArrayList and a LinkedList might not matter. You might need only one type of sequence. You can even imagine the “perfect” container abstraction, which can automatically change its underlying implementation according to the way it is used.

The singly rooted hierarchy

One of the issues in OOP that has become especially prominent since the introduction of C++ is whether all classes should ultimately be inherited from a single base class. In Java (as with virtually all other OOP languages) the answer is “yes” and the name of this ultimate base class is simply Object. It turns out that the benefits of the singly rooted hierarchy are many.

All objects in a singly rooted hierarchy have an interface in common, so they are all ultimately the same type. The alternative (provided by C++) is that you don’t know that everything is the same fundamental type. From a backward-compatibility standpoint this fits the model of C better and

can be thought of as less restrictive, but when you want to do full-on object-oriented programming you must th en build your own hierarchy to provide the same convenience that’s built into other OOP languages. And in any new class library you acquire, some other incompatible interface will be used. It requires effort (and possibly multiple inheritance) to work the new interface into your design. Is the extra “flexibility” of C++ worth it? If you need it—if you have a large investment in C—it’s quite valuable. If you’re starting from scratch, other alternatives such as Java can often be more productive.

All objects in a singly rooted hierarchy (such as Java provides) can be guaranteed to have certain functionality. You know you can perform certain basic operations on every object in your system.

A singly rooted hierarchy, along with creating all objects on the heap, greatly simplifies argument passing (one of the more complex topics in C++).

A singly rooted hierarchy makes it much easier to implement a garbage collector (which is conveniently built into Java). The necessary support can be installed in the base class, and the garbage collector can thus send the appropriate messages to every object in the system. Without a singly rooted hierarchy and a system to manipulate an object via a reference, it is difficult to implement a garbage collector.

Since run-time type information is guaranteed to be in all objects, you’ll never end up with an object whose type you cannot determine. This is especially important with system level operations, such as exception handling, and to allow greater flexibility in programming.

Collection libraries and support for easy collection use

Because a container is a tool that you’ll use frequently, it makes sen se to have a library of containers that are built in a reusable fashion, so you can take one off the shelf Because a container is a tool that you’ll use frequently, it makes sense to have a library of containers that are built in a reusable fashion, so you can take one off the shelf and plug it into your program. Java provides such a library, which should satisfy most needs.

Downcasting vs. templates/generics

To make these containers reusable, they hold the one universal type in Java that was previously mentioned: Object. The singly rooted hierarchy means that everything is an Object, so a container that holds Objects can hold anything. This makes containers easy to reuse.

To use such a container, you simply add object references to it, and later ask for them back. But, since the container holds only Objects, when you add your object reference into the container it is upcast to Object, thus losing its identity. When you fetch it back, you get an Object reference, and not a reference to the type that you put in. So how do you turn it back into something that has the useful interface of the object that you put into the container?

Here, the cast is used again, but this time you’re not casting up the inheritance hierarchy to a more general type, you cast down the hierarchy to a more specific type. This manner of casting is called downcasting. With upcasting, you know, for example, that a Circle is a type of Shape so it’s safe to upcast, but you don’t know that an Object is necessarily a Circle or a Shape so it’s hardly safe to downcast unless you know that’s what you’re dealing with.

It’s not completely dangerous, however, because if you downcast to the wrong thing you’ll get a run-time error called an exception, which will be described shortly. When you fetch object references from a container, though, you must have some way to remember exactly what they are so you can perform a proper downcast.

Downcasting and the run-time checks require extra time for the running program, and extra effort from the programmer. Wouldn’t it make sense to somehow create the container so that it knows the types that it holds, eliminating the need for the downcast and a possible mistake? The solution is parameterized types, which are classes that the compiler can automatically customize to work with particular types. For example, with a parameterized container, the compiler could customize that container so that it would accept only Shapes and fetch only Shapes.

Parameterized types are an important part of C++, partly because C++ has no singly rooted hierarchy. In C++, the keyword that implements parameterized types is “template.” Java currently

has no parameterized types since it is possible for it to get by—however awkwardly—using the singly rooted hierarchy. However, a current proposal for parameterized types uses a syntax that is strikingly similar to C++ templates.

https://www.360docs.net/doc/676772738.html,/

Paper 1翻译

p2p信任模型

对P2P网络存在的问题进行了分析，阐述了建立P2P网络信任模型的需求。在对现有P2P网络中的信任模型进行总结归纳后，指出了以后研究的方向。

引言:随着Internet的广泛普及，端用户系统资源的丰富，以及网络带宽的快速增加，传统的Client/Server网络应用模式中服务器的性能瓶颈以及单点失效的问题不仅限制了端系统资源的充分利用，同时也越来越无法满足新的分布式应用的需求。而P2P网络在协同工作、分布式信息共享、大规模并行计算等方面显示出的独特优势，使其成为新的发展热点。P2P网络是基于节点愿意共享资源这一基本假设的，即每个节点共享自己的资源，并从其他节点那里获取自己需要的资源。然而，这种个人为公众提供资源，且节点行为无约束的工作模式导致P2P网络存在三个问题。

（1）搭便车（Free-Riding）问题

Free-Rriding指节点只消费其他节点贡献的资源，而不共享自己的资源。以Gnutella P2P 文件共享系统为例，70%的节点是Free-Rider。最新的监测也表明在eDonkey文件共享网络中，大约有80%的节点是Free-Rider。

（2）“公共物品的悲哀”（the Tragedy of the Commons）问题

“公共物品的悲哀”指网络资源作为一种非排他的公共资源，被大多数P2P节点无节制地使用，据统计，P2P数据流量占因特网总流量达60%，并且在用户总数没有显着增长的情况下，P2P数据流量仍然在快速持续增长。事实上，P2P网络理性用户的根本目的是最大化自己效用，而并不考虑网络的整体效用。

（3）不可靠服务和欺诈问题

P2P网络中存在着大量不可靠的服务质量以及欺诈行为。以众多的文件共享应用为例，25%的文件是伪造文件（Faked Files）。而在类似于eBay这样的电子商务中，这种不可靠服务和欺诈行为给用户带来的影响则更为严重。

因此，必须设计有效的机制来规范P2P网络中节点的行为来解决上述三个问题，从而提高

P2P服务的可用性，促使节点进行有效的协作并合理使用网络资源。

为什么是信任模型

在节点具有自主权利，自组织的P2P网络中，如何来规范节点的行为呢?事实上，P2P网络提供了真实世界中人类交流的网络环境，是以人为中心的网络，与社会网络具有同构性。而信任作为社会存在的一个整体部分，是社会网络中人与人之间的核心关系。人类社会通过基于信誉的信任关系与激励机制来约束人们的日常生活行为。基于信任的P2P网络与人类社会网络的相似性体现在P2P网络中个体之间的彼此交互会为彼此留下零星的“信用”信息；个体对交互对象具有充分的选择权利；个体往往不看重绝对的可靠性或服务质量，即个体可以忍受少量错误的选择带来的损失，比如文件共享应用；个体有义务为网络中的其它个体提供推荐信息。因此，可以利用信任关系刻画P2P网络中节点之间的关系，并采取基于信任的激励机制解决上述问题。

（1）基于信任值提供区分服务

在文件共享P2P网络中，可以根据节点对网络资源的贡献程度，提供区分服务。例如，Kazaa 将节点提供的资源与消耗资源的比值作为节点参与到系统中的等级，并将其作为节点享受服务的优先级。BitTorrent中节点根据对方上传的速率决定自己上传的速率。在eDonkey网络中节点根据本地信任值来设定请求节点在下载队列中的优先级。

对恶意使用网络资源的节点进行惩罚。例如R.T.B.Ma提出的激励机制关注于类Gnutella 网络中文件传输时的带宽分配问题，根据节点对网络的贡献为其分配带宽资源。当节点共享数据时，贡献值增加从而激励节点共享。当节点从过载节点下载文件时，贡献值减小，从而抑制节点对公共资源的消耗。

基于区分服务的激励机制可促使节点之间合作并合理使用网络资源，从而解决搭便车和“公共物品的悲哀”问题。

（2）根据节点的信任值选择服务提供者

节点可以基于信任值来选择与之进行交易的对方。例如，在eBay网络中，购买信任值较高的商家的产品，从而激励商家保持良好的销售行为并提高可靠的产品。从而有效抑制P2P 网络中的不可靠服务和欺诈问题。

信任的概念

信任是一个多学科的概念，描述了在特定的情境下，一个个体在可能带来不利后果的情况下，愿意相信另一个个体具有某种能力或能够完成某项任务的主观信念。与信任紧密联系的概念是信誉，信誉来自个体的社会网络中，是基于观察到的个体过去行为或过去行为的信息而对个体行为的期望。信誉和信任之间的差别可以用我信任你因为你有好的信誉或我信任你尽管你的信誉不好来说明。由此可见，信誉强调的是一个群体对某一个体或群体的共同的可信赖度，而信任更多强调的是信任个体对被信任方的主观信赖。在本文中所提及的信任指的是信任方对被信任方的主观信任，即信任方根据自己的经验或同时参考被信任方的信誉而得出的被信任方的可信赖程度。在资源共享的P2P网络中，体现节点可信赖程度的不仅包括节点的诸如计算、存储、网络带宽等方面的客观能力，同时与节点参与到P2P网络中的行为特征相关，例如节点的在线时长、友好程度等。在电子商务类的P2P网络中，卖家的可信赖程度与商品说明、与买家的沟通、运送时间、运送及手续费等相关。在实际的应用系统中，将所有影响节点可信度的信任因素进行量化并综合得出节点的可信度并不可行。因此，一般情况下，在P2P网络的信任模型中，根据节点彼此之间对交易的满意程度来确定可信度。

信誉、信任与互惠的关系

正如社会领域，只有当过去的行为对未来有影响时（社会学称之为“未来阴影（Shadow of Future）”现象），人们才有动机去建立彼此间的信任关系。因此，信任模型与激励机制之间具有良好的互动关系，可以有效促进P2P网络中节点之间的合作。

信任模型分类

在P2P网络中，存在着各种各样的攻击模型，包括：欺诈、假冒、诋毁、联合欺诈、具有前端节点（前端节点一般提供可靠的服务，对合作节点给予公正的评价。但这些前端节点试图通过给予集团内部恶意节点高的正面评价来掩饰恶意节点的行为）的联合欺诈、节点改变ID重新进入网络以及节点间歇性地提供不可信信息和服务，或是累积信誉到了一定高度时，利用其较高的信任值，进行诈骗、诋毁或联合欺诈等攻击行为。目前的信任模型大多集中于解决某几类攻击问题，根据建立信任关系的方法，大致可分为基于可信第三方的信任模型和基于反馈/评价的信任模型两类。

基于可信第三方的信任模型

这类信任模型采用传统安全体系中的PKI技术，通过网络中的少数领袖节点来监督整个网络的运行情况，并定期通告违规节点或对其进行处罚。这些领袖节点的合法性通过CA颁发的证书加以保证。这类系统往往依赖于少量中心节点，因此存在单点失效、以及可扩展性的问题。

基于反馈/评价的信任模型

P2P网络中的信任模型大都属于此类，根据被信任客体的不同，存在为资源建立可信度和为交易节点建立可信度两大类。前者关注于P2P网络中可获取信息的可信度，与信息提供者的可信度并不建立直接联系。在这类信任模型中，节点对信息的可靠性进行判定，并给出正面或负面的反馈评价，并进一步计算其信任值。例如，在文件共享应用Kazaa中，只考虑正面的反馈，采取数据签名的方式来建立可信度，即如果用户认可信息的真实性，则进行签名，信息获得的签名越多，其真实性越高。这种为资源建立可信度的信任模型局限于信息共享的应用，不具有广泛的适用性。下文针对为交易节点建立可信度的信任模型进行说明。

（1）全局信任模型

这类信任模型对网络中所有交易反馈进行分析并为每个节点建立惟一的可信度。

全球最大的拍卖网站eBay通过交易结束后，交易双方分别给出正面、负面或中立的反馈评价，并利用正面评价数减去负面评价数得出某个体的信誉。该方法简单易理解，但无法处理交易者给出的不公正的反馈。S.Kamvar提出的全局信任模型EigenTrust根据节点的交易历史，计算本地的信任度，并考虑节点的推荐信任信息，通过节点间信任度的迭代来实现信任的传播，从而为每个节点计算全局可信度。W.Dou提出了与EigenTrust相似的全局信任模型，解决了EigenTrust在求解全局可信度时解的存在性问题。A.Yamamoto提出的P2P网络分布式信任模型把节点之间的信任关系建模为Web页面的链接，利用Pagerank算法采用分布式的方式来计算节点的信任值。但这种建模方式忽略了节点与不同节点信任关系之间的差别，其合理性值得商榷。L.Xiong提出的PeerTrust为了更有效的评估节点的可信度以及描述P2P社区中各种恶意行为，不仅将对交易满意程度的反馈作为评估信任的参数，同时考虑了交易的总数目，反馈的可信程度，交易的上下文因子、社区上下文因子。仿真结果表明，该信任模型能够有效抑制恶意节点的攻击。L.Mekouar提出了部分分布式P2P网络（例如

KaZaa）中的信誉管理机制RMS_PDN。在RMS_PDN中超级节点传递节点之间的信任评价，使每个超级节点能够记录其叶节点对系统的有效贡献并作为叶节点的可信度。但RMS_PDN直接利用所有节点的反馈信息，容易受到恶意节点的联合欺诈攻击。

全局信任模型忽略了信任的私人化特征，对于某个特定的节点，其他节点对他的信任值都是相同的。简单的全局信任模型容易受到恶意节点联合欺诈的攻击。而复杂的全局信任模型需要节点之间合作处理信任信息，计算和通信开销都较大。此外，在大规模的P2P网络中为每个节点计算全局信任值的必要性和可行性仍有待进一步研究。

（2）局部信任模型

已有关于P2P网络的信任模型大多关注于提供机制使得节点可以根据共享信息为给定节点计算局部信任值。Y.Wang提出了P2P环境下基于贝叶斯网络的信任模型。该信任模型主要关注于描述信任的不同方面，使得节点可以根据不同的场景来按需获取节点不同方面的性能。该信任模型能够适应于规模较小的Gnutella网络，或节点交互集中的Gnutella网络。S.Lee提出了一种全分布式的方式来存储用户的信誉信息。与其他信任系统不同的是，在NICE系统中，节点i存储的信任信息是其他节点对i所提供服务的满意反馈，因此节点有动机存储信任信息。L-Xiong提出的PeerTrust机制允许节点根据提供反馈信息的节点与其自身的个体相似性选择反馈信息，计算对给定节点的主观可信度，利用该方法可防止节点的联合欺诈攻击，但在大规模P2P网络中由于交易的稀疏性，并不一定存在足够的具有个体相似性的节点。

在基于共享信息的局部信任模型中，共享信息的获取有两种途径：一是通过向其他节点洪泛信任请求获得，该方法可扩展性差；另一种是通过采用DHT机制的P2P存储系统如Chord 等获得，这种方法不适合于节点频繁加入和离开系统的P2P系统。此外，这类基于共享信息的局部信任模型也不适合于节点之间不能进行管理信息直接交互的部分分布式P2P网络。

结束语

在没有有效管理机制的P2P网络中，建立能够抑制所有攻击模式的信任模型是非常困难的，除了要能够抑制节点的攻击外，在建立信任模型的时候，要充分考虑信任模型是否具有规模可扩展性，在信任计算以及信任信息存储方面的可扩展性，以及信任信息传播过程中的带宽开销问题。此外，在节点动态进出网络频繁的情况下，信任模型的容错性或健壮性也是需要特别强调的。