git.scottworley.com Git - voter/blame_incremental - src/main.rs

use rand::prelude::*;
use std::io::prelude::*;
use std::path::{Path, PathBuf};

const DATA_PATH: &str = "/var/lib/voter";
const COOKIE_NAME: &[u8] = b"__Secure-id";
const COOKIE_LENGTH: usize = 12;

fn validate_path(path: &str) -> Result<PathBuf, cgi::Response> {
    let invalid_path = || cgi::text_response(404, "Invalid path");
    if path == "/" {
        return Err(cgi::text_response(404, "(This is the voting place.  You should have been given a more specific URL for the specific thing you've been invited to vote on.)"));
    }
    if path.contains("..") || !path.starts_with("/") {
        return Err(invalid_path());
    }
    let dir = Path::new(&format!("{DATA_PATH}{path}")).to_path_buf();
    if !dir
        .canonicalize()
        .map_err(|_| invalid_path())?
        .starts_with(DATA_PATH)
    {
        return Err(invalid_path());
    }
    if !dir.is_dir() {
        return Err(invalid_path());
    }
    Ok(dir)
}

fn get_voter(request: &cgi::Request) -> Result<&[u8], cgi::Response> {
    // Expect exactly one cookie, exactly as we generate it.
    let cookie = request
        .headers()
        .get(cgi::http::header::COOKIE)
        .map(|c| c.as_bytes())
        .and_then(|c| c.strip_prefix(COOKIE_NAME))
        .and_then(|c| c.strip_prefix(b"="))
        .ok_or_else(|| cgi::text_response(400, "Invalid cookie"))?;
    if cookie.len() != COOKIE_LENGTH || cookie.contains(&b' ') || cookie.contains(&b';') {
        Err(cgi::text_response(400, "Invalid cookie"))
    } else {
        Ok(cookie)
    }
}

fn make_random_id() -> [u8; COOKIE_LENGTH] {
    let mut id = [0; COOKIE_LENGTH];
    for i in 0..COOKIE_LENGTH {
        while !(b'A'..=b'Z').contains(&id[i])
            && !(b'a'..=b'z').contains(&id[i])
            && !(b'0'..=b'9').contains(&id[i])
        {
            id[i] = random()
        }
    }
    id
}

fn set_cookie(mut response: cgi::Response, path: &str) -> Result<cgi::Response, cgi::Response> {
    response.headers_mut().append(
        cgi::http::header::SET_COOKIE,
        cgi::http::header::HeaderValue::from_bytes(
            &[
                COOKIE_NAME,
                b"=",
                &make_random_id(),
                b"; Secure HttpOnly SameSite=Strict Max-Age=30000000 Path=",
                path.as_bytes(),
            ]
            .concat(),
        )
        .map_err(|_| cgi::text_response(503, "Couldn't make cookie"))?,
    );
    Ok(response)
}

const HTML_HEADER: &str = "<!DOCTYPE html>
<html>
  <head>
    <meta charset=\"utf-8\">
    <title>Vote!</title>
    <style>
      input { transform: scale(1.5) }
      div { animation: 2s infinite linear spin }
      @keyframes spin {
        from { transform:rotate(0) }
        to { transform:rotate(1turn) }
      }
    </style>
    <script>
      window.onload = function() {
        for (cb of document.getElementsByTagName('input')) {
          cb.addEventListener('click', (function(cb) {
            return function() {
              cb.style.display = 'none'
              const spin = document.createElement('div')
              spin.appendChild(document.createTextNode('⏳'))
              cb.parentElement.insertBefore(spin, cb)
            }
          })(cb))
          cb.disabled = false
        }
      }
    </script>
  </head>
  <body>
    <table>";
const HTML_FOOTER: &str = "
    </table>
  </body>
</html>";

fn prompt_for_vote(dir: PathBuf, request: cgi::Request) -> Result<cgi::Response, cgi::Response> {
    let voter = get_voter(&request);
    let cfile = std::fs::File::open(dir.join("candidates"))
        .map_err(|_| cgi::text_response(503, "No candidates"))?;
    let mut response = cgi::html_response(
        200,
        std::iter::once(Ok(HTML_HEADER.to_owned()))
            .chain(std::io::BufReader::new(cfile).lines().map(|rc| {
                rc.map(|c| {
                    format!("<tr><td><input type=\"checkbox\" disabled></td><td>{c}</td></tr>")
                })
            }))
            .chain(std::iter::once(Ok(HTML_FOOTER.to_owned())))
            .collect::<std::io::Result<String>>()
            .map_err(|_| cgi::text_response(503, "Missing candidates"))?,
    );
    if voter.is_err() {
        response = set_cookie(response, request.uri().path())?
    }
    Ok(response)
}

fn write_vote(dir: PathBuf, voter: &[u8], vote: &[u8]) -> std::io::Result<()> {
    let datum = [voter, b" ", vote, b"\n"].concat();
    let vpath = dir.join("votes");
    let vfile = std::fs::File::options()
        .append(true)
        .create(true)
        .open(vpath)?;
    let mut vlock = fd_lock::RwLock::new(vfile);
    vlock.write()?.write(&datum)?;
    Ok(())
}

fn record_vote(dir: PathBuf, request: cgi::Request) -> Result<cgi::Response, cgi::Response> {
    let body = request.body();
    // Valid votes look like "0 foo" or "1 bar"
    if body.len() < 3
        || (body[0] != b'0' && body[0] != b'1')
        || body[1] != b' '
        || body.contains(&b'\n')
    {
        return Err(cgi::text_response(415, "Invalid vote"));
    }
    write_vote(dir, &get_voter(&request)?, body)
        .map_err(|_| cgi::text_response(503, "Couldn't record vote"))?;
    Ok(cgi::text_response(200, "Vote recorded"))
}

fn strip_body(mut response: cgi::Response) -> cgi::Response {
    response.body_mut().clear();
    response
}

fn respond(request: cgi::Request) -> Result<cgi::Response, cgi::Response> {
    let dir = validate_path(request.uri().path())?;
    match request.method() {
        &cgi::http::Method::HEAD => prompt_for_vote(dir, request).map(strip_body),
        &cgi::http::Method::GET => prompt_for_vote(dir, request),
        &cgi::http::Method::PUT => record_vote(dir, request),
        _ => Err(cgi::text_response(405, "Huh?")),
    }
}

fn respond_or_report_error(request: cgi::Request) -> cgi::Response {
    match respond(request) {
        Ok(result) => result,
        Err(error) => error,
    }
}

cgi::cgi_main! { respond_or_report_error }
Commit	Line	Data
	1	use rand::prelude::*;
	2	use std::io::prelude::*;
	3	use std::path::{Path, PathBuf};
	4
	5	const DATA_PATH: &str = "/var/lib/voter";
	6	const COOKIE_NAME: &[u8] = b"__Secure-id";
	7	const COOKIE_LENGTH: usize = 12;
	8
	9	fn validate_path(path: &str) -> Result<PathBuf, cgi::Response> {
	10	let invalid_path = \|\| cgi::text_response(404, "Invalid path");
	11	if path == "/" {
	12	return Err(cgi::text_response(404, "(This is the voting place. You should have been given a more specific URL for the specific thing you've been invited to vote on.)"));
	13	}
	14	if path.contains("..") \|\| !path.starts_with("/") {
	15	return Err(invalid_path());
	16	}
	17	let dir = Path::new(&format!("{DATA_PATH}{path}")).to_path_buf();
	18	if !dir
	19	.canonicalize()
	20	.map_err(\|_\| invalid_path())?
	21	.starts_with(DATA_PATH)
	22	{
	23	return Err(invalid_path());
	24	}
	25	if !dir.is_dir() {
	26	return Err(invalid_path());
	27	}
	28	Ok(dir)
	29	}
	30
	31	fn get_voter(request: &cgi::Request) -> Result<&[u8], cgi::Response> {
	32	// Expect exactly one cookie, exactly as we generate it.
	33	let cookie = request
	34	.headers()
	35	.get(cgi::http::header::COOKIE)
	36	.map(\|c\| c.as_bytes())
	37	.and_then(\|c\| c.strip_prefix(COOKIE_NAME))
	38	.and_then(\|c\| c.strip_prefix(b"="))
	39	.ok_or_else(\|\| cgi::text_response(400, "Invalid cookie"))?;
	40	if cookie.len() != COOKIE_LENGTH \|\| cookie.contains(&b' ') \|\| cookie.contains(&b';') {
	41	Err(cgi::text_response(400, "Invalid cookie"))
	42	} else {
	43	Ok(cookie)
	44	}
	45	}
	46
	47	fn make_random_id() -> [u8; COOKIE_LENGTH] {
	48	let mut id = [0; COOKIE_LENGTH];
	49	for i in 0..COOKIE_LENGTH {
	50	while !(b'A'..=b'Z').contains(&id[i])
	51	&& !(b'a'..=b'z').contains(&id[i])
	52	&& !(b'0'..=b'9').contains(&id[i])
	53	{
	54	id[i] = random()
	55	}
	56	}
	57	id
	58	}
	59
	60	fn set_cookie(mut response: cgi::Response, path: &str) -> Result<cgi::Response, cgi::Response> {
	61	response.headers_mut().append(
	62	cgi::http::header::SET_COOKIE,
	63	cgi::http::header::HeaderValue::from_bytes(
	64	&[
	65	COOKIE_NAME,
	66	b"=",
	67	&make_random_id(),
	68	b"; Secure HttpOnly SameSite=Strict Max-Age=30000000 Path=",
	69	path.as_bytes(),
	70	]
	71	.concat(),
	72	)
	73	.map_err(\|_\| cgi::text_response(503, "Couldn't make cookie"))?,
	74	);
	75	Ok(response)
	76	}
	77
	78	const HTML_HEADER: &str = "<!DOCTYPE html>
	79	<html>
	80	<head>
	81	<meta charset=\"utf-8\">
	82	<title>Vote!</title>
	83	<style>
	84	input { transform: scale(1.5) }
	85	div { animation: 2s infinite linear spin }
	86	@keyframes spin {
	87	from { transform:rotate(0) }
	88	to { transform:rotate(1turn) }
	89	}
	90	</style>
	91	<script>
	92	window.onload = function() {
	93	for (cb of document.getElementsByTagName('input')) {
	94	cb.addEventListener('click', (function(cb) {
	95	return function() {
	96	cb.style.display = 'none'
	97	const spin = document.createElement('div')
	98	spin.appendChild(document.createTextNode('⏳'))
	99	cb.parentElement.insertBefore(spin, cb)
	100	}
	101	})(cb))
	102	cb.disabled = false
	103	}
	104	}
	105	</script>
	106	</head>
	107	<body>
	108	<table>";
	109	const HTML_FOOTER: &str = "
	110	</table>
	111	</body>
	112	</html>";
	113
	114	fn prompt_for_vote(dir: PathBuf, request: cgi::Request) -> Result<cgi::Response, cgi::Response> {
	115	let voter = get_voter(&request);
	116	let cfile = std::fs::File::open(dir.join("candidates"))
	117	.map_err(\|_\| cgi::text_response(503, "No candidates"))?;
	118	let mut response = cgi::html_response(
	119	200,
	120	std::iter::once(Ok(HTML_HEADER.to_owned()))
	121	.chain(std::io::BufReader::new(cfile).lines().map(\|rc\| {
	122	rc.map(\|c\| {
	123	format!("<tr><td><input type=\"checkbox\" disabled></td><td>{c}</td></tr>")
	124	})
	125	}))
	126	.chain(std::iter::once(Ok(HTML_FOOTER.to_owned())))
	127	.collect::<std::io::Result<String>>()
	128	.map_err(\|_\| cgi::text_response(503, "Missing candidates"))?,
	129	);
	130	if voter.is_err() {
	131	response = set_cookie(response, request.uri().path())?
	132	}
	133	Ok(response)
	134	}
	135
	136	fn write_vote(dir: PathBuf, voter: &[u8], vote: &[u8]) -> std::io::Result<()> {
	137	let datum = [voter, b" ", vote, b"\n"].concat();
	138	let vpath = dir.join("votes");
	139	let vfile = std::fs::File::options()
	140	.append(true)
	141	.create(true)
	142	.open(vpath)?;
	143	let mut vlock = fd_lock::RwLock::new(vfile);
	144	vlock.write()?.write(&datum)?;
	145	Ok(())
	146	}
	147
	148	fn record_vote(dir: PathBuf, request: cgi::Request) -> Result<cgi::Response, cgi::Response> {
	149	let body = request.body();
	150	// Valid votes look like "0 foo" or "1 bar"
	151	if body.len() < 3
	152	\|\| (body[0] != b'0' && body[0] != b'1')
	153	\|\| body[1] != b' '
	154	\|\| body.contains(&b'\n')
	155	{
	156	return Err(cgi::text_response(415, "Invalid vote"));
	157	}
	158	write_vote(dir, &get_voter(&request)?, body)
	159	.map_err(\|_\| cgi::text_response(503, "Couldn't record vote"))?;
	160	Ok(cgi::text_response(200, "Vote recorded"))
	161	}
	162
	163	fn strip_body(mut response: cgi::Response) -> cgi::Response {
	164	response.body_mut().clear();
	165	response
	166	}
	167
	168	fn respond(request: cgi::Request) -> Result<cgi::Response, cgi::Response> {
	169	let dir = validate_path(request.uri().path())?;
	170	match request.method() {
	171	&cgi::http::Method::HEAD => prompt_for_vote(dir, request).map(strip_body),
	172	&cgi::http::Method::GET => prompt_for_vote(dir, request),
	173	&cgi::http::Method::PUT => record_vote(dir, request),
	174	_ => Err(cgi::text_response(405, "Huh?")),
	175	}
	176	}
	177
	178	fn respond_or_report_error(request: cgi::Request) -> cgi::Response {
	179	match respond(request) {
	180	Ok(result) => result,
	181	Err(error) => error,
	182	}
	183	}
	184
	185	cgi::cgi_main! { respond_or_report_error }