“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

2
 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.

2. DETAILS OF PARASITIC COMPUTING

Parasitic computing is a concept by which one can use the resources of machines that
are connected on the Internet. This technology exploits open Internet protocols to use the
resources of remote machines. As the name suggests, the machine that requires the
services of others does not need to be authorized by the latter. Any machine, which is
connected to the Internet, has to carry out minimum processing of any packet they
receive without any authorization. This concept is exploited by parasitic computing in
order to make use of computing powers of remote machines and web servers all around
the globe. So one cannot really stop their machines from being utilized in this manner.

How it differs from cluster computing?

Parasitic computing differs from cluster computing. Cluster computing is an idea in

which many computers pool in their resources willingly to create a cumulative power
equivalent to that of a supercomputer capable of solving complex computational

3
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 won’t deteriorate much and our task will be also be accomplished.

It is not cracking.

Parasitic computing though works without authorization it is entirely different from

the concept of cracking. In cracking data is sent to the remote computer with malicious
intentions and in order to corrupt some resource of the remote machine whereas in this
case we are utilizing those resources for a constructive purpose and also accessing only
those parts of remote machines, which are made open on the Internet and that is done
without any malicious intentions but it can cause delay of services in the remote
machines as resources are being utilized without the knowledge of the owner.

3. IMPLEMENTATION USING TCP

Sending a message over an internet is a very sophisticated process as the message is

processed across many layers from HTTP then to TCP then to IP layer, going through
data link layer finally to the physical layer and in the same manner the message is
constructed back at the destination. To implement this concept of parasitic computing we
can choose to exploit processing theoretically any of these layers but below TCP layer it

is not very beneficial.

Till now there has been only one implementation, which has exploited this concept of
parasitic computing. Idea is to use some feature of the protocol in such a manner that

4
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.

4. APPLICATION: SOLVING 2-SAT AND 3-SAT PROBLEMS

The problem that we are addressing is called the “satisfiablity” problem, which

means, deciding whether a given Boolean formula in conjunctive normal form has an

assignment that makes the formula "true." In 1971, Cook showed that the problem is NP-

complete. Before we define what the problem is, we must know what a conjunctive

normal form means and what is NP-completeness.

5
Conjunctive Normal Form

A statement is in conjunctive normal form if it is a conjunction (sequence of ANDs)

consisting of one or more conjuncts, each of which is a disjunction (OR) of one or more
literals. Every statement in logic consisting of a combination of multiple , , 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

6
 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:

Where Tc is the complement of the checksum sent to verify the solution.

The TCP checksum function as performed by the target computer will do the
following:

• Suppose the data sent is in the form of S1, S2... Sk (each 16-bit). The target machine
calculates the sum of each of these 16-bit data parts and adds it to the checksum
sent

7
 • 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

8
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.

6. ISSUES IN PARASTIC COMPUTING

Basic protocols are exploited by parasitic computing to use resources of remote

computer without any authentication as messages are exchanged based on a trust
relationship. As it uses basic Internet protocols one cannot stop anyone from launching it.
Disrupting functions used by parasitic computing will eliminate remote computers ability
to communicate with rest of the Internet!
It can cause delay in services of the remote computer (denial of service attacks). It
also causes problems in Internet service. It can clog the network and effectively bring the
Internet down. It never compromises the security of the computer as it sends standard
packets and no malicious packets and also one has many other efficient ways of hacking
than using standard protocols functions. It probably never breaks any law, but it still leads
to certain ethical issues.
For the parasite, it may not be the best way to solve as it takes large number of
computational cycles to process the possible solution but it introduces the way in which
common protocols, like TCP, can be exploited. Also it cannot guarantee the correctness
of the result due to the possibility of false negatives and false positives. So at present
parasitic computing may be a slow technique to solve, but it could be used to load heavy
requests on a server and also get the solution for its problem. So, It does raise the
question for future by exploiting TCP layer.

9
 REFERENCES:

• Barabasi et.al., Parasitic Computing, NATURE 412, 30 Aug 2001.

• Barabasi et.al. Supplement material for Parasitic Computing :
http://www.nd.edu/~parasite/
• Barger N. Robert & Crowell R. Charles,The ethics of Parasitic
Computing, Sept 2003 :
www.nd.edu/~ccrowell/Parasitic%20Computing.pdf
• Ivars Peterson, Sneaky Calculations, Science News 160, 17 Nov 2001.
• www.hindu.com/thehindu/2001/09/13/stories/08130001.htm

10