2023/12/4 02:20
Final project F23 - HackMD
Final project
Overview
We have reached the end of the course, congratulations! Take a deep breath. You’ve made it.
In this course, we have discussed some of the core protocols and concepts that power the Internet. Yet, there are many topics we have not had time to cover. Though some of the core protocols will be around forever, networking is a fast-moving field of CS, with new protocols, ways to build applications, and new performance and security concerns evolving every day. Thus, our goal is to give you the tools you need to tackle new networking challenges you encounter.
In this project, you will have an opportunity to implement a protocol or concept we have discussed in class but did not get to do in our other projects. Examples could include building a client/server for a protocol we’ve discussed, or implementing a networked application in some interesting way. Your project could also extend an existing project we have already completed, so long as you propose a significant-enough extension.
See the Sample topics section for a list of possible topics. You are welcome to use any of these, modify them, or suggest your own! Any ideas you suggest do not need to fit into these two categories—you can work on any topic you want, so long as we approve your idea.
2023/12/4 02:20
Final project F23 - HackMD
Logistics and Timeline
Teams
You SHOULD work on the project in a team of 2. You MAY keep the same team as for IP/TCP, or you may form a new team. Working solo is permitted, but we don’t recommend it unless you have extenuating circumstances or a very narrow project topic (ask Nick if you’re unsure).
If you worked as a group of 3 for IP/TCP, or if you had permission to work solo, you may continue to do so for this project.
Note: Regardless of your team situation, you MUST fill out the team preference form (https://forms.gle/3rVghQRL5kdHNV5J8) to register your team (even if it’s a team of size 1), or ask to be matched to a team, by Wednesday, November 29 at 5pm EST.
All team mumbers must fill out the form–only mutual requests will be honored.
If you do not submit the form on time, we may not be able to match you to a team, requiring you to work solo.
Timeline
Your project has two deadlines:
A brief project proposal due by Friday, December 1 at 11:59pm. No late days may be used on this part, since we need to review your proposals and provide feedback.
Your final submission, including a your implementation and a brief writeup are due by
Thursday, December 14
2023/12/4 02:20
Final project F23 - HackMD
Repository
Once your team has been formed, you will receive a github classroom link to create a repository.
This repository is completely blank. Since this is an open-ended project, there is no starter code or reference implementation—this repository is just a place to keep your work and collaborate!
Languages
You can work on the project using any language(s) you want—whatever you think will help you accomplish the project most easily. You are are NOT restricted to Go/C/C++/Rust: Python or other scripting languages are fine.
As with previous projects, you may also use any software libraries to help, so long as they do not trivialize the project you have proposed. For example, if your project is to build a DNS resolver, it’s fine to use a library to build/parse DNS packets, so long as you write the actual logic to decide what to query and interpret the responses yourself.
Project proposal
To ensure your project has a suitable scope, you must write a short project proposal and submit it via Gradescope on or before Friday, December 1 by 11:59pm EST. No late days may be used on this part, since we need to review your work and provide feedback–any late submissions will incur a penalty.
Your proposal should be short (no more than 1–2 pages) and should include the following:
An outline of the project you want to implement–what do you want to acheive? Any stretch goals you think may be difficult but nice to have
Any tools, libraries, or language(s) you intend to use (doesn’t need to be a final list)
Any open questions you’d like us to help you answer
2023/12/4 02:20
Final project F23 - HackMD
If you’re not sure about all your project’s details–that’s okay! Let us know what you’d like to learn and how we can help.
Final implementation and writeup
When you are done, you will submit your work by pushing all code to your repository and submitting a final report and demo video that describe your overall results. The requirements for each part are described in the following sections.
Writeup: There is no official length requirement, but a reasonable estimate is on the order of 3–4 pages of text/figures. In general, your writeup should contain at least the following components:
Introduction: What were your overall project goals? What (briefly) did you achieve?
Design/Implementation: What did you build, and how does it work? For this part, give an overview of the major components of your system design and how they work, similar what you might write in a readme.
Discussion/Results: Describe any results you have, what you have learned, and any challenges you faced along the way. For this part, please include any relevant logs/screenshots of your program operating (and/or reference your demo video).
Conclusions/Future work: Overall, what have you learned? How did you feel about this project overall? If you could keep working on this project, what would you do next?
Demo video: In addition to your code and writeup, your final submission should include a short (no more than 5min) demo video to demonstrate your work. This can be as simple as a screen recording while you run your code, or a more involved presentation where you also describe your project and how it works. Basically, this is just a way to supplement your writeup in a video format–we will look at both when grading. If your video is too large to upload to your repo, please upload it to Google Drive and include a shareable link in your document.
2023/12/4 02:20
Final project F23 - HackMD
Final Deadline
Your final submission (code, writeup, demo video) is due by Thursday, December 14 at 11:59pm EST.
Warning: If this deadline would be problematic for you, please contact the instructor ASAP so that we can make a plan together. Late days may not be used without prior permission (or an excused extension), since this deadline approaches the official University grading deadline.
Depending on your individual circumstances (graduation date, final grade logistics), some extensions may not be possible. If you have concerns, you should contact Nick sooner rather than later!
Sample project topics
The following pages contain some sample project ideas. These are meant to be a starting point to think about your own project–you can use one of these, or pick your own!
Note: We’ll be adding some more resource links soon!
Simple HTTP server
Relevant lectures: Lectures 19–21
2023/12/4 02:20
Final project F23 - HackMD
Implement a simple webserver to serve static pages from a directory using HTTP 1.0 or 1.1. A basic implementation would involve implementing the GET method to request pages. From there, you could consider adding support for generating content dynamically, uploading content via the
POST method, or measuring your webserver’s performance with a benchmarking tool like wrk (https://github.com/wg/wrk).
DNS resolver
Relevant lectures: Lectures 18–19
Implement a DNS resolver that can perform recursive and iterative queries (ie, by starting with a root nameserver). Some extensions could include adding support for caching, or querying different record types ( A , AAAA , TXT , ...).
Some implementation details
Build an application with RPCs, eg. a better Snowcast
Note: We’ll talk more about RPCs and Web APIs in class on Tuesday, November 28. For now, here’s some more background on what this means.
Relevant lectures: Lecture 23
When we built Snowcast, you wrote code to manually compose messages in the Snowcast protocol format and send them along TCP sockets. This is a great exercise in implementing a protocol. However, modern applications often leverage frameworks to help build network APIs more quickly. One such framework is gRPC (https://grpc.io): users can define their API and message formats, and the gRPC framework automatically generates code for establishing connections, authentication, serializing messages and more, in your language of choice.
2023/12/4 02:20
Final project F23 - HackMD
To explore these tools, you could implement part of Snowcast (or some other application of your choice) in gRPC (https://grpc.io), or some other framework that provides similar functionality. A good starting point might be to build a client and server that connects and exchanges Snowcast’s Hello / Welcome messages, and then continue with selecting stations and streaming data.
Some implementation details
HTTP API: ActivityPub
Note: We’ll talk more about Web APIs in class on Tuesday, November 28. Relevant lectures: Lecture 23
Mastodon, the open-source, decentralized Twitter alternative, is built on the ActivityPub protocol (Overview (https://en.wikipedia.org/wiki/ActivityPub), Full Specification (https://www.w3.org/TR/2018/REC-activitypub- 20180123/)), which is an HTTP API for exchanging messages between ActivityPub servers and clients. While ActivityPub has a lot of features, the mechanics essentially boil down to exchanging JSON messages via HTTP.
For this project, you could implement a basic ActivityPub client and server that support some basic methods. To do this, you can use any web programming libraries you like to serve HTTP endpoints. A good starting point would be to implement some methods from ActivityPub’s “Social API”, which specifies communication between clients and the server (posting and fetching messages). As a stretch goal, you could consider parts of its “Federation API”, for communicating between your own servers to build a larger social network.
2023/12/4 02:20
Final project F23 - HackMD
Build your own traffic analyzer
Wireshark and similar tools are great for viewing and analyzing network traffic, but you can also build your own custom packet analysis tool to answer very specific question. Using a packet capture library like scapy (https://scapy.net/) (Python), pcap (https://pkg.go.dev/github.com/google/gopacket/pcap) (Go), or libpcap (C/C++), implement your own traffic analyzer that can either watch for packets on a live network interface, or read a capture file, to perform some specific analyses on your own traffic.
What should you analyze? You decide! Examples could include:
Extracting files and images from HTTP (not HTTPS) traffic
Logging your DNS traffic, and outputting a list of all domains queried from your system, how
often you query them, etc.
Measuring average latency of TCP connections, or drawing your own TCP stream graphs (https://www.packetsafari.com/blog/2021/10/31/wireshark-tcp-graphs/) to examine congestion control performance
