Syllabus
Syllabus — Fall 2026 (DRAFT)
601.445/601.645 Practical Cryptographic Systems Mondays & Wednesdays 3:00–4:15 pm · First class August 31 · Last class December 9
Classroom: Shaffer 307. Video recordings of lectures will be made available eventually, but not immediately after class.
Course communications: we will use Piazza for all course communications — announcements, Q&A, and assignment clarifications. Please sign up here at the start of the semester.
Both sections (undergraduate 601.445 and graduate 601.645) meet together and follow the same structure.
Course description
This is a course about cryptography as it is used in real systems: encryption, authentication, key exchange: classical and post-quantum (ML-KEM), secure protocols (TLS, Signal), side-channel attacks, multi-party computation, zero-knowledge proofs, anonymity systems, and cryptographic backdoors. The emphasis throughout is practical: you’ll implement cryptographic systems, attack them, and learn to recognize the implementation mistakes that cause real-world failures.
Prerequisites: Working programming ability in a mainstream language of your choice, plus comfort with basic probability and algebra. Prior security coursework helps but is not required. Graduate students (601.645) complete the same assignments with additional depth expected on exams and written work.
How this course works in the age of AI
AI coding assistants can now complete traditional programming assignments end to end. Rather than pretend otherwise, this course is built around that fact:
- AI tools are permitted and encouraged on all take-home work (programming assignments and written homework), with disclosure (see AI policy below).
- Portions of the code still need to be written and understood by you: assignments will be very specific about this. Let the AI agents do the dumb glue work.
- Your grade primarily reflects what you can demonstrate in person: written exams and interactive code-review sessions, where no tools are available.
- Assignments are still essential — they are where the learning happens, and the in-person components directly examine your submitted code. Students who outsource an assignment without understanding it will discover that the assignment credit was the smallest part of what they lost.
Grading
| Component | Weight | Notes |
|---|---|---|
| Written exams (in person) | 40% | Midterm 1 (12%), Midterm 2 (12%), Final (16%) |
| Interactive code-review labs | 25% | Three rounds, one after each programming assignment |
| Programming assignments | 15% | Three assignments; autograded; scaled by review performance |
| Written homework | 10% | Problem sets, take-home |
| Reading engagement | 5% | Details TBA in September |
| Participation | 5% | In-class engagement |
Written exams
Two in-class midterms (see Schedule) and a final exam during the December examination period (date set by the registrar, TBA). Exams are closed-book, on paper, and no electronic devices are permitted. Expect a substantial fraction of exam questions to involve reading and evaluating code and protocols: explaining what a routine does, identifying the vulnerability in a fragment, or critiquing a proposed design (“an AI assistant produced this key-exchange implementation: what’s wrong with it?”).
Interactive code-review labs
After each programming assignment, you will sign up for a 15-minute individual session with course staff, scheduled outside class time. In the session you will:
- walk through your own submission and explain how it works;
- answer questions about the security-critical regions designated in the assignment handout (e.g., nonce and IV handling, padding, MAC verification, key derivation, randomness use, constant-time comparison);
- make or explain a small live modification (“what would break if…?”), which may include finding bugs planted in a modified copy of your own code.
Sessions are graded with a standard rubric shared in advance. The skill being assessed, such as reviewing security-critical code you did not necessarily write yourself, is exactly the skill that modern cryptographic engineering demands.
Programming assignments
Three programming assignments, autograded for functionality. You may use any mainstream programming language: the autograder tests command-line and wire-protocol behavior, which is language-independent, and the review labs test your understanding of your own code in whatever language you wrote it. (Course reference materials and skeletons are provided in one language per assignment; using them is optional.) Two rules connect assignments to the review labs:
- Requirement: you must pass the autograder to sign up for the corresponding review lab. No review, no review-lab credit.
- Multiplier: your assignment credit is scaled by your performance in the corresponding review session. Working code you can’t explain is worth very little; working code you understand deeply is worth full credit.
Reading engagement (TBA)
This semester the course readings will increasingly come from instructor-written lecture notes hosted on this site. An optional structured reading platform with embedded practice questions is under development; details and the associated 5% credit mechanism will be announced in September. Honestly, I’m not sure if this is worth it, which is why it’s not final.
AI policy
- Take-home work (programming assignments, written homework): AI assistants and coding agents are allowed and encouraged. Each submission must include a brief AI usage note: what tools you used, what you delegated, what you verified yourself, and one thing you learned from (or caught wrong in) the AI’s output. This note is not graded for how much you used AI (using none is fine, using a lot is fine) but omitting the note or misrepresenting your process is an academic integrity violation.
- In-person work (exams, code-review labs): no tools, no devices, no AI.
- You are responsible for every line you submit. “The agent wrote that part” is not an answer that will serve you well in a review session.
- The course provides (optionally) a context bundle you can load into your own AI assistant, configured to tutor rather than solve. Details in September.
Policies
- Late work: You have 120 late hours (5 days) across the semester for take-home work, tracked via Gradescope, no questions asked. After they are exhausted, late work receives zero credit. Late hours do not apply to exams or review-lab sign-ups. For genuinely exceptional circumstances, contact the instructor.
- Collaboration: Except where explicitly noted, all submitted work must be completed individually. You may discuss ideas with classmates; you may not share code or solutions. (Your AI assistant is not a “collaborator” for the purposes of this rule [see AI policy] but another student’s AI transcript is.)
- Academic integrity: All students must comply with the CS Department and university academic integrity policies. Misrepresenting AI usage, submitting another person’s work, or bringing unauthorized materials to in-person assessments are violations.
- Accommodations: Students with documented disabilities should contact Student Disability Services and the instructor early in the semester; review-lab formats can be adapted.
Textbooks and readings
There is no required textbook to purchase. Readings will be drawn from:
- Draft chapters of my book: the primary reading for the symmetric-cryptography portion of the course (symmetric encryption & authentication, hash functions, random number generation, with portions of the public-key chapter as available). Distributed to enrolled students; please do not redistribute drafts;
- Instructor-written course notes (hosted on this site, expanding through the semester);
- Boneh & Shoup, A Graduate Course in Applied Cryptography (free online) — supplementary reference for selected topics;
- Ross Anderson, Security Engineering (free online) — supplementary;
- Selected papers and incident postmortems, linked from the Schedule.
This syllabus is a draft and subject to revision before the first day of class. The authoritative version is whatever this page says on August 31, 2026.
Authorship & AI usage note (in the same format this course requires of you): This syllabus was written by Matthew Green with Claude (Anthropic’s Fable 5 model, via Claude Code). Delegated to the AI: a literature review of post-LLM assessment research, drafting of this document and the course website, and the semester date arithmetic. Done by the human: the course design and every grading decision, plus review and editing of every section you just read. One thing we learned from the process: the research consistently shows that students won’t use a course-provided chatbot when better general-purpose ones exist — which is partly why this course’s AI integration looks the way it does.