Suggested
Projects:
Below is a tentative list of suggested projects. This
list is subject to change. The description below is very terse. More
details will be given in class. Projects may be added in the coming
weeks. In addition, teams are welcome to propose their own
security-related projects. These proposals will of course be subject to
approval of the course staff.
Endpoint Risk Assessment/Awareness Tool (Advisor:
Checkpoint, Leonid Belkind) (2 students)
The goal of the project is to
create a lean tool that would run on the Workstation machines (targeted
at various Microsoft Windows operating systems) and assesses the security
risk the machine is under in a number of categories:
1.
By scanning
the history of connected plug-n-play devices and displaying it, the
tool will show a potential risk of copying proprietary data
(intentionally or by mistake)
2.
By scanning
the history of a Web Browser and passing the URLs through an external
mechanism that’d classify them as (dangerous, distributing malware,
allowing to upload files, allowing peer-to-peer communication, etc…),
the tool would show a potential risk to the system caused by the end
user’s actions
3.
By scanning
the installed programs and identifying them as dangerous ones
(Peer-to-Peer, Supporting File Transfer, etc…) the tool would show a
potential data loss risk
4.
By scanning
the send items folder of the email client (Support for the most common
ones – Microsoft Outlook, Mozilla Thunderbird), the tool would identify
the amount of emails (potentially with attachments) that were forwarded
from the inside organization to the outside, or were sent to a mixed
list of recipients, including both internal and external parties
The
overall benefit of running such a tool and generating a report
summarizing the abovementioned security risks (alongside potential more
advanced ones) is raising the awareness of the end-users to different
ways their system can be infected or their data can be exposed to
unauthorized parties. Another feature would be to execute the tools
from a centralized server in a way that all network assessments will be
summarized in a meaningful way.
Quick Crash Detection (Advisors:
Checkpoint, Yoav Nir
and Yaron Sheffer)
(2 students)
The
IKEv2 key exchange protocol, defined in RFC 4306, is a reliable
security protocol. But failures do happen, and should be detected both
quickly and securely. The current protocol relies on rather long
timeouts for an IKE peer to detect that the other peer has restarted,
and re-initiate the protocol. What is needed is a way for a restarted
IKE party to “convince” its peer that it has rebooted, to eliminate
this long delay. And given the context of IKE, this must be secured –
an attacker must NOT be able to do the same. The “Quick Crash
Detection” protocol proposes to do just that. The protocol is defined
in an Internet Draft, http://tools.ietf.org/html/draft-nir-ike-qcd-05. The team
will implement this extension within an open source implementation
(probably StrongSwan). Any issues discovered
during the implementation will be reflected in the upcoming Internet
standard!
Elliptic Curves cryptography (Advisor:
Intel, Barukh Ziv) (2
students)
Cryptosystems
based on Elliptic Curves are one of the latest developments in
Public-Key Cryptography. Proposed a decade after RSA algorithm, they
received increased commercial acceptance and were included in important
security standards. Nowadays, they are among the most attractive
candidates in new developments of cryptographic schemes both in
hardware and software. Thanks to the unique properties of Elliptic
Curves, the cryptosystems based on them achieve a desired security
level with significantly smaller keys than the more conventional
schemes (for instance, a 160-bit elliptic curve key provides the
same level of security as a 1024-bit RSA key).
Implementing
an efficient elliptic curve-based cryptosystem performing at security
level proposed by acclaimed standards (i.e. 200-300-bit keys) is a
non-trivial task. Generating a random elliptic curve with
“cryptographically strong” properties is really challenging!
Students may choose from one
of the following projects:
Elliptic Curve Based
Public-Key Cryptosystem:
Design and implement a specific public-key cryptographic scheme
(digital signature, encryption, or key establishment) based on elliptic
curves. The steps in the project include learning the theory of
elliptic curves (a fascinating subject in its own); efficient
implementations of elliptic curve arithmetic; design and implementation
of a cryptographic scheme itself.
Efficient Generation of
Cryptographically Strong Elliptic Curves: Based on existing implementations of elliptic curve
arithmetic, design and implement an efficient algorithm for random
generation of elliptic curves with “cryptographically strong’
properties. The goal is to achieve a speed of at most several seconds
for standard-level security (200-300 bits).
Prerequisites-
1.
Basic knowledge in modular arithmetic, and number
theory (or willingness to learn)
2.
Excellent programming skills.
3.
Acquaintance with Public-key cryptosystems.
General secure multi-party computation protocol (2-3 students)
Secure multi-party computation is a cryptographic paradigm that allows
a set of mutually distrustful parties to perform some joint computation
in a way that guarantees correctness of the outputs along with secrecy
of local data (to the maximum possible extent). Our current ongoing
project works on inputs of circuits, and assumes communication channels
are in order. We want to improve those two weaknesses, specifically we
want to implement:
1.
A compiler that takes a
program written in C-like language and produces a matching circuit.
2.
A reliable broadcast channel
or a semi-trusted public board
Binary
Diffing Framework – “Diversus” (4+
students)
A binary diffing is a way of finding the exact differences between
2 variants of the same executable. It is useful for analyzing patched
executable for silently closed vulnerabilities (in order to extract
signatures for AV, etc), or, to find
similarities between malwares.
Why is it hard? different compiler flags, compiler optimizations,
small change in code may produce much different binary, etc.
The framework consists of
several sub-projects that depends on each other:
- (2 students) Asm2Ir –
Disassemble binary (e.g. using IDA), analyze it and build
intermediate representation of the code. Also, output textual
files with all export/import tables and other important data
sections.
- (1 student) Binary
Instrumentation for Dynamic Analysis (BIDA) – use Intel's PIN
framework (www.pintool.org) / DynamoRIO
(dynamorio.org) / OllyDbg’s
traces in order to
- record information
about control flow
- record information
about basic blocks flow
- chopping of relevant
areas
- record specific data (e.g.,
socket data for some function) or dynamic function calls
- other interesting
information..
- (2-4 students)
"High level" algorithms
- binary diffing
algorithms:
- find trivial
“anchors” (date refs, symbols, external functions, etc)
- BitBlaze’s basic algorithms
(without semantic analysis) - control graph matching, register
reordering, etc
- use dynamic traces to
improve diff (add more “anchors”)
- semantic analysis in
order to reduce “false positives”
- trace diff – analyze
the edit distance (diff) between two traces in order to different
paths
- GUI (optional) - Graph
visualization for our diff framework (e.g., using www.oreas.com or www.ogdf.net)
- Data tainting
(optional)
Search on encrypted database on the cloud (2 students)
When you store something on the cloud, you can’t assume that its
privacy will be ensured. Hackers, malicious insiders or just lack of
security measures can result in leakage of your most sensitive information.
The goal of this project is to implement an encrypted database such
that the client is capable of querying the database without exposing
the decryption key to the cloud provider or anyone else. The idea is to
implement the protocol over existing database (e.g. MySQL, Amazon SimpleDB). The solution should be based on previous
works, including http://www.eecs.harvard.edu/~michaelm/postscripts/acns2005.pdf and/or http://cs.ucla.edu/~rafail/PUBLIC/74.pdf.
Verifiable computation on clouds (2-3)
When you delegate your computation to some powerful server
(e.g., Google, Amazon) you assume that the computation was executed
properly. If the server has some interest to cheat (e.g., to save up
resources) then you cannot catch him easily.
This project will implement an efficient protocol that uses 2 clouds in
order to verify that their computations were done properly. The project
will consist of a “record and replay” interpreter that will wrap the
computation inside a controlled environment in a way that it will be
verifiable. The computation could be any program of some easy to
work with assembly.
Qilin project (2 or more students)
Qilin (qilin.seas.harvard.edu) is an open source project for providing JAVA SDK
for prototyping of cryptographic protocols. We want to implement
primitives or protocols as part of this project. Specific ideas can be:
encryption schemes, hashes, signature schemes, verified mix-net,
oblivious RAM, 2PC, etc.
Other
general projects
1. Write
a BlueTooth scanner for 1-2 mobile phones,
and , a server that shows all scanned mobiles on google
maps (similar to http://trifinite.org/trifinite_stuff_btaudit.html) (1-2 students)
2. Encrypted
DiskOnKey (with drivers, GUI, hidden volume, etc). e.g., www.truecrypt.org. (2 students)
Your suggested
project!
|
