prefixed

.drone.yml

@@ -3,12 +3,11 @@ name: default
 
 steps:
  - name: build
-   image: rust:1.37.0-buster
+   image: rust:1.41.0-buster
    commands:
     - apt update && apt install git clang make pkg-config nettle-dev libssl-dev capnproto libsqlite3-dev -y
     - cargo test
-    - rustup target add x86_64-unknown-linux-musl
+    - cargo install --path . --root .
-    - cargo build --release --target x86_64-unknown-linux-musl
  - name: dockerize
    image: plugins/docker
    settings:

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "brownpaper"
-version = "0.1.0"
+version = "0.4.0"
-authors = ["shim_ <shimun@shimun.net>"]
+authors = ["shimun <shimun@shimun.net>"]
 edition = "2018"
 
 [dependencies]
@@ -16,7 +16,7 @@ rand = "0.4.2"
 
 byteorder = "1.3.2"
 chrono = "0.4.9"
-sequoia-openpgp = "0.9.0"
+sequoia-openpgp = "0.12.0"
 lazy_static = "1.4.0"
 c2-chacha = "0.2.2"
 sha2 = "0.8.0"

Dockerfile

@@ -1,9 +1,21 @@
+FROM rust:1.41.0 as builder
+
+COPY . /bp
+
+RUN apt update
+
+RUN apt install clang nettle-dev -y 
+
+RUN cargo install --path /bp --root /usr
+
 FROM debian:buster-slim
 
 VOLUME /snips
 
 EXPOSE 3000
 
-COPY target/release/brownpaper /bin/
+COPY --from=builder /usr/bin/brownpaper /bin/
+
+WORKDIR /
 
 ENTRYPOINT [ "/bin/brownpaper" ]

bp.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+BP_ENDPOINT=${BROWNPAPER_ENDPOINT:-https://shimun.net/bp}
+CURL_ARGS="--write-out %{url_effective}\\n --silent -o /dev/null"
+GPG_ARGS="$([ ! -z "$BROWNPAPER_KEY" ] && echo "--local-user $BROWNPAPER_KEY")"
+if [ ! -z "$1" ]; then
+	printf "$1" | gpg --sign -a $GPG_ARGS | curl -s --data @-  -X POST $BP_ENDPOINT/new -Ls $CURL_ARGS
+else
+	gpg --sign -a $GPG_ARGS | curl -s --data @-  -X POST $BP_ENDPOINT/new -Ls $CURL_ARGS
+fi

default.nix

@@ -0,0 +1,25 @@
+{ pkgs ? import <nixpkgs> { }
+, callPackage ? pkgs.callPackage
+, stdenv ? pkgs.stdenv
+, fetchgit ? pkgs.fetchgit
+, name ? "brownpaper"
+, src ? (builtins.filterSource (path: type: baseNameOf path != "target") ./.)
+}:
+let
+  crate2nix_tools = import "${fetchgit { url = "https://github.com/kolloch/crate2nix.git"; rev = "adecff03c53b87255b3299f5a5787327342a69b2"; sha256 = "0l10yqa3gq73fc4xc977vb9zk5jlp70xiz5qd9c1vq873yqk1c7g"; }}/tools.nix" { inherit pkgs; };
+  overrides = pkgs.defaultCrateOverrides // rec {
+    nettle-sys = attrs: with pkgs; {
+      propagatedBuildInputs = [ clang nettle pkg-config ];
+      LIBCLANG_PATH = "${clang.cc.lib}/lib";
+    };
+    sequoia-openpgp = attrs: with pkgs; {
+      nativeBuildInputs = [ clang gmp pkg-config ];
+      LIBCLANG_PATH = "${clang.cc.lib}/lib";
+    };
+    brownpaper = sequoia-openpgp; # requires gmp as well
+  };
+  client = pkgs.writeShellScriptBin "brownpaper" ''
+    PATH=${pkgs.bash}/bin/:${pkgs.gnupg}/bin/:${pkgs.curl}/bin/:$PATH ${./bp.sh} "$@"
+  '';
+in
+{ server = callPackage (crate2nix_tools.generatedCargoNix { inherit name src; }) { inherit pkgs; };  inherit client; }

src/main.rs

@@ -8,184 +8,41 @@ extern crate snap;
 
 mod chacha_io;
 mod pgp;
+mod snippet;
 
 use crate::pgp::KnownKeys;
-use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
+use crate::snippet::*;
-use chacha_io::{ChaChaReader, ChaChaWriter};
+
-use chrono::*;
-use core::cell::RefCell;
 use iron::method::Method;
 use iron::modifiers::Redirect;
 use iron::prelude::*;
 use iron::url::Url;
-use rand::Rng;
+
-use sha2::{Digest, Sha256};
+use iron::mime::Mime;
-use std::borrow::BorrowMut;
+use sha2::Digest;
-use std::convert::TryInto;
+
-use std::fs;
+use std::env::{self, args};
-use std::fs::File;
 use std::io;
 use std::io::prelude::*;
 use std::iter::Iterator;
-use std::path::{Path, PathBuf};
+use std::net::SocketAddr;
+use std::path::Path;
+use std::sync::Arc;
 use std::sync::Mutex;
 
-struct Snippet<'a> {
+const STORAGE_DIR: &str = "./snips";
-    id: String,
-    storage: &'a SnippetStorage<'a>,
-}
-
-#[allow(dead_code)]
-struct SnippetMeta {
-    created: DateTime<Utc>,
-    compression: Option<String>,
-}
-
-struct SnippetStorage<'a> {
-    directory: &'a Path,
-}
-
-impl<'a> Snippet<'a> {
-    pub fn random(storage: &'a SnippetStorage) -> Snippet<'a> {
-        Snippet::new(
-            &rand::thread_rng()
-                .gen_ascii_chars()
-                .take(8)
-                .collect::<String>(),
-            storage,
-        )
-    }
-
-    pub fn new(id: &str, storage: &'a SnippetStorage) -> Snippet<'a> {
-        Snippet {
-            id: id.to_string(),
-            storage,
-        }
-    }
-
-    pub fn file_id(&self) -> String {
-        SnippetStorage::file_id(&self.id)
-    }
-
-    pub fn passphrase(&self) -> ([u8; 8], [u8; 32]) {
-        let mut hasher = Sha256::new();
-        hasher.input(self.id.as_bytes());
-        let res = hasher.result();
-        let nonce: [u8; 8] = res[0..8].try_into().unwrap();
-        let mut hasher = Sha256::new();
-        hasher.input(self.id.as_bytes());
-        hasher.input(b"pass");
-        let pass: [u8; 32] = res[0..32].try_into().unwrap();
-        (nonce, pass)
-    }
-
-    pub fn path(&self) -> PathBuf {
-        self.storage.directory.join(&self.file_id())
-    }
-
-    pub fn metadata(&self) -> Result<SnippetMeta, io::Error> {
-        let mut file = File::open(self.path())?;
-        let (nonce, key) = self.passphrase();
-        self.metadata_via_handle(&mut ChaChaReader::new(&key, &nonce, &mut file))
-    }
-
-    fn metadata_via_handle(&self, hdl: &mut impl Read) -> Result<SnippetMeta, io::Error> {
-        let timestamp = hdl.read_i64::<BigEndian>()?;
-        let comp_len = hdl.read_u16::<BigEndian>()? as usize;
-        let mut comp = Vec::with_capacity(comp_len);
-        comp.resize(comp_len, 0u8);
-        hdl.read_exact(&mut comp)?;
-        let comp = String::from_utf8(comp).unwrap();
-        Ok(SnippetMeta {
-            created: Utc.timestamp_millis(timestamp),
-            compression: Some(comp).filter(|_| comp_len > 0),
-        })
-    }
-
-    fn contents(&self) -> Result<String, io::Error> {
-        let mut file = File::open(self.path())?;
-        let (nonce, key) = self.passphrase();
-        let mut reader = ChaChaReader::new(&key, &nonce, &mut file);
-        let meta = self.metadata_via_handle(&mut reader)?;
-        fn read_string(r: &mut impl Read) -> Result<String, io::Error> {
-            let mut text = String::new();
-            r.read_to_string(&mut text)?;
-            Ok(text)
-        }
-        dbg!((&meta.compression, &meta.created, self.file_id()));
-        match meta.compression {
-            Some(ref comp) if comp == "snap" => {
-                let mut r = snap::Reader::new(&mut reader);
-                read_string(&mut r)
-            }
-            _ => read_string(&mut reader),
-        }
-    }
-
-    fn write(self, content: &str) -> Result<Snippet<'a>, io::Error> {
-        let mut file = File::create(self.path())?;
-        let (nonce, key) = self.passphrase();
-        let mut writer = ChaChaWriter::new(&key, &nonce, &mut file);
-        writer.write_i64::<BigEndian>(Utc::now().timestamp())?;
-        let comp = if content.len() > 2048 {
-            Some("snap")
-        } else {
-            None
-        };
-        writer.write_u16::<BigEndian>(comp.map(|s| s.len() as u16).unwrap_or(0u16))?;
-        writer.write(comp.map(|s| s.as_bytes()).unwrap_or(&[0u8; 0]))?;
-        match comp {
-            Some(ref comp) if comp == &"snap" => {
-                let mut w = snap::Writer::new(&mut writer);
-                w.write_all(content.as_bytes())?
-            }
-            _ => writer.write_all(content.as_bytes())?,
-        };
-        Ok(Snippet::new(&self.id, self.storage))
-    }
-}
-
-impl<'a> SnippetStorage<'a> {
-    pub fn new(directory: &'a Path) -> SnippetStorage<'a> {
-        SnippetStorage {
-            directory: directory,
-        }
-    }
-    pub fn file_id(id: &str) -> String {
-        let mut hasher = Sha256::new();
-        hasher.input(id.as_bytes());
-        hex::encode(&hasher.result()[0..12])
-    }
-    fn has(&self, id: &str) -> bool {
-        self.directory.join(Self::file_id(id)).exists()
-    }
-
-    fn open(&self, id: &str) -> Option<Snippet> {
-        if self.has(id) {
-            Some(Snippet::new(id, self))
-        } else {
-            None
-        }
-    }
-}
-
-#[cfg(not(debug_assertions))]
-const STORAGE_DIR: &str = "/snips";
-
-#[cfg(debug_assertions)]
-const STORAGE_DIR: &str = "/tmp";
 
 lazy_static! {
-    static ref KNOWN_KEYS: Mutex<KnownKeys> = Mutex::new(
+    static ref KNOWN_KEYS: Arc<Mutex<KnownKeys>> = Arc::new(Mutex::new(
         KnownKeys::load_dir([STORAGE_DIR, "keys"].join("/")).expect("Failed to load pubkeys")
-    );
+    ));
 }
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 
 fn handle(req: &mut Request) -> IronResult<Response> {
     println!("{}", req.url);
-    let storage = SnippetStorage::new(&Path::new(STORAGE_DIR));
+    let storage = SnippetStorage::new(&Path::new(&STORAGE_DIR));
     let segments: Vec<&str> = req.url.path();
     match (&req.method, segments.first()) {
         (Method::Get, Some(&"version")) => Ok(Response::with((iron::status::Ok, VERSION))),
@@ -235,7 +92,17 @@ fn handle(req: &mut Request) -> IronResult<Response> {
                 )))
             }
         }
-        (Method::Get, Some(id)) => {
+        (Method::Get, Some(path)) => {
+            let (id, mime) = {
+                let mut parts = path.split(".");
+                (
+                    parts.next().unwrap().to_string(),
+                    Some(parts.collect::<Vec<_>>().join("/"))
+                        .filter(|s| s.len() > 0)
+                        .and_then(|format| format.parse::<Mime>().ok()),
+                )
+            };
+            let mime = mime.unwrap_or("text/plain".parse().unwrap());
             let att = storage.open(&id).map(|snip| snip.contents()).map(|res| {
                 Response::with(
                     match res.map(|text| (iron::status::Ok, text)).map_err(|err| {
@@ -246,6 +113,7 @@ fn handle(req: &mut Request) -> IronResult<Response> {
                         Err(e) => (iron::status::InternalServerError, e),
                     },
                 )
+                .set(mime)
             });
             Ok(att.unwrap_or(Response::with((iron::status::NotFound, "Not here sry"))))
         }
@@ -257,5 +125,16 @@ fn handle(req: &mut Request) -> IronResult<Response> {
 fn main() {
     let chain = Chain::new(handle);
     println!("Starting brownpaper: {}", STORAGE_DIR);
-    Iron::new(chain).http("0.0.0.0:3000").unwrap();
+    Iron::new(chain).http(
+        args()
+            .skip(1)
+            .next()
+            .map(|ip| {
+                ip.parse::<SocketAddr>()
+                    .expect("can't parse socket address")
+            })
+            .unwrap_or("0.0.0.0:3000".parse::<SocketAddr>().unwrap())
+            .to_string()
+            .as_str(),
+    );
 }

src/pgp.rs

@@ -37,9 +37,32 @@ impl KnownKeys {
     pub fn verify(&mut self, r: impl Read) -> io::Result<Vec<u8>> {
         let mut content = Vec::with_capacity(2048);
         let helper = &*self;
-        let mut v = Verifier::<&KnownKeys>::from_reader(r, helper, None)
+        let mut v = Verifier::<&KnownKeys>::from_reader(r, helper, None).map_err(|e| {
-            .map_err(|e| dbg!(e))
+            io::Error::new(io::ErrorKind::InvalidData, "Failed to verify signature")
-            .unwrap();
+        })?;
+        let mut buf = [0u8; 512];
+        let bp = "brownpaper".as_bytes();
+        loop {
+            match v.read(&mut buf)? {
+                0 => break,
+                read => {
+                    // first buffer read
+                    if content.len() == 0 {
+                        if !(buf.len() > bp.len() && bp == &buf[0..bp.len()]) {
+                            return Err(io::Error::new(
+                                io::ErrorKind::InvalidData,
+                                "Failed to verify signature(prefix)",
+                            ));
+                        } else {
+                            // remove prefix
+                            content.extend_from_slice(&buf[bp.len()..read])
+                        }
+                    } else {
+                        content.extend_from_slice(&buf[0..read]);
+                    }
+                }
+            }
+        }
         if v.read_to_end(&mut content).is_err() {
             return Err(io::Error::new(
                 io::ErrorKind::InvalidData,

src/snippet.rs

@@ -0,0 +1,153 @@
+use crate::chacha_io::{ChaChaReader, ChaChaWriter};
+use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
+use chrono::*;
+
+use rand::Rng;
+use sha2::{Digest, Sha256};
+
+use std::convert::TryInto;
+
+use std::fs::File;
+use std::io;
+use std::io::prelude::*;
+use std::iter::Iterator;
+use std::path::{Path, PathBuf};
+
+pub struct Snippet<'a> {
+    pub id: String,
+    pub storage: &'a SnippetStorage<'a>,
+}
+
+#[allow(dead_code)]
+pub struct SnippetMeta {
+    created: DateTime<Utc>,
+    compression: Option<String>,
+}
+
+pub struct SnippetStorage<'a> {
+    directory: &'a Path,
+}
+
+impl<'a> Snippet<'a> {
+    pub fn random(storage: &'a SnippetStorage) -> Snippet<'a> {
+        Snippet::new(
+            &rand::thread_rng()
+                .gen_ascii_chars()
+                .take(8)
+                .collect::<String>(),
+            storage,
+        )
+    }
+
+    pub fn new(id: &str, storage: &'a SnippetStorage) -> Snippet<'a> {
+        Snippet {
+            id: id.to_string(),
+            storage,
+        }
+    }
+
+    pub fn file_id(&self) -> String {
+        SnippetStorage::file_id(&self.id)
+    }
+
+    pub fn passphrase(&self) -> ([u8; 8], [u8; 32]) {
+        let mut hasher = Sha256::new();
+        hasher.input(self.id.as_bytes());
+        let res = hasher.result();
+        let nonce: [u8; 8] = res[0..8].try_into().unwrap();
+        let mut hasher = Sha256::new();
+        hasher.input(self.id.as_bytes());
+        hasher.input(b"pass");
+        let pass: [u8; 32] = res[0..32].try_into().unwrap();
+        (nonce, pass)
+    }
+
+    pub fn path(&self) -> PathBuf {
+        self.storage.directory.join(&self.file_id())
+    }
+
+    pub fn metadata(&self) -> Result<SnippetMeta, io::Error> {
+        let mut file = File::open(self.path())?;
+        let (nonce, key) = self.passphrase();
+        self.metadata_via_handle(&mut ChaChaReader::new(&key, &nonce, &mut file))
+    }
+
+    fn metadata_via_handle(&self, hdl: &mut impl Read) -> Result<SnippetMeta, io::Error> {
+        let timestamp = hdl.read_i64::<BigEndian>()?;
+        let comp_len = hdl.read_u16::<BigEndian>()? as usize;
+        let mut comp = Vec::with_capacity(comp_len);
+        comp.resize(comp_len, 0u8);
+        hdl.read_exact(&mut comp)?;
+        let comp = String::from_utf8(comp).unwrap();
+        Ok(SnippetMeta {
+            created: Utc.timestamp(timestamp, 0),
+            compression: Some(comp).filter(|_| comp_len > 0),
+        })
+    }
+
+    pub fn contents(&self) -> Result<String, io::Error> {
+        let mut file = File::open(self.path())?;
+        let (nonce, key) = self.passphrase();
+        let mut reader = ChaChaReader::new(&key, &nonce, &mut file);
+        let meta = self.metadata_via_handle(&mut reader)?;
+        fn read_string(r: &mut impl Read) -> Result<String, io::Error> {
+            let mut text = String::new();
+            r.read_to_string(&mut text)?;
+            Ok(text)
+        }
+        dbg!((&meta.compression, &meta.created, self.file_id()));
+        match meta.compression {
+            Some(ref comp) if comp == "snap" => {
+                let mut r = snap::Reader::new(&mut reader);
+                read_string(&mut r)
+            }
+            _ => read_string(&mut reader),
+        }
+    }
+
+    pub fn write(self, content: &str) -> Result<Snippet<'a>, io::Error> {
+        let mut file = File::create(self.path())?;
+        let (nonce, key) = self.passphrase();
+        let mut writer = ChaChaWriter::new(&key, &nonce, &mut file);
+        writer.write_i64::<BigEndian>(Utc::now().timestamp())?;
+        let comp = if content.len() > 2048 {
+            Some("snap")
+        } else {
+            None
+        };
+        writer.write_u16::<BigEndian>(comp.map(|s| s.len() as u16).unwrap_or(0u16))?;
+        writer.write(comp.map(|s| s.as_bytes()).unwrap_or(&[0u8; 0]))?;
+        match comp {
+            Some(ref comp) if comp == &"snap" => {
+                let mut w = snap::Writer::new(&mut writer);
+                w.write_all(content.as_bytes())?
+            }
+            _ => writer.write_all(content.as_bytes())?,
+        };
+        Ok(Snippet::new(&self.id, self.storage))
+    }
+}
+
+impl<'a> SnippetStorage<'a> {
+    pub fn new(directory: &'a Path) -> SnippetStorage<'a> {
+        SnippetStorage {
+            directory: directory,
+        }
+    }
+    pub fn file_id(id: &str) -> String {
+        let mut hasher = Sha256::new();
+        hasher.input(id.as_bytes());
+        hex::encode(&hasher.result()[0..12])
+    }
+    fn has(&self, id: &str) -> bool {
+        self.directory.join(Self::file_id(id)).exists()
+    }
+
+    pub fn open(&self, id: &str) -> Option<Snippet> {
+        if self.has(id) {
+            Some(Snippet::new(id, self))
+        } else {
+            None
+        }
+    }
+}