From 7c5a0789ba80f890c868e81b981315dd53e9dd94 Mon Sep 17 00:00:00 2001
From: Linus Nordberg <linus@nordu.net>
Date: Tue, 29 Apr 2014 16:56:09 +0200
Subject: Turn it all into an application.

Warning: Rough edges.
---
 include/plop.hrl | 79 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 include/plop.hrl

(limited to 'include')

diff --git a/include/plop.hrl b/include/plop.hrl
new file mode 100644
index 0000000..5492024
--- /dev/null
+++ b/include/plop.hrl
@@ -0,0 +1,79 @@
+%%% plop data structures. Heavily based on RFC 6962. Some are for
+%%% database storage, some for interfacing with consumers and some are
+%%% for serialisation.
+
+-type signature_type() :: certificate_timestamp | tree_hash | test. % uint8
+-type entry_type() :: x509 | precert | test.    % uint16
+-type leaf_type() :: timestamped_entry | test.  % uint8
+
+%% @doc What's stored in the database.
+-record(plop, {
+          index :: non_neg_integer(),           % Primary key.
+          hash :: binary(), % SHA-256 over #FIXME.entry. Indexed in db.
+          spt :: binary()   % serialise(#spt_on_wire{})
+         }).
+
+%% @doc Merkle Tree Leaf -- input to hash function for leaf hashes.
+-record(mtl, {
+          version = 1 :: pos_integer(),
+          leaf_type = timestamped_entry :: leaf_type(),
+          entry :: timestamped_entry()
+         }).
+-type mtl() :: #mtl{}.
+
+%% @doc Parts of what goes in an SPT. Used for FIXME.
+%% -record(spt, {
+%%           version = 1 :: pos_integer(),
+%%           signature_type :: signature_type(),
+%%           entry :: timestamped_entry()
+%%           }).
+%%-type spt() :: #spt{}.
+
+-record(spt_on_wire, {
+          version :: pos_integer(),             % uint8
+          logid :: binary(),                    % SHA-256 over DER encoded public log key
+          timestamp :: integer(),               % uint64
+          signature :: binary()
+         }).
+-type spt_on_wire() :: #spt_on_wire{}.
+
+%% @doc What's signed in an SPT. Used for serialisation before hasning
+%% and signing. FIXME: Overlapping #spt{} -- merge somehow.
+-record(spt_signed, {
+          version :: pos_integer(),
+          signature_type :: signature_type(),
+          timestamp :: integer(),
+          entry_type :: entry_type(),
+          signed_entry :: binary()
+         }).
+-type spt_signed() :: #spt_signed{}.
+
+%% Internal representation of a data entry.
+-record(timestamped_entry, {
+          timestamp = now :: now | integer(),
+          entry_type :: entry_type(),
+          entry :: binary()
+         }).
+-type timestamped_entry() :: #timestamped_entry{}.
+
+%% %% Part of interface to plop:add/1.
+%% -record(plop_entry, {
+%%           type :: entry_type(),
+%%           data :: binary()
+%%          }).                   
+%% -type plop_entry() :: #plop_entry{}.
+
+
+%% @doc The parts of an STH which is to be signed. Used as the
+%% interface to plop:sth/1, for testing. Should probably be internal
+%% to plop, if that can be arranged wrt testing.
+-record(sth, {
+          version = 1 :: pos_integer(),
+          signature_type :: signature_type(),
+          timestamp = now :: 'now' | integer(),
+          tree_size :: integer(),
+          root_hash :: binary()                 % SHA-256
+         }).
+-type sth() :: #sth{}.
+
+-export_type([timestamped_entry/0, mtl/0, entry_type/0]).
-- 
cgit v1.1