From 90b7c385f4e2f293502f9aca38aaa041b7b2f486 Mon Sep 17 00:00:00 2001
From: Joey Hess <joeyh@joeyh.name>
Date: Wed, 10 Aug 2016 12:16:44 -0400
Subject: types for new version storage scheme

---
 Types.hs | 81 ++++------------------------------------------------------------
 1 file changed, 4 insertions(+), 77 deletions(-)

(limited to 'Types.hs')

diff --git a/Types.hs b/Types.hs
index 41c3a00..7262f33 100644
--- a/Types.hs
+++ b/Types.hs
@@ -6,94 +6,21 @@ import Types.Cost
 import Entropy
 import qualified Data.ByteString as B
 import qualified Data.ByteString.Lazy as BL
-import qualified Crypto.Argon2 as Argon2
 import Data.String
 
 -- | keysafe stores secret keys.
 newtype SecretKey = SecretKey B.ByteString
 
--- | Objects stored on a keysafe server are (probably) a shard of an
--- encrypted secret key.
-newtype StorableObject = StorableObject { fromStorableObject :: BL.ByteString }
-
--- | Parameters for sharding. The secret is split into
--- N objects, such that only M are needed to reconstruct it.
-data ShardParams = ShardParams
-	{ totalObjects :: Int -- ^ N
-	, neededObjects :: Int -- ^ M
-	}
-
--- | keysafe stores data for a long time, and needs to be able to process
--- data from a long time ago when restoring a key. We don't want to be 
--- locked into old choices of crypto primitives etc forever. 
---
--- So, every parameter that can be tuned is configured in this data
--- structure. Carefully chosen parts of this are exposed at various points
--- in the data stored for a key, to allow future versions of keysafe to
--- make the right decisions when processing it.
-data Tunables = Tunables
-	{ shardParams :: ShardParams
-	, objectSize :: Int
-	-- ^ a StorableObject is exactly this many bytes in size
-	, expensiveHashTunable :: ExpensiveHashTunable
-	, encryptionTunable :: EncryptionTunable
-	, decryptionPuzzleTunable :: DecryptionPuzzleTunable
-	}
-
--- | An expensive hash, used to make it hard to crack an encrypted secret key.
-data ExpensiveHashTunable = UseArgon2 Argon2.HashOptions (Cost CreationOp)
-	deriving (Show)
-
--- | What encryption to use.
-data EncryptionTunable = UseAES256
-	deriving (Show)
-
--- | An additional puzzle that makes decryption more expensive.
-data DecryptionPuzzleTunable = KeyBlindingLeftSide (Cost DecryptionOp)
-	deriving (Show)
-
-defaultTunables :: Tunables
-defaultTunables = Tunables
-	{ shardParams = ShardParams { totalObjects = 3, neededObjects = 2 }
-	, objectSize = 1024*64 -- 64 kb
-	, expensiveHashTunable = UseArgon2 argonoptions argoncost
-	, encryptionTunable = UseAES256
-	-- AES can be calculated more efficiently by a GPU, so the
-	-- cost is a GPU cost.
-	-- This is set to only 1 minute because GPUs are quite a lot
-	-- faster than CPUs at AES, and so setting it higher would make
-	-- clients too slow at key recovery.
-	, decryptionPuzzleTunable = KeyBlindingLeftSide (GPUCost (Seconds 60))
-	}
-  where
-	argonoptions = Argon2.HashOptions
-		{ Argon2.hashIterations = 10000
-		, Argon2.hashMemory = 131072 -- 128 mebibtyes per thread
-		, Argon2.hashParallelism = 4 -- 4 threads
-		, Argon2.hashVariant = Argon2.Argon2i
-		}
-	-- argon2 is GPU and ASIC resistent, so it uses CPU time.
-	-- The above HashOptions were benchmarked at 661 seconds CPU time
-	-- on a 2 core Intel(R) Core(TM) i5-4210Y CPU @ 1.50GHz.
-	-- Since cost is measured per core, we double that.
-	argoncost = CPUCost (Seconds (2*600))
-
--- | Dials back cryptographic difficulty, not for production use.
-testModeTunables :: Tunables
-testModeTunables = Tunables
-	{ shardParams = ShardParams { totalObjects = 3, neededObjects = 2 }
-	, objectSize = 1024*64
-	, expensiveHashTunable = UseArgon2 Argon2.defaultHashOptions (CPUCost (Seconds (2*600)))
-	, encryptionTunable = UseAES256
-	, decryptionPuzzleTunable = KeyBlindingLeftSide (GPUCost (Seconds 60))
-	}
-
 -- | The secret key, encrypted with a password.
 data EncryptedSecretKey = EncryptedSecretKey B.ByteString (CostCalc BruteForceOp UnknownPassword)
 
 instance Bruteforceable EncryptedSecretKey UnknownPassword where
 	getBruteCostCalc (EncryptedSecretKey _ cc) = cc
 
+-- | Objects stored on a keysafe server are (probably) a shard of an
+-- encrypted secret key.
+newtype StorableObject = StorableObject { fromStorableObject :: BL.ByteString }
+
 -- | A password used to encrypt a key stored in keysafe.
 newtype Password = Password B.ByteString
 	deriving (IsString)
-- 
cgit v1.2.3