Add tests to verify accuracy of hash chain. NEXT: Tests to verify accuracy of signatures

dist/pigeon/key_pair.rb

@@ -3,14 +3,6 @@ module Pigeon
   # help us maintain our sanity when the Gem's API
   # changes.
   class KeyPair
-    def self.strip_headers(identity)
-      identity.sub(HEADER, "").sub(FOOTER, "")
-    end
-
-    def self.add_headers(urlsafe_b64_no_headers)
-      [HEADER, urlsafe_b64_no_headers, FOOTER].join("")
-    end
-
     def self.reset
       @current = nil
     end
@@ -54,6 +46,14 @@ module Pigeon
 
     private
 
+    def self.strip_headers(identity)
+      identity.sub(HEADER, "").sub(FOOTER, "")
+    end
+
+    def self.add_headers(urlsafe_b64_no_headers)
+      [HEADER, urlsafe_b64_no_headers, FOOTER].join("")
+    end
+
     def raw_key
       @raw_key ||= Ed25519::SigningKey.new(@seed)
     end

dist/pigeon/message.rb

@@ -16,7 +16,7 @@ module Pigeon
     end
 
     def render
-      Serializer.new(self).render
+      Serializer.new(self).render.chomp
     end
 
     def multihash

dist/pigeon/storage.rb

@@ -26,8 +26,7 @@ module Pigeon
 
     def save_message(msg)
       store.transaction do
-        store[MESG_NS][msg.signature] = msg
-        update_indices(msg)
+        insert_and_update_index(msg)
       end
     end
 
@@ -123,11 +122,17 @@ module Pigeon
       return @store
     end
 
-    def update_indices(message)
+    def insert_and_update_index(message)
+      # STEP 1: Update MESG_NS, the main storage spot.
+      store[MESG_NS][message.multihash] = message
+
+      # STEP 2: Update the "message by author and depth" index
+      #         this index is used to find a person's nth
+      #         message
       # SECURITY AUDIT: How can we be certain the message is
       # not lying about its depth?
       key = [message.author.public_key, message.depth]
-      store[DEPTH_INDEX_NS][key] = message.signature
+      store[DEPTH_INDEX_NS][key] = message.multihash
     end
   end
 end

scratchpad2.rb

@@ -1,18 +0,0 @@
-require "json"
-require "base64"
-require "ed25519"
-file = File.read("../scratchpad2.json")
-json = JSON.parse(file)
-
-message_plaintext = File.read("./scratchpad3.json").chomp
-what_we_want = json[1]["signature"].gsub(".sig.ed25519", "")
-seed = Base64.urlsafe_decode64(json[0]["private"].gsub!(".ed25519", ""))
-signing_key = Ed25519::SigningKey.from_keypair(seed)
-signature = signing_key.sign(message_plaintext)
-signature_b64 = Base64.urlsafe_encode64(signature)
-
-puts file
-puts message_plaintext
-puts "HAVE: " + signature_b64
-puts "WANT: " + what_we_want
-puts signature_b64 == what_we_want ? "HOORAY!!!" : "Did not work"

spec/pigeon/message_spec.rb

@@ -6,14 +6,23 @@ RSpec.describe Pigeon::Message do
     Pigeon::KeyPair.reset
   end
 
-  let(:draft) do
+  def create_draft(params)
     draft = Pigeon::Draft.create(kind: "unit_test")
-    hash = Pigeon::Storage.current.set_blob(File.read("./logo.png"))
-    draft["a"] = "bar"
-    draft["b"] = hash
+    params.each { |(k, v)| draft[k] = v }
     draft
   end
 
+  def create_message(params)
+    draft = create_draft(params)
+    Pigeon::Message.from_draft(draft)
+  end
+
+  let(:draft) do
+    hash = Pigeon::Storage.current.set_blob(File.read("./logo.png"))
+    create_draft({ "a" => "bar",
+                   "b" => hash })
+  end
+
   it "discards a draft after signing" do
     expect(draft.internal_id).to eq(Pigeon::Draft.current.internal_id)
     Pigeon::Message.from_draft(draft)
@@ -56,12 +65,37 @@ RSpec.describe Pigeon::Message do
       all.push(message)
       expect(message.depth).to eq(expected_depth)
       if n > 1
-        expect(message.prev).to eq(all[n - 2].signature)
+        expect(message.prev).to eq(all[n - 2].multihash)
       else
         expect(message.prev).to be nil
       end
     end
   end
 
-  it "verifies accuracy of signature chain"
+  it "verifies accuracy of hash chain" do
+    m1 = create_message({ "a" => "b" })
+    m2 = create_message({ "c" => "d" })
+    m3 = create_message({ "e" => "f" })
+    m4 = create_message({ "g" => "h" })
+    expect(m1.prev).to eq(nil)
+    expect(m2.prev).to be
+    expect(m2.prev).to eq(m1.multihash)
+    expect(m3.prev).to eq(m2.multihash)
+    expect(m3.prev).to be
+    expect(m4.prev).to eq(m3.multihash)
+    expect(m4.prev).to be
+  end
+
+  it "verifies accuracy of signatures" do
+    m1 = create_message({ "a" => "b" })
+    template = Pigeon::Serializer.new(m1)
+    string = template.render_without_signature
+    secret = Pigeon::Storage.current.get_config(Pigeon::SEED_CONFIG_KEY)
+    expect(secret.length).to eq(32)
+    signing_key = Ed25519::SigningKey.new(secret)
+    raw_signature = signing_key.sign(string)
+    b64_signature = Base64.urlsafe_encode64(raw_signature)
+    signature = b64_signature + ".sig.ed25519"
+    expect(m1.signature).to eq(signature)
+  end
 end