.dockerignore

@@ -1,5 +1,4 @@
 .*
-target/rls
 target/*/deps
 target/*/build
 target/*/.fingerprint

.drone.yml

@@ -3,11 +3,11 @@ name: default
 
 steps:
  - name: build
-   image: rust:1.41.0-buster
+   image: rust:1.37.0
    commands:
-    - apt update && apt install git clang make pkg-config nettle-dev libssl-dev capnproto libsqlite3-dev -y
     - cargo test
-    - cargo install --path . --root .
+    - rustup target add x86_64-unknown-linux-musl
+    - 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.4.0"
+version = "0.1.0"
-authors = ["shimun <shimun@shimun.net>"]
+authors = ["shim_ <shimun@shimun.net>"]
 edition = "2018"
 
 [dependencies]
@@ -16,8 +16,3 @@ rand = "0.4.2"
 
 byteorder = "1.3.2"
 chrono = "0.4.9"
-sequoia-openpgp = "0.12.0"
-lazy_static = "1.4.0"
-c2-chacha = "0.3.3"
-sha2 = "0.8.0"
-hex = "0.3.2"

Dockerfile

@@ -1,21 +1,9 @@
-FROM rust:1.41.0 as builder
+FROM scratch
-
-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 --from=builder /usr/bin/brownpaper /bin/
+COPY target/x86_64-unknown-linux-musl/release/brownpaper /bin/
-
-WORKDIR /
 
 ENTRYPOINT [ "/bin/brownpaper" ]

bp.sh

@@ -1,9 +0,0 @@
-#!/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 "brownpaper$1" | gpg --sign -a $GPG_ARGS | curl -s --data @-  -X POST $BP_ENDPOINT/new -Ls $CURL_ARGS
-else
-	(printf "brownpaper"; cat) | gpg --sign -a $GPG_ARGS | curl -s --data @-  -X POST $BP_ENDPOINT/new -Ls $CURL_ARGS
-fi

default.nix

@@ -1,31 +0,0 @@
-{ pkgs ? (import <nixpkgs> { })
-, callPackage ? pkgs.callPackage
-, stdenv ? pkgs.stdenv
-, fetchgit ? pkgs.fetchgit
-, name ? "brownpaper"
-, src ? ./.
-}:
-let
-  filteredSrc = src; # flake only includeds files tracked by git builtins.filterSource pkgs.lib.cleanSourceFilter src;
-  crate2nix_tools = callPackage (pkgs.crate2nix.src + "/tools.nix") { };
-  overrides = with pkgs.llvmPackages_10;
-    pkgs.defaultCrateOverrides // rec {
-      nettle-sys = attrs: rec {
-        nativeBuildInputs = [ clang pkgs.pkg-config ];
-        buildInputs = [ pkgs.nettle ];
-        LIBCLANG_PATH = "${libclang.lib}/lib";
-      };
-      brownpaper = attrs: {
-        buildInputs = [ pkgs.gmp ];
-      };
-    };
-  client = with pkgs; runCommandLocal "brownpaper"
-    {
-      script = "${filteredSrc}/bp.sh";
-      nativeBuildInputs = [ makeWrapper ];
-    } ''
-    makeWrapper $script $out/bin/brownpaper \
-    --prefix PATH : ${with pkgs; lib.makeBinPath [ bash curl gnupg ]}
-  '';
-in
-{ server = (callPackage (crate2nix_tools.generatedCargoNix { inherit name; src = filteredSrc; }) { inherit pkgs; defaultCrateOverrides = overrides; }).rootCrate.build;  inherit client; }

flake.lock

@@ -1,42 +0,0 @@
-{
-  "nodes": {
-    "flake-utils": {
-      "locked": {
-        "lastModified": 1642700792,
-        "narHash": "sha256-XqHrk7hFb+zBvRg6Ghl+AZDq03ov6OshJLiSWOoX5es=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "846b2ae0fc4cc943637d3d1def4454213e203cba",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1642847654,
-        "narHash": "sha256-0rwMCG/xGoVlV01qMZSQu/1GdhKNpWPWyu2Xr5CNhg4=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "7534942c6a009e8035d24c273b77a0b275db9bf1",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

flake.nix

@@ -1,64 +0,0 @@
-{
-  description = "Brownpaper pastebin";
-
-  inputs.flake-utils.url = "github:numtide/flake-utils";
-
-  inputs.nixpkgs.url = "github:NixOS/nixpkgs";
-
-  inputs.naersk.url = "github:nix-community/naersk";
-
-  outputs = { self, nixpkgs, flake-utils, naersk }:
-    (flake-utils.lib.eachSystem [ "x86_64-linux" ]
-      (system:
-        let
-          pkgs = import nixpkgs { inherit system; };
-          naersk-lib = naersk.lib."${system}";
-          bp = pkgs.callPackage ./default.nix { inherit pkgs; src = ./.; };
-        in
-        rec {
-          apps = builtins.mapAttrs (_n: pkg: flake-utils.lib.mkApp { drv = pkg; }) packages;
-          defaultApp = apps.brownpaper;
-          packages = rec {
-            brownpaper = bp.client;
-            brownpaper-server = bp.server;
-            brownpaper-server-nk = naersk-lib.buildPackage (with pkgs; with llvmPackages_10; {
-              pname = "brownpaper";
-              root = self;
-              nativeBuildInputs = [ clang pkg-config ];
-              buildInputs = [ gmp nettle ];
-              LIBCLANG_PATH = "${libclang.lib}/lib";
-
-            });
-            brownpaper-server-docker = pkgs.dockerTools.buildLayeredImage {
-              name = "brownpaper";
-              config = {
-                Volume = "/snips";
-                Port = "3000";
-                Cmd = [ "${brownpaper-server}/bin/brownpaper" ];
-              };
-            };
-          };
-          defaultPackage = packages.brownpaper;
-          devShell = with pkgs; mkShell {
-            buildInputs = [ cargo rustfmt nettle llvmPackages_10.clang llvmPackages_10.libclang pkgconfig ];
-            LIBCLANG_PATH = "${llvmPackages_10.libclang}/lib";
-          };
-          hydraJobs.build = defaultPackage;
-        }
-      ) // rec {
-      nixosModules.brownpaper = import ./mod.nix;
-      nixosModule = nixosModules.brownpaper;
-    }) // rec {
-      overlay = final: prev:
-        let
-          bp = final.callPackage ./default.nix { pkgs = final; src = self; };
-        in
-        {
-          brownpaper = bp.client;
-          brownpaper-server = bp.server;
-        };
-      overlays = {
-        pinned = final: prev: (overlay (import nixpkgs { inherit (final) system; }) { });
-      };
-    };
-}

mod.nix

@@ -1,102 +0,0 @@
-{ lib, pkgs, config, ... }:
-with lib;
-let
-  cfg = config.services.brownpaper;
-  cfgc = config.programs.brownpaper;
-  package = if pkgs ? brownpaper-server && pkgs ? brownpaper then { server = pkgs.brownpaper-server; client = pkgs.brownpaper; } else (pkgs.callPackage ./. { inherit pkgs; src = ./.; });
-  keyDir = pkgs.runCommand "brownpaper-keys" { } ''
-    mkdir -p $out
-    ${concatStringsSep " && " (builtins.map (key: "cp ${key} $out/") cfg.pgpKeys)}
-  '';
-in
-{
-  options.services.brownpaper = {
-    enable = mkEnableOption "brownpaper service";
-    listen = mkOption {
-      type = types.str;
-      default = "127.0.0.1";
-    };
-    port = mkOption {
-      type = types.int;
-      default = 3000;
-    };
-    dataDir = mkOption {
-      type = types.path;
-      default = "/var/lib/brownpaper";
-    };
-    user = mkOption {
-      type = types.str;
-      default = "brownpaper";
-    };
-    pgpKeys = mkOption {
-      type = with types; listOf path;
-      default = [ ];
-    };
-    gc = {
-      enable = mkEnableOption "delete old snippets";
-      dates = mkOption {
-        type = types.str;
-        default = "00:00";
-        description = ''
-          Specification (in the format described by
-          <citerefentry><refentrytitle>systemd.time</refentrytitle>
-          <manvolnum>7</manvolnum></citerefentry>) of the time at
-          which the garbage collector will run.
-        '';
-      };
-      maxAge = mkOption {
-        type = types.ints.positive;
-        default = 60 * 24 * 30;
-        description = "maximum age in minutes after which snippets will be garbage collected. Defaults to 30 days";
-      };
-    };
-  };
-  options.programs.brownpaper = {
-    enable = mkEnableOption "brownpaper client";
-    endpoint = mkOption {
-      type = types.str;
-      default = "http://${cfg.listen}:${toString cfg.port}";
-    };
-  };
-  config = {
-    users.users = mkIf (cfg.enable && cfg.user == "brownpaper") { ${cfg.user} = { isSystemUser = true; group = "brownpaper"; }; };
-    systemd.services = mkIf cfg.enable {
-      brownpaper-init.script = ''
-        mkdir -p '${cfg.dataDir}'
-        chown ${cfg.user} -R '${cfg.dataDir}'
-      '' + (optionalString (cfg.pgpKeys != [ ]) ''
-        DATADIR='${toString cfg.dataDir}'
-        ([ ! -s "$DATADIR/keys" ] && [ -d "$DATADIR/keys" ]) && mv "$DATADIR/keys" "$DATADIR/keys.bak"
-        [ -s "$DATADIR/keys" ] && rm "$DATADIR/keys"
-        ln -s ${keyDir} "$DATADIR/keys"
-      '');
-      brownpaper = {
-        wantedBy = [ "multi-user.target" ];
-        wants = [ "brownpaper-init.service" ];
-        after = [ "brownpaper-init.service" "network-online.target" ];
-        path = [ pkgs.coreutils ];
-        environment.BROWNPAPER_STORAGE_DIR = "${toString cfg.dataDir}";
-        confinement = {
-          enable = true;
-          packages = with pkgs; [ bash coreutils findutils tzdata keyDir ];
-        };
-        script = ''
-          ${package.server}/bin/brownpaper ${cfg.listen}:${toString cfg.port}
-        '';
-        serviceConfig = {
-          BindPaths = [ cfg.dataDir ] ++ (optional (cfg.pgpKeys != [ ]) keyDir);
-          User = cfg.user;
-        };
-      };
-      brownpaper-gc = mkIf cfg.gc.enable {
-        startAt = cfg.gc.dates;
-        script = "${pkgs.findutils}/bin/find ${cfg.dataDir} -maxdepth 1 -type f -mmin +${toString cfg.gc.maxAge} -delete";
-      };
-    };
-    environment.systemPackages = optionals cfgc.enable [
-      (pkgs.writeShellScriptBin "brownpaper" ''
-        BROWNPAPER_ENDPOINT='${cfgc.endpoint}' ${package.client}/bin/brownpaper "$@"
-      '')
-    ];
-  };
-}

src/chacha_io.rs

@@ -1,45 +0,0 @@
-use c2_chacha::stream_cipher::{NewStreamCipher, SyncStreamCipher, SyncStreamCipherSeek};
-use c2_chacha::{ChaCha12, ChaCha20};
-use std::convert::TryInto;
-use std::io::{Read, Result, Write};
-
-pub struct ChaChaReader<'a>(ChaCha20, &'a mut Read);
-
-impl<'a> ChaChaReader<'a> {
-    pub fn new(key: &[u8], nonce: &[u8], source: &'a mut Read) -> ChaChaReader<'a> {
-        ChaChaReader(ChaCha20::new_var(key, nonce).unwrap(), source)
-    }
-}
-
-impl<'a> Read for ChaChaReader<'a> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
-        let red = self.1.read(buf)?;
-        self.0.apply_keystream(buf);
-        Ok(red)
-    }
-}
-
-pub struct ChaChaWriter<'a>(ChaCha20, &'a mut Write);
-
-impl<'a> ChaChaWriter<'a> {
-    pub fn new(key: &[u8], nonce: &[u8], sink: &'a mut Write) -> ChaChaWriter<'a> {
-        ChaChaWriter(ChaCha20::new_var(key, nonce).unwrap(), sink)
-    }
-}
-
-impl<'a> Write for ChaChaWriter<'a> {
-    fn write(&mut self, buf: &[u8]) -> Result<usize> {
-        let mut cipher_text = [0u8; 256];
-        let mut written = 0usize;
-        for chunk in buf.chunks(cipher_text.len()) {
-            cipher_text[0..chunk.len()].copy_from_slice(&chunk);
-            self.0.apply_keystream(&mut cipher_text[0..chunk.len()]);
-            written += self.1.write(&cipher_text[0..chunk.len()])?;
-        }
-        Ok(written)
-    }
-
-    fn flush(&mut self) -> Result<()> {
-        self.1.flush()
-    }
-}

src/main.rs

@@ -1,55 +1,154 @@
-#[macro_use]
-extern crate lazy_static;
 extern crate chrono;
 extern crate iron;
 extern crate rand;
-extern crate sequoia_openpgp as openpgp;
 extern crate snap;
 
-mod chacha_io;
+use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
-mod pgp;
+use chrono::*;
-mod snippet;
-
-use crate::pgp::KnownKeys;
-use crate::snippet::*;
-
 use iron::method::Method;
 use iron::modifiers::Redirect;
 use iron::prelude::*;
 use iron::url::Url;
-
+use rand::Rng;
-use iron::mime::Mime;
+use std::fs;
-use sha2::Digest;
+use std::fs::File;
-
-use std::env::{self, args};
 use std::io;
 use std::io::prelude::*;
 use std::iter::Iterator;
-use std::net::SocketAddr;
+use std::path::{Path, PathBuf};
-use std::path::Path;
-use std::sync::Arc;
-use std::sync::Mutex;
 
-lazy_static! {
+struct Snippet<'a> {
-    static ref STORAGE_DIR: String =
+    id: String,
-        env::var("BROWNPAPER_STORAGE_DIR").unwrap_or("/snips".to_string());
+    storage: &'a SnippetStorage<'a>,
-    static ref KNOWN_KEYS: Arc<Mutex<KnownKeys>> = Arc::new(Mutex::new(
-        KnownKeys::load_dir([&*STORAGE_DIR, "keys"].join("/")).expect("Failed to load pubkeys")
-    ));
 }
 
+#[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(6)
+                .collect::<String>(),
+            storage,
+        )
+    }
+
+    pub fn new(id: &str, storage: &'a SnippetStorage) -> Snippet<'a> {
+        Snippet {
+            id: id.to_string(),
+            storage,
+        }
+    }
+
+    pub fn path(&self) -> PathBuf {
+        self.storage.directory.join(&self.id)
+    }
+
+    pub fn metadata(&self) -> Result<SnippetMeta, io::Error> {
+        let mut file = File::open(self.path())?;
+        self.metadata_via_handle(&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 meta = self.metadata_via_handle(&mut file)?;
+        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));
+        match meta.compression {
+            Some(ref comp) if comp == "snap" => {
+                let mut r = snap::Reader::new(&mut file);
+                read_string(&mut r)
+            }
+            _ => read_string(&mut file),
+        }
+    }
+
+    fn write(self, content: &str) -> Result<Snippet<'a>, io::Error> {
+        let mut file = File::create(self.path())?;
+        file.write_i64::<BigEndian>(Utc::now().timestamp())?;
+        let comp = if content.len() > 2048 {
+            Some("snap")
+        } else {
+            None
+        };
+        file.write_u16::<BigEndian>(comp.map(|s| s.len() as u16).unwrap_or(0u16))?;
+        file.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 file);
+                w.write_all(content.as_bytes())?
+            }
+            _ => file.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,
+        }
+    }
+
+    fn has(&self, id: &str) -> bool {
+        self.directory.join(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";
+
 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))),
         (Method::Post, Some(path)) => {
             if path == &"new" {
                 let snip = {
-                    let pgp_text: String = {
+                    let text: String = {
                         let bytes = ((&mut req.body).bytes().take(1024 * 512).collect::<Result<
                             Vec<u8>,
                             io::Error,
@@ -59,12 +158,6 @@ fn handle(req: &mut Request) -> IronResult<Response> {
                         String::from_utf8(bytes)
                             .map_err(|err| IronError::new(err, "Invalid utf8"))?
                     };
-                    let b_text = KNOWN_KEYS
-                        .lock()
-                        .unwrap() //.map_err(|_| IronError::new(std::error::Error::from("Mutex Err"), "PGP Context unavailable"))?
-                        .verify(pgp_text.as_bytes())
-                        .map_err(|err| IronError::new(err, "Untrusted signature"))?;
-                    let text = String::from_utf8(b_text).unwrap();
                     Snippet::random(&storage).write(&*text).map_err(|err| {
                         let msg = format!("Failed to save snippet: {:?}", &err);
                         IronError::new(err, msg)
@@ -92,17 +185,7 @@ fn handle(req: &mut Request) -> IronResult<Response> {
                 )))
             }
         }
-        (Method::Get, Some(path)) => {
+        (Method::Get, Some(id)) => {
-            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| {
@@ -113,7 +196,6 @@ 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"))))
         }
@@ -124,17 +206,6 @@ fn handle(req: &mut Request) -> IronResult<Response> {
 
 fn main() {
     let chain = Chain::new(handle);
-    println!("Starting brownpaper: {}", &*STORAGE_DIR);
+    println!("Starting brownpaper: {}", STORAGE_DIR);
-    Iron::new(chain).http(
+    Iron::new(chain).http("0.0.0.0:3000").unwrap();
-        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

@@ -1,74 +0,0 @@
-use openpgp::parse::stream::*;
-use openpgp::parse::Parse;
-use openpgp::*;
-use std::fs;
-use std::fs::File;
-use std::io;
-use std::io::prelude::*;
-use std::path::Path;
-
-pub struct KnownKeys {
-    keys: Vec<openpgp::TPK>,
-}
-impl VerificationHelper for &KnownKeys {
-    fn get_public_keys(&mut self, _ids: &[KeyID]) -> Result<Vec<TPK>> {
-        Ok(self.keys.clone())
-    }
-    fn check(&mut self, structure: &MessageStructure) -> Result<()> {
-        Ok(()) // Implement your verification policy here.
-    }
-}
-
-impl KnownKeys {
-    pub fn load_dir(dir: impl AsRef<Path>) -> io::Result<KnownKeys> {
-        let mut keys: Vec<openpgp::TPK> = Vec::with_capacity(3);
-        for f in fs::read_dir(dir)? {
-            let f = f?;
-            if f.metadata()?.is_dir() {
-                continue;
-            }
-            let tpk = openpgp::TPK::from_file(f.path()).unwrap();
-            println!("Fingerprint: {}", tpk.fingerprint());
-            keys.push(tpk);
-        }
-        Ok(KnownKeys { keys: keys })
-    }
-
-    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).map_err(|e| {
-            io::Error::new(io::ErrorKind::InvalidData, "Failed to verify signature")
-        })?;
-        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,
-                "Signature Mismatch",
-            ));
-        }
-        Ok(content)
-    }
-}

src/snippet.rs

@@ -1,153 +0,0 @@
-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
-        }
-    }
-}