diary-ruby 0.1.0

data/lib/diary-ruby/ext/encryptor.rb

@@ -0,0 +1,95 @@
+# -*- encoding: utf-8 -*-
+#
+# Create an encrypted bundled string version of a message, given a particular
+# passphrase.
+#
+# Decrypt a bundled document given a particular passphrase.
+#
+# NOTE: the encrypted bundle chooses a random initialization vector
+# and salt and includes them in the bundle in plain text alongside the
+# encrypted message.
+#
+
+require 'openssl'
+require 'base64'
+
+module Encryptor
+  class Error < StandardError
+  end
+
+  def self.encrypt(msg, pwd)
+    cipher = OpenSSL::Cipher.new 'AES-128-CBC'
+    cipher.encrypt
+
+    # random salt
+    salt = OpenSSL::Random.random_bytes(16)
+
+    # random initialization vector
+    iv = cipher.random_iv
+
+    iter = 20000
+    key_len = cipher.key_len
+    digest = OpenSSL::Digest::SHA256.new
+
+    key = OpenSSL::PKCS5.pbkdf2_hmac(pwd, salt, iter, key_len, digest)
+    cipher.key = key
+
+    # Now encrypt the data:
+    encrypted = cipher.update(msg)
+    encrypted << cipher.final
+
+    # And encode final format
+    wrap(iv, salt, encrypted)
+  end
+
+  def self.decrypt(document, pwd)
+    iv, salt, encrypted = unwrap(document)
+
+    Diary.debug "DECRYPT WITH"
+    Diary.debug "  iv    #{ Base64.encode64(iv) }"
+    Diary.debug "  salt  #{ Base64.encode64(salt) }"
+    Diary.debug "  msg   #{ Base64.encode64(encrypted) }"
+
+    ## Decrypt
+    cipher = OpenSSL::Cipher.new 'AES-128-CBC'
+    cipher.decrypt
+    cipher.iv = iv
+
+    salt = salt
+    iter = 20000
+    key_len = cipher.key_len
+    digest = OpenSSL::Digest::SHA256.new
+
+    key = OpenSSL::PKCS5.pbkdf2_hmac(pwd, salt, iter, key_len, digest)
+    cipher.key = key
+
+    decrypted = cipher.update(encrypted)
+    decrypted << cipher.final
+  end
+
+  def self.wrap(iv, salt, encrypted)
+    [
+      Base64.encode64(iv),
+      Base64.encode64(salt),
+      Base64.encode64(encrypted)
+    ].join('|')
+  end
+
+  def self.unwrap(document)
+    if document.is_a?(File)
+      document = document.read
+    end
+
+    if document.count('|') != 2
+      raise Encryptor::Error.new("Document is not a vaild encrypted store.")
+    end
+
+    iv64, salt64, encrypted64 = document.split('|')
+
+    iv = Base64.decode64(iv64.to_s.strip)
+    salt = Base64.decode64(salt64.to_s.strip)
+    encrypted = Base64.decode64(encrypted64.to_s.strip)
+
+    [iv, salt, encrypted]
+  end
+end

data/lib/diary-ruby/ext/secure_pstore.rb

@@ -0,0 +1,86 @@
+
+require 'pstore'
+require 'diary-ruby/ext/encryptor'
+
+#
+# Wrap PStore, combine with OpenSSL::Cipher to secure store on disk with a
+# given passphrase
+#
+# SecurePStore
+#
+# Useable exactly like PStore except for initialization.
+#
+# With PStore:
+#
+#     wiki = PStore.new("wiki_pages.pstore")
+#     wiki.transaction do  # begin transaction; do all of this or none of it
+#       # store page...
+#       wiki[home_page.page_name] = home_page
+#       # ensure that an index has been created...
+#       wiki[:wiki_index] ||= Array.new
+#       # update wiki index...
+#       wiki[:wiki_index].push(*home_page.wiki_page_references)
+#     end                  # commit changes to wiki data store file
+#
+# With SecurePStore:
+#
+#     wiki = SecurePStore.new("wiki_pages.pstore", passphrase: 'do it this way instead')
+#     wiki.transaction do  # begin transaction; do all of this or none of it
+#       # store page...
+#       wiki[home_page.page_name] = home_page
+#       # ensure that an index has been created...
+#       wiki[:wiki_index] ||= Array.new
+#       # update wiki index...
+#       wiki[:wiki_index].push(*home_page.wiki_page_references)
+#     end                  # commit changes to wiki data store file
+#
+# Simple!
+#
+class SecurePStore < PStore
+  # :call-seq:
+  #   initialize( file_name, secure_opts = {} )
+  #
+  # Creates a new SecureStore object, which will store data in +file_name+.
+  # If the file does not already exist, it will be created.
+  #
+  # Options passed in through +secure_opts+ will be used behind the scenes
+  # when writing the encrypted file to disk.
+  def initialize file_name, secure_opts = {}
+    @opt = secure_opts
+    super
+  end
+
+  # Override PStore's private low-level storage methods, similar to YAML::Store
+  #
+  def dump(table)  # :nodoc:
+    marshalled = Marshal::dump(table)
+    # return encrypted
+    Encryptor.encrypt(marshalled, @opt[:passphrase])
+  end
+
+  def load(content)  # :nodoc:
+    begin
+      dcontent = Encryptor.decrypt(content, @opt[:passphrase])
+      Marshal::load(dcontent)
+    rescue OpenSSL::Cipher::CipherError => ex
+      raise PStore::Error.new("Failed to decrypt stored data: #{ ex.message }")
+    end
+  end
+
+  def marshal_dump_supports_canonical_option?
+    false
+  end
+
+  def empty_marshal_data
+    @empty_marshal_data ||= begin
+                              m = Marshal.dump({})
+                              Encryptor.encrypt(m, @opt[:passphrase])
+                            end
+  end
+
+  def empty_marshal_checksum
+    @empty_marshal_checksum ||= begin
+                                  Digest::MD5.digest(empty_marshal_data)
+                                end
+  end
+end

data/lib/diary-ruby/parser.rb

@@ -0,0 +1,68 @@
+# Parse a plaintext diary entry into a Diary::Entry object
+
+module Diary
+  class Parser
+    def self.parse(infile)
+      header = []
+      body = []
+      in_header = true
+      split_match = /^---+$/
+
+      Diary.debug("PARSE #{ infile.size } BYTES")
+
+      infile.lines.each do |line|
+        if in_header
+          if split_match =~ line
+            in_header = false
+            next
+          end
+
+          # check for line
+          header << line
+        else
+          body << line
+        end
+      end
+
+      metadata = {}
+
+      key_match = /^([A-Za-z_-]+):? (.+)$/
+      header.each do |h_line|
+        if key_match =~ h_line
+          key = $1.strip.downcase
+          val = $2.strip
+
+          if /tags/i =~ key
+            val = val.split(',').map {|v| v.strip}
+          end
+
+          metadata[key] = val
+        end
+      end
+
+      key = Entry.keygen(metadata['day'], metadata['time'])
+      Diary.debug "KEY #{ key }"
+      Diary.debug "METADATA #{ metadata.inspect }"
+      Diary.debug "BODY #{ body.join(" ") }"
+
+      return Entry.new(
+        nil,
+        day: metadata['day'],
+        time: metadata['time'],
+        tags: metadata['tags'],
+        text: body.join("\n").strip,
+        title: metadata['title'],
+        key: key,
+      )
+    end
+
+    def self.parse_file(file)
+      # read
+      file.seek(0)
+      contents = file.read
+
+      # now parse
+      self.parse(contents)
+    end
+  end
+end

data/lib/diary-ruby/server/public/script.js

@@ -0,0 +1,57 @@
+// alert('hello world!')
+
+// vanilla js AJAX
+/*
+var r = new XMLHttpRequest();
+r.open("POST", "path/to/api", true);
+r.onreadystatechange = function () {
+  if (r.readyState != 4 || r.status != 200) return;
+  alert("Success: " + r.responseText);
+};
+r.send("banana=yellow");
+*/
+
+var each = function (el, func) {
+  if (el instanceof NodeList) {
+    var forEach = Array.prototype.forEach
+    forEach.call(el, func)
+  } else {
+    func(el)
+  }
+  return el
+}
+
+// get NodeList of elements
+var $$ = function (selector) {
+  return document.querySelectorAll(selector)
+}
+
+// get single element
+var $ = function (selector) {
+  return document.querySelector(selector)
+}
+
+var zp = function (n) {
+  n = parseInt(n)
+  if (n < 10 && n >= 0) {
+    return "0" + n
+  } else {
+    return n
+  }
+}
+
+var strftime_F = function () {
+  var now = new Date()
+  return now.getFullYear() + "-" + zp(now.getMonth() + 1) + "-" + zp(now.getDate())
+}
+
+var strftime_T = function () {
+  var now = new Date()
+  return zp(now.getHours()) + ":" + zp(now.getMinutes()) + ":" + zp(now.getSeconds())
+}
+
+window.onload = function () {
+  $('input.day').value = strftime_F()
+  $('input.time').value = strftime_T()
+}
+

data/lib/diary-ruby/server/public/style.css

@@ -0,0 +1,33 @@
+.wrapper {
+  width: 960px;
+  margin: 0 auto;
+}
+
+form {
+}
+
+form input[type=text] {
+  border: 0;
+  border-bottom: 1px solid black;
+}
+
+form input.tags {
+  width: 300px;
+}
+
+form label {
+  display: block;
+  margin-bottom: 8px;
+}
+
+form label span {
+  display: inline-block;
+  width: 50px;
+}
+
+form textarea {
+  display: block;
+  width: 600px;
+  height: 300px;
+  margin-top: 8px;
+}

data/lib/diary-ruby/server/server.rb

@@ -0,0 +1,93 @@
+require 'sinatra'
+require 'json'
+require 'rdiscount'
+require 'tilt/erb'
+
+module Diary
+  class Server < Sinatra::Base
+    configure :production, :development do
+      enable :logging
+    end
+
+    def self.store=(val)
+      @store = val
+    end
+
+    def self.store
+      @store
+    end
+
+    def store
+      self.class.store
+    end
+
+    get '/' do
+      keys = store.read(:entries)
+
+      if keys.nil?
+        store.write do |db|
+          db[:entries] = []
+        end
+
+        keys = []
+      end
+
+      @entries = keys.uniq.map {|entry_key|
+        entry = store.read(entry_key)
+
+        if entry
+          logger.debug "LOAD #{ entry }"
+          Entry.from_store(entry)
+        else
+          nil
+        end
+      }.compact
+
+      logger.info "returning keys: #{ keys }"
+      logger.info "returning entries: #{ @entries }"
+
+      erb :index
+    end
+
+    get '/entry/:key' do
+      content_type :json
+
+      key = params[:key]
+      entry_hash = store.read(key)
+      entry = Entry.from_store(entry_hash)
+
+      content = RDiscount.new entry.text
+      entry_hash[:formatted] = content.to_html
+
+      if entry
+        entry_hash.to_json
+      else
+        {}
+      end
+    end
+
+    # create
+    post '/entries' do
+      logger.info "ENTRY"
+
+      begin
+        tags = params[:tags].split(',').map(&:strip)
+      rescue
+        tags = []
+      end
+
+      entry = Entry.new(
+        nil,
+        day: params[:day],
+        time: params[:time],
+        tags: tags,
+        text: params[:text],
+      )
+
+      store.write_entry(entry)
+
+      redirect to('/')
+    end
+  end
+end
+

data/lib/diary-ruby/server/views/index.erb

@@ -0,0 +1,61 @@
+<!doctype html>
+<html>
+  <head>
+    <link href='style.css' rel='stylesheet' type='text/css' />
+    <script src='script.js'></script>
+  </head>
+
+  <body>
+    <div class='wrapper'>
+      <h1>Existing Entries</h1>
+      <% if @entries.size == 0 %>
+        <p>Nothing to see here...</p>
+      <% else %>
+        <% @entries.each do |entry| %>
+          <div class='entry'>
+            <p>
+              <strong><%= entry.day %> <%= entry.time %></strong>
+              <a href='/entry/<%= entry.key %>'>json</a>
+            </p>
+            <div class='entry--text'>
+              <%= entry.formatted_text %>
+            </div>
+          </div>
+        <% end %>
+      <% end %>
+
+      <hr>
+
+      <h3>New Entry</h3>
+      <form action='/entries' method='POST'>
+        <label>
+          <span>Day</span>
+          <input class='day'  name='day' type='text' />
+        </label>
+
+        <label>
+          <span>Time</span>
+          <input class='time' name='time' type='text' />
+        </label>
+
+        <label>
+          <span>Tags</span>
+          <input type='text' class='tags' name='tags' />
+        </label>
+
+        <label>
+          <span>Text</span>
+          <textarea class='text' name='text'></textarea>
+        </label>
+
+        <input type='submit' value='commit' />
+      </form>
+    </div>
+  </body>
+</html>
+
+
+
+
+
+