The data-dispersal package


This library provides space-efficient (m,n)-information dispersal algorithms (IDAs).

Given a ByteString bstr of length D, we encode bstr as a list fs of n Fragments, each containing a ByteString of length O(D/m). Then, each fragment in fs could be stored on a separate machine for fault-tolerance. Even if up to n-m of these machines crash, we can still reconstruct the original ByteString out of the remaining m fragments. The total space required for the n fragments is O((n/m)*D). Note that m and n are roughly in the same order, so the actual storage overhead for getting good fault-tolerance increases only by a constant factor.

The module Data.IDA contains the basic information dispersal algorithm. The module Crypto.IDA augments the dispersal scheme by combining it with secret sharing, i.e., the knowledge of up to m-1 fragments does not leak any information about the original data. See Crypto.IDA for details.

GHCi Example:

 > :m + Data.IDA
 > let msg = Data.ByteString.Char8.pack "my really important data"
 > let fragments = encode 5 15 msg
 -- Now we could distributed the fragments on different sites to add some
 -- fault-tolerance.
 > let frags' = drop 5 $ take 10 fragments -- let's pretend that 10 machines crashed
 > decode frags'
 "my really important data"


Suppose that we have N machines and encode our data as 2log(N) fragments with reconstruction threshold m = log(N). Let's assume that we store each fragment on a separate machine and each machine fails (independently) with probability at most 0.5.

This library is based on the following works:


DependenciesAES (>=0.2.9), array (>=, base (==4.6.*), binary (>=, bytestring (>=, entropy (>=0.3.2), finite-field (>=0.8.0), matrix (>=, secret-sharing (>=, syb (>=0.4.0), vector (>= [details]
CopyrightPeter Robinson 2014
AuthorPeter Robinson <>
CategoryData, Cryptography
Home page
UploadedMon Sep 8 16:30:25 UTC 2014 by PeterRobinson



Maintainers' corner

For package maintainers and hackage trustees