Professional Documents
Culture Documents
"Parasitic Computing": Seminar Report By
"Parasitic Computing": Seminar Report By
Kunal Goswami
(05IT6006)
School of Information Technology
IIT Kharagpur
Table of Contents
1. Introduction
2. Details of Parasitic Computing
3. Implementation using TCP
a. TCP checksum
4. Solving 2-SAT and 3-SAT problems
5. Alternative Implementations
6. Issues
7. References
1. INTRODUCTION
THE NET is a fertile place where new ideas/products surface quite often. We have
already come across many innovative ideas such as Peer-to-Peer file sharing, distributed
computing and the like. Parasitic computing, which harnesses the computing power of
machines that spread across the Net to accomplish complex computing tasks, is new in
this category. The successor to distributed computing has opened up a whole new can of
worms. It works by exploiting a weakness in the TCP/IP system's error checking system.
The problem is that forcing target machines into performing calculations puts a greater
load on them than a regular packet would, and the server owner has not agreed to take
part - in effect the technique is stealing processing power, but without breaking any laws.
Although the technique is too slow to have much practical value at present, it does raise
questions for the future. The report discusses the technical aspects of what has already
been carried out and the related issues.
problems. In contrast, parasitic computing does not require the willingness of any target
machine to participate in the problem solving. This way one can make use of many
distributed resources across the Internet, which is otherwise remaining idle. Also if one
divides the task in such a manner that no computer is overloaded remote machine
performance wont deteriorate much and our task will be also be accomplished.
It is not cracking.
remote machines respond to the request unknowingly that they are involved in solving a
complex problem and they believe that they are responding to a simple application
request over TCP connection.
The main target problems for such distributed environments are NP-complete
problems i.e. non-deterministic polynomial problems. These problems are such that their
steps cannot be expressed in terms of polynomial time and therefore to know the right
solutions one has to evaluate many possible alternatives. The property, which can be
exploited here, is that all the alternative solutions can be evaluated in parallel and
therefore different machines across the Internet can be used simultaneously for evaluation
thousands of possible candidate solutions for any such problem. Like in this case the
protocol, which is being used for this purpose, is TCP. To understand the implementation
one first needs to have a brief idea of TCP checksum.
TCP Checksum:
The checksum field is the 16 bit one's complement of the one's complement sum of
all 16-bit words in the header and text. If a segment contains an odd number of header
and text octets to be checksummed, the last octet is padded on the right with zeros to
form a 16-bit word for checksum purposes. The pad is not transmitted as part of the
segment. While computing the checksum, the checksum field itself is replaced with
zeros. This information is carried in the Internet Protocol and is transferred across the
TCP/Network interface in the arguments or results of calls by the TCP on the IP.
, and s
can be written in conjunctive normal form. A disjunctive normal form (DNF) is a similar
expression, which joins the clauses together with ORs.
Satisfiability arises whenever we seek a configuration or object that must be consistent
with (i.e. satisfy) a given set of constraints. The input to the problem could be a set of
clauses in conjunctive normal form. The problem is to determine whether there is a truth
assignment to the Boolean variables such that every clauses is simultaneously satisified.
Satisfiability is the original NP-complete problem. Despite its applications to constraint
satisfaction, logic, and automatic theorem proving, it is perhaps most important
theoretically as the root problem from which all other NP-completeness proofs originate.
Now let us understand how such problems were tackled by parasitic computing. Note
that all packets are inserted at the IP level, bypassing the TCP layer of the host, to avoid
the client side TCP( which buils it s own checksum).
Consider the following expression in 2-SAT.
The expression contains 16 variables, which are in CNF. They are connected by
XORs (exclusive ORs) or by conjunction. A XOR clause is true iff one of the literals is
true and a conjunctive clause is true iff both the literals are true. A message is created in
which each variable is appended with a zero is created.
Message: 0x0 0x1 0x2 0x3 0x4 0x5 0x6 0x7 0x8 0x9 0x10 0x11 0x12 0x13 0x14 0x15
For evaluating this expression using the TCP checksum method, we create a special
TCP segment that contains the message in the data part and the checksum obtained by
calculation. Suppose a candidate solution is given by 0100010100010101 (S1)
0000010001010100 (S2), the transmitted packet would look like this:
Since a number and its compliment add up to all ones (111111.... 1), the right
solution will result in a sum containing all ones, thereby enabling TCP to send it to
the higher layer (HTTP). All solutions that reach the HTTP layer are considered as
right ones. Therefore the construction of the message ensures that the TCP
checksum fails for all messages containing the invalid solution to the posed SAT
problem.
A 3-SAT problem can be similarly addressed, the reason being that 3 Boolean literals
add up within two bits without overflow, i.e., in the worst case 1 + 1 + 1 = 11 in binary.
5. ALTERNATIVE IMPLEMENTATIONS
Due to many layers of communication involved in receiving and interpreting a
message, there are, in principle many layers that can be used in parasitic computation.
Parasitic computing can be implemented on all underlying communication layers that a
packet has to go though before reaching the target program (which is the web server in
this case) for processing it. Therefore it can be implemented in the IP layer too, but it will
cause unwanted local bottlenecks since it will force the routers to solve the problem and
therefore degrading the performance. From what was suggested by the inventor of this
concept it is more efficient to implement it using TCP of higher layers, potential
candidates being TCP, HTTP, or encryption/decryption with SSL.
REFERENCES:
www.hindu.com/thehindu/2001/09/13/stories/08130001.htm
10