CS 261 Homework 1
Briefly sketch answers to each of the following problems.
A few short sentences should be
enough for the first two questions.
Feel free to use incomplete sentences if you like.
This problem set is due Thursday, 30 September.
Turn in your answers, in paper, at the beginning of class that Thursday.
Please include both your name and your WebReview username at the top
of the first page of your solutions.
Work on your own for this homework.
You may use any source you like (including other papers or textbooks),
but if you use any source not discussed in class,
you must cite it.
Prof. Beanstalk makes the following claim:
Stack smashing attacks are made
possible by the fact that stacks grow downwards (towards smaller addresses)
on most popular modern architectures.
Therefore, future architectures should ensure that the stack
grows upwards; this would provide a good defense against buffer
Do you agree or disagree? Why?
As we saw in class, C programs are commonly prone to buffer-overflow attacks.
What changes could be made to the C compiler to help protect against
(or prevent) these attacks?
This is a brainstorming question; give as many good answers as
This question asks you to design and implement a safe HTML filter.
I want some way to safely view HTML pages from the web,
and this method better not harm my machine even through these pages
come from an untrusted source, and even though my web browser is too
complex for me to have full faith in its ability to safely handle
totally untrusted web pages.
You're going to write me a sanitizing filter that I can use
something like this:
I have two goals for this composed system:
./htmlfilter < scarywebstuff.html > safe.html
Security matters more than functionality; my threshold for security will
be pretty high, while my threshold for functionality will be very low.
- This procedure must not, under any circumstances, cause any harm
to my system.
Ideally, using this procedure to view web pages should be as harmless
as viewing an ASCII text file with, say, /bin/more;
note that even if an attacker supplies the entire contents of a text file,
viewing it with /bin/more cannot harm my machine,
so /bin/more is in some sense the gold standard.
In particular, viewing untrusted files using your HTML filter and my
favorite web browser should not cause any lasting side effects to my machine,
and it should not leak any confidential information (e.g., the contents of
files on my hard disk; or, information about what I'm viewing in another
window with the same browser).
Your scheme must not only be secure; it must also be verifiably secure.
You will have to provide an assurance argument why it is reasonable to
believe that your filter achieves this goal.
- In an ideal world, your filter would allow me to view as much
of the content on the
web page as possible -- except where this would conflict with the previous
requirement, in which case security is more important than functionality.
For instance, a filter that ignores its input and always outputs the
empty HTML page is not very useful.
Thus, your solution should be at least minimally useful for viewing
the text content of web pages.
However, I don't really care whether I get to see pretty pictures,
dancing pigs and other fancy decorative stuff or not.
Also, feel free to keep your implementation simple and to omit support
for complex functionality.
This is intended only as a proof of concept
exercise -- no need for feature-complete production code.
To keep this tractable as a homework question,
you can err on the side of omitting functionality (though it might
be nice if your approach can be generalized to support as much
functionality as possible).
I want you to come up with a design, implement it, document your basic
architecture and assurance argument, and submit both the document and the
Your submission should contain at least three files:
From within this directory, run
- Document the basic architecture you've used and the theory of operation
for your scheme.
Sketch the assurance argument why one should expect your scheme
to be secure.
This should be an ASCII text file, and it doesn't have to be too
lengthy; a page or so should be enough.
- A Makefile with everything needed to compile your program.
If I run make, it should do everything needed to compile your
program and finally generate in the current
directory an executable file called htmlfilter.
This program should read an untrusted HTML file from stdin and write a
sanitized HTML file to stdout.
- Source files
- Include any source files needed to build the executable.
Don't include the executable itself; I will run make myself.
You can use pretty much any well-supported language you like
(e.g., C, C++, Java, Perl, Python, ML, OCaml, bash script)
as long as it will work on my Linux system.
However, to avoid any difficulties,
please take care to make your program as portable as possible.
Feel free to keep it simple. If you are writing more than a few hundred
of lines of code, you're probably working too hard.
where your-username denotes your two-letter username
for the WebReview system. Then, email me this file as an attachment
by the due date.
Also, print out the README file and attach it to your homework
solution that you turn in to class.
tar cf your-username.tar .
Yes, I will be running your programs.
Because I will be using automated scripts to do so, I ask you to follow
the above instructions carefully.
To help demonstrate the format, here is reference code that demonstrates
the required format: ref.tar.
(Feel free to steal from this code in your implementation, if you like.)