The module provides k of n encoding - a way to generate (n - k) secondary blocks of data from k primary blocks such that any k blocks (primary or secondary) are sufficient to regenerate all blocks.
All blocks must be the same length and you need to keep track of which blocks you have in order to tell decode. By convention, the blocks are numbered 0..(n - 1) and blocks numbered < k are the primary blocks.
- data FECParams
- fec :: Int -> Int -> FECParams
- encode :: FECParams -> [ByteString] -> [ByteString]
- decode :: FECParams -> [(Int, ByteString)] -> [ByteString]
- secureDivide :: Int -> ByteString -> IO [ByteString]
- secureCombine :: [ByteString] -> ByteString
- enFEC :: Int -> Int -> ByteString -> [ByteString]
- deFEC :: Int -> Int -> [ByteString] -> ByteString
Return a FEC with the given parameters.
Generate the secondary blocks from a list of the primary blocks. The
primary blocks must be in order and all of the same size. There must be
k primary blocks.
|-> [(Int, ByteString)]|
a list of
a list the
Recover the primary blocks from a list of
k blocks. Each block must be
tagged with its number (see the module comments about block numbering)
Break a ByteString into
n parts, equal in length to the original, such
n are required to reconstruct the original, but having less
n parts reveals no information about the orginal.
This code works in IO monad because it needs a source of random bytes, which it gets from devurandom. If this file doesn't exist an exception results
Not terribly fast - probably best to do it with short inputs (e.g. an encryption key)
Reverse the operation of secureDivide. The order of the inputs doesn't matter, but they must all be the same length
the number of blocks required to reconstruct
the total number of blocks
the data to divide
the resulting blocks
A utility function which takes an arbitary input and FEC encodes it into a
number of blocks. The order the resulting blocks doesn't matter so long
as you have enough to present to