skein-1.0.9.4/c_impl/0000755000000000000000000000000012641032067012426 5ustar0000000000000000skein-1.0.9.4/c_impl/optimized/0000755000000000000000000000000012641032067014432 5ustar0000000000000000skein-1.0.9.4/c_impl/reference/0000755000000000000000000000000012641032067014364 5ustar0000000000000000skein-1.0.9.4/src/0000755000000000000000000000000012641032067011752 5ustar0000000000000000skein-1.0.9.4/src/Crypto/0000755000000000000000000000000012641032067013232 5ustar0000000000000000skein-1.0.9.4/src/Crypto/Skein/0000755000000000000000000000000012641032067014303 5ustar0000000000000000skein-1.0.9.4/tests/0000755000000000000000000000000012641032067012325 5ustar0000000000000000skein-1.0.9.4/src/Crypto/Skein.hs0000644000000000000000000006762512641032067014657 0ustar0000000000000000----------------------------------------------------------------------------- -- | -- Module : Crypto.Skein -- Copyright : (c) 2011 Felipe A. Lessa -- License : BSD3 (see LICENSE) -- -- Maintainer : felipe.lessa@gmail.com -- Stability : provisional -- Portability : portable (needs FFI) -- -- High-level interface for the Skein family of hash functions. -- ----------------------------------------------------------------------------- module Crypto.Skein ( -- * Using this module -- $usingMod -- ** Skein as a cryptographic hash function -- $skeinAsHash -- ** Skein as a message authentication code (MAC) -- $skeinAsMAC -- * About Skein -- $about -- * Main cryptographic hash functions -- $mainHash -- ** Skein-512-512 Skein_512_512 , Skein_512_512_Ctx -- ** Skein-1024-1024 , Skein_1024_1024 , Skein_1024_1024_Ctx -- ** Skein-256-256 , Skein_256_256 , Skein_256_256_Ctx -- * Skein-MAC -- $skeinmac , Key , skeinMAC , skeinMAC' , SkeinMAC (skeinMACCtx) -- * Other variants of cryptographic hash functions -- $variants -- ** Skein-256-128 , Skein_256_128 , Skein_256_128_Ctx -- ** Skein-256-160 , Skein_256_160 , Skein_256_160_Ctx -- ** Skein-256-224 , Skein_256_224 , Skein_256_224_Ctx -- * Skein-512 -- ** Skein-512-128 , Skein_512_128 , Skein_512_128_Ctx -- ** Skein-512-160 , Skein_512_160 , Skein_512_160_Ctx -- ** Skein-512-224 , Skein_512_224 , Skein_512_224_Ctx -- ** Skein-512-256 , Skein_512_256 , Skein_512_256_Ctx -- ** Skein-512-384 , Skein_512_384 , Skein_512_384_Ctx -- * Skein-1024 -- ** Skein-1024-384 , Skein_1024_384 , Skein_1024_384_Ctx -- ** Skein-1024-512 , Skein_1024_512 , Skein_1024_512_Ctx ) where -- from base import Control.Monad (unless) import Foreign import Foreign.C import qualified System.IO.Unsafe as U -- from bytestring import qualified Data.ByteString as B import qualified Data.ByteString.Lazy as L import qualified Data.ByteString.Internal as BI import qualified Data.ByteString.Unsafe as BU -- from cereal import Data.Serialize -- from tagged import Data.Tagged (Tagged(..)) -- from crypto-api import Crypto.Classes -- from this package import Crypto.Skein.Internal ---------------------------------------------------------------------- -- $usingMod -- -- Currently this module provides both Skein as a cryptographic -- hash function and Skein as a MAC. This module currently does -- not provide some Skein functions, such as tree hashing, -- pseudo-random number generation, stream ciphing or key -- derivation. -- -- Terminology note: we say \"message\" for your variable-sized -- data that is given to Skein. -- $skeinAsHash -- -- There are many variants of Skein as a cryptographic hash -- function. They are called @Skein_X_Y@, where @X@ is internal -- state size in bits and @Y@ is the output size in bits. The -- main ones are 'Skein_512_512', 'Skein_1024_1024' and -- 'Skein_256_256'. If you are unsure, then use 'Skein_512_512'. -- -- To use these data types, you have to use 'Hash' and -- 'Serialize'. Suppose you wanted to hash a lazy 'L.ByteString' -- @bs@. Then you could use -- -- @ -- digest :: 'S.ByteString' -- digest = let h = 'hash' bs :: 'Skein_512_512' -- in 'encode' h -- @ -- -- where 'hash' is from "Crypto.Classes" (@crypto-api@ package), -- 'encode' is from 'Serialize' (@cereal@ package) and @digest@ -- is a strict 'B.ByteString' with the hash. Given that we've -- used 'Skein_512_512' which has an output size of 512 bits, -- @digest@ will have @512 / 8 = 64@ bytes of length. -- $skeinAsMAC -- -- If you need a message authentication code (MAC), you may use -- HMAC with Skein (e.g. HMAC-Skein-512-512). Using HMAC with -- Skein is supported and secure. However, Skein also supports -- another secure method, called Skein-MAC. -- -- Skein-MAC is as secure as HMAC with Skein, however with a much -- lower overhead (especially for short messages). HMAC requires -- two hash invocations. Skein-MAC, on the other hand, requires -- just one hash invocation after the setup. -- -- To use Skein-MAC, you need 'skeinMAC' (or 'skeinMAC'') and -- 'Serialize'. You also need a 'Key' with at least as many bits -- as the state size you choose (@256@, @512@ or @1024@ bits). -- -- Suppose you want to use Skein-MAC with 'Skein_512_512'. To -- setup the MAC function with a 'Key' @key@ (that has at least -- @512 / 8 = 64@ bytes), use -- -- @ -- let calcMAC :: 'L.ByteString' -> 'Skein_512_512' -- calcMAC = 'skeinMAC' key -- @ -- -- It is recommended to partially apply 'skeinMAC' (or -- 'skeinMAC'') to avoid recomputing the key setup. We give an -- explicit type to 'calcMAC' because we have to choose which -- Skein we want. -- -- Now, if you want to calculate the Skein-MAC of a lazy -- 'L.ByteString' message @msg@, use -- -- @ -- let msgMAC = 'encode' (calcMAC msg) -- @ -- -- where 'encode' is from 'Serialize' (@cereal@ package) and -- @msgMAC@ is a strict 'B.ByteString' with the MAC. -- -- Now, suppose you are given a @msg'@ with MAC @msgMAC'@ and -- want to check the integrity and authenticity of @msg'@. You -- may do so by calculating the MAC of @msg'@ and checking -- against @msgMAC'@: -- -- @ -- let msgMAC'' = 'encode' (calcMAC msg') -- in if msgMAC' == msgMAC'' -- then Right \"Message is okay\" -- else Left \"Message has been corrupted or tampered with\" -- @ -- $about -- -- From at 09/2011: -- -- Skein is a new family of cryptographic hash functions. Its -- design combines speed, security, simplicity, and a great deal -- of flexibility in a modular package that is easy to analyze. -- -- Skein is fast. Skein-512 -- our primary proposal -- hashes data at -- 6.1 clock cycles per byte on a 64-bit CPU. This means that on -- a 3.1 GHz x64 Core 2 Duo CPU, Skein hashes data at 500 -- MBytes/second per core -- almost twice as fast as SHA-512 and -- three times faster than SHA-256. An optional hash-tree mode -- speeds up parallelizable implementations even more. Skein is -- fast for short messages, too; Skein-512 hashes short messages -- in about 1000 clock cycles. -- -- Skein is secure. Our current best attack on Skein-512 is on 25 -- of 72 rounds, for a safety factor of 2.9. For comparison, at a -- similar stage in the standardization process, the AES -- encryption algorithm had an attack on 6 of 10 rounds, for a -- safety factor of only 1.7. Additionally, Skein has a number of -- provably secure properties, increasing confidence in the -- algorithm. -- -- Skein is simple. Using only three primitive operations, the -- Skein compression function can be easily understood and -- remembered. The rest of the algorithm is a straightforward -- iteration of this function. -- -- Skein is flexible. Skein is defined for three different -- internal state sizes -- 256 bits, 512 bits, and 1024 bits -- -- and any output size. This allows Skein to be a drop-in -- replacement for the entire SHA family of hash functions. A -- completely optional and extendable argument system makes Skein -- an efficient tool to use for a very large number of functions: -- a PRNG, a stream cipher, a key derivation function, -- authentication without the overhead of HMAC, and a -- personalization capability. All these features can be -- implemented with very low overhead. Together with the -- Threefish large-block cipher at Skein core, this design -- provides a full set of symmetric cryptographic primitives -- suitable for most modern applications. -- -- Skein is efficient on a variety of platforms, both hardware -- and software. Skein-512 can be implemented in about 200 bytes -- of state. Small devices, such as 8-bit smart cards, can -- implement Skein-256 using about 100 bytes of memory. Larger -- devices can implement the larger versions of Skein to achieve -- faster speeds. -- -- Skein was designed by a team of highly experienced -- cryptographic experts from academia and industry, with -- expertise in cryptography, security analysis, software, chip -- design, and implementation of real-world cryptographic -- systems. This breadth of knowledge allowed them to create a -- balanced design that works well in all environments. -- $mainHash -- -- These are the main Skein hash functions. Unless you have any -- special reasons, you should use one of these. -- -- ['Skein_512_512'] is the primary cryptographic hash function -- of this package. It can safely be used for all current -- hashing applications, and should remain secure for the -- foreseeable future. -- -- ['Skein_1024_1024'] is the ultra-conservative variant. Even -- if some future attack managed to break 'Skein_512_512', it -- is quite likely that 'Skein_1024_1024' would remain secure. -- -- ['Skein_256_256'] is the low-memory variant. It can be -- implemented using 100 bytes of RAM, but this is not the case -- with this implementation. It is faster than 'Skein_512_512' -- only for small message lengths, so it's preferable to use -- 'Skein_512_512'. If you can't afford 512 bits of output, -- you may get the speed advantage of 'Skein_512_512' by using -- 'Skein_512_256'. -- $variants -- -- These hash functions produce less output bits than their state -- size. For example, 'Skein_512_160' produces 160 output bits -- while having 512 bits of state size. Their main use is to be -- a drop-in replacement to legacy hash functions. If you don't -- have any special reason for using them, use one of the main -- hash functions above (e.g. 'Skein_512_512'). -- -- You may replace: -- -- [MD5] with 'Skein_256_128' or 'Skein_512_128'. -- -- [SHA-1] with 'Skein_256_160' or 'Skein_512_160'. -- -- [SHA-224] with 'Skein_256_224' or 'Skein_512_224'. -- -- [SHA-256] with 'Skein_256_256' or 'Skein_512_256'. -- -- [SHA-384] with 'Skein_512_384' or 'Skein_1024_384'. -- -- [SHA-512] with 'Skein_512_512' or 'Skein_1024_512'. ---------------------------------------------------------------------- -- $skeinmac -- -- The standard way to use a hash function for authentication is -- to use the HMAC construction. While you may securely use -- Skein with HMAC (e.g. HMAC-Skein-512-512), Skein also supports -- another mode for MAC. Skein-MAC is as secure as -- HMAC-Skein, however faster. Skein-MAC is as fast as -- Skein as a hash function, with zero overhead. -- | Secret key used to calculate the Skein-MAC. -- -- The 'Key' may have any length. However, it's recommended to -- have at least the same number of bits of the state size. For -- example, when using 'skeinMAC' with 'Skein_512_256', it is -- recommended to have a key with at least 64 bytes (512 bits), -- which is the state size of 'Skein_512_256' (the first of the -- two numbers). type Key = B.ByteString -- | Class of Skein contexts that may be used for Skein-MAC (all -- of them). Included here mostly for documentation purposes, -- since adding new instances is not safe (functions using -- 'SkeinMAC' unsurprisingly assume that they are using Skein). class SkeinMAC skeinCtx where -- | Construct a context @skeinCtx@ given a 'Key'. This -- context may be used with the usual 'Hash' interface to -- obtain a message authentication code (MAC). -- -- For a simpler interface, see 'skeinMAC' and 'skeinMAC''. skeinMACCtx :: Key -> skeinCtx -- | Calculate the Skein-MAC of a lazy 'L.ByteString' given a -- 'Key'. You probably also want to apply 'encode' to get a -- 'B.ByteString' out of the @digest@. -- -- This function may be partially applied for increased -- performance. Using a partially applied @skeinMAC@ is as fast -- as using Skein as a cryptographic hash function. So, instead -- of -- -- @ -- let mac1 = skeinMAC key message1 -- mac2 = skeinMAC key message2 -- mac3 = skeinMAC key message3 -- ... -- @ -- -- write the following code: -- -- @ -- let calcMAC = skeinMAC key -- mac1 = calcMAC message1 -- mac2 = calcMAC message2 -- mac3 = calcMAC message3 -- ... -- @ -- -- This way the key will be processed only once (with -- 'skeinMACCtx'). skeinMAC :: (SkeinMAC skeinCtx, Hash skeinCtx digest) => Key -> L.ByteString -> digest skeinMAC k = go where ctx = skeinMACCtx k go = go' ctx . L.toChunks go' ctx' [] = finalize ctx' B.empty go' ctx' [x] = finalize ctx' x go' ctx' (x:xs) = go' (updateCtx ctx' x) xs -- See the comment below on skeinMAC'. -- | Same as 'skeinMAC', however using a strict 'B.ByteString'. -- Should be faster for small 'B.ByteString'@s@. skeinMAC' :: (SkeinMAC skeinCtx, Hash skeinCtx digest) => Key -> B.ByteString -> digest skeinMAC' k = go where ctx = skeinMACCtx k go = finalize ctx -- We can just call 'finalize' because of the way our -- implementation works. Basically, we accept ByteString -- of any length on both 'updateCtx' and 'finalize'. -- Calling just 'finalize' is more efficient. ---------------------------------------------------------------------- -- | Helper function to create 'initialCtx'. initialCtxSkein :: Storable internalCtx => CSize -> (Ptr internalCtx -> CSize -> IO CInt) -> (internalCtx -> externalCtx) -> externalCtx initialCtxSkein bits init_ mkCtx = U.unsafePerformIO $ alloca $ \ctx_ptr -> do check $ init_ ctx_ptr bits fmap mkCtx $ peek ctx_ptr -- | Helper function to create 'updateCtxSkein'. updateCtxSkein :: Storable internalCtx => (Ptr internalCtx -> Ptr Word8 -> CSize -> IO CInt) -> (externalCtx -> internalCtx) -> (internalCtx -> externalCtx) -> (externalCtx -> B.ByteString -> externalCtx) updateCtxSkein update unCtx mkCtx = \ctx bs -> U.unsafePerformIO $ BU.unsafeUseAsCStringLen bs $ \(bs_ptr, bs_len) -> with (unCtx ctx) $ \ctx_ptr -> do check $ update ctx_ptr (castPtr bs_ptr) (fromIntegral bs_len) fmap mkCtx $ peek ctx_ptr -- | Helper function to create 'finalize'. finalizeSkein :: Storable internalCtx => Int -> (Ptr internalCtx -> Ptr Word8 -> CSize -> IO CInt) -> (Ptr internalCtx -> Ptr Word8 -> IO CInt) -> (externalCtx -> internalCtx) -> (B.ByteString -> hash) -> (externalCtx -> B.ByteString -> hash) finalizeSkein hashLenBytes update final unCtx mkHash = \ctx bs -> U.unsafePerformIO $ with (unCtx ctx) $ \ctx_ptr -> do unless (B.null bs) $ BU.unsafeUseAsCStringLen bs $ \(bs_ptr, bs_len) -> check $ update ctx_ptr (castPtr bs_ptr) (fromIntegral bs_len) fmap mkHash $ BI.create hashLenBytes $ check . final ctx_ptr . castPtr -- | Helper function to create 'skeinMACCtx'. skeinMACCtxSkein :: Storable internalCtx => CSize -> (Ptr internalCtx -> CSize -> Word64 -> Ptr Word8 -> CSize -> IO CInt) -> (internalCtx -> externalCtx) -> (Key -> externalCtx) skeinMACCtxSkein bits initExt mkCtx = \key -> U.unsafePerformIO $ BU.unsafeUseAsCStringLen key $ \(key_ptr, key_len) -> alloca $ \ctx_ptr -> do check $ initExt ctx_ptr bits sKEIN_SEQUENTIAL (castPtr key_ptr) (fromIntegral key_len) fmap mkCtx $ peek ctx_ptr ---------------------------------------------------------------------- -- Skein-256 ---------------------------------------------------------------------- -- | Context of the Skein-256-128 hash function. newtype Skein_256_128_Ctx = S_256_128_Ctx {unS_256_128_Ctx :: Skein256Ctx} -- | Skein-256-128 hash. You probably want to use 'encode' to -- obtain a 128-bit (16-byte) 'B.ByteString'. May be used as a -- drop-in replacement for MD5. newtype Skein_256_128 = S_256_128 B.ByteString deriving (Eq, Ord) instance Serialize Skein_256_128 where put (S_256_128 bs) = putByteString bs get = fmap S_256_128 $ getByteString 16 instance Hash Skein_256_128_Ctx Skein_256_128 where outputLength = Tagged 128 blockLength = Tagged 256 initialCtx = initialCtxSkein 128 skein256Init S_256_128_Ctx updateCtx = updateCtxSkein skein256Update unS_256_128_Ctx S_256_128_Ctx finalize = finalizeSkein 16 skein256Update skein256Final unS_256_128_Ctx S_256_128 instance SkeinMAC Skein_256_128_Ctx where skeinMACCtx = skeinMACCtxSkein 128 skein256InitExt S_256_128_Ctx -- | Context of the Skein-256-160 hash function. newtype Skein_256_160_Ctx = S_256_160_Ctx {unS_256_160_Ctx :: Skein256Ctx} -- | Skein-256-160 hash. You probably want to use 'encode' to -- obtain a 160-bit (20-byte) 'B.ByteString'. May be used as a -- drop-in replacement for SHA-1. newtype Skein_256_160 = S_256_160 B.ByteString deriving (Eq, Ord) instance Serialize Skein_256_160 where put (S_256_160 bs) = putByteString bs get = fmap S_256_160 $ getByteString 20 instance Hash Skein_256_160_Ctx Skein_256_160 where outputLength = Tagged 160 blockLength = Tagged 256 initialCtx = initialCtxSkein 160 skein256Init S_256_160_Ctx updateCtx = updateCtxSkein skein256Update unS_256_160_Ctx S_256_160_Ctx finalize = finalizeSkein 20 skein256Update skein256Final unS_256_160_Ctx S_256_160 instance SkeinMAC Skein_256_160_Ctx where skeinMACCtx = skeinMACCtxSkein 160 skein256InitExt S_256_160_Ctx -- | Context of the Skein-256-224 hash function. newtype Skein_256_224_Ctx = S_256_224_Ctx {unS_256_224_Ctx :: Skein256Ctx} -- | Skein-256-224 hash. You probably want to use 'encode' to -- obtain a 224-bit (28-byte) 'B.ByteString'. May be used as a -- drop-in replacement for SHA-224. newtype Skein_256_224 = S_256_224 B.ByteString deriving (Eq, Ord) instance Serialize Skein_256_224 where put (S_256_224 bs) = putByteString bs get = fmap S_256_224 $ getByteString 28 instance Hash Skein_256_224_Ctx Skein_256_224 where outputLength = Tagged 224 blockLength = Tagged 256 initialCtx = initialCtxSkein 224 skein256Init S_256_224_Ctx updateCtx = updateCtxSkein skein256Update unS_256_224_Ctx S_256_224_Ctx finalize = finalizeSkein 28 skein256Update skein256Final unS_256_224_Ctx S_256_224 instance SkeinMAC Skein_256_224_Ctx where skeinMACCtx = skeinMACCtxSkein 224 skein256InitExt S_256_224_Ctx -- | Context of the Skein-256-256 hash function. newtype Skein_256_256_Ctx = S_256_256_Ctx {unS_256_256_Ctx :: Skein256Ctx} -- | Skein-256-256 hash. You probably want to use 'encode' to -- obtain a 256-bit (32-byte) 'B.ByteString'. Usually it's better -- to use 'Skein_512_256' (256 bits of output) or 'Skein_512_512' -- (512 bits of output). newtype Skein_256_256 = S_256_256 B.ByteString deriving (Eq, Ord) instance Serialize Skein_256_256 where put (S_256_256 bs) = putByteString bs get = fmap S_256_256 $ getByteString 32 instance Hash Skein_256_256_Ctx Skein_256_256 where outputLength = Tagged 256 blockLength = Tagged 256 initialCtx = initialCtxSkein 256 skein256Init S_256_256_Ctx updateCtx = updateCtxSkein skein256Update unS_256_256_Ctx S_256_256_Ctx finalize = finalizeSkein 32 skein256Update skein256Final unS_256_256_Ctx S_256_256 instance SkeinMAC Skein_256_256_Ctx where skeinMACCtx = skeinMACCtxSkein 256 skein256InitExt S_256_256_Ctx ---------------------------------------------------------------------- -- Skein-512 ---------------------------------------------------------------------- -- | Context of the Skein-512-128 hash function. newtype Skein_512_128_Ctx = S_512_128_Ctx {unS_512_128_Ctx :: Skein512Ctx} -- | Skein-512-128 hash. You probably want to use 'encode' to -- obtain a 128-bit (16-byte) 'B.ByteString'. May be used as a -- drop-in replacement for MD5. newtype Skein_512_128 = S_512_128 B.ByteString deriving (Eq, Ord) instance Serialize Skein_512_128 where put (S_512_128 bs) = putByteString bs get = fmap S_512_128 $ getByteString 16 instance Hash Skein_512_128_Ctx Skein_512_128 where outputLength = Tagged 128 blockLength = Tagged 512 initialCtx = initialCtxSkein 128 skein512Init S_512_128_Ctx updateCtx = updateCtxSkein skein512Update unS_512_128_Ctx S_512_128_Ctx finalize = finalizeSkein 16 skein512Update skein512Final unS_512_128_Ctx S_512_128 instance SkeinMAC Skein_512_128_Ctx where skeinMACCtx = skeinMACCtxSkein 128 skein512InitExt S_512_128_Ctx -- | Context of the Skein-512-160 hash function. newtype Skein_512_160_Ctx = S_512_160_Ctx {unS_512_160_Ctx :: Skein512Ctx} -- | Skein-512-160 hash. You probably want to use 'encode' to -- obtain a 160-bit (20-byte) 'B.ByteString'. May be used as a -- drop-in replacement for SHA-1. newtype Skein_512_160 = S_512_160 B.ByteString deriving (Eq, Ord) instance Serialize Skein_512_160 where put (S_512_160 bs) = putByteString bs get = fmap S_512_160 $ getByteString 20 instance Hash Skein_512_160_Ctx Skein_512_160 where outputLength = Tagged 160 blockLength = Tagged 512 initialCtx = initialCtxSkein 160 skein512Init S_512_160_Ctx updateCtx = updateCtxSkein skein512Update unS_512_160_Ctx S_512_160_Ctx finalize = finalizeSkein 20 skein512Update skein512Final unS_512_160_Ctx S_512_160 instance SkeinMAC Skein_512_160_Ctx where skeinMACCtx = skeinMACCtxSkein 160 skein512InitExt S_512_160_Ctx -- | Context of the Skein-512-224 hash function. newtype Skein_512_224_Ctx = S_512_224_Ctx {unS_512_224_Ctx :: Skein512Ctx} -- | Skein-512-224 hash. You probably want to use 'encode' to -- obtain a 224-bit (28-byte) 'B.ByteString'. May be used as a drop-in replacement for SHA-224. newtype Skein_512_224 = S_512_224 B.ByteString deriving (Eq, Ord) instance Serialize Skein_512_224 where put (S_512_224 bs) = putByteString bs get = fmap S_512_224 $ getByteString 28 instance Hash Skein_512_224_Ctx Skein_512_224 where outputLength = Tagged 224 blockLength = Tagged 512 initialCtx = initialCtxSkein 224 skein512Init S_512_224_Ctx updateCtx = updateCtxSkein skein512Update unS_512_224_Ctx S_512_224_Ctx finalize = finalizeSkein 28 skein512Update skein512Final unS_512_224_Ctx S_512_224 instance SkeinMAC Skein_512_224_Ctx where skeinMACCtx = skeinMACCtxSkein 224 skein512InitExt S_512_224_Ctx -- | Context of the Skein-512-256 hash function. newtype Skein_512_256_Ctx = S_512_256_Ctx {unS_512_256_Ctx :: Skein512Ctx} -- | Skein-512-256 hash. You probably want to use 'encode' to -- obtain a 256-bit (32-byte) 'B.ByteString'. newtype Skein_512_256 = S_512_256 B.ByteString deriving (Eq, Ord) instance Serialize Skein_512_256 where put (S_512_256 bs) = putByteString bs get = fmap S_512_256 $ getByteString 32 instance Hash Skein_512_256_Ctx Skein_512_256 where outputLength = Tagged 256 blockLength = Tagged 512 initialCtx = initialCtxSkein 256 skein512Init S_512_256_Ctx updateCtx = updateCtxSkein skein512Update unS_512_256_Ctx S_512_256_Ctx finalize = finalizeSkein 32 skein512Update skein512Final unS_512_256_Ctx S_512_256 instance SkeinMAC Skein_512_256_Ctx where skeinMACCtx = skeinMACCtxSkein 256 skein512InitExt S_512_256_Ctx -- | Context of the Skein-512-384 hash function. newtype Skein_512_384_Ctx = S_512_384_Ctx {unS_512_384_Ctx :: Skein512Ctx} -- | Skein-512-384 hash. You probably want to use 'encode' to -- obtain a 384-bit (48-byte) 'B.ByteString'. May be used as a -- drop-in replacement for SHA-384. newtype Skein_512_384 = S_512_384 B.ByteString deriving (Eq, Ord) instance Serialize Skein_512_384 where put (S_512_384 bs) = putByteString bs get = fmap S_512_384 $ getByteString 48 instance Hash Skein_512_384_Ctx Skein_512_384 where outputLength = Tagged 384 blockLength = Tagged 512 initialCtx = initialCtxSkein 384 skein512Init S_512_384_Ctx updateCtx = updateCtxSkein skein512Update unS_512_384_Ctx S_512_384_Ctx finalize = finalizeSkein 48 skein512Update skein512Final unS_512_384_Ctx S_512_384 instance SkeinMAC Skein_512_384_Ctx where skeinMACCtx = skeinMACCtxSkein 384 skein512InitExt S_512_384_Ctx -- | Context of the Skein-512-512 hash function. newtype Skein_512_512_Ctx = S_512_512_Ctx {unS_512_512_Ctx :: Skein512Ctx} -- | Skein-512-512 hash. You probably want to use 'encode' to -- obtain a 512-bit (64-byte) 'B.ByteString'. It's the main Skein -- hash function. May be used as a drop-in replacement for -- SHA-512 as well. newtype Skein_512_512 = S_512_512 B.ByteString deriving (Eq, Ord) instance Serialize Skein_512_512 where put (S_512_512 bs) = putByteString bs get = fmap S_512_512 $ getByteString 64 instance Hash Skein_512_512_Ctx Skein_512_512 where outputLength = Tagged 512 blockLength = Tagged 512 initialCtx = initialCtxSkein 512 skein512Init S_512_512_Ctx updateCtx = updateCtxSkein skein512Update unS_512_512_Ctx S_512_512_Ctx finalize = finalizeSkein 64 skein512Update skein512Final unS_512_512_Ctx S_512_512 instance SkeinMAC Skein_512_512_Ctx where skeinMACCtx = skeinMACCtxSkein 512 skein512InitExt S_512_512_Ctx ---------------------------------------------------------------------- -- Skein-1024 ---------------------------------------------------------------------- -- | Context of the Skein-1024-384 hash function. newtype Skein_1024_384_Ctx = S_1024_384_Ctx {unS_1024_384_Ctx :: Skein1024Ctx} -- | Skein-1024-384 hash. You probably want to use 'encode' to -- obtain a 384-bit (48-byte) 'B.ByteString'. May be used as a -- drop-in replacement for SHA-384. newtype Skein_1024_384 = S_1024_384 B.ByteString deriving (Eq, Ord) instance Serialize Skein_1024_384 where put (S_1024_384 bs) = putByteString bs get = fmap S_1024_384 $ getByteString 48 instance Hash Skein_1024_384_Ctx Skein_1024_384 where outputLength = Tagged 384 blockLength = Tagged 1024 initialCtx = initialCtxSkein 384 skein1024Init S_1024_384_Ctx updateCtx = updateCtxSkein skein1024Update unS_1024_384_Ctx S_1024_384_Ctx finalize = finalizeSkein 48 skein1024Update skein1024Final unS_1024_384_Ctx S_1024_384 instance SkeinMAC Skein_1024_384_Ctx where skeinMACCtx = skeinMACCtxSkein 384 skein1024InitExt S_1024_384_Ctx -- | Context of the Skein-1024-512 hash function. newtype Skein_1024_512_Ctx = S_1024_512_Ctx {unS_1024_512_Ctx :: Skein1024Ctx} -- | Skein-1024-512 hash. You probably want to use 'encode' to -- obtain a 512-bit (64-byte) 'B.ByteString'. May be used as a -- drop-in replacement for SHA-512. newtype Skein_1024_512 = S_1024_512 B.ByteString deriving (Eq, Ord) instance Serialize Skein_1024_512 where put (S_1024_512 bs) = putByteString bs get = fmap S_1024_512 $ getByteString 64 instance Hash Skein_1024_512_Ctx Skein_1024_512 where outputLength = Tagged 512 blockLength = Tagged 1024 initialCtx = initialCtxSkein 512 skein1024Init S_1024_512_Ctx updateCtx = updateCtxSkein skein1024Update unS_1024_512_Ctx S_1024_512_Ctx finalize = finalizeSkein 64 skein1024Update skein1024Final unS_1024_512_Ctx S_1024_512 instance SkeinMAC Skein_1024_512_Ctx where skeinMACCtx = skeinMACCtxSkein 512 skein1024InitExt S_1024_512_Ctx -- | Context of the Skein-1024-1024 hash function. newtype Skein_1024_1024_Ctx = S_1024_1024_Ctx {unS_1024_1024_Ctx :: Skein1024Ctx} -- | Skein-1024-1024 hash. You probably want to use 'encode' to -- obtain a 1024-bit (128-byte) 'B.ByteString'. This is the -- ultra-conservative variant. Even if some future attack -- managed to break Skein-512, it's quite likely that Skein-1024 -- would remain secure. newtype Skein_1024_1024 = S_1024_1024 B.ByteString deriving (Eq, Ord) instance Serialize Skein_1024_1024 where put (S_1024_1024 bs) = putByteString bs get = fmap S_1024_1024 $ getByteString 128 instance Hash Skein_1024_1024_Ctx Skein_1024_1024 where outputLength = Tagged 1024 blockLength = Tagged 1024 initialCtx = initialCtxSkein 1024 skein1024Init S_1024_1024_Ctx updateCtx = updateCtxSkein skein1024Update unS_1024_1024_Ctx S_1024_1024_Ctx finalize = finalizeSkein 128 skein1024Update skein1024Final unS_1024_1024_Ctx S_1024_1024 instance SkeinMAC Skein_1024_1024_Ctx where skeinMACCtx = skeinMACCtxSkein 1024 skein1024InitExt S_1024_1024_Ctx skein-1.0.9.4/src/Crypto/Skein/Internal.hsc0000644000000000000000000001342512641032067016563 0ustar0000000000000000{-# CFILES c_impl/reference/skein.c c_impl/reference/skein_block.c #-} ----------------------------------------------------------------------------- -- | -- Module : Crypto.Skein.Internal -- Copyright : (c) 2011 Felipe A. Lessa -- License : BSD3 (see LICENSE) -- -- Maintainer : felipe.lessa@gmail.com -- Stability : provisional -- Portability : portable (needs FFI) -- -- Basic wrappers around the C library. You shouldn't need to -- use these functions. Instead, use the high-level -- "Crypto.Skein" module. -- ----------------------------------------------------------------------------- module Crypto.Skein.Internal ( -- * Return codes sKEIN_SUCCESS , sKEIN_FAIL , sKEIN_BAD_HASHLEN , check -- * Skein-256 , Skein256Ctx(..) , skein256Init , skein256Update , skein256Final , skein256InitExt , skein256FinalPad , skein256Output -- * Skein-512 , Skein512Ctx(..) , skein512Init , skein512Update , skein512Final , skein512InitExt , skein512FinalPad , skein512Output -- * Skein-1024 , Skein1024Ctx(..) , skein1024Init , skein1024Update , skein1024Final , skein1024InitExt , skein1024FinalPad , skein1024Output -- * Misc constants , sKEIN_SEQUENTIAL ) where -- from base import Foreign import Foreign.C -- from bytestring import qualified Data.ByteString as B import qualified Data.ByteString.Internal as BI import qualified Data.ByteString.Unsafe as BU -- from this package #include "skein.h" sKEIN_SUCCESS, sKEIN_FAIL, sKEIN_BAD_HASHLEN :: CInt sKEIN_SUCCESS = #{const SKEIN_SUCCESS} sKEIN_FAIL = #{const SKEIN_FAIL} sKEIN_BAD_HASHLEN = #{const SKEIN_BAD_HASHLEN} -- | Throws exception if the function does not return -- successfully. check :: IO CInt -> IO () check act = do x <- act case () of () | x == sKEIN_SUCCESS -> return () | x == sKEIN_FAIL -> fail "Skein returned FAIL." | x == sKEIN_BAD_HASHLEN -> fail "Skein returned BAD_HASHLEN." | otherwise -> fail "Skein returned unknown code." newtype Skein256Ctx = S256Ctx {unS256Ctx :: B.ByteString} newtype Skein512Ctx = S512Ctx {unS512Ctx :: B.ByteString} newtype Skein1024Ctx = S1024Ctx {unS1024Ctx :: B.ByteString} size256Ctx, size512Ctx, size1024Ctx :: Int size256Ctx = #{size Skein_256_Ctxt_t} size512Ctx = #{size Skein_512_Ctxt_t} size1024Ctx = #{size Skein1024_Ctxt_t} instance Storable Skein256Ctx where sizeOf _ = size256Ctx alignment _ = 16 peek ptr = fmap S256Ctx $ BI.create size256Ctx $ \bptr -> BI.memcpy bptr (castPtr ptr) (fromIntegral size256Ctx) poke ptr (S256Ctx bs) = BU.unsafeUseAsCString bs $ \bs_ptr -> BI.memcpy (castPtr ptr) (castPtr bs_ptr) (fromIntegral size256Ctx) instance Storable Skein512Ctx where sizeOf _ = size512Ctx alignment _ = 16 peek ptr = fmap S512Ctx $ BI.create size512Ctx $ \bptr -> BI.memcpy bptr (castPtr ptr) (fromIntegral size512Ctx) poke ptr (S512Ctx bs) = BU.unsafeUseAsCString bs $ \bs_ptr -> BI.memcpy (castPtr ptr) (castPtr bs_ptr) (fromIntegral size512Ctx) instance Storable Skein1024Ctx where sizeOf _ = size1024Ctx alignment _ = 16 peek ptr = fmap S1024Ctx $ BI.create size1024Ctx $ \bptr -> BI.memcpy bptr (castPtr ptr) (fromIntegral size1024Ctx) poke ptr (S1024Ctx bs) = BU.unsafeUseAsCString bs $ \bs_ptr -> BI.memcpy (castPtr ptr) (castPtr bs_ptr) (fromIntegral size1024Ctx) foreign import ccall unsafe "skein.h Skein_256_Init" skein256Init :: Ptr Skein256Ctx -> CSize -> IO CInt foreign import ccall unsafe "skein.h Skein_512_Init" skein512Init :: Ptr Skein512Ctx -> CSize -> IO CInt foreign import ccall unsafe "skein.h Skein1024_Init" skein1024Init :: Ptr Skein1024Ctx -> CSize -> IO CInt foreign import ccall unsafe "skein.h Skein_256_Update" skein256Update :: Ptr Skein256Ctx -> Ptr Word8 -> CSize -> IO CInt foreign import ccall unsafe "skein.h Skein_512_Update" skein512Update :: Ptr Skein512Ctx -> Ptr Word8 -> CSize -> IO CInt foreign import ccall unsafe "skein.h Skein1024_Update" skein1024Update :: Ptr Skein1024Ctx -> Ptr Word8 -> CSize -> IO CInt foreign import ccall unsafe "skein.h Skein_256_Final" skein256Final :: Ptr Skein256Ctx -> Ptr Word8 -> IO CInt foreign import ccall unsafe "skein.h Skein_512_Final" skein512Final :: Ptr Skein512Ctx -> Ptr Word8 -> IO CInt foreign import ccall unsafe "skein.h Skein1024_Final" skein1024Final :: Ptr Skein1024Ctx -> Ptr Word8 -> IO CInt foreign import ccall unsafe "skein.h Skein_256_InitExt" skein256InitExt :: Ptr Skein256Ctx -> CSize -> Word64 -> Ptr Word8 -> CSize -> IO CInt foreign import ccall unsafe "skein.h Skein_512_InitExt" skein512InitExt :: Ptr Skein512Ctx -> CSize -> Word64 -> Ptr Word8 -> CSize -> IO CInt foreign import ccall unsafe "skein.h Skein1024_InitExt" skein1024InitExt :: Ptr Skein1024Ctx -> CSize -> Word64 -> Ptr Word8 -> CSize -> IO CInt foreign import ccall unsafe "skein.h Skein_256_Final_Pad" skein256FinalPad :: Ptr Skein256Ctx -> Ptr Word8 -> IO CInt foreign import ccall unsafe "skein.h Skein_512_Final_Pad" skein512FinalPad :: Ptr Skein512Ctx -> Ptr Word8 -> IO CInt foreign import ccall unsafe "skein.h Skein1024_Final_Pad" skein1024FinalPad :: Ptr Skein1024Ctx -> Ptr Word8 -> IO CInt foreign import ccall unsafe "skein.h Skein_256_Output" skein256Output :: Ptr Skein256Ctx -> Ptr Word8 -> IO CInt foreign import ccall unsafe "skein.h Skein_512_Output" skein512Output :: Ptr Skein512Ctx -> Ptr Word8 -> IO CInt foreign import ccall unsafe "skein.h Skein1024_Output" skein1024Output :: Ptr Skein1024Ctx -> Ptr Word8 -> IO CInt -- | Pass to @InitExt@ to get sequential processing. sKEIN_SEQUENTIAL :: Word64 sKEIN_SEQUENTIAL = 0 skein-1.0.9.4/c_impl/reference/skein.c0000644000000000000000000010425612641032067015651 0ustar0000000000000000/*********************************************************************** ** ** Implementation of the Skein hash function. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ************************************************************************/ #include /* get the memcpy/memset functions */ #include "skein.h" /* get the Skein API definitions */ /*****************************************************************/ /* External function to process blkCnt (nonzero) full block(s) of data. */ void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); /*****************************************************************/ /* Portable (i.e., slow) endianness conversion functions */ u64b_t Skein_Swap64(u64b_t w64) { /* instantiate the function body here */ static const u64b_t ONE = 1; /* use this to check endianness */ /* figure out endianness "on-the-fly" */ if (1 == ((u08b_t *) & ONE)[0]) return w64; /* little-endian is fast */ else return (( w64 & 0xFF) << 56) | /* big-endian is slow */ (((w64 >> 8) & 0xFF) << 48) | (((w64 >>16) & 0xFF) << 40) | (((w64 >>24) & 0xFF) << 32) | (((w64 >>32) & 0xFF) << 24) | (((w64 >>40) & 0xFF) << 16) | (((w64 >>48) & 0xFF) << 8) | (((w64 >>56) & 0xFF) ) ; } void Skein_Put64_LSB_First(u08b_t *dst,const u64b_t *src,size_t bCnt) { /* this version is fully portable (big-endian or little-endian), but slow */ size_t n; for (n=0;n>3] >> (8*(n&7))); } void Skein_Get64_LSB_First(u64b_t *dst,const u08b_t *src,size_t wCnt) { /* this version is fully portable (big-endian or little-endian), but slow */ size_t n; for (n=0;n<8*wCnt;n+=8) dst[n/8] = (((u64b_t) src[n ]) ) + (((u64b_t) src[n+1]) << 8) + (((u64b_t) src[n+2]) << 16) + (((u64b_t) src[n+3]) << 24) + (((u64b_t) src[n+4]) << 32) + (((u64b_t) src[n+5]) << 40) + (((u64b_t) src[n+6]) << 48) + (((u64b_t) src[n+7]) << 56) ; } /*****************************************************************/ /* 256-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein_256_Init(Skein_256_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN_256_STATE_BYTES]; u64b_t w[SKEIN_256_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); /* build/process config block for hashing */ ctx->h.hashBitLen = hashBitLen; /* output hash byte count */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein_256_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein_256_InitExt(Skein_256_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { uint_t i; union { u08b_t b[SKEIN_256_STATE_BYTES]; u64b_t w[SKEIN_256_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein_256_Update(ctx,key,keyBytes); /* hash the key */ Skein_256_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(256,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein_256_Update(Skein_256_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN_256_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN_256_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN_256_BLOCK_BYTES); Skein_256_Process_Block(ctx,ctx->b,1,SKEIN_256_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN_256_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN_256_BLOCK_BYTES; /* number of full blocks to process */ Skein_256_Process_Block(ctx,msg,n,SKEIN_256_BLOCK_BYTES); msgByteCnt -= n * SKEIN_256_BLOCK_BYTES; msg += n * SKEIN_256_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein_256_Final(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_256_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_256_BLOCK_BYTES) n = SKEIN_256_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_256_API_CodeSize(void) { return ((u08b_t *) Skein_256_API_CodeSize) - ((u08b_t *) Skein_256_Init); } #endif /*****************************************************************/ /* 512-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN_512_STATE_BYTES]; u64b_t w[SKEIN_512_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); /* build/process config block for hashing */ ctx->h.hashBitLen = hashBitLen; /* output hash byte count */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein_512_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein_512_InitExt(Skein_512_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { uint_t i; union { u08b_t b[SKEIN_512_STATE_BYTES]; u64b_t w[SKEIN_512_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein_512_Update(ctx,key,keyBytes); /* hash the key */ Skein_512_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(512,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein_512_Update(Skein_512_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN_512_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN_512_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN_512_BLOCK_BYTES); Skein_512_Process_Block(ctx,ctx->b,1,SKEIN_512_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN_512_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN_512_BLOCK_BYTES; /* number of full blocks to process */ Skein_512_Process_Block(ctx,msg,n,SKEIN_512_BLOCK_BYTES); msgByteCnt -= n * SKEIN_512_BLOCK_BYTES; msg += n * SKEIN_512_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein_512_Final(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_512_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate more output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_512_BLOCK_BYTES) n = SKEIN_512_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(512,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_512_API_CodeSize(void) { return ((u08b_t *) Skein_512_API_CodeSize) - ((u08b_t *) Skein_512_Init); } #endif /*****************************************************************/ /* 1024-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein1024_Init(Skein1024_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN1024_STATE_BYTES]; u64b_t w[SKEIN1024_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); /* build/process config block for hashing */ ctx->h.hashBitLen = hashBitLen; /* output hash byte count */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein1024_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein1024_InitExt(Skein1024_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { uint_t i; union { u08b_t b[SKEIN1024_STATE_BYTES]; u64b_t w[SKEIN1024_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein1024_Update(ctx,key,keyBytes); /* hash the key */ Skein1024_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(1024,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein1024_Update(Skein1024_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN1024_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN1024_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN1024_BLOCK_BYTES); Skein1024_Process_Block(ctx,ctx->b,1,SKEIN1024_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN1024_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN1024_BLOCK_BYTES; /* number of full blocks to process */ Skein1024_Process_Block(ctx,msg,n,SKEIN1024_BLOCK_BYTES); msgByteCnt -= n * SKEIN1024_BLOCK_BYTES; msg += n * SKEIN1024_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein1024_Final(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN1024_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN1024_BLOCK_BYTES) n = SKEIN1024_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(1024,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein1024_API_CodeSize(void) { return ((u08b_t *) Skein1024_API_CodeSize) - ((u08b_t *) Skein1024_Init); } #endif /**************** Functions to support MAC/tree hashing ***************/ /* (this code is identical for Optimized and Reference versions) */ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_256_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_512_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN1024_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } #if SKEIN_TREE_HASH /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein_256_Output(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_256_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_256_BLOCK_BYTES) n = SKEIN_256_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein_512_Output(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_512_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_512_BLOCK_BYTES) n = SKEIN_512_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein1024_Output(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN1024_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN1024_BLOCK_BYTES) n = SKEIN1024_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #endif skein-1.0.9.4/c_impl/reference/skein_block.c0000644000000000000000000004416412641032067017024 0ustar0000000000000000/*********************************************************************** ** ** Implementation of the Skein block functions. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ** Compile-time switches: ** ** SKEIN_USE_ASM -- set bits (256/512/1024) to select which ** versions use ASM code for block processing ** [default: use C for all block sizes] ** ************************************************************************/ #include #include "skein.h" /* 64-bit rotate left */ u64b_t RotL_64(u64b_t x,uint_t N) { return (x << (N & 63)) | (x >> ((64-N) & 63)); } #define BLK_BITS (WCNT*64) /* macro to perform a key injection (same for all block sizes) */ #define InjectKey(r) \ for (i=0;i < WCNT;i++) \ X[i] += ks[((r)+i) % (WCNT+1)]; \ X[WCNT-3] += ts[((r)+0) % 3]; \ X[WCNT-2] += ts[((r)+1) % 3]; \ X[WCNT-1] += (r); /* avoid slide attacks */ \ Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,X); void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C */ enum { WCNT = SKEIN_256_STATE_WORDS }; size_t i,r; u64b_t ts[3]; /* key schedule: tweak */ u64b_t ks[WCNT+1]; /* key schedule: chaining vars */ u64b_t X [WCNT]; /* local copy of context vars */ u64b_t w [WCNT]; /* local copy of input block */ Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ctx->h.T[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[WCNT] = SKEIN_KS_PARITY; for (i=0;i < WCNT; i++) { ks[i] = ctx->X[i]; ks[WCNT] ^= ctx->X[i]; /* compute overall parity */ } ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); for (i=0;i < WCNT; i++) /* do the first full key injection */ { X[i] = w[i] + ks[i]; } X[WCNT-3] += ts[0]; X[WCNT-2] += ts[1]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X); /* show starting state values */ for (r=1;r <= SKEIN_256_ROUNDS_TOTAL/8; r++) { /* unroll 8 rounds */ X[0] += X[1]; X[1] = RotL_64(X[1],R_256_0_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_256_0_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X); X[0] += X[3]; X[3] = RotL_64(X[3],R_256_1_0); X[3] ^= X[0]; X[2] += X[1]; X[1] = RotL_64(X[1],R_256_1_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X); X[0] += X[1]; X[1] = RotL_64(X[1],R_256_2_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_256_2_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X); X[0] += X[3]; X[3] = RotL_64(X[3],R_256_3_0); X[3] ^= X[0]; X[2] += X[1]; X[1] = RotL_64(X[1],R_256_3_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X); InjectKey(2*r-1); X[0] += X[1]; X[1] = RotL_64(X[1],R_256_4_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_256_4_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X); X[0] += X[3]; X[3] = RotL_64(X[3],R_256_5_0); X[3] ^= X[0]; X[2] += X[1]; X[1] = RotL_64(X[1],R_256_5_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X); X[0] += X[1]; X[1] = RotL_64(X[1],R_256_6_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_256_6_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X); X[0] += X[3]; X[3] = RotL_64(X[3],R_256_7_0); X[3] ^= X[0]; X[2] += X[1]; X[1] = RotL_64(X[1],R_256_7_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r ,X); InjectKey(2*r); } /* do the final "feedforward" xor, update context chaining vars */ for (i=0;i < WCNT;i++) ctx->X[i] = X[i] ^ w[i]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); Skein_Clear_First_Flag(ctx->h); /* clear the start bit */ blkPtr += SKEIN_256_BLOCK_BYTES; } while (--blkCnt); } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_256_Process_Block_CodeSize(void) { return ((u08b_t *) Skein_256_Process_Block_CodeSize) - ((u08b_t *) Skein_256_Process_Block); } uint_t Skein_256_Unroll_Cnt(void) { return 1; } #endif void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C */ enum { WCNT = SKEIN_512_STATE_WORDS }; size_t i,r; u64b_t ts[3]; /* key schedule: tweak */ u64b_t ks[WCNT+1]; /* key schedule: chaining vars */ u64b_t X [WCNT]; /* local copy of vars */ u64b_t w [WCNT]; /* local copy of input block */ Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ctx->h.T[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[WCNT] = SKEIN_KS_PARITY; for (i=0;i < WCNT; i++) { ks[i] = ctx->X[i]; ks[WCNT] ^= ctx->X[i]; /* compute overall parity */ } ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); for (i=0;i < WCNT; i++) /* do the first full key injection */ { X[i] = w[i] + ks[i]; } X[WCNT-3] += ts[0]; X[WCNT-2] += ts[1]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X); for (r=1;r <= SKEIN_512_ROUNDS_TOTAL/8; r++) { /* unroll 8 rounds */ X[0] += X[1]; X[1] = RotL_64(X[1],R_512_0_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_512_0_1); X[3] ^= X[2]; X[4] += X[5]; X[5] = RotL_64(X[5],R_512_0_2); X[5] ^= X[4]; X[6] += X[7]; X[7] = RotL_64(X[7],R_512_0_3); X[7] ^= X[6]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X); X[2] += X[1]; X[1] = RotL_64(X[1],R_512_1_0); X[1] ^= X[2]; X[4] += X[7]; X[7] = RotL_64(X[7],R_512_1_1); X[7] ^= X[4]; X[6] += X[5]; X[5] = RotL_64(X[5],R_512_1_2); X[5] ^= X[6]; X[0] += X[3]; X[3] = RotL_64(X[3],R_512_1_3); X[3] ^= X[0]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X); X[4] += X[1]; X[1] = RotL_64(X[1],R_512_2_0); X[1] ^= X[4]; X[6] += X[3]; X[3] = RotL_64(X[3],R_512_2_1); X[3] ^= X[6]; X[0] += X[5]; X[5] = RotL_64(X[5],R_512_2_2); X[5] ^= X[0]; X[2] += X[7]; X[7] = RotL_64(X[7],R_512_2_3); X[7] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X); X[6] += X[1]; X[1] = RotL_64(X[1],R_512_3_0); X[1] ^= X[6]; X[0] += X[7]; X[7] = RotL_64(X[7],R_512_3_1); X[7] ^= X[0]; X[2] += X[5]; X[5] = RotL_64(X[5],R_512_3_2); X[5] ^= X[2]; X[4] += X[3]; X[3] = RotL_64(X[3],R_512_3_3); X[3] ^= X[4]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X); InjectKey(2*r-1); X[0] += X[1]; X[1] = RotL_64(X[1],R_512_4_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_512_4_1); X[3] ^= X[2]; X[4] += X[5]; X[5] = RotL_64(X[5],R_512_4_2); X[5] ^= X[4]; X[6] += X[7]; X[7] = RotL_64(X[7],R_512_4_3); X[7] ^= X[6]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X); X[2] += X[1]; X[1] = RotL_64(X[1],R_512_5_0); X[1] ^= X[2]; X[4] += X[7]; X[7] = RotL_64(X[7],R_512_5_1); X[7] ^= X[4]; X[6] += X[5]; X[5] = RotL_64(X[5],R_512_5_2); X[5] ^= X[6]; X[0] += X[3]; X[3] = RotL_64(X[3],R_512_5_3); X[3] ^= X[0]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X); X[4] += X[1]; X[1] = RotL_64(X[1],R_512_6_0); X[1] ^= X[4]; X[6] += X[3]; X[3] = RotL_64(X[3],R_512_6_1); X[3] ^= X[6]; X[0] += X[5]; X[5] = RotL_64(X[5],R_512_6_2); X[5] ^= X[0]; X[2] += X[7]; X[7] = RotL_64(X[7],R_512_6_3); X[7] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X); X[6] += X[1]; X[1] = RotL_64(X[1],R_512_7_0); X[1] ^= X[6]; X[0] += X[7]; X[7] = RotL_64(X[7],R_512_7_1); X[7] ^= X[0]; X[2] += X[5]; X[5] = RotL_64(X[5],R_512_7_2); X[5] ^= X[2]; X[4] += X[3]; X[3] = RotL_64(X[3],R_512_7_3); X[3] ^= X[4]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r ,X); InjectKey(2*r); } /* do the final "feedforward" xor, update context chaining vars */ for (i=0;i < WCNT;i++) ctx->X[i] = X[i] ^ w[i]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); Skein_Clear_First_Flag(ctx->h); /* clear the start bit */ blkPtr += SKEIN_512_BLOCK_BYTES; } while (--blkCnt); } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_512_Process_Block_CodeSize(void) { return ((u08b_t *) Skein_512_Process_Block_CodeSize) - ((u08b_t *) Skein_512_Process_Block); } uint_t Skein_512_Unroll_Cnt(void) { return 1; } #endif void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C */ enum { WCNT = SKEIN1024_STATE_WORDS }; size_t i,r; u64b_t ts[3]; /* key schedule: tweak */ u64b_t ks[WCNT+1]; /* key schedule: chaining vars */ u64b_t X [WCNT]; /* local copy of vars */ u64b_t w [WCNT]; /* local copy of input block */ Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ctx->h.T[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[WCNT] = SKEIN_KS_PARITY; for (i=0;i < WCNT; i++) { ks[i] = ctx->X[i]; ks[WCNT] ^= ctx->X[i]; /* compute overall parity */ } ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); for (i=0;i < WCNT; i++) /* do the first full key injection */ { X[i] = w[i] + ks[i]; } X[WCNT-3] += ts[0]; X[WCNT-2] += ts[1]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X); /* show starting state values */ for (r=1;r <= SKEIN1024_ROUNDS_TOTAL/8; r++) { /* unroll 8 rounds */ X[ 0] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_0_0); X[ 1] ^= X[ 0]; X[ 2] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_0_1); X[ 3] ^= X[ 2]; X[ 4] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_0_2); X[ 5] ^= X[ 4]; X[ 6] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_0_3); X[ 7] ^= X[ 6]; X[ 8] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_0_4); X[ 9] ^= X[ 8]; X[10] += X[11]; X[11] = RotL_64(X[11],R1024_0_5); X[11] ^= X[10]; X[12] += X[13]; X[13] = RotL_64(X[13],R1024_0_6); X[13] ^= X[12]; X[14] += X[15]; X[15] = RotL_64(X[15],R1024_0_7); X[15] ^= X[14]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X); X[ 0] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_1_0); X[ 9] ^= X[ 0]; X[ 2] += X[13]; X[13] = RotL_64(X[13],R1024_1_1); X[13] ^= X[ 2]; X[ 6] += X[11]; X[11] = RotL_64(X[11],R1024_1_2); X[11] ^= X[ 6]; X[ 4] += X[15]; X[15] = RotL_64(X[15],R1024_1_3); X[15] ^= X[ 4]; X[10] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_1_4); X[ 7] ^= X[10]; X[12] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_1_5); X[ 3] ^= X[12]; X[14] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_1_6); X[ 5] ^= X[14]; X[ 8] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_1_7); X[ 1] ^= X[ 8]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X); X[ 0] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_2_0); X[ 7] ^= X[ 0]; X[ 2] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_2_1); X[ 5] ^= X[ 2]; X[ 4] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_2_2); X[ 3] ^= X[ 4]; X[ 6] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_2_3); X[ 1] ^= X[ 6]; X[12] += X[15]; X[15] = RotL_64(X[15],R1024_2_4); X[15] ^= X[12]; X[14] += X[13]; X[13] = RotL_64(X[13],R1024_2_5); X[13] ^= X[14]; X[ 8] += X[11]; X[11] = RotL_64(X[11],R1024_2_6); X[11] ^= X[ 8]; X[10] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_2_7); X[ 9] ^= X[10]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X); X[ 0] += X[15]; X[15] = RotL_64(X[15],R1024_3_0); X[15] ^= X[ 0]; X[ 2] += X[11]; X[11] = RotL_64(X[11],R1024_3_1); X[11] ^= X[ 2]; X[ 6] += X[13]; X[13] = RotL_64(X[13],R1024_3_2); X[13] ^= X[ 6]; X[ 4] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_3_3); X[ 9] ^= X[ 4]; X[14] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_3_4); X[ 1] ^= X[14]; X[ 8] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_3_5); X[ 5] ^= X[ 8]; X[10] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_3_6); X[ 3] ^= X[10]; X[12] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_3_7); X[ 7] ^= X[12]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X); InjectKey(2*r-1); X[ 0] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_4_0); X[ 1] ^= X[ 0]; X[ 2] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_4_1); X[ 3] ^= X[ 2]; X[ 4] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_4_2); X[ 5] ^= X[ 4]; X[ 6] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_4_3); X[ 7] ^= X[ 6]; X[ 8] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_4_4); X[ 9] ^= X[ 8]; X[10] += X[11]; X[11] = RotL_64(X[11],R1024_4_5); X[11] ^= X[10]; X[12] += X[13]; X[13] = RotL_64(X[13],R1024_4_6); X[13] ^= X[12]; X[14] += X[15]; X[15] = RotL_64(X[15],R1024_4_7); X[15] ^= X[14]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X); X[ 0] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_5_0); X[ 9] ^= X[ 0]; X[ 2] += X[13]; X[13] = RotL_64(X[13],R1024_5_1); X[13] ^= X[ 2]; X[ 6] += X[11]; X[11] = RotL_64(X[11],R1024_5_2); X[11] ^= X[ 6]; X[ 4] += X[15]; X[15] = RotL_64(X[15],R1024_5_3); X[15] ^= X[ 4]; X[10] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_5_4); X[ 7] ^= X[10]; X[12] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_5_5); X[ 3] ^= X[12]; X[14] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_5_6); X[ 5] ^= X[14]; X[ 8] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_5_7); X[ 1] ^= X[ 8]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X); X[ 0] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_6_0); X[ 7] ^= X[ 0]; X[ 2] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_6_1); X[ 5] ^= X[ 2]; X[ 4] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_6_2); X[ 3] ^= X[ 4]; X[ 6] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_6_3); X[ 1] ^= X[ 6]; X[12] += X[15]; X[15] = RotL_64(X[15],R1024_6_4); X[15] ^= X[12]; X[14] += X[13]; X[13] = RotL_64(X[13],R1024_6_5); X[13] ^= X[14]; X[ 8] += X[11]; X[11] = RotL_64(X[11],R1024_6_6); X[11] ^= X[ 8]; X[10] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_6_7); X[ 9] ^= X[10]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X); X[ 0] += X[15]; X[15] = RotL_64(X[15],R1024_7_0); X[15] ^= X[ 0]; X[ 2] += X[11]; X[11] = RotL_64(X[11],R1024_7_1); X[11] ^= X[ 2]; X[ 6] += X[13]; X[13] = RotL_64(X[13],R1024_7_2); X[13] ^= X[ 6]; X[ 4] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_7_3); X[ 9] ^= X[ 4]; X[14] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_7_4); X[ 1] ^= X[14]; X[ 8] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_7_5); X[ 5] ^= X[ 8]; X[10] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_7_6); X[ 3] ^= X[10]; X[12] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_7_7); X[ 7] ^= X[12]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r ,X); InjectKey(2*r); } /* do the final "feedforward" xor, update context chaining vars */ for (i=0;iX[i] = X[i] ^ w[i]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); Skein_Clear_First_Flag(ctx->h); /* clear the start bit */ blkPtr += SKEIN1024_BLOCK_BYTES; } while (--blkCnt); } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein1024_Process_Block_CodeSize(void) { return ((u08b_t *) Skein1024_Process_Block_CodeSize) - ((u08b_t *) Skein1024_Process_Block); } uint_t Skein1024_Unroll_Cnt(void) { return 1; } #endif skein-1.0.9.4/c_impl/optimized/skein.c0000644000000000000000000010531612641032067015715 0ustar0000000000000000/*********************************************************************** ** ** Implementation of the Skein hash function. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ************************************************************************/ #define SKEIN_PORT_CODE /* instantiate any code in skein_port.h */ #include /* get the memcpy/memset functions */ #include "skein.h" /* get the Skein API definitions */ #include "skein_iv.h" /* get precomputed IVs */ /*****************************************************************/ /* External function to process blkCnt (nonzero) full block(s) of data. */ void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); /*****************************************************************/ /* 256-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein_256_Init(Skein_256_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN_256_STATE_BYTES]; u64b_t w[SKEIN_256_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ switch (hashBitLen) { /* use pre-computed values, where available */ #ifndef SKEIN_NO_PRECOMP case 256: memcpy(ctx->X,SKEIN_256_IV_256,sizeof(ctx->X)); break; case 224: memcpy(ctx->X,SKEIN_256_IV_224,sizeof(ctx->X)); break; case 160: memcpy(ctx->X,SKEIN_256_IV_160,sizeof(ctx->X)); break; case 128: memcpy(ctx->X,SKEIN_256_IV_128,sizeof(ctx->X)); break; #endif default: /* here if there is no precomputed IV value available */ /* build/process the config block, type == CONFIG (could be precomputed) */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); memset(&cfg.w[3],0,sizeof(cfg) - 3*sizeof(cfg.w[0])); /* zero pad config block */ /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); break; } /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein_256_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein_256_InitExt(Skein_256_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { union { u08b_t b[SKEIN_256_STATE_BYTES]; u64b_t w[SKEIN_256_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein_256_Update(ctx,key,keyBytes); /* hash the key */ Skein_256_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ #if SKEIN_NEED_SWAP { uint_t i; for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } #endif } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(256,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash (default) */ ctx->h.bCnt = 0; /* buffer b[] starts out empty */ Skein_Start_New_Type(ctx,MSG); return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein_256_Update(Skein_256_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN_256_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN_256_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN_256_BLOCK_BYTES); Skein_256_Process_Block(ctx,ctx->b,1,SKEIN_256_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN_256_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN_256_BLOCK_BYTES; /* number of full blocks to process */ Skein_256_Process_Block(ctx,msg,n,SKEIN_256_BLOCK_BYTES); msgByteCnt -= n * SKEIN_256_BLOCK_BYTES; msg += n * SKEIN_256_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein_256_Final(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_256_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_256_BLOCK_BYTES) n = SKEIN_256_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_256_API_CodeSize(void) { return ((u08b_t *) Skein_256_API_CodeSize) - ((u08b_t *) Skein_256_Init); } #endif /*****************************************************************/ /* 512-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN_512_STATE_BYTES]; u64b_t w[SKEIN_512_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ switch (hashBitLen) { /* use pre-computed values, where available */ #ifndef SKEIN_NO_PRECOMP case 512: memcpy(ctx->X,SKEIN_512_IV_512,sizeof(ctx->X)); break; case 384: memcpy(ctx->X,SKEIN_512_IV_384,sizeof(ctx->X)); break; case 256: memcpy(ctx->X,SKEIN_512_IV_256,sizeof(ctx->X)); break; case 224: memcpy(ctx->X,SKEIN_512_IV_224,sizeof(ctx->X)); break; #endif default: /* here if there is no precomputed IV value available */ /* build/process the config block, type == CONFIG (could be precomputed) */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); memset(&cfg.w[3],0,sizeof(cfg) - 3*sizeof(cfg.w[0])); /* zero pad config block */ /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); break; } /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein_512_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein_512_InitExt(Skein_512_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { union { u08b_t b[SKEIN_512_STATE_BYTES]; u64b_t w[SKEIN_512_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein_512_Update(ctx,key,keyBytes); /* hash the key */ Skein_512_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ #if SKEIN_NEED_SWAP { uint_t i; for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } #endif } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(512,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash (default) */ ctx->h.bCnt = 0; /* buffer b[] starts out empty */ Skein_Start_New_Type(ctx,MSG); return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein_512_Update(Skein_512_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN_512_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN_512_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN_512_BLOCK_BYTES); Skein_512_Process_Block(ctx,ctx->b,1,SKEIN_512_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN_512_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN_512_BLOCK_BYTES; /* number of full blocks to process */ Skein_512_Process_Block(ctx,msg,n,SKEIN_512_BLOCK_BYTES); msgByteCnt -= n * SKEIN_512_BLOCK_BYTES; msg += n * SKEIN_512_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein_512_Final(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_512_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_512_BLOCK_BYTES) n = SKEIN_512_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(512,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_512_API_CodeSize(void) { return ((u08b_t *) Skein_512_API_CodeSize) - ((u08b_t *) Skein_512_Init); } #endif /*****************************************************************/ /* 1024-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein1024_Init(Skein1024_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN1024_STATE_BYTES]; u64b_t w[SKEIN1024_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ switch (hashBitLen) { /* use pre-computed values, where available */ #ifndef SKEIN_NO_PRECOMP case 512: memcpy(ctx->X,SKEIN1024_IV_512 ,sizeof(ctx->X)); break; case 384: memcpy(ctx->X,SKEIN1024_IV_384 ,sizeof(ctx->X)); break; case 1024: memcpy(ctx->X,SKEIN1024_IV_1024,sizeof(ctx->X)); break; #endif default: /* here if there is no precomputed IV value available */ /* build/process the config block, type == CONFIG (could be precomputed) */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); memset(&cfg.w[3],0,sizeof(cfg) - 3*sizeof(cfg.w[0])); /* zero pad config block */ /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); break; } /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein1024_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein1024_InitExt(Skein1024_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { union { u08b_t b[SKEIN1024_STATE_BYTES]; u64b_t w[SKEIN1024_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein1024_Update(ctx,key,keyBytes); /* hash the key */ Skein1024_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ #if SKEIN_NEED_SWAP { uint_t i; for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } #endif } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(1024,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash (default) */ ctx->h.bCnt = 0; /* buffer b[] starts out empty */ Skein_Start_New_Type(ctx,MSG); return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein1024_Update(Skein1024_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN1024_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN1024_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN1024_BLOCK_BYTES); Skein1024_Process_Block(ctx,ctx->b,1,SKEIN1024_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN1024_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN1024_BLOCK_BYTES; /* number of full blocks to process */ Skein1024_Process_Block(ctx,msg,n,SKEIN1024_BLOCK_BYTES); msgByteCnt -= n * SKEIN1024_BLOCK_BYTES; msg += n * SKEIN1024_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein1024_Final(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN1024_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN1024_BLOCK_BYTES) n = SKEIN1024_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(1024,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein1024_API_CodeSize(void) { return ((u08b_t *) Skein1024_API_CodeSize) - ((u08b_t *) Skein1024_Init); } #endif /**************** Functions to support MAC/tree hashing ***************/ /* (this code is identical for Optimized and Reference versions) */ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_256_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_512_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN1024_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } #if SKEIN_TREE_HASH /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein_256_Output(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_256_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_256_BLOCK_BYTES) n = SKEIN_256_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein_512_Output(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_512_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_512_BLOCK_BYTES) n = SKEIN_512_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein1024_Output(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN1024_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN1024_BLOCK_BYTES) n = SKEIN1024_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #endif skein-1.0.9.4/c_impl/optimized/skein_block.c0000644000000000000000000006437512641032067017100 0ustar0000000000000000/*********************************************************************** ** ** Implementation of the Skein block functions. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ** Compile-time switches: ** ** SKEIN_USE_ASM -- set bits (256/512/1024) to select which ** versions use ASM code for block processing ** [default: use C for all block sizes] ** ************************************************************************/ #include #include "skein.h" #ifndef SKEIN_USE_ASM #define SKEIN_USE_ASM (0) /* default is all C code (no ASM) */ #endif #ifndef SKEIN_LOOP #define SKEIN_LOOP 001 /* default: unroll 256 and 512, but not 1024 */ #endif #define BLK_BITS (WCNT*64) /* some useful definitions for code here */ #define KW_TWK_BASE (0) #define KW_KEY_BASE (3) #define ks (kw + KW_KEY_BASE) #define ts (kw + KW_TWK_BASE) #ifdef SKEIN_DEBUG #define DebugSaveTweak(ctx) { ctx->h.T[0] = ts[0]; ctx->h.T[1] = ts[1]; } #else #define DebugSaveTweak(ctx) #endif /***************************** Skein_256 ******************************/ #if !(SKEIN_USE_ASM & 256) void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C */ enum { WCNT = SKEIN_256_STATE_WORDS }; #undef RCNT #define RCNT (SKEIN_256_ROUNDS_TOTAL/8) #ifdef SKEIN_LOOP /* configure how much to unroll the loop */ #define SKEIN_UNROLL_256 (((SKEIN_LOOP)/100)%10) #else #define SKEIN_UNROLL_256 (0) #endif #if SKEIN_UNROLL_256 #if (RCNT % SKEIN_UNROLL_256) #error "Invalid SKEIN_UNROLL_256" /* sanity check on unroll count */ #endif size_t r; u64b_t kw[WCNT+4+RCNT*2]; /* key schedule words : chaining vars + tweak + "rotation"*/ #else u64b_t kw[WCNT+4]; /* key schedule words : chaining vars + tweak */ #endif u64b_t X0,X1,X2,X3; /* local copy of context vars, for speed */ u64b_t w [WCNT]; /* local copy of input block */ #ifdef SKEIN_DEBUG const u64b_t *Xptr[4]; /* use for debugging (help compiler put Xn in registers) */ Xptr[0] = &X0; Xptr[1] = &X1; Xptr[2] = &X2; Xptr[3] = &X3; #endif Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ts[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[0] = ctx->X[0]; ks[1] = ctx->X[1]; ks[2] = ctx->X[2]; ks[3] = ctx->X[3]; ks[4] = ks[0] ^ ks[1] ^ ks[2] ^ ks[3] ^ SKEIN_KS_PARITY; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ DebugSaveTweak(ctx); Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); X0 = w[0] + ks[0]; /* do the first full key injection */ X1 = w[1] + ks[1] + ts[0]; X2 = w[2] + ks[2] + ts[1]; X3 = w[3] + ks[3]; Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,Xptr); /* show starting state values */ blkPtr += SKEIN_256_BLOCK_BYTES; /* run the rounds */ #define Round256(p0,p1,p2,p3,ROT,rNum) \ X##p0 += X##p1; X##p1 = RotL_64(X##p1,ROT##_0); X##p1 ^= X##p0; \ X##p2 += X##p3; X##p3 = RotL_64(X##p3,ROT##_1); X##p3 ^= X##p2; \ #if SKEIN_UNROLL_256 == 0 #define R256(p0,p1,p2,p3,ROT,rNum) /* fully unrolled */ \ Round256(p0,p1,p2,p3,ROT,rNum) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,rNum,Xptr); #define I256(R) \ X0 += ks[((R)+1) % 5]; /* inject the key schedule value */ \ X1 += ks[((R)+2) % 5] + ts[((R)+1) % 3]; \ X2 += ks[((R)+3) % 5] + ts[((R)+2) % 3]; \ X3 += ks[((R)+4) % 5] + (R)+1; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); #else /* looping version */ #define R256(p0,p1,p2,p3,ROT,rNum) \ Round256(p0,p1,p2,p3,ROT,rNum) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,4*(r-1)+rNum,Xptr); #define I256(R) \ X0 += ks[r+(R)+0]; /* inject the key schedule value */ \ X1 += ks[r+(R)+1] + ts[r+(R)+0]; \ X2 += ks[r+(R)+2] + ts[r+(R)+1]; \ X3 += ks[r+(R)+3] + r+(R) ; \ ks[r + (R)+4 ] = ks[r+(R)-1]; /* rotate key schedule */\ ts[r + (R)+2 ] = ts[r+(R)-1]; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); for (r=1;r < 2*RCNT;r+=2*SKEIN_UNROLL_256) /* loop thru it */ #endif { #define R256_8_rounds(R) \ R256(0,1,2,3,R_256_0,8*(R) + 1); \ R256(0,3,2,1,R_256_1,8*(R) + 2); \ R256(0,1,2,3,R_256_2,8*(R) + 3); \ R256(0,3,2,1,R_256_3,8*(R) + 4); \ I256(2*(R)); \ R256(0,1,2,3,R_256_4,8*(R) + 5); \ R256(0,3,2,1,R_256_5,8*(R) + 6); \ R256(0,1,2,3,R_256_6,8*(R) + 7); \ R256(0,3,2,1,R_256_7,8*(R) + 8); \ I256(2*(R)+1); R256_8_rounds( 0); #define R256_Unroll_R(NN) ((SKEIN_UNROLL_256 == 0 && SKEIN_256_ROUNDS_TOTAL/8 > (NN)) || (SKEIN_UNROLL_256 > (NN))) #if R256_Unroll_R( 1) R256_8_rounds( 1); #endif #if R256_Unroll_R( 2) R256_8_rounds( 2); #endif #if R256_Unroll_R( 3) R256_8_rounds( 3); #endif #if R256_Unroll_R( 4) R256_8_rounds( 4); #endif #if R256_Unroll_R( 5) R256_8_rounds( 5); #endif #if R256_Unroll_R( 6) R256_8_rounds( 6); #endif #if R256_Unroll_R( 7) R256_8_rounds( 7); #endif #if R256_Unroll_R( 8) R256_8_rounds( 8); #endif #if R256_Unroll_R( 9) R256_8_rounds( 9); #endif #if R256_Unroll_R(10) R256_8_rounds(10); #endif #if R256_Unroll_R(11) R256_8_rounds(11); #endif #if R256_Unroll_R(12) R256_8_rounds(12); #endif #if R256_Unroll_R(13) R256_8_rounds(13); #endif #if R256_Unroll_R(14) R256_8_rounds(14); #endif #if (SKEIN_UNROLL_256 > 14) #error "need more unrolling in Skein_256_Process_Block" #endif } /* do the final "feedforward" xor, update context chaining vars */ ctx->X[0] = X0 ^ w[0]; ctx->X[1] = X1 ^ w[1]; ctx->X[2] = X2 ^ w[2]; ctx->X[3] = X3 ^ w[3]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); ts[1] &= ~SKEIN_T1_FLAG_FIRST; } while (--blkCnt); ctx->h.T[0] = ts[0]; ctx->h.T[1] = ts[1]; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_256_Process_Block_CodeSize(void) { return ((u08b_t *) Skein_256_Process_Block_CodeSize) - ((u08b_t *) Skein_256_Process_Block); } uint_t Skein_256_Unroll_Cnt(void) { return SKEIN_UNROLL_256; } #endif #endif /***************************** Skein_512 ******************************/ #if !(SKEIN_USE_ASM & 512) void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C */ enum { WCNT = SKEIN_512_STATE_WORDS }; #undef RCNT #define RCNT (SKEIN_512_ROUNDS_TOTAL/8) #ifdef SKEIN_LOOP /* configure how much to unroll the loop */ #define SKEIN_UNROLL_512 (((SKEIN_LOOP)/10)%10) #else #define SKEIN_UNROLL_512 (0) #endif #if SKEIN_UNROLL_512 #if (RCNT % SKEIN_UNROLL_512) #error "Invalid SKEIN_UNROLL_512" /* sanity check on unroll count */ #endif size_t r; u64b_t kw[WCNT+4+RCNT*2]; /* key schedule words : chaining vars + tweak + "rotation"*/ #else u64b_t kw[WCNT+4]; /* key schedule words : chaining vars + tweak */ #endif u64b_t X0,X1,X2,X3,X4,X5,X6,X7; /* local copy of vars, for speed */ u64b_t w [WCNT]; /* local copy of input block */ #ifdef SKEIN_DEBUG const u64b_t *Xptr[8]; /* use for debugging (help compiler put Xn in registers) */ Xptr[0] = &X0; Xptr[1] = &X1; Xptr[2] = &X2; Xptr[3] = &X3; Xptr[4] = &X4; Xptr[5] = &X5; Xptr[6] = &X6; Xptr[7] = &X7; #endif Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ts[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[0] = ctx->X[0]; ks[1] = ctx->X[1]; ks[2] = ctx->X[2]; ks[3] = ctx->X[3]; ks[4] = ctx->X[4]; ks[5] = ctx->X[5]; ks[6] = ctx->X[6]; ks[7] = ctx->X[7]; ks[8] = ks[0] ^ ks[1] ^ ks[2] ^ ks[3] ^ ks[4] ^ ks[5] ^ ks[6] ^ ks[7] ^ SKEIN_KS_PARITY; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ DebugSaveTweak(ctx); Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); X0 = w[0] + ks[0]; /* do the first full key injection */ X1 = w[1] + ks[1]; X2 = w[2] + ks[2]; X3 = w[3] + ks[3]; X4 = w[4] + ks[4]; X5 = w[5] + ks[5] + ts[0]; X6 = w[6] + ks[6] + ts[1]; X7 = w[7] + ks[7]; blkPtr += SKEIN_512_BLOCK_BYTES; Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,Xptr); /* run the rounds */ #define Round512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ X##p0 += X##p1; X##p1 = RotL_64(X##p1,ROT##_0); X##p1 ^= X##p0; \ X##p2 += X##p3; X##p3 = RotL_64(X##p3,ROT##_1); X##p3 ^= X##p2; \ X##p4 += X##p5; X##p5 = RotL_64(X##p5,ROT##_2); X##p5 ^= X##p4; \ X##p6 += X##p7; X##p7 = RotL_64(X##p7,ROT##_3); X##p7 ^= X##p6; \ #if SKEIN_UNROLL_512 == 0 #define R512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) /* unrolled */ \ Round512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,rNum,Xptr); #define I512(R) \ X0 += ks[((R)+1) % 9]; /* inject the key schedule value */ \ X1 += ks[((R)+2) % 9]; \ X2 += ks[((R)+3) % 9]; \ X3 += ks[((R)+4) % 9]; \ X4 += ks[((R)+5) % 9]; \ X5 += ks[((R)+6) % 9] + ts[((R)+1) % 3]; \ X6 += ks[((R)+7) % 9] + ts[((R)+2) % 3]; \ X7 += ks[((R)+8) % 9] + (R)+1; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); #else /* looping version */ #define R512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ Round512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,4*(r-1)+rNum,Xptr); #define I512(R) \ X0 += ks[r+(R)+0]; /* inject the key schedule value */ \ X1 += ks[r+(R)+1]; \ X2 += ks[r+(R)+2]; \ X3 += ks[r+(R)+3]; \ X4 += ks[r+(R)+4]; \ X5 += ks[r+(R)+5] + ts[r+(R)+0]; \ X6 += ks[r+(R)+6] + ts[r+(R)+1]; \ X7 += ks[r+(R)+7] + r+(R) ; \ ks[r + (R)+8] = ks[r+(R)-1]; /* rotate key schedule */ \ ts[r + (R)+2] = ts[r+(R)-1]; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); for (r=1;r < 2*RCNT;r+=2*SKEIN_UNROLL_512) /* loop thru it */ #endif /* end of looped code definitions */ { #define R512_8_rounds(R) /* do 8 full rounds */ \ R512(0,1,2,3,4,5,6,7,R_512_0,8*(R)+ 1); \ R512(2,1,4,7,6,5,0,3,R_512_1,8*(R)+ 2); \ R512(4,1,6,3,0,5,2,7,R_512_2,8*(R)+ 3); \ R512(6,1,0,7,2,5,4,3,R_512_3,8*(R)+ 4); \ I512(2*(R)); \ R512(0,1,2,3,4,5,6,7,R_512_4,8*(R)+ 5); \ R512(2,1,4,7,6,5,0,3,R_512_5,8*(R)+ 6); \ R512(4,1,6,3,0,5,2,7,R_512_6,8*(R)+ 7); \ R512(6,1,0,7,2,5,4,3,R_512_7,8*(R)+ 8); \ I512(2*(R)+1); /* and key injection */ R512_8_rounds( 0); #define R512_Unroll_R(NN) ((SKEIN_UNROLL_512 == 0 && SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || (SKEIN_UNROLL_512 > (NN))) #if R512_Unroll_R( 1) R512_8_rounds( 1); #endif #if R512_Unroll_R( 2) R512_8_rounds( 2); #endif #if R512_Unroll_R( 3) R512_8_rounds( 3); #endif #if R512_Unroll_R( 4) R512_8_rounds( 4); #endif #if R512_Unroll_R( 5) R512_8_rounds( 5); #endif #if R512_Unroll_R( 6) R512_8_rounds( 6); #endif #if R512_Unroll_R( 7) R512_8_rounds( 7); #endif #if R512_Unroll_R( 8) R512_8_rounds( 8); #endif #if R512_Unroll_R( 9) R512_8_rounds( 9); #endif #if R512_Unroll_R(10) R512_8_rounds(10); #endif #if R512_Unroll_R(11) R512_8_rounds(11); #endif #if R512_Unroll_R(12) R512_8_rounds(12); #endif #if R512_Unroll_R(13) R512_8_rounds(13); #endif #if R512_Unroll_R(14) R512_8_rounds(14); #endif #if (SKEIN_UNROLL_512 > 14) #error "need more unrolling in Skein_512_Process_Block" #endif } /* do the final "feedforward" xor, update context chaining vars */ ctx->X[0] = X0 ^ w[0]; ctx->X[1] = X1 ^ w[1]; ctx->X[2] = X2 ^ w[2]; ctx->X[3] = X3 ^ w[3]; ctx->X[4] = X4 ^ w[4]; ctx->X[5] = X5 ^ w[5]; ctx->X[6] = X6 ^ w[6]; ctx->X[7] = X7 ^ w[7]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); ts[1] &= ~SKEIN_T1_FLAG_FIRST; } while (--blkCnt); ctx->h.T[0] = ts[0]; ctx->h.T[1] = ts[1]; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_512_Process_Block_CodeSize(void) { return ((u08b_t *) Skein_512_Process_Block_CodeSize) - ((u08b_t *) Skein_512_Process_Block); } uint_t Skein_512_Unroll_Cnt(void) { return SKEIN_UNROLL_512; } #endif #endif /***************************** Skein1024 ******************************/ #if !(SKEIN_USE_ASM & 1024) void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C, always looping (unrolled is bigger AND slower!) */ enum { WCNT = SKEIN1024_STATE_WORDS }; #undef RCNT #define RCNT (SKEIN1024_ROUNDS_TOTAL/8) #ifdef SKEIN_LOOP /* configure how much to unroll the loop */ #define SKEIN_UNROLL_1024 ((SKEIN_LOOP)%10) #else #define SKEIN_UNROLL_1024 (0) #endif #if (SKEIN_UNROLL_1024 != 0) #if (RCNT % SKEIN_UNROLL_1024) #error "Invalid SKEIN_UNROLL_1024" /* sanity check on unroll count */ #endif size_t r; u64b_t kw[WCNT+4+RCNT*2]; /* key schedule words : chaining vars + tweak + "rotation"*/ #else u64b_t kw[WCNT+4]; /* key schedule words : chaining vars + tweak */ #endif u64b_t X00,X01,X02,X03,X04,X05,X06,X07, /* local copy of vars, for speed */ X08,X09,X10,X11,X12,X13,X14,X15; u64b_t w [WCNT]; /* local copy of input block */ #ifdef SKEIN_DEBUG const u64b_t *Xptr[16]; /* use for debugging (help compiler put Xn in registers) */ Xptr[ 0] = &X00; Xptr[ 1] = &X01; Xptr[ 2] = &X02; Xptr[ 3] = &X03; Xptr[ 4] = &X04; Xptr[ 5] = &X05; Xptr[ 6] = &X06; Xptr[ 7] = &X07; Xptr[ 8] = &X08; Xptr[ 9] = &X09; Xptr[10] = &X10; Xptr[11] = &X11; Xptr[12] = &X12; Xptr[13] = &X13; Xptr[14] = &X14; Xptr[15] = &X15; #endif Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ts[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[ 0] = ctx->X[ 0]; ks[ 1] = ctx->X[ 1]; ks[ 2] = ctx->X[ 2]; ks[ 3] = ctx->X[ 3]; ks[ 4] = ctx->X[ 4]; ks[ 5] = ctx->X[ 5]; ks[ 6] = ctx->X[ 6]; ks[ 7] = ctx->X[ 7]; ks[ 8] = ctx->X[ 8]; ks[ 9] = ctx->X[ 9]; ks[10] = ctx->X[10]; ks[11] = ctx->X[11]; ks[12] = ctx->X[12]; ks[13] = ctx->X[13]; ks[14] = ctx->X[14]; ks[15] = ctx->X[15]; ks[16] = ks[ 0] ^ ks[ 1] ^ ks[ 2] ^ ks[ 3] ^ ks[ 4] ^ ks[ 5] ^ ks[ 6] ^ ks[ 7] ^ ks[ 8] ^ ks[ 9] ^ ks[10] ^ ks[11] ^ ks[12] ^ ks[13] ^ ks[14] ^ ks[15] ^ SKEIN_KS_PARITY; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ DebugSaveTweak(ctx); Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); X00 = w[ 0] + ks[ 0]; /* do the first full key injection */ X01 = w[ 1] + ks[ 1]; X02 = w[ 2] + ks[ 2]; X03 = w[ 3] + ks[ 3]; X04 = w[ 4] + ks[ 4]; X05 = w[ 5] + ks[ 5]; X06 = w[ 6] + ks[ 6]; X07 = w[ 7] + ks[ 7]; X08 = w[ 8] + ks[ 8]; X09 = w[ 9] + ks[ 9]; X10 = w[10] + ks[10]; X11 = w[11] + ks[11]; X12 = w[12] + ks[12]; X13 = w[13] + ks[13] + ts[0]; X14 = w[14] + ks[14] + ts[1]; X15 = w[15] + ks[15]; Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,Xptr); #define Round1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rNum) \ X##p0 += X##p1; X##p1 = RotL_64(X##p1,ROT##_0); X##p1 ^= X##p0; \ X##p2 += X##p3; X##p3 = RotL_64(X##p3,ROT##_1); X##p3 ^= X##p2; \ X##p4 += X##p5; X##p5 = RotL_64(X##p5,ROT##_2); X##p5 ^= X##p4; \ X##p6 += X##p7; X##p7 = RotL_64(X##p7,ROT##_3); X##p7 ^= X##p6; \ X##p8 += X##p9; X##p9 = RotL_64(X##p9,ROT##_4); X##p9 ^= X##p8; \ X##pA += X##pB; X##pB = RotL_64(X##pB,ROT##_5); X##pB ^= X##pA; \ X##pC += X##pD; X##pD = RotL_64(X##pD,ROT##_6); X##pD ^= X##pC; \ X##pE += X##pF; X##pF = RotL_64(X##pF,ROT##_7); X##pF ^= X##pE; \ #if SKEIN_UNROLL_1024 == 0 #define R1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ Round1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,rn,Xptr); #define I1024(R) \ X00 += ks[((R)+ 1) % 17]; /* inject the key schedule value */ \ X01 += ks[((R)+ 2) % 17]; \ X02 += ks[((R)+ 3) % 17]; \ X03 += ks[((R)+ 4) % 17]; \ X04 += ks[((R)+ 5) % 17]; \ X05 += ks[((R)+ 6) % 17]; \ X06 += ks[((R)+ 7) % 17]; \ X07 += ks[((R)+ 8) % 17]; \ X08 += ks[((R)+ 9) % 17]; \ X09 += ks[((R)+10) % 17]; \ X10 += ks[((R)+11) % 17]; \ X11 += ks[((R)+12) % 17]; \ X12 += ks[((R)+13) % 17]; \ X13 += ks[((R)+14) % 17] + ts[((R)+1) % 3]; \ X14 += ks[((R)+15) % 17] + ts[((R)+2) % 3]; \ X15 += ks[((R)+16) % 17] + (R)+1; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); #else /* looping version */ #define R1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ Round1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,4*(r-1)+rn,Xptr); #define I1024(R) \ X00 += ks[r+(R)+ 0]; /* inject the key schedule value */ \ X01 += ks[r+(R)+ 1]; \ X02 += ks[r+(R)+ 2]; \ X03 += ks[r+(R)+ 3]; \ X04 += ks[r+(R)+ 4]; \ X05 += ks[r+(R)+ 5]; \ X06 += ks[r+(R)+ 6]; \ X07 += ks[r+(R)+ 7]; \ X08 += ks[r+(R)+ 8]; \ X09 += ks[r+(R)+ 9]; \ X10 += ks[r+(R)+10]; \ X11 += ks[r+(R)+11]; \ X12 += ks[r+(R)+12]; \ X13 += ks[r+(R)+13] + ts[r+(R)+0]; \ X14 += ks[r+(R)+14] + ts[r+(R)+1]; \ X15 += ks[r+(R)+15] + r+(R) ; \ ks[r + (R)+16] = ks[r+(R)-1]; /* rotate key schedule */ \ ts[r + (R)+ 2] = ts[r+(R)-1]; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); for (r=1;r <= 2*RCNT;r+=2*SKEIN_UNROLL_1024) /* loop thru it */ #endif { #define R1024_8_rounds(R) /* do 8 full rounds */ \ R1024(00,01,02,03,04,05,06,07,08,09,10,11,12,13,14,15,R1024_0,8*(R) + 1); \ R1024(00,09,02,13,06,11,04,15,10,07,12,03,14,05,08,01,R1024_1,8*(R) + 2); \ R1024(00,07,02,05,04,03,06,01,12,15,14,13,08,11,10,09,R1024_2,8*(R) + 3); \ R1024(00,15,02,11,06,13,04,09,14,01,08,05,10,03,12,07,R1024_3,8*(R) + 4); \ I1024(2*(R)); \ R1024(00,01,02,03,04,05,06,07,08,09,10,11,12,13,14,15,R1024_4,8*(R) + 5); \ R1024(00,09,02,13,06,11,04,15,10,07,12,03,14,05,08,01,R1024_5,8*(R) + 6); \ R1024(00,07,02,05,04,03,06,01,12,15,14,13,08,11,10,09,R1024_6,8*(R) + 7); \ R1024(00,15,02,11,06,13,04,09,14,01,08,05,10,03,12,07,R1024_7,8*(R) + 8); \ I1024(2*(R)+1); R1024_8_rounds( 0); #define R1024_Unroll_R(NN) ((SKEIN_UNROLL_1024 == 0 && SKEIN1024_ROUNDS_TOTAL/8 > (NN)) || (SKEIN_UNROLL_1024 > (NN))) #if R1024_Unroll_R( 1) R1024_8_rounds( 1); #endif #if R1024_Unroll_R( 2) R1024_8_rounds( 2); #endif #if R1024_Unroll_R( 3) R1024_8_rounds( 3); #endif #if R1024_Unroll_R( 4) R1024_8_rounds( 4); #endif #if R1024_Unroll_R( 5) R1024_8_rounds( 5); #endif #if R1024_Unroll_R( 6) R1024_8_rounds( 6); #endif #if R1024_Unroll_R( 7) R1024_8_rounds( 7); #endif #if R1024_Unroll_R( 8) R1024_8_rounds( 8); #endif #if R1024_Unroll_R( 9) R1024_8_rounds( 9); #endif #if R1024_Unroll_R(10) R1024_8_rounds(10); #endif #if R1024_Unroll_R(11) R1024_8_rounds(11); #endif #if R1024_Unroll_R(12) R1024_8_rounds(12); #endif #if R1024_Unroll_R(13) R1024_8_rounds(13); #endif #if R1024_Unroll_R(14) R1024_8_rounds(14); #endif #if (SKEIN_UNROLL_1024 > 14) #error "need more unrolling in Skein_1024_Process_Block" #endif } /* do the final "feedforward" xor, update context chaining vars */ ctx->X[ 0] = X00 ^ w[ 0]; ctx->X[ 1] = X01 ^ w[ 1]; ctx->X[ 2] = X02 ^ w[ 2]; ctx->X[ 3] = X03 ^ w[ 3]; ctx->X[ 4] = X04 ^ w[ 4]; ctx->X[ 5] = X05 ^ w[ 5]; ctx->X[ 6] = X06 ^ w[ 6]; ctx->X[ 7] = X07 ^ w[ 7]; ctx->X[ 8] = X08 ^ w[ 8]; ctx->X[ 9] = X09 ^ w[ 9]; ctx->X[10] = X10 ^ w[10]; ctx->X[11] = X11 ^ w[11]; ctx->X[12] = X12 ^ w[12]; ctx->X[13] = X13 ^ w[13]; ctx->X[14] = X14 ^ w[14]; ctx->X[15] = X15 ^ w[15]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); ts[1] &= ~SKEIN_T1_FLAG_FIRST; blkPtr += SKEIN1024_BLOCK_BYTES; } while (--blkCnt); ctx->h.T[0] = ts[0]; ctx->h.T[1] = ts[1]; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein1024_Process_Block_CodeSize(void) { return ((u08b_t *) Skein1024_Process_Block_CodeSize) - ((u08b_t *) Skein1024_Process_Block); } uint_t Skein1024_Unroll_Cnt(void) { return SKEIN_UNROLL_1024; } #endif #endif skein-1.0.9.4/tests/runtests.hs0000644000000000000000000001413512641032067014554 0ustar0000000000000000-- from base import Control.Applicative ((<$>)) import Control.Monad (forM_, unless) import Data.Char (isNumber) import Data.Maybe (catMaybes) import Text.Printf -- from bytestring import qualified Data.ByteString as B --import qualified Data.ByteString.Lazy as L -- from tagged import Data.Tagged (Tagged(..)) -- from crypto-api import Crypto.Classes -- from filepath import System.FilePath (()) -- from hspec import Test.Hspec -- from this package import Paths_skein (getDataFileName) import Crypto.Skein main :: IO () main = do skein_golden_kat_txt <- getDataFileName ("tests" "skein_golden_kat.txt") kats <- parseKats <$> readFile skein_golden_kat_txt putStrLn $ "Parsed " ++ show (length kats) ++ " known answer tests" hspec $ do describe "Skein golden known answer tests" $ do skeinKats kats (undefined :: Skein_512_512) skeinKats kats (undefined :: Skein_1024_1024) skeinKats kats (undefined :: Skein_256_256) skeinKats kats (undefined :: Skein_256_128) skeinKats kats (undefined :: Skein_256_160) skeinKats kats (undefined :: Skein_256_224) skeinKats kats (undefined :: Skein_512_128) skeinKats kats (undefined :: Skein_512_160) skeinKats kats (undefined :: Skein_512_224) skeinKats kats (undefined :: Skein_512_256) skeinKats kats (undefined :: Skein_512_384) skeinKats kats (undefined :: Skein_1024_384) skeinKats kats (undefined :: Skein_1024_512) readMsg :: Read a => String -> String -> a readMsg msg str = case readsPrec 0 str of [(r, "")] -> r _ -> error msg ---------------------------------------------------------------------- data Kat = Kat { skeinType :: SkeinType , message :: B.ByteString , macKey :: Maybe B.ByteString , result :: B.ByteString } data SkeinType = Skein !Int !Int deriving (Eq) instance Show SkeinType where show (Skein s o) = printf "Skein-%d-%d" s o parseKats :: String -> [Kat] parseKats = catMaybes . map parseKat . groupKats . lines . filter (/= '\r') groupKats :: [String] -> [[String]] groupKats = go [] where sep = "--------------------------------" go acc (x:xs) | x == sep = reverse acc : go [] xs | otherwise = go (x:acc) xs go [] [] = [] go (_:_) [] = error "groupKats: didn't find last separator" parseKat :: [String] -> Maybe Kat parseKat ("":xs) = parseKat xs parseKat (header:"":rest) = case (isTree header, parseMsgLen header, parseBlocks rest) of (_, msgLen, _) | msgLen `mod` 8 /= 0 -> Nothing (False, _, [Message msg, Result ret]) -> kat msg Nothing ret (False, _, [Message msg, MACKey mac, Result ret]) -> kat msg (Just mac) ret _ -> Nothing where kat msg mac ret = Just $ Kat (parseSkeinType header) msg mac ret parseKat _ = Nothing isTree :: String -> Bool isTree ('T':'r':'e':'e':':':_) = True isTree (_:xs) = isTree xs isTree [] = False parseMsgLen :: String -> Int parseMsgLen ('m':'s':'g':'L':'e':'n':' ':'=':xs) = readMsg "parseMsgLen" $ take 6 xs parseMsgLen (_:xs) = parseMsgLen xs parseMsgLen [] = error "parseMsgLen: didn't find msgLen" parseSkeinType :: String -> SkeinType parseSkeinType xs0 = let (":Skein", '-':xs1) = break (== '-') xs0 (stateS, xs2) = span isNumber xs1 (':':_, xs3) = break isNumber xs2 (outputS, _) = span isNumber xs3 in Skein (readMsg "stateS" stateS) (readMsg "outputS" outputS) data Block = Message B.ByteString | MACKey B.ByteString | Result B.ByteString block :: String -> B.ByteString -> Block block "Message data:" = Message block "Result:" = Result block ('M':'A':'C':_) = MACKey block x = error $ "block: unknown block type " ++ x parseBlocks :: [String] -> [Block] parseBlocks [] = [] parseBlocks (header:rest) | last header /= ':' = error "parseBlocks: something went wrong" | otherwise = let (data_, rest') = span ((== ' ') . head) rest in block header (parseData data_) : parseBlocks rest' parseData :: [String] -> B.ByteString parseData [' ':' ':' ':' ':'(':'n':'o':'n':'e':')':_] = B.empty parseData xs = B.pack $ map (readMsg "parseData" . ("0x"++)) $ concatMap words xs ---------------------------------------------------------------------- skeinKats :: (SkeinMAC skeinCtx, Hash skeinCtx digest) => [Kat] -> digest -> Spec skeinKats kats digest = let get t@(Tagged x) = x where f :: Tagged d a -> d f = undefined p = f t `asTypeOf` digest skeinType = Skein (get blockLength) (get outputLength) myHashKats = [(msg, ret) | Kat t msg Nothing ret <- kats, t == skeinType] myMacKats = [(msg, macKey, ret) | Kat t msg (Just macKey) ret <- kats, t == skeinType] lenHashKats = length myHashKats lenMacKats = length myMacKats testName = if lenHashKats + lenMacKats == 0 then printf "has no tests for %s =(" (show skeinType) else printf "works for %s (%d hash tests, %d MAC tests)" (show skeinType) lenHashKats lenMacKats in it testName $ do putStrLn "Testing hashes..." forM_ myHashKats $ \(msg, ret) -> do let myHash = hash' msg `asTypeOf` digest unless (encode myHash == ret) $ fail $ concat ["Message: ", show msg, "\nExpected: ", show ret, "\nCalculated: ", show (encode myHash)] putStrLn "Testing MACs..." forM_ myMacKats $ \(msg, macKey, ret) -> do let myMAC = skeinMAC' macKey msg `asTypeOf` digest unless (encode myMAC == ret) $ fail $ concat ["Message: ", show msg, "MAC Key: ", show macKey, "\nExpected: ", show ret, "\nCalculated: ", show (encode myMAC)] skein-1.0.9.4/LICENSE0000644000000000000000000000276112641032067012176 0ustar0000000000000000Copyright (c)2011, Felipe Lessa All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Felipe Lessa nor the names of other contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. skein-1.0.9.4/Setup.hs0000644000000000000000000000005612641032067012620 0ustar0000000000000000import Distribution.Simple main = defaultMain skein-1.0.9.4/skein.cabal0000644000000000000000000001014212641032106013250 0ustar0000000000000000Cabal-version: >= 1.8 Name: skein Version: 1.0.9.4 Synopsis: Skein, a family of cryptographic hash functions. Includes Skein-MAC as well. License: BSD3 License-file: LICENSE Author: Felipe Lessa , Doug Whiting Maintainer: Felipe Lessa Category: Cryptography Build-type: Simple Homepage: https://github.com/meteficha/skein Description: Skein () is a family of fast secure cryptographic hash functions designed by Niels Ferguson, Stefan Lucks, Bruce Schneier, Doug Whiting, Mihir Bellare, Tadayoshi Kohno, Jon Callas and Jesse Walker. . This package uses bindings to the optimized C implementation of Skein. We provide a high-level interface (see module "Crypto.Skein") to some of the Skein use cases. We also provide a low-level interface (see module "Crypto.Skein.Internal") should you need to use Skein in a different way. . Currently we have support for Skein as cryptographic hash function as Skein as a message authentication code (Skein-MAC). For examples of how to use this package, see "Crypto.Skein" module documentation. . This package includes Skein v1.3. Versions of this package before 1.0.0 implemented Skein v1.1. Extra-source-files: c_impl/optimized/brg_endian.h c_impl/optimized/skein.c c_impl/optimized/skein.h c_impl/optimized/skein_block.c c_impl/optimized/skein_debug.c c_impl/optimized/skein_debug.h c_impl/optimized/skein_iv.h c_impl/optimized/skein_port.h c_impl/reference/skein.c c_impl/reference/skein.h c_impl/reference/skein_block.c c_impl/reference/skein_debug.c c_impl/reference/skein_debug.h c_impl/reference/skein_port.h tests/runtests.hs tests/skein_golden_kat.txt Source-repository head Type: git Location: git://github.com/meteficha/skein.git Flag reference Description: Use the reference implementation instead of the optimized one. Default: False Flag force-endianness Description: Use a manually selected endian when compiling (see flag 'big-endian'). Default: False Flag big-endian Description: When manually selecting the endianness, use big-endian (default is little-endian). Default: False Library Hs-Source-Dirs: src Exposed-modules: Crypto.Skein Crypto.Skein.Internal Build-depends: base >= 3 && < 5, bytestring >= 0.9, cereal >= 0.3 && < 0.6, tagged >= 0.2 && < 0.9, crypto-api >= 0.6 && < 0.14 Build-tools: hsc2hs GHC-options: -Wall Extensions: BangPatterns CPP ForeignFunctionInterface MultiParamTypeClasses Includes: skein.h if flag(force-endianness) if flag(big-endian) CC-options: "-DSKEIN_NEED_SWAP=1" else CC-options: "-DSKEIN_NEED_SWAP=0" else if arch(i386) || arch(x86_64) CC-options: "-DSKEIN_NEED_SWAP=0" if arch(ppc) || arch(sparc) || arch(s390) || arch(hppa) CC-options: "-DSKEIN_NEED_SWAP=1" if flag(reference) Include-Dirs: c_impl/reference C-sources: c_impl/reference/skein.c c_impl/reference/skein_block.c -- c_impl/reference/skein_debug.c -- not used else Include-Dirs: c_impl/optimized C-sources: c_impl/optimized/skein.c c_impl/optimized/skein_block.c -- c_impl/optimized/skein_debug.c -- not used Test-suite runtests Type: exitcode-stdio-1.0 Build-depends: base >= 3 && < 5, bytestring >= 0.9, cereal >= 0.3 && < 0.6, tagged >= 0.2 && < 0.9, crypto-api >= 0.6 && < 0.14, filepath == 1.*, hspec >= 1.3, -- finally, our own package skein GHC-options: -Wall Hs-source-dirs: tests Main-is: runtests.hs Other-modules: Paths_skein skein-1.0.9.4/c_impl/optimized/brg_endian.h0000644000000000000000000001377512641032067016710 0ustar0000000000000000/* --------------------------------------------------------------------------- Copyright (c) 2003, Dr Brian Gladman, Worcester, UK. All rights reserved. LICENSE TERMS The free distribution and use of this software in both source and binary form is allowed (with or without changes) provided that: 1. distributions of this source code include the above copyright notice, this list of conditions and the following disclaimer; 2. distributions in binary form include the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other associated materials; 3. the copyright holder's name is not used to endorse products built using this software without specific written permission. ALTERNATIVELY, provided that this notice is retained in full, this product may be distributed under the terms of the GNU General Public License (GPL), in which case the provisions of the GPL apply INSTEAD OF those given above. DISCLAIMER This software is provided 'as is' with no explicit or implied warranties in respect of its properties, including, but not limited to, correctness and/or fitness for purpose. --------------------------------------------------------------------------- Issue 20/10/2006 */ #ifndef BRG_ENDIAN_H #define BRG_ENDIAN_H #define IS_BIG_ENDIAN 4321 /* byte 0 is most significant (mc68k) */ #define IS_LITTLE_ENDIAN 1234 /* byte 0 is least significant (i386) */ /* Include files where endian defines and byteswap functions may reside */ #if defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __NetBSD__ ) # include #elif defined( BSD ) && ( BSD >= 199103 ) || defined( __APPLE__ ) || \ defined( __CYGWIN32__ ) || defined( __DJGPP__ ) || defined( __osf__ ) # include #elif defined( __linux__ ) || defined( __GNUC__ ) || defined( __GNU_LIBRARY__ ) # if !defined( __MINGW32__ ) && !defined(AVR) # include # if !defined( __BEOS__ ) # include # endif # endif #endif /* Now attempt to set the define for platform byte order using any */ /* of the four forms SYMBOL, _SYMBOL, __SYMBOL & __SYMBOL__, which */ /* seem to encompass most endian symbol definitions */ #if defined( BIG_ENDIAN ) && defined( LITTLE_ENDIAN ) # if defined( BYTE_ORDER ) && BYTE_ORDER == BIG_ENDIAN # define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN # elif defined( BYTE_ORDER ) && BYTE_ORDER == LITTLE_ENDIAN # define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN # endif #elif defined( BIG_ENDIAN ) # define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN #elif defined( LITTLE_ENDIAN ) # define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN #endif #if defined( _BIG_ENDIAN ) && defined( _LITTLE_ENDIAN ) # if defined( _BYTE_ORDER ) && _BYTE_ORDER == _BIG_ENDIAN # define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN # elif defined( _BYTE_ORDER ) && _BYTE_ORDER == _LITTLE_ENDIAN # define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN # endif #elif defined( _BIG_ENDIAN ) # define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN #elif defined( _LITTLE_ENDIAN ) # define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN #endif #if defined( __BIG_ENDIAN ) && defined( __LITTLE_ENDIAN ) # if defined( __BYTE_ORDER ) && __BYTE_ORDER == __BIG_ENDIAN # define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN # elif defined( __BYTE_ORDER ) && __BYTE_ORDER == __LITTLE_ENDIAN # define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN # endif #elif defined( __BIG_ENDIAN ) # define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN #elif defined( __LITTLE_ENDIAN ) # define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN #endif #if defined( __BIG_ENDIAN__ ) && defined( __LITTLE_ENDIAN__ ) # if defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __BIG_ENDIAN__ # define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN # elif defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __LITTLE_ENDIAN__ # define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN # endif #elif defined( __BIG_ENDIAN__ ) # define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN #elif defined( __LITTLE_ENDIAN__ ) # define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN #endif /* if the platform byte order could not be determined, then try to */ /* set this define using common machine defines */ #if !defined(PLATFORM_BYTE_ORDER) #if defined( __alpha__ ) || defined( __alpha ) || defined( i386 ) || \ defined( __i386__ ) || defined( _M_I86 ) || defined( _M_IX86 ) || \ defined( __OS2__ ) || defined( sun386 ) || defined( __TURBOC__ ) || \ defined( vax ) || defined( vms ) || defined( VMS ) || \ defined( __VMS ) || defined( _M_X64 ) || defined( AVR ) # define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN #elif defined( AMIGA ) || defined( applec ) || defined( __AS400__ ) || \ defined( _CRAY ) || defined( __hppa ) || defined( __hp9000 ) || \ defined( ibm370 ) || defined( mc68000 ) || defined( m68k ) || \ defined( __MRC__ ) || defined( __MVS__ ) || defined( __MWERKS__ ) || \ defined( sparc ) || defined( __sparc) || defined( SYMANTEC_C ) || \ defined( __VOS__ ) || defined( __TIGCC__ ) || defined( __TANDEM ) || \ defined( THINK_C ) || defined( __VMCMS__ ) # define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN #elif 0 /* **** EDIT HERE IF NECESSARY **** */ # define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN #elif 0 /* **** EDIT HERE IF NECESSARY **** */ # define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN #else # error Please edit lines 126 or 128 in brg_endian.h to set the platform byte order #endif #endif /* special handler for IA64, which may be either endianness (?) */ /* here we assume little-endian, but this may need to be changed */ #if defined(__ia64) || defined(__ia64__) || defined(_M_IA64) # define PLATFORM_MUST_ALIGN (1) #ifndef PLATFORM_BYTE_ORDER # define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN #endif #endif #ifndef PLATFORM_MUST_ALIGN # define PLATFORM_MUST_ALIGN (0) #endif #endif /* ifndef BRG_ENDIAN_H */ skein-1.0.9.4/c_impl/optimized/skein.c0000644000000000000000000010531612641032067015715 0ustar0000000000000000/*********************************************************************** ** ** Implementation of the Skein hash function. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ************************************************************************/ #define SKEIN_PORT_CODE /* instantiate any code in skein_port.h */ #include /* get the memcpy/memset functions */ #include "skein.h" /* get the Skein API definitions */ #include "skein_iv.h" /* get precomputed IVs */ /*****************************************************************/ /* External function to process blkCnt (nonzero) full block(s) of data. */ void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); /*****************************************************************/ /* 256-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein_256_Init(Skein_256_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN_256_STATE_BYTES]; u64b_t w[SKEIN_256_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ switch (hashBitLen) { /* use pre-computed values, where available */ #ifndef SKEIN_NO_PRECOMP case 256: memcpy(ctx->X,SKEIN_256_IV_256,sizeof(ctx->X)); break; case 224: memcpy(ctx->X,SKEIN_256_IV_224,sizeof(ctx->X)); break; case 160: memcpy(ctx->X,SKEIN_256_IV_160,sizeof(ctx->X)); break; case 128: memcpy(ctx->X,SKEIN_256_IV_128,sizeof(ctx->X)); break; #endif default: /* here if there is no precomputed IV value available */ /* build/process the config block, type == CONFIG (could be precomputed) */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); memset(&cfg.w[3],0,sizeof(cfg) - 3*sizeof(cfg.w[0])); /* zero pad config block */ /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); break; } /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein_256_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein_256_InitExt(Skein_256_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { union { u08b_t b[SKEIN_256_STATE_BYTES]; u64b_t w[SKEIN_256_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein_256_Update(ctx,key,keyBytes); /* hash the key */ Skein_256_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ #if SKEIN_NEED_SWAP { uint_t i; for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } #endif } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(256,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash (default) */ ctx->h.bCnt = 0; /* buffer b[] starts out empty */ Skein_Start_New_Type(ctx,MSG); return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein_256_Update(Skein_256_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN_256_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN_256_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN_256_BLOCK_BYTES); Skein_256_Process_Block(ctx,ctx->b,1,SKEIN_256_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN_256_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN_256_BLOCK_BYTES; /* number of full blocks to process */ Skein_256_Process_Block(ctx,msg,n,SKEIN_256_BLOCK_BYTES); msgByteCnt -= n * SKEIN_256_BLOCK_BYTES; msg += n * SKEIN_256_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein_256_Final(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_256_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_256_BLOCK_BYTES) n = SKEIN_256_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_256_API_CodeSize(void) { return ((u08b_t *) Skein_256_API_CodeSize) - ((u08b_t *) Skein_256_Init); } #endif /*****************************************************************/ /* 512-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN_512_STATE_BYTES]; u64b_t w[SKEIN_512_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ switch (hashBitLen) { /* use pre-computed values, where available */ #ifndef SKEIN_NO_PRECOMP case 512: memcpy(ctx->X,SKEIN_512_IV_512,sizeof(ctx->X)); break; case 384: memcpy(ctx->X,SKEIN_512_IV_384,sizeof(ctx->X)); break; case 256: memcpy(ctx->X,SKEIN_512_IV_256,sizeof(ctx->X)); break; case 224: memcpy(ctx->X,SKEIN_512_IV_224,sizeof(ctx->X)); break; #endif default: /* here if there is no precomputed IV value available */ /* build/process the config block, type == CONFIG (could be precomputed) */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); memset(&cfg.w[3],0,sizeof(cfg) - 3*sizeof(cfg.w[0])); /* zero pad config block */ /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); break; } /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein_512_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein_512_InitExt(Skein_512_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { union { u08b_t b[SKEIN_512_STATE_BYTES]; u64b_t w[SKEIN_512_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein_512_Update(ctx,key,keyBytes); /* hash the key */ Skein_512_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ #if SKEIN_NEED_SWAP { uint_t i; for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } #endif } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(512,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash (default) */ ctx->h.bCnt = 0; /* buffer b[] starts out empty */ Skein_Start_New_Type(ctx,MSG); return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein_512_Update(Skein_512_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN_512_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN_512_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN_512_BLOCK_BYTES); Skein_512_Process_Block(ctx,ctx->b,1,SKEIN_512_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN_512_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN_512_BLOCK_BYTES; /* number of full blocks to process */ Skein_512_Process_Block(ctx,msg,n,SKEIN_512_BLOCK_BYTES); msgByteCnt -= n * SKEIN_512_BLOCK_BYTES; msg += n * SKEIN_512_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein_512_Final(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_512_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_512_BLOCK_BYTES) n = SKEIN_512_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(512,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_512_API_CodeSize(void) { return ((u08b_t *) Skein_512_API_CodeSize) - ((u08b_t *) Skein_512_Init); } #endif /*****************************************************************/ /* 1024-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein1024_Init(Skein1024_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN1024_STATE_BYTES]; u64b_t w[SKEIN1024_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ switch (hashBitLen) { /* use pre-computed values, where available */ #ifndef SKEIN_NO_PRECOMP case 512: memcpy(ctx->X,SKEIN1024_IV_512 ,sizeof(ctx->X)); break; case 384: memcpy(ctx->X,SKEIN1024_IV_384 ,sizeof(ctx->X)); break; case 1024: memcpy(ctx->X,SKEIN1024_IV_1024,sizeof(ctx->X)); break; #endif default: /* here if there is no precomputed IV value available */ /* build/process the config block, type == CONFIG (could be precomputed) */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); memset(&cfg.w[3],0,sizeof(cfg) - 3*sizeof(cfg.w[0])); /* zero pad config block */ /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); break; } /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein1024_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein1024_InitExt(Skein1024_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { union { u08b_t b[SKEIN1024_STATE_BYTES]; u64b_t w[SKEIN1024_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein1024_Update(ctx,key,keyBytes); /* hash the key */ Skein1024_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ #if SKEIN_NEED_SWAP { uint_t i; for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } #endif } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(1024,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash (default) */ ctx->h.bCnt = 0; /* buffer b[] starts out empty */ Skein_Start_New_Type(ctx,MSG); return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein1024_Update(Skein1024_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN1024_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN1024_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN1024_BLOCK_BYTES); Skein1024_Process_Block(ctx,ctx->b,1,SKEIN1024_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN1024_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN1024_BLOCK_BYTES; /* number of full blocks to process */ Skein1024_Process_Block(ctx,msg,n,SKEIN1024_BLOCK_BYTES); msgByteCnt -= n * SKEIN1024_BLOCK_BYTES; msg += n * SKEIN1024_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein1024_Final(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN1024_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN1024_BLOCK_BYTES) n = SKEIN1024_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(1024,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein1024_API_CodeSize(void) { return ((u08b_t *) Skein1024_API_CodeSize) - ((u08b_t *) Skein1024_Init); } #endif /**************** Functions to support MAC/tree hashing ***************/ /* (this code is identical for Optimized and Reference versions) */ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_256_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_512_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN1024_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } #if SKEIN_TREE_HASH /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein_256_Output(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_256_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_256_BLOCK_BYTES) n = SKEIN_256_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein_512_Output(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_512_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_512_BLOCK_BYTES) n = SKEIN_512_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein1024_Output(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN1024_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN1024_BLOCK_BYTES) n = SKEIN1024_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #endif skein-1.0.9.4/c_impl/optimized/skein.h0000644000000000000000000004024712641032067015723 0ustar0000000000000000#ifndef _SKEIN_H_ #define _SKEIN_H_ 1 /************************************************************************** ** ** Interface declarations and internal definitions for Skein hashing. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** *************************************************************************** ** ** The following compile-time switches may be defined to control some ** tradeoffs between speed, code size, error checking, and security. ** ** The "default" note explains what happens when the switch is not defined. ** ** SKEIN_DEBUG -- make callouts from inside Skein code ** to examine/display intermediate values. ** [default: no callouts (no overhead)] ** ** SKEIN_ERR_CHECK -- how error checking is handled inside Skein ** code. If not defined, most error checking ** is disabled (for performance). Otherwise, ** the switch value is interpreted as: ** 0: use assert() to flag errors ** 1: return SKEIN_FAIL to flag errors ** ***************************************************************************/ #ifdef __cplusplus extern "C" { #endif #include /* get size_t definition */ #include "skein_port.h" /* get platform-specific definitions */ enum { SKEIN_SUCCESS = 0, /* return codes from Skein calls */ SKEIN_FAIL = 1, SKEIN_BAD_HASHLEN = 2 }; #define SKEIN_MODIFIER_WORDS ( 2) /* number of modifier (tweak) words */ #define SKEIN_256_STATE_WORDS ( 4) #define SKEIN_512_STATE_WORDS ( 8) #define SKEIN1024_STATE_WORDS (16) #define SKEIN_MAX_STATE_WORDS (16) #define SKEIN_256_STATE_BYTES ( 8*SKEIN_256_STATE_WORDS) #define SKEIN_512_STATE_BYTES ( 8*SKEIN_512_STATE_WORDS) #define SKEIN1024_STATE_BYTES ( 8*SKEIN1024_STATE_WORDS) #define SKEIN_256_STATE_BITS (64*SKEIN_256_STATE_WORDS) #define SKEIN_512_STATE_BITS (64*SKEIN_512_STATE_WORDS) #define SKEIN1024_STATE_BITS (64*SKEIN1024_STATE_WORDS) #define SKEIN_256_BLOCK_BYTES ( 8*SKEIN_256_STATE_WORDS) #define SKEIN_512_BLOCK_BYTES ( 8*SKEIN_512_STATE_WORDS) #define SKEIN1024_BLOCK_BYTES ( 8*SKEIN1024_STATE_WORDS) typedef struct { size_t hashBitLen; /* size of hash result, in bits */ size_t bCnt; /* current byte count in buffer b[] */ u64b_t T[SKEIN_MODIFIER_WORDS]; /* tweak words: T[0]=byte cnt, T[1]=flags */ } Skein_Ctxt_Hdr_t; typedef struct /* 256-bit Skein hash context structure */ { Skein_Ctxt_Hdr_t h; /* common header context variables */ u64b_t X[SKEIN_256_STATE_WORDS]; /* chaining variables */ u08b_t b[SKEIN_256_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ } Skein_256_Ctxt_t; typedef struct /* 512-bit Skein hash context structure */ { Skein_Ctxt_Hdr_t h; /* common header context variables */ u64b_t X[SKEIN_512_STATE_WORDS]; /* chaining variables */ u08b_t b[SKEIN_512_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ } Skein_512_Ctxt_t; typedef struct /* 1024-bit Skein hash context structure */ { Skein_Ctxt_Hdr_t h; /* common header context variables */ u64b_t X[SKEIN1024_STATE_WORDS]; /* chaining variables */ u08b_t b[SKEIN1024_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ } Skein1024_Ctxt_t; /* Skein APIs for (incremental) "straight hashing" */ int Skein_256_Init (Skein_256_Ctxt_t *ctx, size_t hashBitLen); int Skein_512_Init (Skein_512_Ctxt_t *ctx, size_t hashBitLen); int Skein1024_Init (Skein1024_Ctxt_t *ctx, size_t hashBitLen); int Skein_256_Update(Skein_256_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); int Skein_512_Update(Skein_512_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); int Skein1024_Update(Skein1024_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); int Skein_256_Final (Skein_256_Ctxt_t *ctx, u08b_t * hashVal); int Skein_512_Final (Skein_512_Ctxt_t *ctx, u08b_t * hashVal); int Skein1024_Final (Skein1024_Ctxt_t *ctx, u08b_t * hashVal); /* ** Skein APIs for "extended" initialization: MAC keys, tree hashing. ** After an InitExt() call, just use Update/Final calls as with Init(). ** ** Notes: Same parameters as _Init() calls, plus treeInfo/key/keyBytes. ** When keyBytes == 0 and treeInfo == SKEIN_SEQUENTIAL, ** the results of InitExt() are identical to calling Init(). ** The function Init() may be called once to "precompute" the IV for ** a given hashBitLen value, then by saving a copy of the context ** the IV computation may be avoided in later calls. ** Similarly, the function InitExt() may be called once per MAC key ** to precompute the MAC IV, then a copy of the context saved and ** reused for each new MAC computation. **/ int Skein_256_InitExt(Skein_256_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *key, size_t keyBytes); int Skein_512_InitExt(Skein_512_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *key, size_t keyBytes); int Skein1024_InitExt(Skein1024_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *key, size_t keyBytes); /* ** Skein APIs for MAC and tree hash: ** Final_Pad: pad, do final block, but no OUTPUT type ** Output: do just the output stage */ int Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, u08b_t * hashVal); int Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, u08b_t * hashVal); int Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, u08b_t * hashVal); #ifndef SKEIN_TREE_HASH #define SKEIN_TREE_HASH (1) #endif #if SKEIN_TREE_HASH int Skein_256_Output (Skein_256_Ctxt_t *ctx, u08b_t * hashVal); int Skein_512_Output (Skein_512_Ctxt_t *ctx, u08b_t * hashVal); int Skein1024_Output (Skein1024_Ctxt_t *ctx, u08b_t * hashVal); #endif /***************************************************************** ** "Internal" Skein definitions ** -- not needed for sequential hashing API, but will be ** helpful for other uses of Skein (e.g., tree hash mode). ** -- included here so that they can be shared between ** reference and optimized code. ******************************************************************/ /* tweak word T[1]: bit field starting positions */ #define SKEIN_T1_BIT(BIT) ((BIT) - 64) /* offset 64 because it's the second word */ #define SKEIN_T1_POS_TREE_LVL SKEIN_T1_BIT(112) /* bits 112..118: level in hash tree */ #define SKEIN_T1_POS_BIT_PAD SKEIN_T1_BIT(119) /* bit 119 : partial final input byte */ #define SKEIN_T1_POS_BLK_TYPE SKEIN_T1_BIT(120) /* bits 120..125: type field */ #define SKEIN_T1_POS_FIRST SKEIN_T1_BIT(126) /* bits 126 : first block flag */ #define SKEIN_T1_POS_FINAL SKEIN_T1_BIT(127) /* bit 127 : final block flag */ /* tweak word T[1]: flag bit definition(s) */ #define SKEIN_T1_FLAG_FIRST (((u64b_t) 1 ) << SKEIN_T1_POS_FIRST) #define SKEIN_T1_FLAG_FINAL (((u64b_t) 1 ) << SKEIN_T1_POS_FINAL) #define SKEIN_T1_FLAG_BIT_PAD (((u64b_t) 1 ) << SKEIN_T1_POS_BIT_PAD) /* tweak word T[1]: tree level bit field mask */ #define SKEIN_T1_TREE_LVL_MASK (((u64b_t)0x7F) << SKEIN_T1_POS_TREE_LVL) #define SKEIN_T1_TREE_LEVEL(n) (((u64b_t) (n)) << SKEIN_T1_POS_TREE_LVL) /* tweak word T[1]: block type field */ #define SKEIN_BLK_TYPE_KEY ( 0) /* key, for MAC and KDF */ #define SKEIN_BLK_TYPE_CFG ( 4) /* configuration block */ #define SKEIN_BLK_TYPE_PERS ( 8) /* personalization string */ #define SKEIN_BLK_TYPE_PK (12) /* public key (for digital signature hashing) */ #define SKEIN_BLK_TYPE_KDF (16) /* key identifier for KDF */ #define SKEIN_BLK_TYPE_NONCE (20) /* nonce for PRNG */ #define SKEIN_BLK_TYPE_MSG (48) /* message processing */ #define SKEIN_BLK_TYPE_OUT (63) /* output stage */ #define SKEIN_BLK_TYPE_MASK (63) /* bit field mask */ #define SKEIN_T1_BLK_TYPE(T) (((u64b_t) (SKEIN_BLK_TYPE_##T)) << SKEIN_T1_POS_BLK_TYPE) #define SKEIN_T1_BLK_TYPE_KEY SKEIN_T1_BLK_TYPE(KEY) /* key, for MAC and KDF */ #define SKEIN_T1_BLK_TYPE_CFG SKEIN_T1_BLK_TYPE(CFG) /* configuration block */ #define SKEIN_T1_BLK_TYPE_PERS SKEIN_T1_BLK_TYPE(PERS) /* personalization string */ #define SKEIN_T1_BLK_TYPE_PK SKEIN_T1_BLK_TYPE(PK) /* public key (for digital signature hashing) */ #define SKEIN_T1_BLK_TYPE_KDF SKEIN_T1_BLK_TYPE(KDF) /* key identifier for KDF */ #define SKEIN_T1_BLK_TYPE_NONCE SKEIN_T1_BLK_TYPE(NONCE)/* nonce for PRNG */ #define SKEIN_T1_BLK_TYPE_MSG SKEIN_T1_BLK_TYPE(MSG) /* message processing */ #define SKEIN_T1_BLK_TYPE_OUT SKEIN_T1_BLK_TYPE(OUT) /* output stage */ #define SKEIN_T1_BLK_TYPE_MASK SKEIN_T1_BLK_TYPE(MASK) /* field bit mask */ #define SKEIN_T1_BLK_TYPE_CFG_FINAL (SKEIN_T1_BLK_TYPE_CFG | SKEIN_T1_FLAG_FINAL) #define SKEIN_T1_BLK_TYPE_OUT_FINAL (SKEIN_T1_BLK_TYPE_OUT | SKEIN_T1_FLAG_FINAL) #define SKEIN_VERSION (1) #ifndef SKEIN_ID_STRING_LE /* allow compile-time personalization */ #define SKEIN_ID_STRING_LE (0x33414853) /* "SHA3" (little-endian)*/ #endif #define SKEIN_MK_64(hi32,lo32) ((lo32) + (((u64b_t) (hi32)) << 32)) #define SKEIN_SCHEMA_VER SKEIN_MK_64(SKEIN_VERSION,SKEIN_ID_STRING_LE) #define SKEIN_KS_PARITY SKEIN_MK_64(0x1BD11BDA,0xA9FC1A22) #define SKEIN_CFG_STR_LEN (4*8) /* bit field definitions in config block treeInfo word */ #define SKEIN_CFG_TREE_LEAF_SIZE_POS ( 0) #define SKEIN_CFG_TREE_NODE_SIZE_POS ( 8) #define SKEIN_CFG_TREE_MAX_LEVEL_POS (16) #define SKEIN_CFG_TREE_LEAF_SIZE_MSK (((u64b_t) 0xFF) << SKEIN_CFG_TREE_LEAF_SIZE_POS) #define SKEIN_CFG_TREE_NODE_SIZE_MSK (((u64b_t) 0xFF) << SKEIN_CFG_TREE_NODE_SIZE_POS) #define SKEIN_CFG_TREE_MAX_LEVEL_MSK (((u64b_t) 0xFF) << SKEIN_CFG_TREE_MAX_LEVEL_POS) #define SKEIN_CFG_TREE_INFO(leaf,node,maxLvl) \ ( (((u64b_t)(leaf )) << SKEIN_CFG_TREE_LEAF_SIZE_POS) | \ (((u64b_t)(node )) << SKEIN_CFG_TREE_NODE_SIZE_POS) | \ (((u64b_t)(maxLvl)) << SKEIN_CFG_TREE_MAX_LEVEL_POS) ) #define SKEIN_CFG_TREE_INFO_SEQUENTIAL SKEIN_CFG_TREE_INFO(0,0,0) /* use as treeInfo in InitExt() call for sequential processing */ /* ** Skein macros for getting/setting tweak words, etc. ** These are useful for partial input bytes, hash tree init/update, etc. **/ #define Skein_Get_Tweak(ctxPtr,TWK_NUM) ((ctxPtr)->h.T[TWK_NUM]) #define Skein_Set_Tweak(ctxPtr,TWK_NUM,tVal) {(ctxPtr)->h.T[TWK_NUM] = (tVal);} #define Skein_Get_T0(ctxPtr) Skein_Get_Tweak(ctxPtr,0) #define Skein_Get_T1(ctxPtr) Skein_Get_Tweak(ctxPtr,1) #define Skein_Set_T0(ctxPtr,T0) Skein_Set_Tweak(ctxPtr,0,T0) #define Skein_Set_T1(ctxPtr,T1) Skein_Set_Tweak(ctxPtr,1,T1) /* set both tweak words at once */ #define Skein_Set_T0_T1(ctxPtr,T0,T1) \ { \ Skein_Set_T0(ctxPtr,(T0)); \ Skein_Set_T1(ctxPtr,(T1)); \ } #define Skein_Set_Type(ctxPtr,BLK_TYPE) \ Skein_Set_T1(ctxPtr,SKEIN_T1_BLK_TYPE_##BLK_TYPE) /* set up for starting with a new type: h.T[0]=0; h.T[1] = NEW_TYPE; h.bCnt=0; */ #define Skein_Start_New_Type(ctxPtr,BLK_TYPE) \ { Skein_Set_T0_T1(ctxPtr,0,SKEIN_T1_FLAG_FIRST | SKEIN_T1_BLK_TYPE_##BLK_TYPE); (ctxPtr)->h.bCnt=0; } #define Skein_Clear_First_Flag(hdr) { (hdr).T[1] &= ~SKEIN_T1_FLAG_FIRST; } #define Skein_Set_Bit_Pad_Flag(hdr) { (hdr).T[1] |= SKEIN_T1_FLAG_BIT_PAD; } #define Skein_Set_Tree_Level(hdr,height) { (hdr).T[1] |= SKEIN_T1_TREE_LEVEL(height);} /***************************************************************** ** "Internal" Skein definitions for debugging and error checking ******************************************************************/ #ifdef SKEIN_DEBUG /* examine/display intermediate values? */ #include "skein_debug.h" #else /* default is no callouts */ #define Skein_Show_Block(bits,ctx,X,blkPtr,wPtr,ksEvenPtr,ksOddPtr) #define Skein_Show_Round(bits,ctx,r,X) #define Skein_Show_R_Ptr(bits,ctx,r,X_ptr) #define Skein_Show_Final(bits,ctx,cnt,outPtr) #define Skein_Show_Key(bits,ctx,key,keyBytes) #endif #ifndef SKEIN_ERR_CHECK /* run-time checks (e.g., bad params, uninitialized context)? */ #define Skein_Assert(x,retCode)/* default: ignore all Asserts, for performance */ #define Skein_assert(x) #elif defined(SKEIN_ASSERT) #include #define Skein_Assert(x,retCode) assert(x) #define Skein_assert(x) assert(x) #else #include #define Skein_Assert(x,retCode) { if (!(x)) return retCode; } /* caller error */ #define Skein_assert(x) assert(x) /* internal error */ #endif /***************************************************************** ** Skein block function constants (shared across Ref and Opt code) ******************************************************************/ enum { /* Skein_256 round rotation constants */ R_256_0_0=14, R_256_0_1=16, R_256_1_0=52, R_256_1_1=57, R_256_2_0=23, R_256_2_1=40, R_256_3_0= 5, R_256_3_1=37, R_256_4_0=25, R_256_4_1=33, R_256_5_0=46, R_256_5_1=12, R_256_6_0=58, R_256_6_1=22, R_256_7_0=32, R_256_7_1=32, /* Skein_512 round rotation constants */ R_512_0_0=46, R_512_0_1=36, R_512_0_2=19, R_512_0_3=37, R_512_1_0=33, R_512_1_1=27, R_512_1_2=14, R_512_1_3=42, R_512_2_0=17, R_512_2_1=49, R_512_2_2=36, R_512_2_3=39, R_512_3_0=44, R_512_3_1= 9, R_512_3_2=54, R_512_3_3=56, R_512_4_0=39, R_512_4_1=30, R_512_4_2=34, R_512_4_3=24, R_512_5_0=13, R_512_5_1=50, R_512_5_2=10, R_512_5_3=17, R_512_6_0=25, R_512_6_1=29, R_512_6_2=39, R_512_6_3=43, R_512_7_0= 8, R_512_7_1=35, R_512_7_2=56, R_512_7_3=22, /* Skein1024 round rotation constants */ R1024_0_0=24, R1024_0_1=13, R1024_0_2= 8, R1024_0_3=47, R1024_0_4= 8, R1024_0_5=17, R1024_0_6=22, R1024_0_7=37, R1024_1_0=38, R1024_1_1=19, R1024_1_2=10, R1024_1_3=55, R1024_1_4=49, R1024_1_5=18, R1024_1_6=23, R1024_1_7=52, R1024_2_0=33, R1024_2_1= 4, R1024_2_2=51, R1024_2_3=13, R1024_2_4=34, R1024_2_5=41, R1024_2_6=59, R1024_2_7=17, R1024_3_0= 5, R1024_3_1=20, R1024_3_2=48, R1024_3_3=41, R1024_3_4=47, R1024_3_5=28, R1024_3_6=16, R1024_3_7=25, R1024_4_0=41, R1024_4_1= 9, R1024_4_2=37, R1024_4_3=31, R1024_4_4=12, R1024_4_5=47, R1024_4_6=44, R1024_4_7=30, R1024_5_0=16, R1024_5_1=34, R1024_5_2=56, R1024_5_3=51, R1024_5_4= 4, R1024_5_5=53, R1024_5_6=42, R1024_5_7=41, R1024_6_0=31, R1024_6_1=44, R1024_6_2=47, R1024_6_3=46, R1024_6_4=19, R1024_6_5=42, R1024_6_6=44, R1024_6_7=25, R1024_7_0= 9, R1024_7_1=48, R1024_7_2=35, R1024_7_3=52, R1024_7_4=23, R1024_7_5=31, R1024_7_6=37, R1024_7_7=20 }; #ifndef SKEIN_ROUNDS #define SKEIN_256_ROUNDS_TOTAL (72) /* number of rounds for the different block sizes */ #define SKEIN_512_ROUNDS_TOTAL (72) #define SKEIN1024_ROUNDS_TOTAL (80) #else /* allow command-line define in range 8*(5..14) */ #define SKEIN_256_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/100) + 5) % 10) + 5)) #define SKEIN_512_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/ 10) + 5) % 10) + 5)) #define SKEIN1024_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS ) + 5) % 10) + 5)) #endif #ifdef __cplusplus } #endif #endif /* ifndef _SKEIN_H_ */ skein-1.0.9.4/c_impl/optimized/skein_block.c0000644000000000000000000006437512641032067017100 0ustar0000000000000000/*********************************************************************** ** ** Implementation of the Skein block functions. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ** Compile-time switches: ** ** SKEIN_USE_ASM -- set bits (256/512/1024) to select which ** versions use ASM code for block processing ** [default: use C for all block sizes] ** ************************************************************************/ #include #include "skein.h" #ifndef SKEIN_USE_ASM #define SKEIN_USE_ASM (0) /* default is all C code (no ASM) */ #endif #ifndef SKEIN_LOOP #define SKEIN_LOOP 001 /* default: unroll 256 and 512, but not 1024 */ #endif #define BLK_BITS (WCNT*64) /* some useful definitions for code here */ #define KW_TWK_BASE (0) #define KW_KEY_BASE (3) #define ks (kw + KW_KEY_BASE) #define ts (kw + KW_TWK_BASE) #ifdef SKEIN_DEBUG #define DebugSaveTweak(ctx) { ctx->h.T[0] = ts[0]; ctx->h.T[1] = ts[1]; } #else #define DebugSaveTweak(ctx) #endif /***************************** Skein_256 ******************************/ #if !(SKEIN_USE_ASM & 256) void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C */ enum { WCNT = SKEIN_256_STATE_WORDS }; #undef RCNT #define RCNT (SKEIN_256_ROUNDS_TOTAL/8) #ifdef SKEIN_LOOP /* configure how much to unroll the loop */ #define SKEIN_UNROLL_256 (((SKEIN_LOOP)/100)%10) #else #define SKEIN_UNROLL_256 (0) #endif #if SKEIN_UNROLL_256 #if (RCNT % SKEIN_UNROLL_256) #error "Invalid SKEIN_UNROLL_256" /* sanity check on unroll count */ #endif size_t r; u64b_t kw[WCNT+4+RCNT*2]; /* key schedule words : chaining vars + tweak + "rotation"*/ #else u64b_t kw[WCNT+4]; /* key schedule words : chaining vars + tweak */ #endif u64b_t X0,X1,X2,X3; /* local copy of context vars, for speed */ u64b_t w [WCNT]; /* local copy of input block */ #ifdef SKEIN_DEBUG const u64b_t *Xptr[4]; /* use for debugging (help compiler put Xn in registers) */ Xptr[0] = &X0; Xptr[1] = &X1; Xptr[2] = &X2; Xptr[3] = &X3; #endif Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ts[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[0] = ctx->X[0]; ks[1] = ctx->X[1]; ks[2] = ctx->X[2]; ks[3] = ctx->X[3]; ks[4] = ks[0] ^ ks[1] ^ ks[2] ^ ks[3] ^ SKEIN_KS_PARITY; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ DebugSaveTweak(ctx); Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); X0 = w[0] + ks[0]; /* do the first full key injection */ X1 = w[1] + ks[1] + ts[0]; X2 = w[2] + ks[2] + ts[1]; X3 = w[3] + ks[3]; Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,Xptr); /* show starting state values */ blkPtr += SKEIN_256_BLOCK_BYTES; /* run the rounds */ #define Round256(p0,p1,p2,p3,ROT,rNum) \ X##p0 += X##p1; X##p1 = RotL_64(X##p1,ROT##_0); X##p1 ^= X##p0; \ X##p2 += X##p3; X##p3 = RotL_64(X##p3,ROT##_1); X##p3 ^= X##p2; \ #if SKEIN_UNROLL_256 == 0 #define R256(p0,p1,p2,p3,ROT,rNum) /* fully unrolled */ \ Round256(p0,p1,p2,p3,ROT,rNum) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,rNum,Xptr); #define I256(R) \ X0 += ks[((R)+1) % 5]; /* inject the key schedule value */ \ X1 += ks[((R)+2) % 5] + ts[((R)+1) % 3]; \ X2 += ks[((R)+3) % 5] + ts[((R)+2) % 3]; \ X3 += ks[((R)+4) % 5] + (R)+1; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); #else /* looping version */ #define R256(p0,p1,p2,p3,ROT,rNum) \ Round256(p0,p1,p2,p3,ROT,rNum) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,4*(r-1)+rNum,Xptr); #define I256(R) \ X0 += ks[r+(R)+0]; /* inject the key schedule value */ \ X1 += ks[r+(R)+1] + ts[r+(R)+0]; \ X2 += ks[r+(R)+2] + ts[r+(R)+1]; \ X3 += ks[r+(R)+3] + r+(R) ; \ ks[r + (R)+4 ] = ks[r+(R)-1]; /* rotate key schedule */\ ts[r + (R)+2 ] = ts[r+(R)-1]; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); for (r=1;r < 2*RCNT;r+=2*SKEIN_UNROLL_256) /* loop thru it */ #endif { #define R256_8_rounds(R) \ R256(0,1,2,3,R_256_0,8*(R) + 1); \ R256(0,3,2,1,R_256_1,8*(R) + 2); \ R256(0,1,2,3,R_256_2,8*(R) + 3); \ R256(0,3,2,1,R_256_3,8*(R) + 4); \ I256(2*(R)); \ R256(0,1,2,3,R_256_4,8*(R) + 5); \ R256(0,3,2,1,R_256_5,8*(R) + 6); \ R256(0,1,2,3,R_256_6,8*(R) + 7); \ R256(0,3,2,1,R_256_7,8*(R) + 8); \ I256(2*(R)+1); R256_8_rounds( 0); #define R256_Unroll_R(NN) ((SKEIN_UNROLL_256 == 0 && SKEIN_256_ROUNDS_TOTAL/8 > (NN)) || (SKEIN_UNROLL_256 > (NN))) #if R256_Unroll_R( 1) R256_8_rounds( 1); #endif #if R256_Unroll_R( 2) R256_8_rounds( 2); #endif #if R256_Unroll_R( 3) R256_8_rounds( 3); #endif #if R256_Unroll_R( 4) R256_8_rounds( 4); #endif #if R256_Unroll_R( 5) R256_8_rounds( 5); #endif #if R256_Unroll_R( 6) R256_8_rounds( 6); #endif #if R256_Unroll_R( 7) R256_8_rounds( 7); #endif #if R256_Unroll_R( 8) R256_8_rounds( 8); #endif #if R256_Unroll_R( 9) R256_8_rounds( 9); #endif #if R256_Unroll_R(10) R256_8_rounds(10); #endif #if R256_Unroll_R(11) R256_8_rounds(11); #endif #if R256_Unroll_R(12) R256_8_rounds(12); #endif #if R256_Unroll_R(13) R256_8_rounds(13); #endif #if R256_Unroll_R(14) R256_8_rounds(14); #endif #if (SKEIN_UNROLL_256 > 14) #error "need more unrolling in Skein_256_Process_Block" #endif } /* do the final "feedforward" xor, update context chaining vars */ ctx->X[0] = X0 ^ w[0]; ctx->X[1] = X1 ^ w[1]; ctx->X[2] = X2 ^ w[2]; ctx->X[3] = X3 ^ w[3]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); ts[1] &= ~SKEIN_T1_FLAG_FIRST; } while (--blkCnt); ctx->h.T[0] = ts[0]; ctx->h.T[1] = ts[1]; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_256_Process_Block_CodeSize(void) { return ((u08b_t *) Skein_256_Process_Block_CodeSize) - ((u08b_t *) Skein_256_Process_Block); } uint_t Skein_256_Unroll_Cnt(void) { return SKEIN_UNROLL_256; } #endif #endif /***************************** Skein_512 ******************************/ #if !(SKEIN_USE_ASM & 512) void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C */ enum { WCNT = SKEIN_512_STATE_WORDS }; #undef RCNT #define RCNT (SKEIN_512_ROUNDS_TOTAL/8) #ifdef SKEIN_LOOP /* configure how much to unroll the loop */ #define SKEIN_UNROLL_512 (((SKEIN_LOOP)/10)%10) #else #define SKEIN_UNROLL_512 (0) #endif #if SKEIN_UNROLL_512 #if (RCNT % SKEIN_UNROLL_512) #error "Invalid SKEIN_UNROLL_512" /* sanity check on unroll count */ #endif size_t r; u64b_t kw[WCNT+4+RCNT*2]; /* key schedule words : chaining vars + tweak + "rotation"*/ #else u64b_t kw[WCNT+4]; /* key schedule words : chaining vars + tweak */ #endif u64b_t X0,X1,X2,X3,X4,X5,X6,X7; /* local copy of vars, for speed */ u64b_t w [WCNT]; /* local copy of input block */ #ifdef SKEIN_DEBUG const u64b_t *Xptr[8]; /* use for debugging (help compiler put Xn in registers) */ Xptr[0] = &X0; Xptr[1] = &X1; Xptr[2] = &X2; Xptr[3] = &X3; Xptr[4] = &X4; Xptr[5] = &X5; Xptr[6] = &X6; Xptr[7] = &X7; #endif Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ts[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[0] = ctx->X[0]; ks[1] = ctx->X[1]; ks[2] = ctx->X[2]; ks[3] = ctx->X[3]; ks[4] = ctx->X[4]; ks[5] = ctx->X[5]; ks[6] = ctx->X[6]; ks[7] = ctx->X[7]; ks[8] = ks[0] ^ ks[1] ^ ks[2] ^ ks[3] ^ ks[4] ^ ks[5] ^ ks[6] ^ ks[7] ^ SKEIN_KS_PARITY; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ DebugSaveTweak(ctx); Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); X0 = w[0] + ks[0]; /* do the first full key injection */ X1 = w[1] + ks[1]; X2 = w[2] + ks[2]; X3 = w[3] + ks[3]; X4 = w[4] + ks[4]; X5 = w[5] + ks[5] + ts[0]; X6 = w[6] + ks[6] + ts[1]; X7 = w[7] + ks[7]; blkPtr += SKEIN_512_BLOCK_BYTES; Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,Xptr); /* run the rounds */ #define Round512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ X##p0 += X##p1; X##p1 = RotL_64(X##p1,ROT##_0); X##p1 ^= X##p0; \ X##p2 += X##p3; X##p3 = RotL_64(X##p3,ROT##_1); X##p3 ^= X##p2; \ X##p4 += X##p5; X##p5 = RotL_64(X##p5,ROT##_2); X##p5 ^= X##p4; \ X##p6 += X##p7; X##p7 = RotL_64(X##p7,ROT##_3); X##p7 ^= X##p6; \ #if SKEIN_UNROLL_512 == 0 #define R512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) /* unrolled */ \ Round512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,rNum,Xptr); #define I512(R) \ X0 += ks[((R)+1) % 9]; /* inject the key schedule value */ \ X1 += ks[((R)+2) % 9]; \ X2 += ks[((R)+3) % 9]; \ X3 += ks[((R)+4) % 9]; \ X4 += ks[((R)+5) % 9]; \ X5 += ks[((R)+6) % 9] + ts[((R)+1) % 3]; \ X6 += ks[((R)+7) % 9] + ts[((R)+2) % 3]; \ X7 += ks[((R)+8) % 9] + (R)+1; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); #else /* looping version */ #define R512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ Round512(p0,p1,p2,p3,p4,p5,p6,p7,ROT,rNum) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,4*(r-1)+rNum,Xptr); #define I512(R) \ X0 += ks[r+(R)+0]; /* inject the key schedule value */ \ X1 += ks[r+(R)+1]; \ X2 += ks[r+(R)+2]; \ X3 += ks[r+(R)+3]; \ X4 += ks[r+(R)+4]; \ X5 += ks[r+(R)+5] + ts[r+(R)+0]; \ X6 += ks[r+(R)+6] + ts[r+(R)+1]; \ X7 += ks[r+(R)+7] + r+(R) ; \ ks[r + (R)+8] = ks[r+(R)-1]; /* rotate key schedule */ \ ts[r + (R)+2] = ts[r+(R)-1]; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); for (r=1;r < 2*RCNT;r+=2*SKEIN_UNROLL_512) /* loop thru it */ #endif /* end of looped code definitions */ { #define R512_8_rounds(R) /* do 8 full rounds */ \ R512(0,1,2,3,4,5,6,7,R_512_0,8*(R)+ 1); \ R512(2,1,4,7,6,5,0,3,R_512_1,8*(R)+ 2); \ R512(4,1,6,3,0,5,2,7,R_512_2,8*(R)+ 3); \ R512(6,1,0,7,2,5,4,3,R_512_3,8*(R)+ 4); \ I512(2*(R)); \ R512(0,1,2,3,4,5,6,7,R_512_4,8*(R)+ 5); \ R512(2,1,4,7,6,5,0,3,R_512_5,8*(R)+ 6); \ R512(4,1,6,3,0,5,2,7,R_512_6,8*(R)+ 7); \ R512(6,1,0,7,2,5,4,3,R_512_7,8*(R)+ 8); \ I512(2*(R)+1); /* and key injection */ R512_8_rounds( 0); #define R512_Unroll_R(NN) ((SKEIN_UNROLL_512 == 0 && SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || (SKEIN_UNROLL_512 > (NN))) #if R512_Unroll_R( 1) R512_8_rounds( 1); #endif #if R512_Unroll_R( 2) R512_8_rounds( 2); #endif #if R512_Unroll_R( 3) R512_8_rounds( 3); #endif #if R512_Unroll_R( 4) R512_8_rounds( 4); #endif #if R512_Unroll_R( 5) R512_8_rounds( 5); #endif #if R512_Unroll_R( 6) R512_8_rounds( 6); #endif #if R512_Unroll_R( 7) R512_8_rounds( 7); #endif #if R512_Unroll_R( 8) R512_8_rounds( 8); #endif #if R512_Unroll_R( 9) R512_8_rounds( 9); #endif #if R512_Unroll_R(10) R512_8_rounds(10); #endif #if R512_Unroll_R(11) R512_8_rounds(11); #endif #if R512_Unroll_R(12) R512_8_rounds(12); #endif #if R512_Unroll_R(13) R512_8_rounds(13); #endif #if R512_Unroll_R(14) R512_8_rounds(14); #endif #if (SKEIN_UNROLL_512 > 14) #error "need more unrolling in Skein_512_Process_Block" #endif } /* do the final "feedforward" xor, update context chaining vars */ ctx->X[0] = X0 ^ w[0]; ctx->X[1] = X1 ^ w[1]; ctx->X[2] = X2 ^ w[2]; ctx->X[3] = X3 ^ w[3]; ctx->X[4] = X4 ^ w[4]; ctx->X[5] = X5 ^ w[5]; ctx->X[6] = X6 ^ w[6]; ctx->X[7] = X7 ^ w[7]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); ts[1] &= ~SKEIN_T1_FLAG_FIRST; } while (--blkCnt); ctx->h.T[0] = ts[0]; ctx->h.T[1] = ts[1]; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_512_Process_Block_CodeSize(void) { return ((u08b_t *) Skein_512_Process_Block_CodeSize) - ((u08b_t *) Skein_512_Process_Block); } uint_t Skein_512_Unroll_Cnt(void) { return SKEIN_UNROLL_512; } #endif #endif /***************************** Skein1024 ******************************/ #if !(SKEIN_USE_ASM & 1024) void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C, always looping (unrolled is bigger AND slower!) */ enum { WCNT = SKEIN1024_STATE_WORDS }; #undef RCNT #define RCNT (SKEIN1024_ROUNDS_TOTAL/8) #ifdef SKEIN_LOOP /* configure how much to unroll the loop */ #define SKEIN_UNROLL_1024 ((SKEIN_LOOP)%10) #else #define SKEIN_UNROLL_1024 (0) #endif #if (SKEIN_UNROLL_1024 != 0) #if (RCNT % SKEIN_UNROLL_1024) #error "Invalid SKEIN_UNROLL_1024" /* sanity check on unroll count */ #endif size_t r; u64b_t kw[WCNT+4+RCNT*2]; /* key schedule words : chaining vars + tweak + "rotation"*/ #else u64b_t kw[WCNT+4]; /* key schedule words : chaining vars + tweak */ #endif u64b_t X00,X01,X02,X03,X04,X05,X06,X07, /* local copy of vars, for speed */ X08,X09,X10,X11,X12,X13,X14,X15; u64b_t w [WCNT]; /* local copy of input block */ #ifdef SKEIN_DEBUG const u64b_t *Xptr[16]; /* use for debugging (help compiler put Xn in registers) */ Xptr[ 0] = &X00; Xptr[ 1] = &X01; Xptr[ 2] = &X02; Xptr[ 3] = &X03; Xptr[ 4] = &X04; Xptr[ 5] = &X05; Xptr[ 6] = &X06; Xptr[ 7] = &X07; Xptr[ 8] = &X08; Xptr[ 9] = &X09; Xptr[10] = &X10; Xptr[11] = &X11; Xptr[12] = &X12; Xptr[13] = &X13; Xptr[14] = &X14; Xptr[15] = &X15; #endif Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ts[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[ 0] = ctx->X[ 0]; ks[ 1] = ctx->X[ 1]; ks[ 2] = ctx->X[ 2]; ks[ 3] = ctx->X[ 3]; ks[ 4] = ctx->X[ 4]; ks[ 5] = ctx->X[ 5]; ks[ 6] = ctx->X[ 6]; ks[ 7] = ctx->X[ 7]; ks[ 8] = ctx->X[ 8]; ks[ 9] = ctx->X[ 9]; ks[10] = ctx->X[10]; ks[11] = ctx->X[11]; ks[12] = ctx->X[12]; ks[13] = ctx->X[13]; ks[14] = ctx->X[14]; ks[15] = ctx->X[15]; ks[16] = ks[ 0] ^ ks[ 1] ^ ks[ 2] ^ ks[ 3] ^ ks[ 4] ^ ks[ 5] ^ ks[ 6] ^ ks[ 7] ^ ks[ 8] ^ ks[ 9] ^ ks[10] ^ ks[11] ^ ks[12] ^ ks[13] ^ ks[14] ^ ks[15] ^ SKEIN_KS_PARITY; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ DebugSaveTweak(ctx); Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); X00 = w[ 0] + ks[ 0]; /* do the first full key injection */ X01 = w[ 1] + ks[ 1]; X02 = w[ 2] + ks[ 2]; X03 = w[ 3] + ks[ 3]; X04 = w[ 4] + ks[ 4]; X05 = w[ 5] + ks[ 5]; X06 = w[ 6] + ks[ 6]; X07 = w[ 7] + ks[ 7]; X08 = w[ 8] + ks[ 8]; X09 = w[ 9] + ks[ 9]; X10 = w[10] + ks[10]; X11 = w[11] + ks[11]; X12 = w[12] + ks[12]; X13 = w[13] + ks[13] + ts[0]; X14 = w[14] + ks[14] + ts[1]; X15 = w[15] + ks[15]; Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,Xptr); #define Round1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rNum) \ X##p0 += X##p1; X##p1 = RotL_64(X##p1,ROT##_0); X##p1 ^= X##p0; \ X##p2 += X##p3; X##p3 = RotL_64(X##p3,ROT##_1); X##p3 ^= X##p2; \ X##p4 += X##p5; X##p5 = RotL_64(X##p5,ROT##_2); X##p5 ^= X##p4; \ X##p6 += X##p7; X##p7 = RotL_64(X##p7,ROT##_3); X##p7 ^= X##p6; \ X##p8 += X##p9; X##p9 = RotL_64(X##p9,ROT##_4); X##p9 ^= X##p8; \ X##pA += X##pB; X##pB = RotL_64(X##pB,ROT##_5); X##pB ^= X##pA; \ X##pC += X##pD; X##pD = RotL_64(X##pD,ROT##_6); X##pD ^= X##pC; \ X##pE += X##pF; X##pF = RotL_64(X##pF,ROT##_7); X##pF ^= X##pE; \ #if SKEIN_UNROLL_1024 == 0 #define R1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ Round1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,rn,Xptr); #define I1024(R) \ X00 += ks[((R)+ 1) % 17]; /* inject the key schedule value */ \ X01 += ks[((R)+ 2) % 17]; \ X02 += ks[((R)+ 3) % 17]; \ X03 += ks[((R)+ 4) % 17]; \ X04 += ks[((R)+ 5) % 17]; \ X05 += ks[((R)+ 6) % 17]; \ X06 += ks[((R)+ 7) % 17]; \ X07 += ks[((R)+ 8) % 17]; \ X08 += ks[((R)+ 9) % 17]; \ X09 += ks[((R)+10) % 17]; \ X10 += ks[((R)+11) % 17]; \ X11 += ks[((R)+12) % 17]; \ X12 += ks[((R)+13) % 17]; \ X13 += ks[((R)+14) % 17] + ts[((R)+1) % 3]; \ X14 += ks[((R)+15) % 17] + ts[((R)+2) % 3]; \ X15 += ks[((R)+16) % 17] + (R)+1; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); #else /* looping version */ #define R1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ Round1024(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,pA,pB,pC,pD,pE,pF,ROT,rn) \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,4*(r-1)+rn,Xptr); #define I1024(R) \ X00 += ks[r+(R)+ 0]; /* inject the key schedule value */ \ X01 += ks[r+(R)+ 1]; \ X02 += ks[r+(R)+ 2]; \ X03 += ks[r+(R)+ 3]; \ X04 += ks[r+(R)+ 4]; \ X05 += ks[r+(R)+ 5]; \ X06 += ks[r+(R)+ 6]; \ X07 += ks[r+(R)+ 7]; \ X08 += ks[r+(R)+ 8]; \ X09 += ks[r+(R)+ 9]; \ X10 += ks[r+(R)+10]; \ X11 += ks[r+(R)+11]; \ X12 += ks[r+(R)+12]; \ X13 += ks[r+(R)+13] + ts[r+(R)+0]; \ X14 += ks[r+(R)+14] + ts[r+(R)+1]; \ X15 += ks[r+(R)+15] + r+(R) ; \ ks[r + (R)+16] = ks[r+(R)-1]; /* rotate key schedule */ \ ts[r + (R)+ 2] = ts[r+(R)-1]; \ Skein_Show_R_Ptr(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,Xptr); for (r=1;r <= 2*RCNT;r+=2*SKEIN_UNROLL_1024) /* loop thru it */ #endif { #define R1024_8_rounds(R) /* do 8 full rounds */ \ R1024(00,01,02,03,04,05,06,07,08,09,10,11,12,13,14,15,R1024_0,8*(R) + 1); \ R1024(00,09,02,13,06,11,04,15,10,07,12,03,14,05,08,01,R1024_1,8*(R) + 2); \ R1024(00,07,02,05,04,03,06,01,12,15,14,13,08,11,10,09,R1024_2,8*(R) + 3); \ R1024(00,15,02,11,06,13,04,09,14,01,08,05,10,03,12,07,R1024_3,8*(R) + 4); \ I1024(2*(R)); \ R1024(00,01,02,03,04,05,06,07,08,09,10,11,12,13,14,15,R1024_4,8*(R) + 5); \ R1024(00,09,02,13,06,11,04,15,10,07,12,03,14,05,08,01,R1024_5,8*(R) + 6); \ R1024(00,07,02,05,04,03,06,01,12,15,14,13,08,11,10,09,R1024_6,8*(R) + 7); \ R1024(00,15,02,11,06,13,04,09,14,01,08,05,10,03,12,07,R1024_7,8*(R) + 8); \ I1024(2*(R)+1); R1024_8_rounds( 0); #define R1024_Unroll_R(NN) ((SKEIN_UNROLL_1024 == 0 && SKEIN1024_ROUNDS_TOTAL/8 > (NN)) || (SKEIN_UNROLL_1024 > (NN))) #if R1024_Unroll_R( 1) R1024_8_rounds( 1); #endif #if R1024_Unroll_R( 2) R1024_8_rounds( 2); #endif #if R1024_Unroll_R( 3) R1024_8_rounds( 3); #endif #if R1024_Unroll_R( 4) R1024_8_rounds( 4); #endif #if R1024_Unroll_R( 5) R1024_8_rounds( 5); #endif #if R1024_Unroll_R( 6) R1024_8_rounds( 6); #endif #if R1024_Unroll_R( 7) R1024_8_rounds( 7); #endif #if R1024_Unroll_R( 8) R1024_8_rounds( 8); #endif #if R1024_Unroll_R( 9) R1024_8_rounds( 9); #endif #if R1024_Unroll_R(10) R1024_8_rounds(10); #endif #if R1024_Unroll_R(11) R1024_8_rounds(11); #endif #if R1024_Unroll_R(12) R1024_8_rounds(12); #endif #if R1024_Unroll_R(13) R1024_8_rounds(13); #endif #if R1024_Unroll_R(14) R1024_8_rounds(14); #endif #if (SKEIN_UNROLL_1024 > 14) #error "need more unrolling in Skein_1024_Process_Block" #endif } /* do the final "feedforward" xor, update context chaining vars */ ctx->X[ 0] = X00 ^ w[ 0]; ctx->X[ 1] = X01 ^ w[ 1]; ctx->X[ 2] = X02 ^ w[ 2]; ctx->X[ 3] = X03 ^ w[ 3]; ctx->X[ 4] = X04 ^ w[ 4]; ctx->X[ 5] = X05 ^ w[ 5]; ctx->X[ 6] = X06 ^ w[ 6]; ctx->X[ 7] = X07 ^ w[ 7]; ctx->X[ 8] = X08 ^ w[ 8]; ctx->X[ 9] = X09 ^ w[ 9]; ctx->X[10] = X10 ^ w[10]; ctx->X[11] = X11 ^ w[11]; ctx->X[12] = X12 ^ w[12]; ctx->X[13] = X13 ^ w[13]; ctx->X[14] = X14 ^ w[14]; ctx->X[15] = X15 ^ w[15]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); ts[1] &= ~SKEIN_T1_FLAG_FIRST; blkPtr += SKEIN1024_BLOCK_BYTES; } while (--blkCnt); ctx->h.T[0] = ts[0]; ctx->h.T[1] = ts[1]; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein1024_Process_Block_CodeSize(void) { return ((u08b_t *) Skein1024_Process_Block_CodeSize) - ((u08b_t *) Skein1024_Process_Block); } uint_t Skein1024_Unroll_Cnt(void) { return SKEIN_UNROLL_1024; } #endif #endif skein-1.0.9.4/c_impl/optimized/skein_debug.c0000644000000000000000000002211512641032067017056 0ustar0000000000000000/*********************************************************************** ** ** Debug output functions for Skein hashing. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ************************************************************************/ #include #ifdef SKEIN_DEBUG /* only instantiate this code if SKEIN_DEBUG is on */ #include "skein.h" static const char INDENT[] = " "; /* how much to indent on new line */ uint_t skein_DebugFlag = 0; /* off by default. Must be set externally */ static void Show64_step(size_t cnt,const u64b_t *X,size_t step) { size_t i,j; for (i=j=0;i < cnt;i++,j+=step) { if (i % 4 == 0) printf(INDENT); printf(" %08X.%08X ",(uint_32t)(X[j] >> 32),(uint_32t)X[j]); if (i % 4 == 3 || i==cnt-1) printf("\n"); fflush(stdout); } } #define Show64(cnt,X) Show64_step(cnt,X,1) static void Show64_flag(size_t cnt,const u64b_t *X) { size_t xptr = (size_t) X; size_t step = (xptr & 1) ? 2 : 1; if (step != 1) { X = (const u64b_t *) (xptr & ~1); } Show64_step(cnt,X,step); } static void Show08(size_t cnt,const u08b_t *b) { size_t i; for (i=0;i < cnt;i++) { if (i %16 == 0) printf(INDENT); else if (i % 4 == 0) printf(" "); printf(" %02X",b[i]); if (i %16 == 15 || i==cnt-1) printf("\n"); fflush(stdout); } } static const char *AlgoHeader(uint_t bits) { if (skein_DebugFlag & SKEIN_DEBUG_THREEFISH) switch (bits) { case 256: return ":Threefish-256: "; case 512: return ":Threefish-512: "; case 1024: return ":Threefish-1024:"; } else switch (bits) { case 256: return ":Skein-256: "; case 512: return ":Skein-512: "; case 1024: return ":Skein-1024:"; } return NULL; } void Skein_Show_Final(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t cnt,const u08b_t *outPtr) { if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) if (skein_DebugFlag & SKEIN_DEBUG_FINAL) { printf("\n%s Final output=\n",AlgoHeader(bits)); Show08(cnt,outPtr); printf(" ++++++++++\n"); fflush(stdout); } } /* show state after a round (or "pseudo-round") */ void Skein_Show_Round(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X) { static uint_t injectNum=0; /* not multi-thread safe! */ if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) if (skein_DebugFlag) { if (r >= SKEIN_RND_SPECIAL) { /* a key injection (or feedforward) point */ injectNum = (r == SKEIN_RND_KEY_INITIAL) ? 0 : injectNum+1; if ( skein_DebugFlag & SKEIN_DEBUG_INJECT || ((skein_DebugFlag & SKEIN_DEBUG_FINAL) && r == SKEIN_RND_FEED_FWD)) { printf("\n%s",AlgoHeader(bits)); switch (r) { case SKEIN_RND_KEY_INITIAL: printf(" [state after initial key injection]"); break; case SKEIN_RND_KEY_INJECT: printf(" [state after key injection #%02d]",injectNum); break; case SKEIN_RND_FEED_FWD: printf(" [state after plaintext feedforward]"); injectNum = 0; break; } printf("=\n"); Show64(bits/64,X); if (r== SKEIN_RND_FEED_FWD) printf(" ----------\n"); } } else if (skein_DebugFlag & SKEIN_DEBUG_ROUNDS) { uint_t j; u64b_t p[SKEIN_MAX_STATE_WORDS]; const u08b_t *perm; const static u08b_t PERM_256 [4][ 4] = { { 0,1,2,3 }, { 0,3,2,1 }, { 0,1,2,3 }, { 0,3,2,1 } }; const static u08b_t PERM_512 [4][ 8] = { { 0,1,2,3,4,5,6,7 }, { 2,1,4,7,6,5,0,3 }, { 4,1,6,3,0,5,2,7 }, { 6,1,0,7,2,5,4,3 } }; const static u08b_t PERM_1024[4][16] = { { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15 }, { 0, 9, 2,13, 6,11, 4,15,10, 7,12, 3,14, 5, 8, 1 }, { 0, 7, 2, 5, 4, 3, 6, 1,12,15,14,13, 8,11,10, 9 }, { 0,15, 2,11, 6,13, 4, 9,14, 1, 8, 5,10, 3,12, 7 } }; if ((skein_DebugFlag & SKEIN_DEBUG_PERMUTE) && (r & 3)) { printf("\n%s [state after round %2d (permuted)]=\n",AlgoHeader(bits),(int)r); switch (bits) { case 256: perm = PERM_256 [r&3]; break; case 512: perm = PERM_512 [r&3]; break; default: perm = PERM_1024[r&3]; break; } for (j=0;jT[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) if (skein_DebugFlag) { if (skein_DebugFlag & SKEIN_DEBUG_HDR) { printf("\n%s Block: outBits=%4d. T0=%06X.",AlgoHeader(bits),(uint_t) h->hashBitLen,(uint_t)h->T[0]); printf(" Type="); n = (uint_t) ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) >> SKEIN_T1_POS_BLK_TYPE); switch (n) { case SKEIN_BLK_TYPE_KEY: printf("KEY. "); break; case SKEIN_BLK_TYPE_CFG: printf("CFG. "); break; case SKEIN_BLK_TYPE_PERS: printf("PERS."); break; case SKEIN_BLK_TYPE_PK : printf("PK. "); break; case SKEIN_BLK_TYPE_KDF: printf("KDF. "); break; case SKEIN_BLK_TYPE_MSG: printf("MSG. "); break; case SKEIN_BLK_TYPE_OUT: printf("OUT. "); break; default: printf("0x%02X.",n); break; } printf(" Flags="); printf((h->T[1] & SKEIN_T1_FLAG_FIRST) ? " First":" "); printf((h->T[1] & SKEIN_T1_FLAG_FINAL) ? " Final":" "); printf((h->T[1] & SKEIN_T1_FLAG_BIT_PAD) ? " Pad" :" "); n = (uint_t) ((h->T[1] & SKEIN_T1_TREE_LVL_MASK) >> SKEIN_T1_POS_TREE_LVL); if (n) printf(" TreeLevel = %02X",n); printf("\n"); fflush(stdout); } if (skein_DebugFlag & SKEIN_DEBUG_TWEAK) { printf(" Tweak:\n"); Show64(2,h->T); } if (skein_DebugFlag & SKEIN_DEBUG_STATE) { printf(" %s words:\n",(skein_DebugFlag & SKEIN_DEBUG_THREEFISH)?"Key":"State"); Show64(bits/64,X); } if (skein_DebugFlag & SKEIN_DEBUG_KEYSCHED) { printf(" Tweak schedule:\n"); Show64_flag(3,tsPtr); printf(" Key schedule:\n"); Show64_flag((bits/64)+1,ksPtr); } if (skein_DebugFlag & SKEIN_DEBUG_INPUT_64) { printf(" Input block (words):\n"); Show64(bits/64,wPtr); } if (skein_DebugFlag & SKEIN_DEBUG_INPUT_08) { printf(" Input block (bytes):\n"); Show08(bits/8,blkPtr); } } } void Skein_Show_Key(uint_t bits,const Skein_Ctxt_Hdr_t *h,const u08b_t *key,size_t keyBytes) { if (keyBytes) if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) if (skein_DebugFlag & SKEIN_DEBUG_KEY) { printf("\n%s MAC key = %4u bytes\n",AlgoHeader(bits),(unsigned) keyBytes); Show08(keyBytes,key); } } #endif skein-1.0.9.4/c_impl/optimized/skein_debug.h0000644000000000000000000000512612641032067017066 0ustar0000000000000000#ifndef _SKEIN_DEBUG_H_ #define _SKEIN_DEBUG_H_ /*********************************************************************** ** ** Interface definitions for Skein hashing debug output. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ************************************************************************/ #ifdef SKEIN_DEBUG /* callout functions used inside Skein code */ void Skein_Show_Block(uint_t bits,const Skein_Ctxt_Hdr_t *h,const u64b_t *X,const u08b_t *blkPtr, const u64b_t *wPtr,const u64b_t *ksPtr,const u64b_t *tsPtr); void Skein_Show_Round(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X); void Skein_Show_R_Ptr(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X_ptr[]); void Skein_Show_Final(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t cnt,const u08b_t *outPtr); void Skein_Show_Key (uint_t bits,const Skein_Ctxt_Hdr_t *h,const u08b_t *key,size_t keyBytes); extern uint_t skein_DebugFlag; /* flags to control debug output (0 --> none) */ #define SKEIN_RND_SPECIAL (1000u) #define SKEIN_RND_KEY_INITIAL (SKEIN_RND_SPECIAL+0u) #define SKEIN_RND_KEY_INJECT (SKEIN_RND_SPECIAL+1u) #define SKEIN_RND_FEED_FWD (SKEIN_RND_SPECIAL+2u) /* flag bits: skein_DebugFlag */ #define SKEIN_DEBUG_KEY (1u << 1) /* show MAC key */ #define SKEIN_DEBUG_CONFIG (1u << 2) /* show config block processing */ #define SKEIN_DEBUG_STATE (1u << 3) /* show input state during Show_Block() */ #define SKEIN_DEBUG_TWEAK (1u << 4) /* show input state during Show_Block() */ #define SKEIN_DEBUG_KEYSCHED (1u << 5) /* show expanded key schedule */ #define SKEIN_DEBUG_INPUT_64 (1u << 6) /* show input block as 64-bit words */ #define SKEIN_DEBUG_INPUT_08 (1u << 7) /* show input block as 8-bit bytes */ #define SKEIN_DEBUG_INJECT (1u << 8) /* show state after key injection & feedforward points */ #define SKEIN_DEBUG_ROUNDS (1u << 9) /* show state after all rounds */ #define SKEIN_DEBUG_FINAL (1u <<10) /* show final output of Skein */ #define SKEIN_DEBUG_HDR (1u <<11) /* show block header */ #define SKEIN_DEBUG_THREEFISH (1u <<12) /* use Threefish name instead of Skein */ #define SKEIN_DEBUG_PERMUTE (1u <<13) /* use word permutations */ #define SKEIN_DEBUG_ALL ((~0u) & ~(SKEIN_DEBUG_THREEFISH | SKEIN_DEBUG_PERMUTE)) #define THREEFISH_DEBUG_ALL (SKEIN_DEBUG_ALL | SKEIN_DEBUG_THREEFISH) #endif /* SKEIN_DEBUG */ #endif /* _SKEIN_DEBUG_H_ */ skein-1.0.9.4/c_impl/optimized/skein_iv.h0000644000000000000000000001334012641032067016413 0ustar0000000000000000#ifndef _SKEIN_IV_H_ #define _SKEIN_IV_H_ #include "skein.h" /* get Skein macros and types */ /* ***************** Pre-computed Skein IVs ******************* ** ** NOTE: these values are not "magic" constants, but ** are generated using the Threefish block function. ** They are pre-computed here only for speed; i.e., to ** avoid the need for a Threefish call during Init(). ** ** The IV for any fixed hash length may be pre-computed. ** Only the most common values are included here. ** ************************************************************ **/ #define MK_64 SKEIN_MK_64 /* blkSize = 256 bits. hashSize = 128 bits */ const u64b_t SKEIN_256_IV_128[] = { MK_64(0xE1111906,0x964D7260), MK_64(0x883DAAA7,0x7C8D811C), MK_64(0x10080DF4,0x91960F7A), MK_64(0xCCF7DDE5,0xB45BC1C2) }; /* blkSize = 256 bits. hashSize = 160 bits */ const u64b_t SKEIN_256_IV_160[] = { MK_64(0x14202314,0x72825E98), MK_64(0x2AC4E9A2,0x5A77E590), MK_64(0xD47A5856,0x8838D63E), MK_64(0x2DD2E496,0x8586AB7D) }; /* blkSize = 256 bits. hashSize = 224 bits */ const u64b_t SKEIN_256_IV_224[] = { MK_64(0xC6098A8C,0x9AE5EA0B), MK_64(0x876D5686,0x08C5191C), MK_64(0x99CB88D7,0xD7F53884), MK_64(0x384BDDB1,0xAEDDB5DE) }; /* blkSize = 256 bits. hashSize = 256 bits */ const u64b_t SKEIN_256_IV_256[] = { MK_64(0xFC9DA860,0xD048B449), MK_64(0x2FCA6647,0x9FA7D833), MK_64(0xB33BC389,0x6656840F), MK_64(0x6A54E920,0xFDE8DA69) }; /* blkSize = 512 bits. hashSize = 128 bits */ const u64b_t SKEIN_512_IV_128[] = { MK_64(0xA8BC7BF3,0x6FBF9F52), MK_64(0x1E9872CE,0xBD1AF0AA), MK_64(0x309B1790,0xB32190D3), MK_64(0xBCFBB854,0x3F94805C), MK_64(0x0DA61BCD,0x6E31B11B), MK_64(0x1A18EBEA,0xD46A32E3), MK_64(0xA2CC5B18,0xCE84AA82), MK_64(0x6982AB28,0x9D46982D) }; /* blkSize = 512 bits. hashSize = 160 bits */ const u64b_t SKEIN_512_IV_160[] = { MK_64(0x28B81A2A,0xE013BD91), MK_64(0xC2F11668,0xB5BDF78F), MK_64(0x1760D8F3,0xF6A56F12), MK_64(0x4FB74758,0x8239904F), MK_64(0x21EDE07F,0x7EAF5056), MK_64(0xD908922E,0x63ED70B8), MK_64(0xB8EC76FF,0xECCB52FA), MK_64(0x01A47BB8,0xA3F27A6E) }; /* blkSize = 512 bits. hashSize = 224 bits */ const u64b_t SKEIN_512_IV_224[] = { MK_64(0xCCD06162,0x48677224), MK_64(0xCBA65CF3,0xA92339EF), MK_64(0x8CCD69D6,0x52FF4B64), MK_64(0x398AED7B,0x3AB890B4), MK_64(0x0F59D1B1,0x457D2BD0), MK_64(0x6776FE65,0x75D4EB3D), MK_64(0x99FBC70E,0x997413E9), MK_64(0x9E2CFCCF,0xE1C41EF7) }; /* blkSize = 512 bits. hashSize = 256 bits */ const u64b_t SKEIN_512_IV_256[] = { MK_64(0xCCD044A1,0x2FDB3E13), MK_64(0xE8359030,0x1A79A9EB), MK_64(0x55AEA061,0x4F816E6F), MK_64(0x2A2767A4,0xAE9B94DB), MK_64(0xEC06025E,0x74DD7683), MK_64(0xE7A436CD,0xC4746251), MK_64(0xC36FBAF9,0x393AD185), MK_64(0x3EEDBA18,0x33EDFC13) }; /* blkSize = 512 bits. hashSize = 384 bits */ const u64b_t SKEIN_512_IV_384[] = { MK_64(0xA3F6C6BF,0x3A75EF5F), MK_64(0xB0FEF9CC,0xFD84FAA4), MK_64(0x9D77DD66,0x3D770CFE), MK_64(0xD798CBF3,0xB468FDDA), MK_64(0x1BC4A666,0x8A0E4465), MK_64(0x7ED7D434,0xE5807407), MK_64(0x548FC1AC,0xD4EC44D6), MK_64(0x266E1754,0x6AA18FF8) }; /* blkSize = 512 bits. hashSize = 512 bits */ const u64b_t SKEIN_512_IV_512[] = { MK_64(0x4903ADFF,0x749C51CE), MK_64(0x0D95DE39,0x9746DF03), MK_64(0x8FD19341,0x27C79BCE), MK_64(0x9A255629,0xFF352CB1), MK_64(0x5DB62599,0xDF6CA7B0), MK_64(0xEABE394C,0xA9D5C3F4), MK_64(0x991112C7,0x1A75B523), MK_64(0xAE18A40B,0x660FCC33) }; /* blkSize = 1024 bits. hashSize = 384 bits */ const u64b_t SKEIN1024_IV_384[] = { MK_64(0x5102B6B8,0xC1894A35), MK_64(0xFEEBC9E3,0xFE8AF11A), MK_64(0x0C807F06,0xE32BED71), MK_64(0x60C13A52,0xB41A91F6), MK_64(0x9716D35D,0xD4917C38), MK_64(0xE780DF12,0x6FD31D3A), MK_64(0x797846B6,0xC898303A), MK_64(0xB172C2A8,0xB3572A3B), MK_64(0xC9BC8203,0xA6104A6C), MK_64(0x65909338,0xD75624F4), MK_64(0x94BCC568,0x4B3F81A0), MK_64(0x3EBBF51E,0x10ECFD46), MK_64(0x2DF50F0B,0xEEB08542), MK_64(0x3B5A6530,0x0DBC6516), MK_64(0x484B9CD2,0x167BBCE1), MK_64(0x2D136947,0xD4CBAFEA) }; /* blkSize = 1024 bits. hashSize = 512 bits */ const u64b_t SKEIN1024_IV_512[] = { MK_64(0xCAEC0E5D,0x7C1B1B18), MK_64(0xA01B0E04,0x5F03E802), MK_64(0x33840451,0xED912885), MK_64(0x374AFB04,0xEAEC2E1C), MK_64(0xDF25A0E2,0x813581F7), MK_64(0xE4004093,0x8B12F9D2), MK_64(0xA662D539,0xC2ED39B6), MK_64(0xFA8B85CF,0x45D8C75A), MK_64(0x8316ED8E,0x29EDE796), MK_64(0x053289C0,0x2E9F91B8), MK_64(0xC3F8EF1D,0x6D518B73), MK_64(0xBDCEC3C4,0xD5EF332E), MK_64(0x549A7E52,0x22974487), MK_64(0x67070872,0x5B749816), MK_64(0xB9CD28FB,0xF0581BD1), MK_64(0x0E2940B8,0x15804974) }; /* blkSize = 1024 bits. hashSize = 1024 bits */ const u64b_t SKEIN1024_IV_1024[] = { MK_64(0xD593DA07,0x41E72355), MK_64(0x15B5E511,0xAC73E00C), MK_64(0x5180E5AE,0xBAF2C4F0), MK_64(0x03BD41D3,0xFCBCAFAF), MK_64(0x1CAEC6FD,0x1983A898), MK_64(0x6E510B8B,0xCDD0589F), MK_64(0x77E2BDFD,0xC6394ADA), MK_64(0xC11E1DB5,0x24DCB0A3), MK_64(0xD6D14AF9,0xC6329AB5), MK_64(0x6A9B0BFC,0x6EB67E0D), MK_64(0x9243C60D,0xCCFF1332), MK_64(0x1A1F1DDE,0x743F02D4), MK_64(0x0996753C,0x10ED0BB8), MK_64(0x6572DD22,0xF2B4969A), MK_64(0x61FD3062,0xD00A579A), MK_64(0x1DE0536E,0x8682E539) }; #endif /* _SKEIN_IV_H_ */ skein-1.0.9.4/c_impl/optimized/skein_port.h0000644000000000000000000001075112641032067016764 0ustar0000000000000000#ifndef _SKEIN_PORT_H_ #define _SKEIN_PORT_H_ /******************************************************************* ** ** Platform-specific definitions for Skein hash function. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ** Many thanks to Brian Gladman for his portable header files. ** ** To port Skein to an "unsupported" platform, change the definitions ** in this file appropriately. ** ********************************************************************/ /* 2013-03-30: Modified to avoid brg_types and include stdint.h */ #include typedef unsigned int uint_t; /* native unsigned integer */ typedef uint8_t u08b_t; /* 8-bit unsigned integer */ typedef uint64_t u64b_t; /* 64-bit unsigned integer */ #ifndef RotL_64 #define RotL_64(x,N) (((x) << (N)) | ((x) >> (64-(N)))) #endif /* * Skein is "natively" little-endian (unlike SHA-xxx), for optimal * performance on x86 CPUs. The Skein code requires the following * definitions for dealing with endianness: * * SKEIN_NEED_SWAP: 0 for little-endian, 1 for big-endian * Skein_Put64_LSB_First * Skein_Get64_LSB_First * Skein_Swap64 * * If SKEIN_NEED_SWAP is defined at compile time, it is used here * along with the portable versions of Put64/Get64/Swap64, which * are slow in general. * * Otherwise, an "auto-detect" of endianness is attempted below. * If the default handling doesn't work well, the user may insert * platform-specific code instead (e.g., for big-endian CPUs). * */ #ifndef SKEIN_NEED_SWAP /* compile-time "override" for endianness? */ #include "brg_endian.h" /* get endianness selection */ #if PLATFORM_BYTE_ORDER == IS_BIG_ENDIAN /* here for big-endian CPUs */ #define SKEIN_NEED_SWAP (1) #elif PLATFORM_BYTE_ORDER == IS_LITTLE_ENDIAN /* here for x86 and x86-64 CPUs (and other detected little-endian CPUs) */ #define SKEIN_NEED_SWAP (0) #if PLATFORM_MUST_ALIGN == 0 /* ok to use "fast" versions? */ #define Skein_Put64_LSB_First(dst08,src64,bCnt) memcpy(dst08,src64,bCnt) #define Skein_Get64_LSB_First(dst64,src08,wCnt) memcpy(dst64,src08,8*(wCnt)) #endif #else #error "Skein needs endianness setting!" #endif #endif /* ifndef SKEIN_NEED_SWAP */ /* ****************************************************************** * Provide any definitions still needed. ****************************************************************** */ #ifndef Skein_Swap64 /* swap for big-endian, nop for little-endian */ #if SKEIN_NEED_SWAP #define Skein_Swap64(w64) \ ( (( ((u64b_t)(w64)) & 0xFF) << 56) | \ (((((u64b_t)(w64)) >> 8) & 0xFF) << 48) | \ (((((u64b_t)(w64)) >>16) & 0xFF) << 40) | \ (((((u64b_t)(w64)) >>24) & 0xFF) << 32) | \ (((((u64b_t)(w64)) >>32) & 0xFF) << 24) | \ (((((u64b_t)(w64)) >>40) & 0xFF) << 16) | \ (((((u64b_t)(w64)) >>48) & 0xFF) << 8) | \ (((((u64b_t)(w64)) >>56) & 0xFF) ) ) #else #define Skein_Swap64(w64) (w64) #endif #endif /* ifndef Skein_Swap64 */ #ifndef Skein_Put64_LSB_First void Skein_Put64_LSB_First(u08b_t *dst,const u64b_t *src,size_t bCnt) #ifdef SKEIN_PORT_CODE /* instantiate the function code here? */ { /* this version is fully portable (big-endian or little-endian), but slow */ size_t n; for (n=0;n>3] >> (8*(n&7))); } #else ; /* output only the function prototype */ #endif #endif /* ifndef Skein_Put64_LSB_First */ #ifndef Skein_Get64_LSB_First void Skein_Get64_LSB_First(u64b_t *dst,const u08b_t *src,size_t wCnt) #ifdef SKEIN_PORT_CODE /* instantiate the function code here? */ { /* this version is fully portable (big-endian or little-endian), but slow */ size_t n; for (n=0;n<8*wCnt;n+=8) dst[n/8] = (((u64b_t) src[n ]) ) + (((u64b_t) src[n+1]) << 8) + (((u64b_t) src[n+2]) << 16) + (((u64b_t) src[n+3]) << 24) + (((u64b_t) src[n+4]) << 32) + (((u64b_t) src[n+5]) << 40) + (((u64b_t) src[n+6]) << 48) + (((u64b_t) src[n+7]) << 56) ; } #else ; /* output only the function prototype */ #endif #endif /* ifndef Skein_Get64_LSB_First */ #endif /* ifndef _SKEIN_PORT_H_ */ skein-1.0.9.4/c_impl/reference/skein.c0000644000000000000000000010425612641032067015651 0ustar0000000000000000/*********************************************************************** ** ** Implementation of the Skein hash function. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ************************************************************************/ #include /* get the memcpy/memset functions */ #include "skein.h" /* get the Skein API definitions */ /*****************************************************************/ /* External function to process blkCnt (nonzero) full block(s) of data. */ void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd); /*****************************************************************/ /* Portable (i.e., slow) endianness conversion functions */ u64b_t Skein_Swap64(u64b_t w64) { /* instantiate the function body here */ static const u64b_t ONE = 1; /* use this to check endianness */ /* figure out endianness "on-the-fly" */ if (1 == ((u08b_t *) & ONE)[0]) return w64; /* little-endian is fast */ else return (( w64 & 0xFF) << 56) | /* big-endian is slow */ (((w64 >> 8) & 0xFF) << 48) | (((w64 >>16) & 0xFF) << 40) | (((w64 >>24) & 0xFF) << 32) | (((w64 >>32) & 0xFF) << 24) | (((w64 >>40) & 0xFF) << 16) | (((w64 >>48) & 0xFF) << 8) | (((w64 >>56) & 0xFF) ) ; } void Skein_Put64_LSB_First(u08b_t *dst,const u64b_t *src,size_t bCnt) { /* this version is fully portable (big-endian or little-endian), but slow */ size_t n; for (n=0;n>3] >> (8*(n&7))); } void Skein_Get64_LSB_First(u64b_t *dst,const u08b_t *src,size_t wCnt) { /* this version is fully portable (big-endian or little-endian), but slow */ size_t n; for (n=0;n<8*wCnt;n+=8) dst[n/8] = (((u64b_t) src[n ]) ) + (((u64b_t) src[n+1]) << 8) + (((u64b_t) src[n+2]) << 16) + (((u64b_t) src[n+3]) << 24) + (((u64b_t) src[n+4]) << 32) + (((u64b_t) src[n+5]) << 40) + (((u64b_t) src[n+6]) << 48) + (((u64b_t) src[n+7]) << 56) ; } /*****************************************************************/ /* 256-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein_256_Init(Skein_256_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN_256_STATE_BYTES]; u64b_t w[SKEIN_256_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); /* build/process config block for hashing */ ctx->h.hashBitLen = hashBitLen; /* output hash byte count */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein_256_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein_256_InitExt(Skein_256_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { uint_t i; union { u08b_t b[SKEIN_256_STATE_BYTES]; u64b_t w[SKEIN_256_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein_256_Update(ctx,key,keyBytes); /* hash the key */ Skein_256_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(256,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein_256_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein_256_Update(Skein_256_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN_256_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN_256_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN_256_BLOCK_BYTES); Skein_256_Process_Block(ctx,ctx->b,1,SKEIN_256_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN_256_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN_256_BLOCK_BYTES; /* number of full blocks to process */ Skein_256_Process_Block(ctx,msg,n,SKEIN_256_BLOCK_BYTES); msgByteCnt -= n * SKEIN_256_BLOCK_BYTES; msg += n * SKEIN_256_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein_256_Final(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_256_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_256_BLOCK_BYTES) n = SKEIN_256_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_256_API_CodeSize(void) { return ((u08b_t *) Skein_256_API_CodeSize) - ((u08b_t *) Skein_256_Init); } #endif /*****************************************************************/ /* 512-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein_512_Init(Skein_512_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN_512_STATE_BYTES]; u64b_t w[SKEIN_512_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); /* build/process config block for hashing */ ctx->h.hashBitLen = hashBitLen; /* output hash byte count */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein_512_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein_512_InitExt(Skein_512_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { uint_t i; union { u08b_t b[SKEIN_512_STATE_BYTES]; u64b_t w[SKEIN_512_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein_512_Update(ctx,key,keyBytes); /* hash the key */ Skein_512_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(512,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein_512_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein_512_Update(Skein_512_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN_512_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN_512_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN_512_BLOCK_BYTES); Skein_512_Process_Block(ctx,ctx->b,1,SKEIN_512_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN_512_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN_512_BLOCK_BYTES; /* number of full blocks to process */ Skein_512_Process_Block(ctx,msg,n,SKEIN_512_BLOCK_BYTES); msgByteCnt -= n * SKEIN_512_BLOCK_BYTES; msg += n * SKEIN_512_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein_512_Final(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_512_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate more output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_512_BLOCK_BYTES) n = SKEIN_512_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(512,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_512_API_CodeSize(void) { return ((u08b_t *) Skein_512_API_CodeSize) - ((u08b_t *) Skein_512_Init); } #endif /*****************************************************************/ /* 1024-bit Skein */ /*****************************************************************/ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a straight hashing operation */ int Skein1024_Init(Skein1024_Ctxt_t *ctx, size_t hashBitLen) { union { u08b_t b[SKEIN1024_STATE_BYTES]; u64b_t w[SKEIN1024_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); /* build/process config block for hashing */ ctx->h.hashBitLen = hashBitLen; /* output hash byte count */ Skein_Start_New_Type(ctx,CFG_FINAL); /* set tweaks: T0=0; T1=CFG | FINAL */ memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); /* set the schema, version */ cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(SKEIN_CFG_TREE_INFO_SEQUENTIAL); /* compute the initial chaining values from config block */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the chaining variables */ Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized for the given hashBitLen. */ /* Set up to process the data message portion of the hash (default) */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* init the context for a MAC and/or tree hash operation */ /* [identical to Skein1024_Init() when keyBytes == 0 && treeInfo == SKEIN_CFG_TREE_INFO_SEQUENTIAL] */ int Skein1024_InitExt(Skein1024_Ctxt_t *ctx,size_t hashBitLen,u64b_t treeInfo, const u08b_t *key, size_t keyBytes) { uint_t i; union { u08b_t b[SKEIN1024_STATE_BYTES]; u64b_t w[SKEIN1024_STATE_WORDS]; } cfg; /* config block */ Skein_Assert(hashBitLen > 0,SKEIN_BAD_HASHLEN); Skein_Assert(keyBytes == 0 || key != NULL,SKEIN_FAIL); /* compute the initial chaining values ctx->X[], based on key */ if (keyBytes == 0) /* is there a key? */ { memset(ctx->X,0,sizeof(ctx->X)); /* no key: use all zeroes as key for config block */ } else /* here to pre-process a key */ { Skein_assert(sizeof(cfg.b) >= sizeof(ctx->X)); /* do a mini-Init right here */ ctx->h.hashBitLen=8*sizeof(ctx->X); /* set output hash bit count = state size */ Skein_Start_New_Type(ctx,KEY); /* set tweaks: T0 = 0; T1 = KEY type */ memset(ctx->X,0,sizeof(ctx->X)); /* zero the initial chaining variables */ Skein1024_Update(ctx,key,keyBytes); /* hash the key */ Skein1024_Final_Pad(ctx,cfg.b); /* put result into cfg.b[] */ memcpy(ctx->X,cfg.b,sizeof(cfg.b)); /* copy over into ctx->X[] */ for (i=0;iX[i] = Skein_Swap64(ctx->X[i]); } /* build/process the config block, type == CONFIG (could be precomputed for each key) */ ctx->h.hashBitLen = hashBitLen; /* output hash bit count */ Skein_Start_New_Type(ctx,CFG_FINAL); memset(&cfg.w,0,sizeof(cfg.w)); /* pre-pad cfg.w[] with zeroes */ cfg.w[0] = Skein_Swap64(SKEIN_SCHEMA_VER); cfg.w[1] = Skein_Swap64(hashBitLen); /* hash result length in bits */ cfg.w[2] = Skein_Swap64(treeInfo); /* tree hash config info (or SKEIN_CFG_TREE_INFO_SEQUENTIAL) */ Skein_Show_Key(1024,&ctx->h,key,keyBytes); /* compute the initial chaining values from config block */ Skein1024_Process_Block(ctx,cfg.b,1,SKEIN_CFG_STR_LEN); /* The chaining vars ctx->X are now initialized */ /* Set up to process the data message portion of the hash */ Skein_Start_New_Type(ctx,MSG); /* T0=0, T1= MSG type, h.bCnt=0 */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* process the input bytes */ int Skein1024_Update(Skein1024_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt) { size_t n; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* process full blocks, if any */ if (msgByteCnt + ctx->h.bCnt > SKEIN1024_BLOCK_BYTES) { if (ctx->h.bCnt) /* finish up any buffered message data */ { n = SKEIN1024_BLOCK_BYTES - ctx->h.bCnt; /* # bytes free in buffer b[] */ if (n) { Skein_assert(n < msgByteCnt); /* check on our logic here */ memcpy(&ctx->b[ctx->h.bCnt],msg,n); msgByteCnt -= n; msg += n; ctx->h.bCnt += n; } Skein_assert(ctx->h.bCnt == SKEIN1024_BLOCK_BYTES); Skein1024_Process_Block(ctx,ctx->b,1,SKEIN1024_BLOCK_BYTES); ctx->h.bCnt = 0; } /* now process any remaining full blocks, directly from input message data */ if (msgByteCnt > SKEIN1024_BLOCK_BYTES) { n = (msgByteCnt-1) / SKEIN1024_BLOCK_BYTES; /* number of full blocks to process */ Skein1024_Process_Block(ctx,msg,n,SKEIN1024_BLOCK_BYTES); msgByteCnt -= n * SKEIN1024_BLOCK_BYTES; msg += n * SKEIN1024_BLOCK_BYTES; } Skein_assert(ctx->h.bCnt == 0); } /* copy any remaining source message data bytes into b[] */ if (msgByteCnt) { Skein_assert(msgByteCnt + ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES); memcpy(&ctx->b[ctx->h.bCnt],msg,msgByteCnt); ctx->h.bCnt += msgByteCnt; } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the result */ int Skein1024_Final(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN1024_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN1024_BLOCK_BYTES) n = SKEIN1024_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(1024,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein1024_API_CodeSize(void) { return ((u08b_t *) Skein1024_API_CodeSize) - ((u08b_t *) Skein1024_Init); } #endif /**************** Functions to support MAC/tree hashing ***************/ /* (this code is identical for Optimized and Reference versions) */ /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_256_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_256_BLOCK_BYTES - ctx->h.bCnt); Skein_256_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_256_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN_512_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN_512_BLOCK_BYTES - ctx->h.bCnt); Skein_512_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN_512_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* finalize the hash computation and output the block, no OUTPUT stage */ int Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ ctx->h.T[1] |= SKEIN_T1_FLAG_FINAL; /* tag as the final block */ if (ctx->h.bCnt < SKEIN1024_BLOCK_BYTES) /* zero pad b[] if necessary */ memset(&ctx->b[ctx->h.bCnt],0,SKEIN1024_BLOCK_BYTES - ctx->h.bCnt); Skein1024_Process_Block(ctx,ctx->b,1,ctx->h.bCnt); /* process the final block */ Skein_Put64_LSB_First(hashVal,ctx->X,SKEIN1024_BLOCK_BYTES); /* "output" the state bytes */ return SKEIN_SUCCESS; } #if SKEIN_TREE_HASH /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein_256_Output(Skein_256_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_256_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_256_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_256_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_256_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_256_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_256_BLOCK_BYTES) n = SKEIN_256_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_256_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_256_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein_512_Output(Skein_512_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN_512_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN_512_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN_512_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein_512_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN_512_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN_512_BLOCK_BYTES) n = SKEIN_512_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN_512_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN_512_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } /*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/ /* just do the OUTPUT stage */ int Skein1024_Output(Skein1024_Ctxt_t *ctx, u08b_t *hashVal) { size_t i,n,byteCnt; u64b_t X[SKEIN1024_STATE_WORDS]; Skein_Assert(ctx->h.bCnt <= SKEIN1024_BLOCK_BYTES,SKEIN_FAIL); /* catch uninitialized context */ /* now output the result */ byteCnt = (ctx->h.hashBitLen + 7) >> 3; /* total number of output bytes */ /* run Threefish in "counter mode" to generate output */ memset(ctx->b,0,sizeof(ctx->b)); /* zero out b[], so it can hold the counter */ memcpy(X,ctx->X,sizeof(X)); /* keep a local copy of counter mode "key" */ for (i=0;i*SKEIN1024_BLOCK_BYTES < byteCnt;i++) { ((u64b_t *)ctx->b)[0]= Skein_Swap64((u64b_t) i); /* build the counter block */ Skein_Start_New_Type(ctx,OUT_FINAL); Skein1024_Process_Block(ctx,ctx->b,1,sizeof(u64b_t)); /* run "counter mode" */ n = byteCnt - i*SKEIN1024_BLOCK_BYTES; /* number of output bytes left to go */ if (n >= SKEIN1024_BLOCK_BYTES) n = SKEIN1024_BLOCK_BYTES; Skein_Put64_LSB_First(hashVal+i*SKEIN1024_BLOCK_BYTES,ctx->X,n); /* "output" the ctr mode bytes */ Skein_Show_Final(256,&ctx->h,n,hashVal+i*SKEIN1024_BLOCK_BYTES); memcpy(ctx->X,X,sizeof(X)); /* restore the counter mode key for next time */ } return SKEIN_SUCCESS; } #endif skein-1.0.9.4/c_impl/reference/skein.h0000644000000000000000000004024712641032067015655 0ustar0000000000000000#ifndef _SKEIN_H_ #define _SKEIN_H_ 1 /************************************************************************** ** ** Interface declarations and internal definitions for Skein hashing. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** *************************************************************************** ** ** The following compile-time switches may be defined to control some ** tradeoffs between speed, code size, error checking, and security. ** ** The "default" note explains what happens when the switch is not defined. ** ** SKEIN_DEBUG -- make callouts from inside Skein code ** to examine/display intermediate values. ** [default: no callouts (no overhead)] ** ** SKEIN_ERR_CHECK -- how error checking is handled inside Skein ** code. If not defined, most error checking ** is disabled (for performance). Otherwise, ** the switch value is interpreted as: ** 0: use assert() to flag errors ** 1: return SKEIN_FAIL to flag errors ** ***************************************************************************/ #ifdef __cplusplus extern "C" { #endif #include /* get size_t definition */ #include "skein_port.h" /* get platform-specific definitions */ enum { SKEIN_SUCCESS = 0, /* return codes from Skein calls */ SKEIN_FAIL = 1, SKEIN_BAD_HASHLEN = 2 }; #define SKEIN_MODIFIER_WORDS ( 2) /* number of modifier (tweak) words */ #define SKEIN_256_STATE_WORDS ( 4) #define SKEIN_512_STATE_WORDS ( 8) #define SKEIN1024_STATE_WORDS (16) #define SKEIN_MAX_STATE_WORDS (16) #define SKEIN_256_STATE_BYTES ( 8*SKEIN_256_STATE_WORDS) #define SKEIN_512_STATE_BYTES ( 8*SKEIN_512_STATE_WORDS) #define SKEIN1024_STATE_BYTES ( 8*SKEIN1024_STATE_WORDS) #define SKEIN_256_STATE_BITS (64*SKEIN_256_STATE_WORDS) #define SKEIN_512_STATE_BITS (64*SKEIN_512_STATE_WORDS) #define SKEIN1024_STATE_BITS (64*SKEIN1024_STATE_WORDS) #define SKEIN_256_BLOCK_BYTES ( 8*SKEIN_256_STATE_WORDS) #define SKEIN_512_BLOCK_BYTES ( 8*SKEIN_512_STATE_WORDS) #define SKEIN1024_BLOCK_BYTES ( 8*SKEIN1024_STATE_WORDS) typedef struct { size_t hashBitLen; /* size of hash result, in bits */ size_t bCnt; /* current byte count in buffer b[] */ u64b_t T[SKEIN_MODIFIER_WORDS]; /* tweak words: T[0]=byte cnt, T[1]=flags */ } Skein_Ctxt_Hdr_t; typedef struct /* 256-bit Skein hash context structure */ { Skein_Ctxt_Hdr_t h; /* common header context variables */ u64b_t X[SKEIN_256_STATE_WORDS]; /* chaining variables */ u08b_t b[SKEIN_256_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ } Skein_256_Ctxt_t; typedef struct /* 512-bit Skein hash context structure */ { Skein_Ctxt_Hdr_t h; /* common header context variables */ u64b_t X[SKEIN_512_STATE_WORDS]; /* chaining variables */ u08b_t b[SKEIN_512_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ } Skein_512_Ctxt_t; typedef struct /* 1024-bit Skein hash context structure */ { Skein_Ctxt_Hdr_t h; /* common header context variables */ u64b_t X[SKEIN1024_STATE_WORDS]; /* chaining variables */ u08b_t b[SKEIN1024_BLOCK_BYTES]; /* partial block buffer (8-byte aligned) */ } Skein1024_Ctxt_t; /* Skein APIs for (incremental) "straight hashing" */ int Skein_256_Init (Skein_256_Ctxt_t *ctx, size_t hashBitLen); int Skein_512_Init (Skein_512_Ctxt_t *ctx, size_t hashBitLen); int Skein1024_Init (Skein1024_Ctxt_t *ctx, size_t hashBitLen); int Skein_256_Update(Skein_256_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); int Skein_512_Update(Skein_512_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); int Skein1024_Update(Skein1024_Ctxt_t *ctx, const u08b_t *msg, size_t msgByteCnt); int Skein_256_Final (Skein_256_Ctxt_t *ctx, u08b_t * hashVal); int Skein_512_Final (Skein_512_Ctxt_t *ctx, u08b_t * hashVal); int Skein1024_Final (Skein1024_Ctxt_t *ctx, u08b_t * hashVal); /* ** Skein APIs for "extended" initialization: MAC keys, tree hashing. ** After an InitExt() call, just use Update/Final calls as with Init(). ** ** Notes: Same parameters as _Init() calls, plus treeInfo/key/keyBytes. ** When keyBytes == 0 and treeInfo == SKEIN_SEQUENTIAL, ** the results of InitExt() are identical to calling Init(). ** The function Init() may be called once to "precompute" the IV for ** a given hashBitLen value, then by saving a copy of the context ** the IV computation may be avoided in later calls. ** Similarly, the function InitExt() may be called once per MAC key ** to precompute the MAC IV, then a copy of the context saved and ** reused for each new MAC computation. **/ int Skein_256_InitExt(Skein_256_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *key, size_t keyBytes); int Skein_512_InitExt(Skein_512_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *key, size_t keyBytes); int Skein1024_InitExt(Skein1024_Ctxt_t *ctx, size_t hashBitLen, u64b_t treeInfo, const u08b_t *key, size_t keyBytes); /* ** Skein APIs for MAC and tree hash: ** Final_Pad: pad, do final block, but no OUTPUT type ** Output: do just the output stage */ int Skein_256_Final_Pad(Skein_256_Ctxt_t *ctx, u08b_t * hashVal); int Skein_512_Final_Pad(Skein_512_Ctxt_t *ctx, u08b_t * hashVal); int Skein1024_Final_Pad(Skein1024_Ctxt_t *ctx, u08b_t * hashVal); #ifndef SKEIN_TREE_HASH #define SKEIN_TREE_HASH (1) #endif #if SKEIN_TREE_HASH int Skein_256_Output (Skein_256_Ctxt_t *ctx, u08b_t * hashVal); int Skein_512_Output (Skein_512_Ctxt_t *ctx, u08b_t * hashVal); int Skein1024_Output (Skein1024_Ctxt_t *ctx, u08b_t * hashVal); #endif /***************************************************************** ** "Internal" Skein definitions ** -- not needed for sequential hashing API, but will be ** helpful for other uses of Skein (e.g., tree hash mode). ** -- included here so that they can be shared between ** reference and optimized code. ******************************************************************/ /* tweak word T[1]: bit field starting positions */ #define SKEIN_T1_BIT(BIT) ((BIT) - 64) /* offset 64 because it's the second word */ #define SKEIN_T1_POS_TREE_LVL SKEIN_T1_BIT(112) /* bits 112..118: level in hash tree */ #define SKEIN_T1_POS_BIT_PAD SKEIN_T1_BIT(119) /* bit 119 : partial final input byte */ #define SKEIN_T1_POS_BLK_TYPE SKEIN_T1_BIT(120) /* bits 120..125: type field */ #define SKEIN_T1_POS_FIRST SKEIN_T1_BIT(126) /* bits 126 : first block flag */ #define SKEIN_T1_POS_FINAL SKEIN_T1_BIT(127) /* bit 127 : final block flag */ /* tweak word T[1]: flag bit definition(s) */ #define SKEIN_T1_FLAG_FIRST (((u64b_t) 1 ) << SKEIN_T1_POS_FIRST) #define SKEIN_T1_FLAG_FINAL (((u64b_t) 1 ) << SKEIN_T1_POS_FINAL) #define SKEIN_T1_FLAG_BIT_PAD (((u64b_t) 1 ) << SKEIN_T1_POS_BIT_PAD) /* tweak word T[1]: tree level bit field mask */ #define SKEIN_T1_TREE_LVL_MASK (((u64b_t)0x7F) << SKEIN_T1_POS_TREE_LVL) #define SKEIN_T1_TREE_LEVEL(n) (((u64b_t) (n)) << SKEIN_T1_POS_TREE_LVL) /* tweak word T[1]: block type field */ #define SKEIN_BLK_TYPE_KEY ( 0) /* key, for MAC and KDF */ #define SKEIN_BLK_TYPE_CFG ( 4) /* configuration block */ #define SKEIN_BLK_TYPE_PERS ( 8) /* personalization string */ #define SKEIN_BLK_TYPE_PK (12) /* public key (for digital signature hashing) */ #define SKEIN_BLK_TYPE_KDF (16) /* key identifier for KDF */ #define SKEIN_BLK_TYPE_NONCE (20) /* nonce for PRNG */ #define SKEIN_BLK_TYPE_MSG (48) /* message processing */ #define SKEIN_BLK_TYPE_OUT (63) /* output stage */ #define SKEIN_BLK_TYPE_MASK (63) /* bit field mask */ #define SKEIN_T1_BLK_TYPE(T) (((u64b_t) (SKEIN_BLK_TYPE_##T)) << SKEIN_T1_POS_BLK_TYPE) #define SKEIN_T1_BLK_TYPE_KEY SKEIN_T1_BLK_TYPE(KEY) /* key, for MAC and KDF */ #define SKEIN_T1_BLK_TYPE_CFG SKEIN_T1_BLK_TYPE(CFG) /* configuration block */ #define SKEIN_T1_BLK_TYPE_PERS SKEIN_T1_BLK_TYPE(PERS) /* personalization string */ #define SKEIN_T1_BLK_TYPE_PK SKEIN_T1_BLK_TYPE(PK) /* public key (for digital signature hashing) */ #define SKEIN_T1_BLK_TYPE_KDF SKEIN_T1_BLK_TYPE(KDF) /* key identifier for KDF */ #define SKEIN_T1_BLK_TYPE_NONCE SKEIN_T1_BLK_TYPE(NONCE)/* nonce for PRNG */ #define SKEIN_T1_BLK_TYPE_MSG SKEIN_T1_BLK_TYPE(MSG) /* message processing */ #define SKEIN_T1_BLK_TYPE_OUT SKEIN_T1_BLK_TYPE(OUT) /* output stage */ #define SKEIN_T1_BLK_TYPE_MASK SKEIN_T1_BLK_TYPE(MASK) /* field bit mask */ #define SKEIN_T1_BLK_TYPE_CFG_FINAL (SKEIN_T1_BLK_TYPE_CFG | SKEIN_T1_FLAG_FINAL) #define SKEIN_T1_BLK_TYPE_OUT_FINAL (SKEIN_T1_BLK_TYPE_OUT | SKEIN_T1_FLAG_FINAL) #define SKEIN_VERSION (1) #ifndef SKEIN_ID_STRING_LE /* allow compile-time personalization */ #define SKEIN_ID_STRING_LE (0x33414853) /* "SHA3" (little-endian)*/ #endif #define SKEIN_MK_64(hi32,lo32) ((lo32) + (((u64b_t) (hi32)) << 32)) #define SKEIN_SCHEMA_VER SKEIN_MK_64(SKEIN_VERSION,SKEIN_ID_STRING_LE) #define SKEIN_KS_PARITY SKEIN_MK_64(0x1BD11BDA,0xA9FC1A22) #define SKEIN_CFG_STR_LEN (4*8) /* bit field definitions in config block treeInfo word */ #define SKEIN_CFG_TREE_LEAF_SIZE_POS ( 0) #define SKEIN_CFG_TREE_NODE_SIZE_POS ( 8) #define SKEIN_CFG_TREE_MAX_LEVEL_POS (16) #define SKEIN_CFG_TREE_LEAF_SIZE_MSK (((u64b_t) 0xFF) << SKEIN_CFG_TREE_LEAF_SIZE_POS) #define SKEIN_CFG_TREE_NODE_SIZE_MSK (((u64b_t) 0xFF) << SKEIN_CFG_TREE_NODE_SIZE_POS) #define SKEIN_CFG_TREE_MAX_LEVEL_MSK (((u64b_t) 0xFF) << SKEIN_CFG_TREE_MAX_LEVEL_POS) #define SKEIN_CFG_TREE_INFO(leaf,node,maxLvl) \ ( (((u64b_t)(leaf )) << SKEIN_CFG_TREE_LEAF_SIZE_POS) | \ (((u64b_t)(node )) << SKEIN_CFG_TREE_NODE_SIZE_POS) | \ (((u64b_t)(maxLvl)) << SKEIN_CFG_TREE_MAX_LEVEL_POS) ) #define SKEIN_CFG_TREE_INFO_SEQUENTIAL SKEIN_CFG_TREE_INFO(0,0,0) /* use as treeInfo in InitExt() call for sequential processing */ /* ** Skein macros for getting/setting tweak words, etc. ** These are useful for partial input bytes, hash tree init/update, etc. **/ #define Skein_Get_Tweak(ctxPtr,TWK_NUM) ((ctxPtr)->h.T[TWK_NUM]) #define Skein_Set_Tweak(ctxPtr,TWK_NUM,tVal) {(ctxPtr)->h.T[TWK_NUM] = (tVal);} #define Skein_Get_T0(ctxPtr) Skein_Get_Tweak(ctxPtr,0) #define Skein_Get_T1(ctxPtr) Skein_Get_Tweak(ctxPtr,1) #define Skein_Set_T0(ctxPtr,T0) Skein_Set_Tweak(ctxPtr,0,T0) #define Skein_Set_T1(ctxPtr,T1) Skein_Set_Tweak(ctxPtr,1,T1) /* set both tweak words at once */ #define Skein_Set_T0_T1(ctxPtr,T0,T1) \ { \ Skein_Set_T0(ctxPtr,(T0)); \ Skein_Set_T1(ctxPtr,(T1)); \ } #define Skein_Set_Type(ctxPtr,BLK_TYPE) \ Skein_Set_T1(ctxPtr,SKEIN_T1_BLK_TYPE_##BLK_TYPE) /* set up for starting with a new type: h.T[0]=0; h.T[1] = NEW_TYPE; h.bCnt=0; */ #define Skein_Start_New_Type(ctxPtr,BLK_TYPE) \ { Skein_Set_T0_T1(ctxPtr,0,SKEIN_T1_FLAG_FIRST | SKEIN_T1_BLK_TYPE_##BLK_TYPE); (ctxPtr)->h.bCnt=0; } #define Skein_Clear_First_Flag(hdr) { (hdr).T[1] &= ~SKEIN_T1_FLAG_FIRST; } #define Skein_Set_Bit_Pad_Flag(hdr) { (hdr).T[1] |= SKEIN_T1_FLAG_BIT_PAD; } #define Skein_Set_Tree_Level(hdr,height) { (hdr).T[1] |= SKEIN_T1_TREE_LEVEL(height);} /***************************************************************** ** "Internal" Skein definitions for debugging and error checking ******************************************************************/ #ifdef SKEIN_DEBUG /* examine/display intermediate values? */ #include "skein_debug.h" #else /* default is no callouts */ #define Skein_Show_Block(bits,ctx,X,blkPtr,wPtr,ksEvenPtr,ksOddPtr) #define Skein_Show_Round(bits,ctx,r,X) #define Skein_Show_R_Ptr(bits,ctx,r,X_ptr) #define Skein_Show_Final(bits,ctx,cnt,outPtr) #define Skein_Show_Key(bits,ctx,key,keyBytes) #endif #ifndef SKEIN_ERR_CHECK /* run-time checks (e.g., bad params, uninitialized context)? */ #define Skein_Assert(x,retCode)/* default: ignore all Asserts, for performance */ #define Skein_assert(x) #elif defined(SKEIN_ASSERT) #include #define Skein_Assert(x,retCode) assert(x) #define Skein_assert(x) assert(x) #else #include #define Skein_Assert(x,retCode) { if (!(x)) return retCode; } /* caller error */ #define Skein_assert(x) assert(x) /* internal error */ #endif /***************************************************************** ** Skein block function constants (shared across Ref and Opt code) ******************************************************************/ enum { /* Skein_256 round rotation constants */ R_256_0_0=14, R_256_0_1=16, R_256_1_0=52, R_256_1_1=57, R_256_2_0=23, R_256_2_1=40, R_256_3_0= 5, R_256_3_1=37, R_256_4_0=25, R_256_4_1=33, R_256_5_0=46, R_256_5_1=12, R_256_6_0=58, R_256_6_1=22, R_256_7_0=32, R_256_7_1=32, /* Skein_512 round rotation constants */ R_512_0_0=46, R_512_0_1=36, R_512_0_2=19, R_512_0_3=37, R_512_1_0=33, R_512_1_1=27, R_512_1_2=14, R_512_1_3=42, R_512_2_0=17, R_512_2_1=49, R_512_2_2=36, R_512_2_3=39, R_512_3_0=44, R_512_3_1= 9, R_512_3_2=54, R_512_3_3=56, R_512_4_0=39, R_512_4_1=30, R_512_4_2=34, R_512_4_3=24, R_512_5_0=13, R_512_5_1=50, R_512_5_2=10, R_512_5_3=17, R_512_6_0=25, R_512_6_1=29, R_512_6_2=39, R_512_6_3=43, R_512_7_0= 8, R_512_7_1=35, R_512_7_2=56, R_512_7_3=22, /* Skein1024 round rotation constants */ R1024_0_0=24, R1024_0_1=13, R1024_0_2= 8, R1024_0_3=47, R1024_0_4= 8, R1024_0_5=17, R1024_0_6=22, R1024_0_7=37, R1024_1_0=38, R1024_1_1=19, R1024_1_2=10, R1024_1_3=55, R1024_1_4=49, R1024_1_5=18, R1024_1_6=23, R1024_1_7=52, R1024_2_0=33, R1024_2_1= 4, R1024_2_2=51, R1024_2_3=13, R1024_2_4=34, R1024_2_5=41, R1024_2_6=59, R1024_2_7=17, R1024_3_0= 5, R1024_3_1=20, R1024_3_2=48, R1024_3_3=41, R1024_3_4=47, R1024_3_5=28, R1024_3_6=16, R1024_3_7=25, R1024_4_0=41, R1024_4_1= 9, R1024_4_2=37, R1024_4_3=31, R1024_4_4=12, R1024_4_5=47, R1024_4_6=44, R1024_4_7=30, R1024_5_0=16, R1024_5_1=34, R1024_5_2=56, R1024_5_3=51, R1024_5_4= 4, R1024_5_5=53, R1024_5_6=42, R1024_5_7=41, R1024_6_0=31, R1024_6_1=44, R1024_6_2=47, R1024_6_3=46, R1024_6_4=19, R1024_6_5=42, R1024_6_6=44, R1024_6_7=25, R1024_7_0= 9, R1024_7_1=48, R1024_7_2=35, R1024_7_3=52, R1024_7_4=23, R1024_7_5=31, R1024_7_6=37, R1024_7_7=20 }; #ifndef SKEIN_ROUNDS #define SKEIN_256_ROUNDS_TOTAL (72) /* number of rounds for the different block sizes */ #define SKEIN_512_ROUNDS_TOTAL (72) #define SKEIN1024_ROUNDS_TOTAL (80) #else /* allow command-line define in range 8*(5..14) */ #define SKEIN_256_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/100) + 5) % 10) + 5)) #define SKEIN_512_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS/ 10) + 5) % 10) + 5)) #define SKEIN1024_ROUNDS_TOTAL (8*((((SKEIN_ROUNDS ) + 5) % 10) + 5)) #endif #ifdef __cplusplus } #endif #endif /* ifndef _SKEIN_H_ */ skein-1.0.9.4/c_impl/reference/skein_block.c0000644000000000000000000004416412641032067017024 0ustar0000000000000000/*********************************************************************** ** ** Implementation of the Skein block functions. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ** Compile-time switches: ** ** SKEIN_USE_ASM -- set bits (256/512/1024) to select which ** versions use ASM code for block processing ** [default: use C for all block sizes] ** ************************************************************************/ #include #include "skein.h" /* 64-bit rotate left */ u64b_t RotL_64(u64b_t x,uint_t N) { return (x << (N & 63)) | (x >> ((64-N) & 63)); } #define BLK_BITS (WCNT*64) /* macro to perform a key injection (same for all block sizes) */ #define InjectKey(r) \ for (i=0;i < WCNT;i++) \ X[i] += ks[((r)+i) % (WCNT+1)]; \ X[WCNT-3] += ts[((r)+0) % 3]; \ X[WCNT-2] += ts[((r)+1) % 3]; \ X[WCNT-1] += (r); /* avoid slide attacks */ \ Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INJECT,X); void Skein_256_Process_Block(Skein_256_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C */ enum { WCNT = SKEIN_256_STATE_WORDS }; size_t i,r; u64b_t ts[3]; /* key schedule: tweak */ u64b_t ks[WCNT+1]; /* key schedule: chaining vars */ u64b_t X [WCNT]; /* local copy of context vars */ u64b_t w [WCNT]; /* local copy of input block */ Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ctx->h.T[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[WCNT] = SKEIN_KS_PARITY; for (i=0;i < WCNT; i++) { ks[i] = ctx->X[i]; ks[WCNT] ^= ctx->X[i]; /* compute overall parity */ } ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); for (i=0;i < WCNT; i++) /* do the first full key injection */ { X[i] = w[i] + ks[i]; } X[WCNT-3] += ts[0]; X[WCNT-2] += ts[1]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X); /* show starting state values */ for (r=1;r <= SKEIN_256_ROUNDS_TOTAL/8; r++) { /* unroll 8 rounds */ X[0] += X[1]; X[1] = RotL_64(X[1],R_256_0_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_256_0_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X); X[0] += X[3]; X[3] = RotL_64(X[3],R_256_1_0); X[3] ^= X[0]; X[2] += X[1]; X[1] = RotL_64(X[1],R_256_1_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X); X[0] += X[1]; X[1] = RotL_64(X[1],R_256_2_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_256_2_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X); X[0] += X[3]; X[3] = RotL_64(X[3],R_256_3_0); X[3] ^= X[0]; X[2] += X[1]; X[1] = RotL_64(X[1],R_256_3_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X); InjectKey(2*r-1); X[0] += X[1]; X[1] = RotL_64(X[1],R_256_4_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_256_4_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X); X[0] += X[3]; X[3] = RotL_64(X[3],R_256_5_0); X[3] ^= X[0]; X[2] += X[1]; X[1] = RotL_64(X[1],R_256_5_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X); X[0] += X[1]; X[1] = RotL_64(X[1],R_256_6_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_256_6_1); X[3] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X); X[0] += X[3]; X[3] = RotL_64(X[3],R_256_7_0); X[3] ^= X[0]; X[2] += X[1]; X[1] = RotL_64(X[1],R_256_7_1); X[1] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r ,X); InjectKey(2*r); } /* do the final "feedforward" xor, update context chaining vars */ for (i=0;i < WCNT;i++) ctx->X[i] = X[i] ^ w[i]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); Skein_Clear_First_Flag(ctx->h); /* clear the start bit */ blkPtr += SKEIN_256_BLOCK_BYTES; } while (--blkCnt); } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_256_Process_Block_CodeSize(void) { return ((u08b_t *) Skein_256_Process_Block_CodeSize) - ((u08b_t *) Skein_256_Process_Block); } uint_t Skein_256_Unroll_Cnt(void) { return 1; } #endif void Skein_512_Process_Block(Skein_512_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C */ enum { WCNT = SKEIN_512_STATE_WORDS }; size_t i,r; u64b_t ts[3]; /* key schedule: tweak */ u64b_t ks[WCNT+1]; /* key schedule: chaining vars */ u64b_t X [WCNT]; /* local copy of vars */ u64b_t w [WCNT]; /* local copy of input block */ Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ctx->h.T[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[WCNT] = SKEIN_KS_PARITY; for (i=0;i < WCNT; i++) { ks[i] = ctx->X[i]; ks[WCNT] ^= ctx->X[i]; /* compute overall parity */ } ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); for (i=0;i < WCNT; i++) /* do the first full key injection */ { X[i] = w[i] + ks[i]; } X[WCNT-3] += ts[0]; X[WCNT-2] += ts[1]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X); for (r=1;r <= SKEIN_512_ROUNDS_TOTAL/8; r++) { /* unroll 8 rounds */ X[0] += X[1]; X[1] = RotL_64(X[1],R_512_0_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_512_0_1); X[3] ^= X[2]; X[4] += X[5]; X[5] = RotL_64(X[5],R_512_0_2); X[5] ^= X[4]; X[6] += X[7]; X[7] = RotL_64(X[7],R_512_0_3); X[7] ^= X[6]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X); X[2] += X[1]; X[1] = RotL_64(X[1],R_512_1_0); X[1] ^= X[2]; X[4] += X[7]; X[7] = RotL_64(X[7],R_512_1_1); X[7] ^= X[4]; X[6] += X[5]; X[5] = RotL_64(X[5],R_512_1_2); X[5] ^= X[6]; X[0] += X[3]; X[3] = RotL_64(X[3],R_512_1_3); X[3] ^= X[0]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X); X[4] += X[1]; X[1] = RotL_64(X[1],R_512_2_0); X[1] ^= X[4]; X[6] += X[3]; X[3] = RotL_64(X[3],R_512_2_1); X[3] ^= X[6]; X[0] += X[5]; X[5] = RotL_64(X[5],R_512_2_2); X[5] ^= X[0]; X[2] += X[7]; X[7] = RotL_64(X[7],R_512_2_3); X[7] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X); X[6] += X[1]; X[1] = RotL_64(X[1],R_512_3_0); X[1] ^= X[6]; X[0] += X[7]; X[7] = RotL_64(X[7],R_512_3_1); X[7] ^= X[0]; X[2] += X[5]; X[5] = RotL_64(X[5],R_512_3_2); X[5] ^= X[2]; X[4] += X[3]; X[3] = RotL_64(X[3],R_512_3_3); X[3] ^= X[4]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X); InjectKey(2*r-1); X[0] += X[1]; X[1] = RotL_64(X[1],R_512_4_0); X[1] ^= X[0]; X[2] += X[3]; X[3] = RotL_64(X[3],R_512_4_1); X[3] ^= X[2]; X[4] += X[5]; X[5] = RotL_64(X[5],R_512_4_2); X[5] ^= X[4]; X[6] += X[7]; X[7] = RotL_64(X[7],R_512_4_3); X[7] ^= X[6]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X); X[2] += X[1]; X[1] = RotL_64(X[1],R_512_5_0); X[1] ^= X[2]; X[4] += X[7]; X[7] = RotL_64(X[7],R_512_5_1); X[7] ^= X[4]; X[6] += X[5]; X[5] = RotL_64(X[5],R_512_5_2); X[5] ^= X[6]; X[0] += X[3]; X[3] = RotL_64(X[3],R_512_5_3); X[3] ^= X[0]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X); X[4] += X[1]; X[1] = RotL_64(X[1],R_512_6_0); X[1] ^= X[4]; X[6] += X[3]; X[3] = RotL_64(X[3],R_512_6_1); X[3] ^= X[6]; X[0] += X[5]; X[5] = RotL_64(X[5],R_512_6_2); X[5] ^= X[0]; X[2] += X[7]; X[7] = RotL_64(X[7],R_512_6_3); X[7] ^= X[2]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X); X[6] += X[1]; X[1] = RotL_64(X[1],R_512_7_0); X[1] ^= X[6]; X[0] += X[7]; X[7] = RotL_64(X[7],R_512_7_1); X[7] ^= X[0]; X[2] += X[5]; X[5] = RotL_64(X[5],R_512_7_2); X[5] ^= X[2]; X[4] += X[3]; X[3] = RotL_64(X[3],R_512_7_3); X[3] ^= X[4]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r ,X); InjectKey(2*r); } /* do the final "feedforward" xor, update context chaining vars */ for (i=0;i < WCNT;i++) ctx->X[i] = X[i] ^ w[i]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); Skein_Clear_First_Flag(ctx->h); /* clear the start bit */ blkPtr += SKEIN_512_BLOCK_BYTES; } while (--blkCnt); } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein_512_Process_Block_CodeSize(void) { return ((u08b_t *) Skein_512_Process_Block_CodeSize) - ((u08b_t *) Skein_512_Process_Block); } uint_t Skein_512_Unroll_Cnt(void) { return 1; } #endif void Skein1024_Process_Block(Skein1024_Ctxt_t *ctx,const u08b_t *blkPtr,size_t blkCnt,size_t byteCntAdd) { /* do it in C */ enum { WCNT = SKEIN1024_STATE_WORDS }; size_t i,r; u64b_t ts[3]; /* key schedule: tweak */ u64b_t ks[WCNT+1]; /* key schedule: chaining vars */ u64b_t X [WCNT]; /* local copy of vars */ u64b_t w [WCNT]; /* local copy of input block */ Skein_assert(blkCnt != 0); /* never call with blkCnt == 0! */ do { /* this implementation only supports 2**64 input bytes (no carry out here) */ ctx->h.T[0] += byteCntAdd; /* update processed length */ /* precompute the key schedule for this block */ ks[WCNT] = SKEIN_KS_PARITY; for (i=0;i < WCNT; i++) { ks[i] = ctx->X[i]; ks[WCNT] ^= ctx->X[i]; /* compute overall parity */ } ts[0] = ctx->h.T[0]; ts[1] = ctx->h.T[1]; ts[2] = ts[0] ^ ts[1]; Skein_Get64_LSB_First(w,blkPtr,WCNT); /* get input block in little-endian format */ Skein_Show_Block(BLK_BITS,&ctx->h,ctx->X,blkPtr,w,ks,ts); for (i=0;i < WCNT; i++) /* do the first full key injection */ { X[i] = w[i] + ks[i]; } X[WCNT-3] += ts[0]; X[WCNT-2] += ts[1]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_KEY_INITIAL,X); /* show starting state values */ for (r=1;r <= SKEIN1024_ROUNDS_TOTAL/8; r++) { /* unroll 8 rounds */ X[ 0] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_0_0); X[ 1] ^= X[ 0]; X[ 2] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_0_1); X[ 3] ^= X[ 2]; X[ 4] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_0_2); X[ 5] ^= X[ 4]; X[ 6] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_0_3); X[ 7] ^= X[ 6]; X[ 8] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_0_4); X[ 9] ^= X[ 8]; X[10] += X[11]; X[11] = RotL_64(X[11],R1024_0_5); X[11] ^= X[10]; X[12] += X[13]; X[13] = RotL_64(X[13],R1024_0_6); X[13] ^= X[12]; X[14] += X[15]; X[15] = RotL_64(X[15],R1024_0_7); X[15] ^= X[14]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-7,X); X[ 0] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_1_0); X[ 9] ^= X[ 0]; X[ 2] += X[13]; X[13] = RotL_64(X[13],R1024_1_1); X[13] ^= X[ 2]; X[ 6] += X[11]; X[11] = RotL_64(X[11],R1024_1_2); X[11] ^= X[ 6]; X[ 4] += X[15]; X[15] = RotL_64(X[15],R1024_1_3); X[15] ^= X[ 4]; X[10] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_1_4); X[ 7] ^= X[10]; X[12] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_1_5); X[ 3] ^= X[12]; X[14] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_1_6); X[ 5] ^= X[14]; X[ 8] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_1_7); X[ 1] ^= X[ 8]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-6,X); X[ 0] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_2_0); X[ 7] ^= X[ 0]; X[ 2] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_2_1); X[ 5] ^= X[ 2]; X[ 4] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_2_2); X[ 3] ^= X[ 4]; X[ 6] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_2_3); X[ 1] ^= X[ 6]; X[12] += X[15]; X[15] = RotL_64(X[15],R1024_2_4); X[15] ^= X[12]; X[14] += X[13]; X[13] = RotL_64(X[13],R1024_2_5); X[13] ^= X[14]; X[ 8] += X[11]; X[11] = RotL_64(X[11],R1024_2_6); X[11] ^= X[ 8]; X[10] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_2_7); X[ 9] ^= X[10]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-5,X); X[ 0] += X[15]; X[15] = RotL_64(X[15],R1024_3_0); X[15] ^= X[ 0]; X[ 2] += X[11]; X[11] = RotL_64(X[11],R1024_3_1); X[11] ^= X[ 2]; X[ 6] += X[13]; X[13] = RotL_64(X[13],R1024_3_2); X[13] ^= X[ 6]; X[ 4] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_3_3); X[ 9] ^= X[ 4]; X[14] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_3_4); X[ 1] ^= X[14]; X[ 8] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_3_5); X[ 5] ^= X[ 8]; X[10] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_3_6); X[ 3] ^= X[10]; X[12] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_3_7); X[ 7] ^= X[12]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-4,X); InjectKey(2*r-1); X[ 0] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_4_0); X[ 1] ^= X[ 0]; X[ 2] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_4_1); X[ 3] ^= X[ 2]; X[ 4] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_4_2); X[ 5] ^= X[ 4]; X[ 6] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_4_3); X[ 7] ^= X[ 6]; X[ 8] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_4_4); X[ 9] ^= X[ 8]; X[10] += X[11]; X[11] = RotL_64(X[11],R1024_4_5); X[11] ^= X[10]; X[12] += X[13]; X[13] = RotL_64(X[13],R1024_4_6); X[13] ^= X[12]; X[14] += X[15]; X[15] = RotL_64(X[15],R1024_4_7); X[15] ^= X[14]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-3,X); X[ 0] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_5_0); X[ 9] ^= X[ 0]; X[ 2] += X[13]; X[13] = RotL_64(X[13],R1024_5_1); X[13] ^= X[ 2]; X[ 6] += X[11]; X[11] = RotL_64(X[11],R1024_5_2); X[11] ^= X[ 6]; X[ 4] += X[15]; X[15] = RotL_64(X[15],R1024_5_3); X[15] ^= X[ 4]; X[10] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_5_4); X[ 7] ^= X[10]; X[12] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_5_5); X[ 3] ^= X[12]; X[14] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_5_6); X[ 5] ^= X[14]; X[ 8] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_5_7); X[ 1] ^= X[ 8]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-2,X); X[ 0] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_6_0); X[ 7] ^= X[ 0]; X[ 2] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_6_1); X[ 5] ^= X[ 2]; X[ 4] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_6_2); X[ 3] ^= X[ 4]; X[ 6] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_6_3); X[ 1] ^= X[ 6]; X[12] += X[15]; X[15] = RotL_64(X[15],R1024_6_4); X[15] ^= X[12]; X[14] += X[13]; X[13] = RotL_64(X[13],R1024_6_5); X[13] ^= X[14]; X[ 8] += X[11]; X[11] = RotL_64(X[11],R1024_6_6); X[11] ^= X[ 8]; X[10] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_6_7); X[ 9] ^= X[10]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r-1,X); X[ 0] += X[15]; X[15] = RotL_64(X[15],R1024_7_0); X[15] ^= X[ 0]; X[ 2] += X[11]; X[11] = RotL_64(X[11],R1024_7_1); X[11] ^= X[ 2]; X[ 6] += X[13]; X[13] = RotL_64(X[13],R1024_7_2); X[13] ^= X[ 6]; X[ 4] += X[ 9]; X[ 9] = RotL_64(X[ 9],R1024_7_3); X[ 9] ^= X[ 4]; X[14] += X[ 1]; X[ 1] = RotL_64(X[ 1],R1024_7_4); X[ 1] ^= X[14]; X[ 8] += X[ 5]; X[ 5] = RotL_64(X[ 5],R1024_7_5); X[ 5] ^= X[ 8]; X[10] += X[ 3]; X[ 3] = RotL_64(X[ 3],R1024_7_6); X[ 3] ^= X[10]; X[12] += X[ 7]; X[ 7] = RotL_64(X[ 7],R1024_7_7); X[ 7] ^= X[12]; Skein_Show_Round(BLK_BITS,&ctx->h,8*r ,X); InjectKey(2*r); } /* do the final "feedforward" xor, update context chaining vars */ for (i=0;iX[i] = X[i] ^ w[i]; Skein_Show_Round(BLK_BITS,&ctx->h,SKEIN_RND_FEED_FWD,ctx->X); Skein_Clear_First_Flag(ctx->h); /* clear the start bit */ blkPtr += SKEIN1024_BLOCK_BYTES; } while (--blkCnt); } #if defined(SKEIN_CODE_SIZE) || defined(SKEIN_PERF) size_t Skein1024_Process_Block_CodeSize(void) { return ((u08b_t *) Skein1024_Process_Block_CodeSize) - ((u08b_t *) Skein1024_Process_Block); } uint_t Skein1024_Unroll_Cnt(void) { return 1; } #endif skein-1.0.9.4/c_impl/reference/skein_debug.c0000644000000000000000000002211512641032067017010 0ustar0000000000000000/*********************************************************************** ** ** Debug output functions for Skein hashing. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ************************************************************************/ #include #ifdef SKEIN_DEBUG /* only instantiate this code if SKEIN_DEBUG is on */ #include "skein.h" static const char INDENT[] = " "; /* how much to indent on new line */ uint_t skein_DebugFlag = 0; /* off by default. Must be set externally */ static void Show64_step(size_t cnt,const u64b_t *X,size_t step) { size_t i,j; for (i=j=0;i < cnt;i++,j+=step) { if (i % 4 == 0) printf(INDENT); printf(" %08X.%08X ",(uint_32t)(X[j] >> 32),(uint_32t)X[j]); if (i % 4 == 3 || i==cnt-1) printf("\n"); fflush(stdout); } } #define Show64(cnt,X) Show64_step(cnt,X,1) static void Show64_flag(size_t cnt,const u64b_t *X) { size_t xptr = (size_t) X; size_t step = (xptr & 1) ? 2 : 1; if (step != 1) { X = (const u64b_t *) (xptr & ~1); } Show64_step(cnt,X,step); } static void Show08(size_t cnt,const u08b_t *b) { size_t i; for (i=0;i < cnt;i++) { if (i %16 == 0) printf(INDENT); else if (i % 4 == 0) printf(" "); printf(" %02X",b[i]); if (i %16 == 15 || i==cnt-1) printf("\n"); fflush(stdout); } } static const char *AlgoHeader(uint_t bits) { if (skein_DebugFlag & SKEIN_DEBUG_THREEFISH) switch (bits) { case 256: return ":Threefish-256: "; case 512: return ":Threefish-512: "; case 1024: return ":Threefish-1024:"; } else switch (bits) { case 256: return ":Skein-256: "; case 512: return ":Skein-512: "; case 1024: return ":Skein-1024:"; } return NULL; } void Skein_Show_Final(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t cnt,const u08b_t *outPtr) { if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) if (skein_DebugFlag & SKEIN_DEBUG_FINAL) { printf("\n%s Final output=\n",AlgoHeader(bits)); Show08(cnt,outPtr); printf(" ++++++++++\n"); fflush(stdout); } } /* show state after a round (or "pseudo-round") */ void Skein_Show_Round(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X) { static uint_t injectNum=0; /* not multi-thread safe! */ if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) if (skein_DebugFlag) { if (r >= SKEIN_RND_SPECIAL) { /* a key injection (or feedforward) point */ injectNum = (r == SKEIN_RND_KEY_INITIAL) ? 0 : injectNum+1; if ( skein_DebugFlag & SKEIN_DEBUG_INJECT || ((skein_DebugFlag & SKEIN_DEBUG_FINAL) && r == SKEIN_RND_FEED_FWD)) { printf("\n%s",AlgoHeader(bits)); switch (r) { case SKEIN_RND_KEY_INITIAL: printf(" [state after initial key injection]"); break; case SKEIN_RND_KEY_INJECT: printf(" [state after key injection #%02d]",injectNum); break; case SKEIN_RND_FEED_FWD: printf(" [state after plaintext feedforward]"); injectNum = 0; break; } printf("=\n"); Show64(bits/64,X); if (r== SKEIN_RND_FEED_FWD) printf(" ----------\n"); } } else if (skein_DebugFlag & SKEIN_DEBUG_ROUNDS) { uint_t j; u64b_t p[SKEIN_MAX_STATE_WORDS]; const u08b_t *perm; const static u08b_t PERM_256 [4][ 4] = { { 0,1,2,3 }, { 0,3,2,1 }, { 0,1,2,3 }, { 0,3,2,1 } }; const static u08b_t PERM_512 [4][ 8] = { { 0,1,2,3,4,5,6,7 }, { 2,1,4,7,6,5,0,3 }, { 4,1,6,3,0,5,2,7 }, { 6,1,0,7,2,5,4,3 } }; const static u08b_t PERM_1024[4][16] = { { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15 }, { 0, 9, 2,13, 6,11, 4,15,10, 7,12, 3,14, 5, 8, 1 }, { 0, 7, 2, 5, 4, 3, 6, 1,12,15,14,13, 8,11,10, 9 }, { 0,15, 2,11, 6,13, 4, 9,14, 1, 8, 5,10, 3,12, 7 } }; if ((skein_DebugFlag & SKEIN_DEBUG_PERMUTE) && (r & 3)) { printf("\n%s [state after round %2d (permuted)]=\n",AlgoHeader(bits),(int)r); switch (bits) { case 256: perm = PERM_256 [r&3]; break; case 512: perm = PERM_512 [r&3]; break; default: perm = PERM_1024[r&3]; break; } for (j=0;jT[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) if (skein_DebugFlag) { if (skein_DebugFlag & SKEIN_DEBUG_HDR) { printf("\n%s Block: outBits=%4d. T0=%06X.",AlgoHeader(bits),(uint_t) h->hashBitLen,(uint_t)h->T[0]); printf(" Type="); n = (uint_t) ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) >> SKEIN_T1_POS_BLK_TYPE); switch (n) { case SKEIN_BLK_TYPE_KEY: printf("KEY. "); break; case SKEIN_BLK_TYPE_CFG: printf("CFG. "); break; case SKEIN_BLK_TYPE_PERS: printf("PERS."); break; case SKEIN_BLK_TYPE_PK : printf("PK. "); break; case SKEIN_BLK_TYPE_KDF: printf("KDF. "); break; case SKEIN_BLK_TYPE_MSG: printf("MSG. "); break; case SKEIN_BLK_TYPE_OUT: printf("OUT. "); break; default: printf("0x%02X.",n); break; } printf(" Flags="); printf((h->T[1] & SKEIN_T1_FLAG_FIRST) ? " First":" "); printf((h->T[1] & SKEIN_T1_FLAG_FINAL) ? " Final":" "); printf((h->T[1] & SKEIN_T1_FLAG_BIT_PAD) ? " Pad" :" "); n = (uint_t) ((h->T[1] & SKEIN_T1_TREE_LVL_MASK) >> SKEIN_T1_POS_TREE_LVL); if (n) printf(" TreeLevel = %02X",n); printf("\n"); fflush(stdout); } if (skein_DebugFlag & SKEIN_DEBUG_TWEAK) { printf(" Tweak:\n"); Show64(2,h->T); } if (skein_DebugFlag & SKEIN_DEBUG_STATE) { printf(" %s words:\n",(skein_DebugFlag & SKEIN_DEBUG_THREEFISH)?"Key":"State"); Show64(bits/64,X); } if (skein_DebugFlag & SKEIN_DEBUG_KEYSCHED) { printf(" Tweak schedule:\n"); Show64_flag(3,tsPtr); printf(" Key schedule:\n"); Show64_flag((bits/64)+1,ksPtr); } if (skein_DebugFlag & SKEIN_DEBUG_INPUT_64) { printf(" Input block (words):\n"); Show64(bits/64,wPtr); } if (skein_DebugFlag & SKEIN_DEBUG_INPUT_08) { printf(" Input block (bytes):\n"); Show08(bits/8,blkPtr); } } } void Skein_Show_Key(uint_t bits,const Skein_Ctxt_Hdr_t *h,const u08b_t *key,size_t keyBytes) { if (keyBytes) if (skein_DebugFlag & SKEIN_DEBUG_CONFIG || ((h->T[1] & SKEIN_T1_BLK_TYPE_MASK) != SKEIN_T1_BLK_TYPE_CFG)) if (skein_DebugFlag & SKEIN_DEBUG_KEY) { printf("\n%s MAC key = %4u bytes\n",AlgoHeader(bits),(unsigned) keyBytes); Show08(keyBytes,key); } } #endif skein-1.0.9.4/c_impl/reference/skein_debug.h0000644000000000000000000000512612641032067017020 0ustar0000000000000000#ifndef _SKEIN_DEBUG_H_ #define _SKEIN_DEBUG_H_ /*********************************************************************** ** ** Interface definitions for Skein hashing debug output. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ************************************************************************/ #ifdef SKEIN_DEBUG /* callout functions used inside Skein code */ void Skein_Show_Block(uint_t bits,const Skein_Ctxt_Hdr_t *h,const u64b_t *X,const u08b_t *blkPtr, const u64b_t *wPtr,const u64b_t *ksPtr,const u64b_t *tsPtr); void Skein_Show_Round(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X); void Skein_Show_R_Ptr(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t r,const u64b_t *X_ptr[]); void Skein_Show_Final(uint_t bits,const Skein_Ctxt_Hdr_t *h,size_t cnt,const u08b_t *outPtr); void Skein_Show_Key (uint_t bits,const Skein_Ctxt_Hdr_t *h,const u08b_t *key,size_t keyBytes); extern uint_t skein_DebugFlag; /* flags to control debug output (0 --> none) */ #define SKEIN_RND_SPECIAL (1000u) #define SKEIN_RND_KEY_INITIAL (SKEIN_RND_SPECIAL+0u) #define SKEIN_RND_KEY_INJECT (SKEIN_RND_SPECIAL+1u) #define SKEIN_RND_FEED_FWD (SKEIN_RND_SPECIAL+2u) /* flag bits: skein_DebugFlag */ #define SKEIN_DEBUG_KEY (1u << 1) /* show MAC key */ #define SKEIN_DEBUG_CONFIG (1u << 2) /* show config block processing */ #define SKEIN_DEBUG_STATE (1u << 3) /* show input state during Show_Block() */ #define SKEIN_DEBUG_TWEAK (1u << 4) /* show input state during Show_Block() */ #define SKEIN_DEBUG_KEYSCHED (1u << 5) /* show expanded key schedule */ #define SKEIN_DEBUG_INPUT_64 (1u << 6) /* show input block as 64-bit words */ #define SKEIN_DEBUG_INPUT_08 (1u << 7) /* show input block as 8-bit bytes */ #define SKEIN_DEBUG_INJECT (1u << 8) /* show state after key injection & feedforward points */ #define SKEIN_DEBUG_ROUNDS (1u << 9) /* show state after all rounds */ #define SKEIN_DEBUG_FINAL (1u <<10) /* show final output of Skein */ #define SKEIN_DEBUG_HDR (1u <<11) /* show block header */ #define SKEIN_DEBUG_THREEFISH (1u <<12) /* use Threefish name instead of Skein */ #define SKEIN_DEBUG_PERMUTE (1u <<13) /* use word permutations */ #define SKEIN_DEBUG_ALL ((~0u) & ~(SKEIN_DEBUG_THREEFISH | SKEIN_DEBUG_PERMUTE)) #define THREEFISH_DEBUG_ALL (SKEIN_DEBUG_ALL | SKEIN_DEBUG_THREEFISH) #endif /* SKEIN_DEBUG */ #endif /* _SKEIN_DEBUG_H_ */ skein-1.0.9.4/c_impl/reference/skein_port.h0000644000000000000000000000324112641032067016712 0ustar0000000000000000#ifndef _SKEIN_PORT_H_ #define _SKEIN_PORT_H_ /******************************************************************* ** ** Platform-specific definitions for Skein hash function. ** ** Source code author: Doug Whiting, 2008. ** ** This algorithm and source code is released to the public domain. ** ** Many thanks to Brian Gladman for his portable header files, which ** have been modified slightly here, to handle a few more platforms. ** ** To port Skein to an "unsupported" platform, change the definitions ** in this file appropriately. ** ********************************************************************/ /* 2013-03-30: Modified to avoid brg_types and include stdint.h */ #include typedef unsigned int uint_t; /* native unsigned integer */ typedef uint8_t u08b_t; /* 8-bit unsigned integer */ typedef uint64_t u64b_t; /* 64-bit unsigned integer */ /* * Skein is "natively" little-endian (unlike SHA-xxx), for optimal * performance on x86 CPUs. The Skein code requires the following * definitions for dealing with endianness: * * Skein_Put64_LSB_First * Skein_Get64_LSB_First * Skein_Swap64 * * In the reference code, these functions are implemented in a * very portable (and thus slow) fashion, for clarity. See the file * "skein_port.h" in the Optimized_Code directory for ways to make * these functions fast(er) on x86 platforms. */ u64b_t Skein_Swap64(u64b_t w64); void Skein_Put64_LSB_First(u08b_t *dst,const u64b_t *src,size_t bCnt); void Skein_Get64_LSB_First(u64b_t *dst,const u08b_t *src,size_t wCnt); #endif /* ifndef _SKEIN_PORT_H_ */ skein-1.0.9.4/tests/runtests.hs0000644000000000000000000001413512641032067014554 0ustar0000000000000000-- from base import Control.Applicative ((<$>)) import Control.Monad (forM_, unless) import Data.Char (isNumber) import Data.Maybe (catMaybes) import Text.Printf -- from bytestring import qualified Data.ByteString as B --import qualified Data.ByteString.Lazy as L -- from tagged import Data.Tagged (Tagged(..)) -- from crypto-api import Crypto.Classes -- from filepath import System.FilePath (()) -- from hspec import Test.Hspec -- from this package import Paths_skein (getDataFileName) import Crypto.Skein main :: IO () main = do skein_golden_kat_txt <- getDataFileName ("tests" "skein_golden_kat.txt") kats <- parseKats <$> readFile skein_golden_kat_txt putStrLn $ "Parsed " ++ show (length kats) ++ " known answer tests" hspec $ do describe "Skein golden known answer tests" $ do skeinKats kats (undefined :: Skein_512_512) skeinKats kats (undefined :: Skein_1024_1024) skeinKats kats (undefined :: Skein_256_256) skeinKats kats (undefined :: Skein_256_128) skeinKats kats (undefined :: Skein_256_160) skeinKats kats (undefined :: Skein_256_224) skeinKats kats (undefined :: Skein_512_128) skeinKats kats (undefined :: Skein_512_160) skeinKats kats (undefined :: Skein_512_224) skeinKats kats (undefined :: Skein_512_256) skeinKats kats (undefined :: Skein_512_384) skeinKats kats (undefined :: Skein_1024_384) skeinKats kats (undefined :: Skein_1024_512) readMsg :: Read a => String -> String -> a readMsg msg str = case readsPrec 0 str of [(r, "")] -> r _ -> error msg ---------------------------------------------------------------------- data Kat = Kat { skeinType :: SkeinType , message :: B.ByteString , macKey :: Maybe B.ByteString , result :: B.ByteString } data SkeinType = Skein !Int !Int deriving (Eq) instance Show SkeinType where show (Skein s o) = printf "Skein-%d-%d" s o parseKats :: String -> [Kat] parseKats = catMaybes . map parseKat . groupKats . lines . filter (/= '\r') groupKats :: [String] -> [[String]] groupKats = go [] where sep = "--------------------------------" go acc (x:xs) | x == sep = reverse acc : go [] xs | otherwise = go (x:acc) xs go [] [] = [] go (_:_) [] = error "groupKats: didn't find last separator" parseKat :: [String] -> Maybe Kat parseKat ("":xs) = parseKat xs parseKat (header:"":rest) = case (isTree header, parseMsgLen header, parseBlocks rest) of (_, msgLen, _) | msgLen `mod` 8 /= 0 -> Nothing (False, _, [Message msg, Result ret]) -> kat msg Nothing ret (False, _, [Message msg, MACKey mac, Result ret]) -> kat msg (Just mac) ret _ -> Nothing where kat msg mac ret = Just $ Kat (parseSkeinType header) msg mac ret parseKat _ = Nothing isTree :: String -> Bool isTree ('T':'r':'e':'e':':':_) = True isTree (_:xs) = isTree xs isTree [] = False parseMsgLen :: String -> Int parseMsgLen ('m':'s':'g':'L':'e':'n':' ':'=':xs) = readMsg "parseMsgLen" $ take 6 xs parseMsgLen (_:xs) = parseMsgLen xs parseMsgLen [] = error "parseMsgLen: didn't find msgLen" parseSkeinType :: String -> SkeinType parseSkeinType xs0 = let (":Skein", '-':xs1) = break (== '-') xs0 (stateS, xs2) = span isNumber xs1 (':':_, xs3) = break isNumber xs2 (outputS, _) = span isNumber xs3 in Skein (readMsg "stateS" stateS) (readMsg "outputS" outputS) data Block = Message B.ByteString | MACKey B.ByteString | Result B.ByteString block :: String -> B.ByteString -> Block block "Message data:" = Message block "Result:" = Result block ('M':'A':'C':_) = MACKey block x = error $ "block: unknown block type " ++ x parseBlocks :: [String] -> [Block] parseBlocks [] = [] parseBlocks (header:rest) | last header /= ':' = error "parseBlocks: something went wrong" | otherwise = let (data_, rest') = span ((== ' ') . head) rest in block header (parseData data_) : parseBlocks rest' parseData :: [String] -> B.ByteString parseData [' ':' ':' ':' ':'(':'n':'o':'n':'e':')':_] = B.empty parseData xs = B.pack $ map (readMsg "parseData" . ("0x"++)) $ concatMap words xs ---------------------------------------------------------------------- skeinKats :: (SkeinMAC skeinCtx, Hash skeinCtx digest) => [Kat] -> digest -> Spec skeinKats kats digest = let get t@(Tagged x) = x where f :: Tagged d a -> d f = undefined p = f t `asTypeOf` digest skeinType = Skein (get blockLength) (get outputLength) myHashKats = [(msg, ret) | Kat t msg Nothing ret <- kats, t == skeinType] myMacKats = [(msg, macKey, ret) | Kat t msg (Just macKey) ret <- kats, t == skeinType] lenHashKats = length myHashKats lenMacKats = length myMacKats testName = if lenHashKats + lenMacKats == 0 then printf "has no tests for %s =(" (show skeinType) else printf "works for %s (%d hash tests, %d MAC tests)" (show skeinType) lenHashKats lenMacKats in it testName $ do putStrLn "Testing hashes..." forM_ myHashKats $ \(msg, ret) -> do let myHash = hash' msg `asTypeOf` digest unless (encode myHash == ret) $ fail $ concat ["Message: ", show msg, "\nExpected: ", show ret, "\nCalculated: ", show (encode myHash)] putStrLn "Testing MACs..." forM_ myMacKats $ \(msg, macKey, ret) -> do let myMAC = skeinMAC' macKey msg `asTypeOf` digest unless (encode myMAC == ret) $ fail $ concat ["Message: ", show msg, "MAC Key: ", show macKey, "\nExpected: ", show ret, "\nCalculated: ", show (encode myMAC)] skein-1.0.9.4/tests/skein_golden_kat.txt0000644000000000000000000146600412641032067016401 0ustar0000000000000000 :Skein-256: 256-bit hash, msgLen = 0 bits, data = 'zero' Message data: (none) Result: C8 87 70 87 DA 56 E0 72 87 0D AA 84 3F 17 6E 94 53 11 59 29 09 4C 3A 40 C4 63 A1 96 C2 9B F7 BA -------------------------------- :Skein-256: 256-bit hash, msgLen = 1 bits, data = 'zero' Message data: 00 Result: 52 D2 B5 FF C2 96 6C 06 BA 7B B0 CC 2B AB BC 93 5E 99 14 64 87 FB 36 1A 23 98 30 D4 D6 88 C9 88 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2 bits, data = 'zero' Message data: 00 Result: 86 66 FA 24 37 50 BE 24 C8 45 CF A1 66 41 91 94 DC 6B 1E 9C 91 23 0A 16 FF E4 04 B6 8D 04 19 7C -------------------------------- :Skein-256: 256-bit hash, msgLen = 3 bits, data = 'zero' Message data: 00 Result: 1C 87 FD F9 4B D6 05 DA 4C DF BC BA 94 94 44 94 C5 CC 90 3D 86 75 B7 AF A1 8A 03 29 D6 CD 39 43 -------------------------------- :Skein-256: 256-bit hash, msgLen = 4 bits, data = 'zero' Message data: 00 Result: AF 17 85 F0 2B 2B 19 43 EA 91 E7 EC 29 51 8C 4E 51 62 A0 63 D5 58 B2 0C 44 D2 6B F2 7C AD CB A4 -------------------------------- :Skein-256: 256-bit hash, msgLen = 5 bits, data = 'zero' Message data: 00 Result: 63 68 D2 1E D9 C4 5B AB EA 37 33 1A 92 66 47 27 0A E3 1A 78 BD 97 A0 70 D0 D2 0E 56 7A D0 EB 23 -------------------------------- :Skein-256: 256-bit hash, msgLen = 6 bits, data = 'zero' Message data: 00 Result: 79 70 60 AC 48 1D FE 00 98 46 B1 9C DA B4 29 6F B6 7C 8C EA AB 7F 64 49 46 4C 72 DD 08 1E D2 4D -------------------------------- :Skein-256: 256-bit hash, msgLen = 7 bits, data = 'zero' Message data: 00 Result: CF FC CE 54 EA 30 F1 13 99 73 A0 63 89 C9 7E 19 F9 CC 8A B6 91 14 9E 16 A6 B2 A1 E6 D8 02 CA D0 -------------------------------- :Skein-256: 256-bit hash, msgLen = 8 bits, data = 'zero' Message data: 00 Result: 34 E2 B6 5B F0 BE 66 7C A5 DE BA 82 C3 7C B2 53 EB 9F 84 74 F3 42 6B A6 22 A2 52 19 FD 18 24 33 -------------------------------- :Skein-256: 256-bit hash, msgLen = 9 bits, data = 'zero' Message data: 00 00 Result: FD DD 63 1B A8 79 6C 51 A1 F3 2D A4 E4 BB 7D 3F B2 AE BC 93 A5 1D 8D DA AC F1 E3 AC 6C 7A DE 5C -------------------------------- :Skein-256: 256-bit hash, msgLen = 10 bits, data = 'zero' Message data: 00 00 Result: A4 60 86 A6 D2 56 69 71 3B D5 80 B0 75 25 D2 E7 DE B8 6E D3 05 76 F7 8D 60 98 51 B7 62 F6 65 DC -------------------------------- :Skein-256: 256-bit hash, msgLen = 32 bits, data = 'zero' Message data: 00 00 00 00 Result: 69 60 42 6D 85 F4 F1 0D AA 23 21 3D E5 AD D2 10 1F 4C 1B 79 0B 53 0B F7 AA 66 F0 93 0B B6 B9 06 -------------------------------- :Skein-256: 256-bit hash, msgLen = 64 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 Result: 76 E4 8C FD E0 17 7E C9 B1 18 E7 DF 8F 0C 63 E6 60 39 B7 69 94 64 6D 32 7F 7A DB 6C EE A4 D0 E3 -------------------------------- :Skein-256: 256-bit hash, msgLen = 128 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 73 EC 78 07 DD E9 87 D6 96 00 D1 38 25 5E 4A F0 58 5C 6C A9 0A 6C 7A 4A DF 8B C0 25 A2 FA C3 94 -------------------------------- :Skein-256: 256-bit hash, msgLen = 192 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: CB C2 6D E4 C8 21 2B 6C 7B C4 E0 CA 43 79 0A 55 FB 19 A6 E4 7C 64 A7 7D 8F 8F B3 24 DB 12 68 41 -------------------------------- :Skein-256: 256-bit hash, msgLen = 255 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 4A 90 C6 FF EB 2D C6 60 29 9C A6 A5 96 0B DB 97 01 16 B5 A3 30 7F E4 75 A1 24 84 6E 85 11 71 12 -------------------------------- :Skein-256: 256-bit hash, msgLen = 256 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 0F ED 47 EF 57 B6 13 79 E4 A4 06 A8 FA 3F 8F B9 D3 80 DA FA DA 31 8F F1 49 1D 11 08 D6 60 0A 50 -------------------------------- :Skein-256: 256-bit hash, msgLen = 257 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 3E AE A9 96 FA D9 5B 60 32 65 4D 6C A9 3A C3 45 0B ED 8C 75 4C D8 00 04 60 A2 87 6E 34 E5 2F A7 -------------------------------- :Skein-256: 256-bit hash, msgLen = 384 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: FB F5 67 B1 42 34 F1 40 C0 64 54 EB 26 B8 39 68 DF 8A 8C FC CE 69 AF DE 33 A2 32 EB 22 26 13 7C -------------------------------- :Skein-256: 256-bit hash, msgLen = 511 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 89 93 81 0B 15 FA 33 2F C3 33 AA 2E A8 00 02 19 BC 77 7A E5 16 58 EC 3A 3A 72 E9 90 8A 39 E6 78 -------------------------------- :Skein-256: 256-bit hash, msgLen = 512 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 3E 0C A2 9E 48 63 E8 BE 4D 9F 28 77 7A 7F DC 67 60 32 C4 D9 F6 90 4B 1C B6 AA BB 02 9F 33 74 1A -------------------------------- :Skein-256: 256-bit hash, msgLen = 513 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: A0 CE D7 06 DE 22 FA 8C B8 46 8C D5 8F 4D 89 BD 14 1C F9 42 E3 03 79 F2 52 82 14 B9 AB 0A 4F 06 -------------------------------- :Skein-256: 256-bit hash, msgLen = 768 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 8B 09 13 FE 58 3A F8 38 E7 45 EC 90 11 97 84 82 FB 83 A3 C5 8E DA 5F A0 4F F7 08 32 B1 AC 63 9A -------------------------------- :Skein-256: 256-bit hash, msgLen = 1023 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 59 2C 4A AF 0B F1 F4 63 7D B9 CA FA E2 83 F5 2E 73 41 E5 62 ED 0F 99 33 9D 76 72 45 A8 00 0E 41 -------------------------------- :Skein-256: 160-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 2E 69 3A A8 CA FB 42 D9 0C 80 8F 7D 2F B6 C9 25 DF 61 82 75 -------------------------------- :Skein-256: 224-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: F4 B5 2F CE D0 C8 8E 95 A3 CA 67 B2 D2 D8 D8 D4 D2 DD 16 CA FC 0D B7 AE CE 57 0F 53 -------------------------------- :Skein-256: 256-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 35 DA 44 B9 1B FB 02 0E 6E 85 59 2E 33 10 A6 E6 D8 93 9A 64 C7 78 91 30 03 A6 1B C1 35 83 ED AF -------------------------------- :Skein-256: 384-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 20 ED 53 61 58 C5 E9 B3 FC 04 E4 C4 4B 00 95 74 4B 14 4F 11 B0 A7 31 21 3A 14 34 02 C8 FD A1 D6 04 6F C3 78 4C A3 D4 6F 3F 2A 9F CC AC B9 9B 35 -------------------------------- :Skein-256: 512-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 91 8A 1B 6D 20 01 5D 0B F5 3C F4 FD D3 9E 28 D8 BC 55 04 A9 6C 1D 31 0A D5 AD B1 5D CD DE A2 70 18 4F 94 67 45 1C D9 7B C6 24 D3 08 83 A0 06 33 64 57 81 5A 88 A9 FE B4 49 46 0E 4B 42 D9 66 AC -------------------------------- :Skein-256: 1024-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 73 F2 80 5C D8 AA CD 38 CE 95 65 7D FD C1 F9 2C FF C6 47 12 23 8D 54 52 0C 43 61 B2 FE 95 70 91 40 2E 40 21 D8 2E 55 2F AC 5E 01 5E 79 3C 4B D2 34 BC 24 83 09 F2 85 CF 21 45 56 AB 92 F3 DD 56 30 8E 3A D5 ED 9B 11 26 5F D5 70 8A 53 E2 45 64 76 4F 79 CC 39 E8 BF E2 AC 86 7D 36 84 F2 BF 8E 23 7D 98 7E 51 50 5B FB 6D D7 46 83 51 76 B6 D7 69 63 F0 A6 2D 4E 57 F6 49 C0 D1 00 06 7D DD FB -------------------------------- :Skein-256: 264-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 7F 3C 24 0F C8 FA 57 33 7C BC 0D 36 91 19 C0 AF 71 28 2A 53 BD B5 81 D0 A2 D4 3A D3 36 59 56 4F 67 -------------------------------- :Skein-256: 520-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 32 5D 9D 81 74 85 16 23 C9 AB AA D6 AD 6A 61 24 EB 21 E0 4E F0 40 B4 39 B3 E9 E9 25 B9 91 45 11 2D AC 7A CB D3 35 BA 83 34 90 6B 63 CE 54 00 37 C4 5E 4F 65 04 A3 5C 94 27 4D 03 F8 04 9D 59 7F D9 -------------------------------- :Skein-256: 1032-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: C3 5A 32 B2 CD 5C C7 AA 8B 72 4F 41 A5 E0 F7 FE A4 5C D5 18 F4 E3 99 1C AC A5 39 65 5D 50 39 60 38 60 A1 FA 48 CE D6 73 8C 25 A9 C2 46 68 2D 18 F1 FC 8E 18 98 58 CA 6C 8F CE AA 51 FE 73 2A 36 84 86 88 5A 33 13 D9 84 DB D9 75 D1 38 95 11 69 E1 3A 16 3A C0 2E 6A 36 7C 1C 9E 71 29 D2 E4 04 29 BB 49 3A F1 FB 08 FF 98 14 B1 ED 4B FA 91 90 09 4F D8 98 FC 02 6E 99 35 29 79 96 23 89 AB EA B7 -------------------------------- :Skein-256: 2056-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 6D A9 85 3C DB 81 A3 34 21 2F FD 6A B4 1D 2C 38 3F E1 F8 54 30 C2 B0 E3 4E C1 A7 D9 24 11 4E A3 3D 39 48 79 39 F2 03 38 2B 61 BC 56 48 4D 0D 52 EC C9 DB E9 7F 12 6F EF 21 EE 56 D6 57 20 AD F5 BF 10 1D 4F F4 E9 F4 AB A6 F4 EC 35 95 C8 0E 28 AB C8 2D 46 BE B2 B9 31 FE 36 06 1B B6 BA CE 33 B8 EA B0 73 98 D6 48 5D 30 DB 9E 70 DB E9 A5 F5 D4 42 CD 1D D3 CF 8D 98 37 EC 6A 28 71 74 96 93 C1 43 AB 0C E9 2A D5 27 6C 20 44 B0 DC 92 2F 55 57 2C F4 66 61 F0 82 41 38 DF A8 A2 48 7F 0D 8D D8 13 FB BE 60 2E 20 BF 25 35 A1 B4 ED 66 B5 14 9F 33 82 0B F0 E5 EA 74 23 FA 33 B2 E4 B1 92 46 8D BE 56 AD DE 36 EA 55 D0 DB 35 E3 26 96 80 68 BA 3B 28 34 43 AE C2 AC 8F 5F 1B CF D2 81 7D 77 9F 64 9E 6A 81 D4 2C 79 46 AC D2 33 C5 44 12 79 C9 85 F3 BE 40 ED F9 4B FC E5 92 0D C4 D3 5C D2 9F -------------------------------- :Skein-256: 256-bit hash, msgLen = 1025 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: CC 52 B7 C8 FF B1 69 96 98 A7 30 DA A0 77 D4 7B 6E 6A 29 FB B2 64 67 E0 9F EE 07 D5 F8 8A CA 45 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2047 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 9D 11 36 9D 8B B6 77 2A 50 55 01 25 BB 37 A5 12 D3 94 10 98 8A 78 03 84 C2 8B 49 E0 63 38 82 CA -------------------------------- :Skein-256: 256-bit hash, msgLen = 2048 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: E0 0F A9 CB 56 04 6C C2 D2 55 6E 2A DF 24 E9 2F 68 1A E3 FE 9B D8 C2 10 37 80 C2 99 38 D6 4F FE -------------------------------- :Skein-256: 256-bit hash, msgLen = 2049 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 29 74 00 18 60 D6 21 2B E3 AD 89 4F 31 B2 D8 16 01 98 EE 7E B0 EC AE CB F9 C4 98 BB DF 64 1D B0 -------------------------------- :Skein-512: 512-bit hash, msgLen = 0 bits, data = 'zero' Message data: (none) Result: BC 5B 4C 50 92 55 19 C2 90 CC 63 42 77 AE 3D 62 57 21 23 95 CB A7 33 BB AD 37 A4 AF 0F A0 6A F4 1F CA 79 03 D0 65 64 FE A7 A2 D3 73 0D BD B8 0C 1F 85 56 2D FC C0 70 33 4E A4 D1 D9 E7 2C BA 7A -------------------------------- :Skein-512: 512-bit hash, msgLen = 1 bits, data = 'zero' Message data: 00 Result: BF 96 B3 5C EC AF C8 AD 25 AC 72 07 E9 0E F2 79 FE 99 BE 45 94 AE 99 6F 72 69 68 C4 B7 99 01 8A 24 8D 80 15 29 52 C4 C3 15 89 77 6C 36 7E 7B 61 53 DC 0D BD F1 B4 79 D5 32 98 A6 32 8A A0 3F DB -------------------------------- :Skein-512: 512-bit hash, msgLen = 2 bits, data = 'zero' Message data: 00 Result: 97 3A A7 7A 56 2C A7 1B D5 40 59 8B 1A 88 B8 03 74 30 9B CA 89 CD F9 79 EE 4A D9 20 23 E4 9D 35 D0 EA D2 EE 8D F7 51 C3 62 42 BA 14 79 2C E7 FC AB 91 DD D1 CA 8B D1 18 A3 57 1D 65 81 14 11 CD -------------------------------- :Skein-512: 512-bit hash, msgLen = 3 bits, data = 'zero' Message data: 00 Result: 53 12 DD 38 A2 7B 52 7E 0F A8 14 7A 54 19 A8 6B CF A0 09 B9 8E 0D 49 D2 A1 85 BC D7 87 33 E0 B4 2F FC 06 16 24 56 A7 CE 41 3C 34 41 82 64 F8 B0 E4 A5 10 BC BD 80 A8 AA DA 66 89 BB C5 F8 0B E8 -------------------------------- :Skein-512: 512-bit hash, msgLen = 4 bits, data = 'zero' Message data: 00 Result: D8 8A 69 3B 6C 26 04 9D ED 03 51 91 91 00 4B 9A AB E3 34 28 ED 96 93 59 90 4E CB 0B DA 03 FF D3 F5 F8 C3 94 45 98 20 5A EC 25 79 32 DD 77 33 11 A9 1B 76 B2 53 D1 BA 0E 8B 0A 08 4B EA 88 46 3C -------------------------------- :Skein-512: 512-bit hash, msgLen = 5 bits, data = 'zero' Message data: 00 Result: 84 56 1F 7D 3C B1 88 02 3E 27 C8 30 18 C6 07 6F 4B AF E8 F9 7A 35 3C 83 1C 31 52 7C 1C 37 A8 2E 9D 10 2F DA 45 F7 20 5B 76 27 27 75 B4 D0 6E 3D 04 2A 23 A6 09 16 4A 44 B2 CE BC 1E 89 48 0D 11 -------------------------------- :Skein-512: 512-bit hash, msgLen = 6 bits, data = 'zero' Message data: 00 Result: 37 93 17 F2 68 D4 B1 88 1F 1A 04 75 86 F9 76 A8 BF 43 FC 40 0A F8 2B AD DB D8 FF A2 50 39 C0 B1 8E F2 7C 36 CF EC 7B FE 80 B9 F4 76 25 54 2D 8C 89 AF 31 2C F2 27 95 98 D0 B7 DD B1 BD 06 E7 BE -------------------------------- :Skein-512: 512-bit hash, msgLen = 7 bits, data = 'zero' Message data: 00 Result: 72 08 E0 3C 12 15 EB CC B4 4A F0 D4 E1 9A D5 D6 D9 FC 05 62 3D 2B 1E 0F 63 1B 09 12 42 0F 3A 3B BE 89 ED 1B 91 18 80 FB E7 57 21 56 C4 3B 6B 66 0D E4 FB B8 CE 7C 50 C8 FD 16 D7 EA 70 96 AA 6B -------------------------------- :Skein-512: 512-bit hash, msgLen = 8 bits, data = 'zero' Message data: 00 Result: 40 28 5F 43 36 99 A1 D8 C7 99 B2 76 CC F1 80 10 C9 DC 9D 41 8B 0E 8A 4E D9 87 B4 4C 61 C0 1C 5C CB CC 09 77 B1 D3 4A 4D 36 65 D2 0E 12 71 6D F9 34 D2 08 FE A6 60 7F 74 96 8E D8 6B E3 C9 98 32 -------------------------------- :Skein-512: 512-bit hash, msgLen = 9 bits, data = 'zero' Message data: 00 00 Result: 09 9B 62 E2 22 48 0C 7C 04 36 55 81 F7 5E 99 DE FF B9 B3 77 D6 72 69 69 C9 13 D4 4F DA 78 6A EE E1 58 78 40 C9 C9 CC E7 3C 70 AD 00 49 AA 25 C9 FC 1E 83 E6 80 94 76 5B 2F C9 AA B2 AE 14 AE 54 -------------------------------- :Skein-512: 512-bit hash, msgLen = 10 bits, data = 'zero' Message data: 00 00 Result: EE 15 8A 4F D6 5A 35 99 A1 AE 55 27 2C F1 6E ED 8E 69 54 1A A8 4E 34 57 7E 22 18 B6 7F 20 F1 19 6F F5 F9 6E 56 5D BF CF 1C 4D 5A 37 91 AB 1B 27 87 3B B8 CD 67 B0 DC B1 81 D5 86 33 26 93 4E 47 -------------------------------- :Skein-512: 512-bit hash, msgLen = 32 bits, data = 'zero' Message data: 00 00 00 00 Result: DD 01 C3 25 31 E8 10 0E 47 0C 47 80 9B D2 1F 84 30 7B 6B 8D A6 16 C4 6E A1 BB 4F 85 B5 47 59 16 FB 86 C1 3F AF 65 17 88 AA 17 21 65 18 C7 24 A5 81 94 8B 42 DE 79 15 96 D1 56 9E BE 91 64 8B 89 -------------------------------- :Skein-512: 512-bit hash, msgLen = 64 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 Result: A8 C3 7D 4E D5 47 F6 EC DC A7 FF 52 AC 34 97 7E 17 B5 68 D7 E8 F4 9F 0B D0 6C D9 C9 8E A8 07 99 9B 11 68 1B 3B 39 0F E5 4D 52 3B D0 EA 07 CA AE 6D 31 B2 26 D1 A7 07 5F C3 10 9D 98 59 C8 79 D8 -------------------------------- :Skein-512: 512-bit hash, msgLen = 128 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: FC 71 63 10 CF 81 B8 99 08 44 B1 95 DF A7 65 21 75 6F B0 C8 F2 60 47 72 05 6B E8 6E 83 DE D3 6F 25 77 A8 D7 D6 E3 D2 11 2F 46 37 01 6C 75 09 9E 27 1D F1 2D DC B3 25 74 33 F9 1B BE 97 0B 84 AA -------------------------------- :Skein-512: 512-bit hash, msgLen = 192 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 70 8B 36 3C 78 F1 5C B3 9D 85 82 4E A1 33 98 97 A0 03 A7 92 C2 A0 19 26 04 B3 89 74 07 58 B3 C7 D2 34 4C A8 F5 0F 49 3F 30 6D 84 68 69 5B 18 B8 48 EA C5 23 49 52 E5 AC 47 91 EC 88 E7 18 4C 37 -------------------------------- :Skein-512: 512-bit hash, msgLen = 255 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 86 4A 3F 1A 1A 29 1C AA 28 07 52 B4 99 11 C0 A5 D0 7A 04 5F 5B DF E9 E6 66 0C B1 DF 70 8C 81 82 40 7E 79 B8 A3 81 9B 98 D6 AB 7E 3E B9 83 9E 7E 64 70 C5 44 15 F9 2A FD D4 FA FA 25 52 BB 53 39 -------------------------------- :Skein-512: 512-bit hash, msgLen = 256 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 49 A7 F0 EE 7C AE B2 8E 35 A7 0C 68 04 55 71 ED 66 38 8A 6E 98 93 9C 44 C6 32 ED B2 CA 8A 16 17 CA 95 02 13 45 4D A4 63 E2 DF 5F 32 28 43 63 CF 38 6A 1E F1 30 87 A9 F8 26 EB B5 C8 6D EA C5 EC -------------------------------- :Skein-512: 512-bit hash, msgLen = 257 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: A0 55 50 60 F7 C3 A8 A8 C2 A1 14 8F 7A 69 7A 66 A8 75 10 D5 FB 1C AB 41 CF EC 12 9D 9D ED 18 7E B0 FE 29 B2 63 FE A3 D7 D9 76 4B 61 65 1F 92 43 B0 5B 64 10 F5 F2 D5 C5 CB 89 98 6D A0 E3 83 05 -------------------------------- :Skein-512: 512-bit hash, msgLen = 384 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: E5 D3 7D 8D 3D DC 6A 9C 5F 0B 5D F9 B8 40 EB D7 34 3D 25 EC 20 B8 48 92 BC A4 05 60 39 5D 90 C7 C7 AB 8E 4B 95 FA 2D 7B D1 83 F1 8D 8F DF FC 3B 1E 04 EE 73 F6 E2 D1 7E 92 FC 9C 74 18 3A 1E 8F -------------------------------- :Skein-512: 512-bit hash, msgLen = 511 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: B9 A8 5A 77 96 F0 AC C5 2F 65 8C EA F0 8E 7F 6E D3 D8 DD 57 BC 26 FB 86 E7 29 5F A5 89 26 C1 5F 27 F9 6A 7A 7E E5 3E 54 3F 08 EF C6 FD 3B 91 20 1A 89 E7 06 FC 4E 8C F0 B9 82 32 BA AE 86 A8 22 -------------------------------- :Skein-512: 512-bit hash, msgLen = 512 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 33 F7 45 7D E0 65 69 E7 CF 5F D1 ED D5 0C CF E1 D5 F1 66 42 9E 75 DD BE 54 A5 B7 E2 47 03 0D D9 12 F0 DC 5A B6 01 2F 59 CE 92 03 AB D8 2B 31 6D F6 7D 5C 6F 00 9A 18 BA 84 DB 03 01 46 DA 99 DB -------------------------------- :Skein-512: 512-bit hash, msgLen = 513 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: DC B0 0A 11 32 5F E2 88 15 E1 8E A4 5F 99 28 78 1B CC 06 53 10 6B D1 C1 DE 8E D6 0C A5 51 F7 F1 44 75 46 25 2E 56 7D 26 98 A8 40 82 86 5F CE B1 F2 FE 4D A0 D8 41 D5 6B 3B E1 EA 0E C0 17 78 C6 -------------------------------- :Skein-512: 512-bit hash, msgLen = 768 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 24 35 9E 4D A3 9D B5 B4 99 50 87 C3 17 3B D1 6D C7 3E 65 AB 7E C1 99 1F 7F A8 A3 DB 23 93 97 DC 09 C9 46 11 57 D9 39 B2 8F B8 10 7A 13 B3 1A 15 15 8B D0 0F 85 43 3A D2 AA E4 A1 B0 1B 25 E8 4D -------------------------------- :Skein-512: 512-bit hash, msgLen = 1023 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: C1 05 27 BC 77 C2 E7 DD FC 8D EB 8E E6 D8 28 A8 82 16 F6 89 E5 DC 1A F4 1E F6 39 7E 3B D1 E9 D1 C8 90 AD CC FE 68 A6 BA 7C CD B9 C2 96 F1 9B 79 72 A7 C4 73 FC 29 82 3F 84 A2 48 7D 93 15 69 98 -------------------------------- :Skein-512: 160-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 9C C1 81 0D DF E9 71 CF 71 FE D0 81 5D F8 62 92 6C 85 CA 6E -------------------------------- :Skein-512: 224-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: BE C6 A3 7A 9F 08 6B B2 39 7A E1 BD F0 00 EC 5E B8 7A D5 80 39 F3 61 23 A2 7E 0E F1 -------------------------------- :Skein-512: 256-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 2D 0E 2E 24 19 72 DF 39 BE 82 2A 8C 68 21 05 C6 47 47 FA F8 A1 0E C0 32 88 1D E7 DC 67 88 7C C2 -------------------------------- :Skein-512: 384-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: E6 3E A4 69 8F 31 4A D9 F8 F8 CB D1 F3 36 E0 27 95 5F 8D CE 78 C3 21 0A F9 B1 F4 6B D3 28 36 7D 8E 88 D4 31 07 1C 43 85 CD 8B 50 D7 48 62 C2 48 -------------------------------- :Skein-512: 512-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: FB E6 5B 75 D6 81 B2 FE 35 47 80 BD DF 82 CC F1 64 C5 CB 28 27 F8 E4 E7 DE 96 23 59 07 44 34 28 95 78 81 C7 6C E4 65 55 E2 BB 9E E3 4F 42 F7 A9 B2 E0 90 B5 5D 73 C7 A0 25 06 E1 7B BD FF A4 F2 -------------------------------- :Skein-512: 1024-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 4F C4 31 53 37 41 6A 60 15 74 C3 77 20 5A C5 17 23 5D AE 3D 39 C8 48 5E A5 19 08 AC 86 FB 43 55 D8 5C E6 BC 6F 2B 65 38 D9 BD B0 8B 69 4F 8F DA 4E 46 64 2A EE 61 43 84 28 E6 EE 7E C1 F9 4E AD C0 09 96 F3 A4 41 AA A9 1C 96 C1 91 67 F1 AB 21 0B 6C 99 AB 3D 64 95 92 16 6F 74 20 A9 94 C9 BD 32 BC CD E2 63 91 B0 9C EB 81 5E 2A 12 E3 DF 80 60 5D 70 78 FB 1B 8F CA F0 1B 17 54 CC 27 1B 6E -------------------------------- :Skein-512: 264-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 24 39 4D D2 1F BA 42 A1 D5 D2 30 2A 23 7F CF EA 34 5E 6E 45 C3 C7 D0 EA 9A B9 AE 37 4C 96 22 C3 10 -------------------------------- :Skein-512: 520-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: C7 78 61 B1 FC E6 7C 93 63 09 68 F2 1F 9E 3D 0C 24 D3 47 0E CE E2 05 EC 56 19 2F 23 00 E4 3B 56 D3 C0 63 F6 59 68 75 09 2A 10 8E 8A D3 4C 42 0B C2 F6 97 8D 4F 3C 2B B6 E5 39 49 A5 06 51 E0 0E 2D -------------------------------- :Skein-512: 1032-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: A9 75 80 15 F0 89 2C 5C FE 64 86 04 BA 7C C4 87 FB 6A CB 74 B8 AE C2 8D CF 24 A4 41 1C CD 46 39 B6 02 2C CA 7A 11 F8 B3 EC D3 E4 FB E5 23 B0 F7 AC F0 3C 57 FD 22 CD A2 8E EE 38 95 67 14 95 02 B2 55 83 14 79 2B 6C 01 EB 72 50 E0 4F 79 4D D6 CA 62 FF EC EA 43 B2 29 E3 1A B3 9D 3B 16 01 95 85 47 FB 13 3B 38 7C E9 86 A1 12 B6 53 5F C5 82 67 DB 07 BC 0B E6 19 BA D0 7F C6 D3 F5 53 79 B2 17 -------------------------------- :Skein-512: 2056-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 9C A3 3B E9 20 C5 2D 37 A4 12 17 4D 42 73 C7 1C 10 AD 2F F2 CE C2 F2 39 9E 14 BD 05 D5 85 42 AF 82 E4 E4 47 2A 9C 21 A9 D5 D3 56 25 A9 03 C6 92 5D F1 88 C8 23 26 B7 41 DE 2B 66 02 FA 09 0C 74 3F DF C0 F1 0E 08 68 ED 78 BB 06 7C F2 8A F3 C4 E0 43 B6 69 F6 7D 99 AB DC C3 C4 99 CC B9 C3 71 8F 49 04 1C 93 D8 77 96 60 7C C7 AD 52 DF 4F 92 86 42 2E 4E D2 3D C2 DA 1A 45 23 A1 58 CB 7D 3B C7 79 2C 80 8D 09 43 E1 2C 10 3A 6A FE 68 8E 58 6E 9F 39 C0 EA 88 E1 66 6F 84 06 3C 67 00 F5 4B FE 39 59 B5 FC 91 16 D9 21 A0 33 1F 3A 78 5B 37 3E DA 08 F5 FD A3 39 B6 D7 E8 3D FE 9B 40 3E 39 A2 20 4D D5 65 8B 50 23 CA 89 95 80 D7 49 F1 77 0A 1D 5F 64 A3 B7 0D 04 8B 15 D9 0F FA 7B 2C 22 A1 B2 B5 7B 84 20 AB 9D 05 3C 90 7A 8B F4 33 E4 28 F9 8F 31 EB 18 E8 9F D5 45 0F 68 6D 8D E8 19 20 -------------------------------- :Skein-512: 512-bit hash, msgLen = 1025 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: E4 BB 39 F4 1F FD 4C 58 35 60 DC A8 1D 0E B7 82 0A BA 4F 43 AF 3A 58 68 09 CB FC A2 3D 62 92 47 3A F2 A7 98 28 97 85 88 48 84 FB 62 44 53 DE B1 6D 59 DC DA F9 B2 31 5F 6E 06 BB E4 1E 38 EE 54 -------------------------------- :Skein-512: 512-bit hash, msgLen = 2047 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: C5 5A 80 88 FF 7E 91 49 BD 5B 93 09 42 3B 5E 2C FD 1D 58 68 04 76 48 92 BC F7 79 4E 57 B3 FF 4E FD 6E 3D BE CF 9C F4 B1 C9 1B 91 F7 A6 DD CA 37 FB 69 72 41 63 42 5B F3 CF D1 1A 1E B6 09 80 FF -------------------------------- :Skein-512: 512-bit hash, msgLen = 2048 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: D7 4F 3B 94 6A 59 D1 6A 50 FE D3 47 86 AC B2 3A EB 60 69 A1 56 7B DC C2 44 2A 54 C7 4A 4D 41 A2 4A 62 F3 F1 A7 6C 6B B4 4B D5 4A ED F9 4B 40 F5 3D 93 35 15 45 30 98 6C D4 F5 AA 16 F9 3D 2D 24 -------------------------------- :Skein-512: 512-bit hash, msgLen = 2049 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: B6 1F 47 B2 E9 07 A0 28 08 B0 77 64 DC 04 78 16 22 85 7A 66 9B EB F6 EC A2 E6 7A EE 9A AD A5 25 51 EF A5 7F 21 FE D7 52 78 AF 2C 9D D7 54 AB 1D B7 9E A6 A5 C1 F5 B0 93 12 04 9C 7D 73 5A 9D F0 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 0 bits, data = 'zero' Message data: (none) Result: 0F FF 95 63 BB 32 79 28 92 27 AC 77 D3 19 B6 FF F8 D7 E9 F0 9D A1 24 7B 72 A0 A2 65 CD 6D 2A 62 64 5A D5 47 ED 81 93 DB 48 CF F8 47 C0 64 94 A0 3F 55 66 6D 3B 47 EB 4C 20 45 6C 93 73 C8 62 97 D6 30 D5 57 8E BD 34 CB 40 99 15 78 F9 F5 2B 18 00 3E FA 35 D3 DA 65 53 FF 35 DB 91 B8 1A B8 90 BE C1 B1 89 B7 F5 2C B2 A7 83 EB B7 D8 23 D7 25 B0 B4 A7 1F 68 24 E8 8F 68 F9 82 EE FC 6D 19 C6 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1 bits, data = 'zero' Message data: 00 Result: D1 9B 5B 64 40 EC BD 3E C0 25 BF AB 19 25 F2 1D 2F 15 5C 28 77 83 04 6F 7E B8 C6 8B 34 DF 08 7B 64 87 BA 6D E4 15 C0 96 C8 D9 B4 EF B3 D7 B1 AC 2A 1D ED CA 7C 46 7E 6C AC 0E D3 F2 A9 0B 40 B9 EE C9 3D 5B 20 8B 55 69 D4 88 FC 86 D4 38 40 2C E6 1F F9 4A 00 80 2C F4 BA E1 F4 C2 73 A9 BA EB D9 D9 B0 D6 0E 3A F4 81 E2 5B EF D6 9E E7 1F 36 D9 EF 20 4A 19 42 CC FA E4 E3 3F CB 0B A5 D9 80 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2 bits, data = 'zero' Message data: 00 Result: 8E 54 9F C3 BB D1 E0 14 B1 66 CF 75 15 A1 4E 30 C1 80 51 9A 24 F9 42 C8 53 07 15 D5 9D FB 14 B9 4D 14 B7 DE 42 8C 64 28 28 B0 0D 11 3F 6A A4 30 52 20 A4 19 E6 22 EF 4B F2 FB 7B 86 37 A1 7A 5C E5 CB A9 43 4F 34 6B BF 45 52 56 9B 2A 22 27 66 03 73 F5 EE 1C F7 24 21 0B 37 83 E8 75 C2 6E 47 ED CB 0E CD A5 C3 67 9D BD 6E EC 89 DB 69 7F A9 DC 2B F4 C0 4D 20 FD 59 C3 7C B6 C7 01 5B 0F 9E -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 3 bits, data = 'zero' Message data: 00 Result: FC 4D E7 38 69 A3 10 B2 26 91 25 CE 53 72 41 E1 05 84 C9 BC B1 59 8F 51 CA FA 2D B5 E7 BA E1 B1 33 02 47 87 59 52 6B D1 BD 2D 82 13 00 A2 D4 48 7F 44 7F 01 69 F2 0B 1B 8F 19 A1 97 3A AB 57 53 F7 54 AF 08 04 17 F9 4A 68 54 1B F8 DB 8E E8 46 44 AA A6 CD 02 55 94 64 43 CD 10 21 37 F9 54 5C AD E3 60 14 12 80 B3 8D 41 38 37 B7 42 35 85 A6 E5 14 DA D1 4E 5F E8 19 3E 9A 64 8C 7E FD 3B 4F -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 4 bits, data = 'zero' Message data: 00 Result: E9 58 73 18 B7 AB A0 94 2A 13 17 9B 9E FD 67 42 2A 66 86 47 8D D7 02 51 1F 9F 35 CF 0D E2 B0 7D 51 22 B7 BD 5A 87 C3 93 01 6B 35 95 EB 06 C3 AE ED 10 CA 8E 09 99 04 E9 80 8D 66 52 FA D1 E4 4D 34 5E 49 59 C1 B9 7F 44 3C 92 BA 38 97 75 34 9B 52 DE AC FE E3 13 00 80 56 DC F0 3D 3B 13 9E 16 7A 9A 20 8E 0D B7 36 51 27 42 F6 F3 44 FC 89 5C 69 26 A2 D9 9A 21 CF 0F 99 BA 84 BE E5 86 D1 2B -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 5 bits, data = 'zero' Message data: 00 Result: 5E 8C FF 2D 02 D2 E5 AD 48 30 83 EE 85 08 F0 44 88 36 DF F8 EF 4D 52 B4 A8 59 49 C3 63 8F 8A E9 AF 7A 5D 43 C9 9B F1 92 54 69 B2 CA 01 19 6B EB 54 02 5B 88 1E 7C CE 9B F0 88 E6 6F 17 4E E4 81 33 B4 00 C3 8E B2 6D 4B 54 48 35 1F 59 15 38 C9 88 8F 59 8F 8C 10 22 0E 04 51 89 6D 74 3D 61 82 60 78 9B 2C 07 CC 77 D2 00 00 EC FA 46 4A 5F DB A6 E2 B3 94 44 A8 EB 75 F0 01 9E 8C AC E7 9A BA -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 6 bits, data = 'zero' Message data: 00 Result: 25 24 AA A6 79 11 C3 9E 74 10 C6 85 1A 53 BD 82 63 FF CA 4D 9E 27 30 35 4F E0 86 D1 24 0F A8 1F 0C 99 DA 44 14 90 16 78 54 4E CA 75 4B 70 97 17 0F 32 45 85 14 40 41 68 95 28 33 3D EF 59 C7 00 3C 34 AF 4D 65 52 39 36 58 35 49 C3 F8 94 B7 49 4E AA 62 51 C3 5B 48 0C DD 73 D0 4E B7 56 DC 6A 52 06 78 1E D4 D9 8F 37 66 15 76 74 FD 32 C2 3C 1A 84 95 79 E2 60 F7 B4 57 7B D9 5E D2 82 AA 2D -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 7 bits, data = 'zero' Message data: 00 Result: D9 87 B0 05 F2 5A 88 CD FA B8 09 C1 CC 99 8B 6F 67 C8 F8 CE 7A 11 3C 14 BD A3 26 29 D3 F5 CC 30 0E E2 94 DB 50 F4 3A 90 BC F5 73 04 E7 BE 1F 35 D2 C4 55 99 0A DE 29 F6 A5 8E 05 67 C0 F8 06 CC E0 A4 0B 88 66 34 5D DC F6 A8 CF 29 CB 44 FA 03 27 9C 58 76 47 9B 45 D7 BE 3E 72 B6 BE 9D AA 1B 0B 3B 48 F8 48 51 83 0C 30 B5 1E 42 69 8D FA EA 30 42 E9 A5 90 AC D9 5C 2F 28 82 29 B4 70 05 04 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 8 bits, data = 'zero' Message data: 00 Result: CC 66 6D D8 2A 8D 4D A4 88 00 26 5F 75 ED 5C 08 94 E5 97 12 2F 6B 55 47 A9 39 2F 2D 25 AD 55 62 C1 F9 05 61 E7 02 84 E1 9E C0 D1 FD 20 B3 7F D0 97 82 3E 28 90 91 5B D0 9A 4C E4 73 AB 9F A3 80 F3 2C F8 64 F9 72 CA 12 03 D5 23 75 AE B0 71 F7 15 9F C9 EA D7 54 8B 52 B0 1F 4A 0B 37 70 46 BD 6F E9 DC D6 92 31 2A 5B 60 30 BD DE C5 A4 ED B9 3C 56 81 67 49 0A C5 46 B4 A6 AE A3 F6 30 31 91 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 9 bits, data = 'zero' Message data: 00 00 Result: 8E FE 18 60 A8 6D E7 55 BA 08 A7 CD 65 59 51 CD 6E 6B 84 26 BD EB 3D 98 63 9F DA D6 EA 41 3B 55 D2 DB D0 54 92 01 99 55 DD 43 61 45 CA 1F 82 C5 CC 3E B6 2D 18 DE 23 16 D7 70 03 AA 70 CD C2 2D C0 AC AE C3 0A 03 2C 68 52 8B A6 0B 40 89 02 90 72 7C 27 EA BE 07 B5 E8 A9 28 B3 B1 7C 40 D0 DE 63 70 29 50 EF 44 DF 1B 20 07 D7 29 39 51 AC 8B 01 41 2C 54 5D FB 52 4C B3 67 1B BA CB FB 26 E1 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 10 bits, data = 'zero' Message data: 00 00 Result: 3C 19 E2 1C C9 48 50 C5 BD C3 3A EA 76 AE C0 92 C9 30 B0 6F 04 4B C4 DC 53 AC 26 7B 84 DE EC F5 91 C7 23 5C AE E1 64 E0 B0 4D C8 93 C7 86 D8 31 9A FF 40 50 2A 17 F9 FF 75 0F 64 67 5D 41 08 AF 3B AE 97 2F 0B 4C 29 B4 C5 FC 2F C4 E5 13 24 84 FB 9F 25 9B CE B1 89 8A FF 78 5C A0 3B F6 5D 11 44 96 90 DC 86 1C A1 45 9F 30 17 E1 77 3B BB 46 84 16 39 A6 72 C6 5A 18 8D 0A D1 28 B6 A8 23 D1 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 32 bits, data = 'zero' Message data: 00 00 00 00 Result: B4 C6 A5 C2 31 08 57 3B 3A 4F 0E 06 92 B9 BE 53 E6 E0 16 44 C5 15 21 48 FE 93 B3 B2 81 E3 45 0D 5D D0 FE 3F 62 16 09 6D 48 97 B0 E8 65 F6 AF CE 1C 13 17 09 15 30 99 CB 1E 86 28 6B 15 C4 2E 83 65 C4 51 B8 E9 7F 04 6D 2A 7A 41 28 AD A3 BC 68 AE B8 D5 9D 60 4B 12 75 C8 9F D3 F6 35 11 88 BF 82 ED E1 BF 4F B4 B2 2F A4 58 AE 8E D3 41 94 66 B6 EE 21 53 92 01 12 AB BD 6A 66 0F E8 C9 49 E0 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 64 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 Result: BB 80 34 F4 41 A8 2D 5A 14 3D 19 FF E5 52 B7 96 25 13 4E 9D BE 14 DC 51 4F EC FE 7C 33 12 F3 0C 63 3B 36 1C 68 6E FC 46 07 FE 81 63 99 EE AE F3 9D 4E 9E 81 F0 FE AB F6 73 F0 D7 79 88 46 FB DC 4D D7 7E 75 FF 8D 97 70 43 03 1B F8 08 39 06 3E 4A 03 03 E1 19 38 FB 2F 5B 28 9C 58 98 17 74 A5 7A 51 6E 0F 47 E9 0A 08 D8 2F D3 A2 D0 DC 28 7C 6D C7 22 B6 FF A7 E5 95 0C 65 89 2B 55 1E 18 7F -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 128 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: B6 90 A3 09 B7 AC 0E F4 68 F9 C4 7D 4A 50 F7 AA 3A 78 24 26 DA 68 F9 6A 2A E7 FB A5 E8 89 20 6A 5D E0 D6 1A 4C 68 40 EB 14 FD 1F 50 58 11 B6 C1 4E B2 F0 0A 81 C6 1E 31 C7 9C 02 3D 75 92 4C 6E 52 ED 48 2B 9B 9B 5B 4B 2B DD 5F C4 4F 7A 42 9F 51 D0 95 41 3C 9E 78 0E C6 92 A8 DB 58 1D D1 58 5B 6A 67 BE 35 B4 0E 7D 4D 49 6A 94 E4 73 87 F6 1E DB 27 FC 6E 8E 32 86 0C 5B 8B 04 6E 0A 75 11 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 192 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 56 7D 7D E9 43 79 FA 5F 83 26 6F FF C2 09 45 FD 84 B3 D7 96 5D 56 B6 A2 AC 84 3B 2C 7A 24 E4 92 E2 C4 98 41 1B BC 1E 38 E6 A3 D1 5B D1 3A 19 2D 7B AC F2 88 5E AB D6 C1 9B A1 3F AF 26 B7 30 0D 1C 2B D5 28 2F A0 59 A4 C2 C4 B6 9B D6 03 20 BF 0E 1C 48 28 5F 84 F4 A2 A6 38 06 AB 4B C4 61 7C 60 F7 31 AC 9B 3F DF 91 04 3F 75 C2 93 C8 B5 43 AB 49 C4 2D 18 5F EF 4F 25 F2 47 9F CD E2 29 5F -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 255 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 41 D6 01 57 02 26 C9 13 F9 8E C0 91 49 7C E4 9A 04 BC 34 EF 5F 77 F4 02 37 1C 33 BD 44 85 26 F8 32 0A D3 CF 9B 48 CB C1 5C B0 E2 7A 48 A4 5C A5 0E CF 1D E3 C6 DC E2 FB 4B 49 96 D8 DF 0E A0 8E 00 A3 36 74 FD CA 10 6D B3 5F 0D C6 08 EB 95 58 C1 43 FA 4A 92 8A 76 57 AD 92 46 53 77 87 38 24 09 E3 BB 67 F4 56 54 44 8D EE C4 64 C1 CC 9D 27 CA 70 B0 E0 F6 54 48 7C 5A B7 DA C8 E0 EC 3B 72 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 256 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 32 73 08 74 67 48 85 78 33 0F F2 DE C2 9F 69 10 89 BC 95 C7 70 F5 AC 37 57 1A F4 0C 09 2A E6 E1 24 D1 F3 AC 80 17 EA 44 3D 67 20 96 78 C2 69 4A 62 8F 22 3B BE 4B 76 A2 BE B6 3C 61 17 28 7F 78 2E 7D DF E3 FA C3 A9 A3 58 25 91 CC 1F 9C 57 A6 C1 81 D1 36 9A B3 AD 23 40 60 6B AE F1 1C 3C CD 6E 09 0B 69 54 A5 E1 10 23 92 B2 78 1E 98 69 C5 1E D9 33 8A 3D 32 C9 F7 06 C0 28 E2 DA A8 7B CA -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 257 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 97 72 24 B4 11 C0 51 81 B0 A5 63 D4 6E 3A E3 02 D0 CE 5B 72 C7 E6 A0 8A 6D 03 6B 6A 76 02 71 9C 45 15 2A D9 01 80 AB 28 EB A8 46 8B 9C FA E6 1E 5D 09 C1 11 CC E5 DE 57 74 27 D4 D0 5A 08 5D 5E 69 37 3A 3C 35 60 5D D0 70 0C 76 99 E7 67 AC BD 12 2E 09 BF F7 A3 6E DC 60 44 D8 33 6E BB 26 B3 AA 65 86 AD CB E9 9A 53 2E 7B 79 82 A5 A8 CE 32 BB 0D 7C 61 D0 F9 BD F0 74 9E 5D 1E 87 8A 19 26 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 384 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 18 02 D7 05 C2 41 81 EA A3 1B A8 B4 6A E8 18 06 C1 F3 E9 2D AE 65 AA B9 25 4A 1F 99 C2 F3 10 89 1C FC EF 5F 22 1A 6E AA 99 58 90 B9 A9 57 20 C6 F6 D9 73 07 BA 4F 62 D3 DC 7B 85 FB F9 8F BB 70 2D 64 E5 11 FA CD 98 EB D5 99 4A 6F C8 81 FA 5A 64 0F C1 BD FB EE BC 95 4E F1 73 E8 99 45 4B 3B 1C A5 AA 87 1A 12 09 AF 83 6F 2D 5D AA 54 BB 98 26 8C 1B D6 E8 4B 0E 99 7E C9 93 48 A6 AB A7 E2 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 511 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: A1 8A EA 5D 11 D9 AE 89 75 4B 1B 97 13 E8 51 D5 E2 D0 10 35 D2 05 F1 EB 82 E2 A2 5F 9C 7F 4E 0F C3 A8 DD 29 F8 BB FC 86 F7 86 B5 5A 61 DA 7E 7F DC 0D 79 F5 08 61 D7 33 B9 90 A9 1E D1 7E CF E8 A6 FA C5 C0 B7 AF C8 9D A0 D0 1B A9 C7 2C 21 00 B1 FB 1D D5 E8 2F 15 58 38 11 97 A3 D3 68 A4 25 ED E7 ED D9 E8 E5 40 8F 24 4D 7F B7 7D 5B 6D A3 96 51 BE D2 F7 6C 9F 2B 4F 5D 82 95 69 69 FE 8C -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 512 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: B0 01 53 6B A6 C8 FB 70 00 49 B2 E8 F6 2F 93 31 94 F1 3A C3 E9 6E 99 42 F8 54 C9 59 51 0D 41 7A E0 D4 36 B0 2A 7E CC B1 EC 3F 17 C7 E8 BC 27 8A 23 A6 69 0E BF AC AD A0 8F 26 6E 28 D6 02 51 3A 8F 06 72 9A 91 B9 D0 E0 67 E6 CE 4B 3F 95 42 F0 04 B7 3A 6A E3 21 0E EB 1A 41 F7 6B D0 D7 FA E2 FB 03 55 E7 37 58 B3 D1 FC E0 2E 8C 13 00 CB 69 DB 99 FA F9 5A 7B D9 1C 42 FA 6F 65 25 A5 2B 34 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 513 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 8A D3 60 FA B8 49 3B 8D 9C 78 C4 15 6D 1C 8E 3E 93 31 6E AF 22 34 A9 0A A4 0C AF 5E C9 A6 68 67 58 D1 72 C3 A5 7B 36 20 AC AB 28 F1 61 B5 10 5E AA 0A B7 F3 EB 71 07 D5 E6 97 B3 51 5A E3 C4 18 E2 0A F6 22 FE 8C 01 C0 75 17 8E D7 C1 9E 24 BC D6 58 D8 31 D3 EF CD EB 6C 12 55 1E 9F F6 E1 04 D1 C6 48 4B 00 E3 AA 1F 94 B1 B3 44 46 6D 41 CB 98 7E 0C FD 77 47 05 B9 74 41 EC 6F 13 13 DF 9D -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 768 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: F8 55 17 38 13 D1 24 CE 99 66 14 2D F6 4D C4 F2 F8 82 B5 9F AC 63 AD 51 2E 2A 6F 69 F0 BE F5 C2 5C 28 BE CC DA A9 D7 20 67 F8 88 66 47 4D EB B5 9A 42 26 D2 BD 6D 03 52 C7 55 B6 E0 9A 77 EE 98 1B 5D 1D 29 D9 36 52 7C 1B 94 3A 25 88 42 0A B8 1C 93 B4 59 BC F4 AD E1 D2 6F 6E BD C1 92 71 0E 70 90 D2 3C 1A 18 9C 7C EE A3 0A 6F D6 D3 A3 A6 A6 C9 63 BB EE 9A A6 48 99 7B 2C 59 90 69 FC 74 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1023 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: B3 C6 2C 7B 92 3E 67 BE 49 6F 8E 6D D4 7E A4 E0 04 32 9F 96 63 E6 35 4B 14 D7 3A E8 E9 CD 29 01 4D 06 2D 64 44 EF 0E 89 52 56 3C 21 4A 46 89 96 C8 8D 20 18 C3 B9 FA B4 84 84 48 57 1B 55 85 3D D5 12 5A 59 9B 44 2A CF 00 75 5D 91 13 26 FD 62 CB 49 D6 4E 13 D2 20 D1 44 CF 29 C4 24 6E CD 52 E7 C4 2A 4F 99 1D DA DD DD 5A DF B1 03 32 9E F5 02 2B 69 87 3F 5A E9 CB 4B 2C 1E F9 E8 8F F4 F8 -------------------------------- :Skein-1024: 160-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 7C 94 3C 8C D2 BE 40 4E 87 C3 A0 FD B5 04 99 A3 95 44 7A 84 -------------------------------- :Skein-1024: 224-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: A7 BF 35 94 3E F2 09 C7 01 C0 66 DA 52 26 69 70 D2 44 A5 8F 08 C2 7D E5 4B E7 41 34 -------------------------------- :Skein-1024: 256-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 35 EB 69 E5 04 AF 45 4E 83 4A F1 A4 73 41 8D 69 B7 26 38 DD 75 68 95 75 39 AB 6A 15 48 39 F4 E9 -------------------------------- :Skein-1024: 384-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: B4 0D 9E 51 10 DF 88 37 6A A7 44 D6 55 44 D2 6E 8C 57 05 B2 D4 61 EF F6 FA ED 65 EB CE 94 58 3F FC 53 99 A5 FA C0 0B FF 11 84 52 3B C5 5B AC 0A -------------------------------- :Skein-1024: 512-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 2D F8 9E 10 21 07 1C 13 6C A6 8C 02 0D 0A 67 0D 98 0D C7 75 0D 23 BB 08 4D 7B FF 10 CA 2F 2F 51 FA 1E 58 4D A8 58 DF 1F C5 82 87 B7 C6 F2 BE C2 C4 8D CA AF CC D3 5F 46 82 E6 87 59 B6 2B 6A 70 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 81 18 D1 74 A0 BC 09 50 5A 2F 67 7C 6D CB C1 B8 C5 A7 C6 72 0F 6C 59 D6 0A FB C7 CD 6F 64 E2 0A 92 B6 40 95 C3 9E DB 56 A2 F4 7C 26 83 C5 11 6F F3 58 FD 96 9E 76 D4 4C 1F 50 C9 2B 26 17 1A 33 FA 9E EB AF 0D 1F 32 0D 41 44 BC 97 EA 00 D5 9F 00 59 86 43 43 9C C1 3B BD AD DD E6 67 1A 89 E9 A4 0D 30 02 A2 93 00 E7 C6 65 B6 06 D8 B7 16 72 54 78 7C 86 7B E8 14 1A 56 E8 D1 14 58 65 CC B9 -------------------------------- :Skein-1024: 264-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: EB 10 A2 4C CD 60 A8 A1 12 1B 72 AC 09 4A E3 58 34 94 00 7F 57 64 34 52 C6 3E AE 9B FF CB 4E 40 41 -------------------------------- :Skein-1024: 520-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 28 30 B7 87 DB 1A AF 66 52 92 C4 F6 5B EB 75 38 12 33 15 51 C2 41 DC EC 91 E6 97 9E 9F FC 04 5C CF DB 2D 86 70 DE 81 DA 38 F8 E2 04 BF C2 00 EF C6 F9 2F F9 F6 AA 13 17 E2 C6 17 B9 A4 28 5B B2 2B -------------------------------- :Skein-1024: 1032-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 26 98 D7 23 40 6F 91 42 89 D0 04 A6 17 69 65 FC 25 34 E0 50 92 EA 5E A8 8D 7E E9 21 8C C1 07 7F A1 1A 12 9B 76 AB 3A 24 D0 69 49 C5 99 D9 47 29 E8 A3 D2 9D C7 C0 5B 4A A5 36 2C CD F3 F2 32 3A 5B 63 F3 4E C5 D7 1D A7 9E AF 2C E5 F5 F9 89 A1 7F 80 A9 37 07 5E 71 7E E8 B6 37 DB 49 C2 60 8B B8 4F 27 6C 34 D9 37 5B C2 D4 A4 29 F6 63 0A 24 5C F2 01 7E 7C 28 45 E3 37 F0 A4 F7 63 C5 63 AC 4D -------------------------------- :Skein-1024: 2056-bit hash, msgLen = 1024 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 5B 2D D6 A0 44 5A FB A8 2B 84 E8 70 90 72 F7 72 61 4A B2 CB 7F 28 23 19 59 62 20 6F 16 3F 25 0C 66 36 30 E3 27 73 EC 73 42 7E B7 99 FE AC 47 50 FB 85 49 33 2C 45 BF 1F EF 12 69 3D F7 44 CF BA 61 A2 04 1C 3E EC DC 8F 8E C8 DB CD 3E 76 C4 C8 D8 1B 20 8E 87 E3 C9 6F 7A AE 95 7C 61 41 CE D5 56 37 42 97 05 B4 63 B8 8E 10 0C BD 5F 25 12 37 F5 5A E2 E3 3C BC 8F CC 1C 96 04 67 58 F9 94 FF FD 7B 8B 68 A1 FD C7 27 00 43 9A E3 80 66 5F DD ED 73 74 F1 8F 5F 8F B5 84 32 91 C0 5B 1D BC 0C B4 20 26 33 74 03 F9 AF D4 84 53 62 5B 47 93 66 DF 41 C8 A6 20 C6 AA A7 B4 AC 06 18 13 02 F3 13 4F CF 60 25 09 67 B8 C7 B1 D0 C3 2B B9 5E 40 D2 4E C3 77 69 45 3B F2 1F C3 60 DC BB 9B CE 3F E6 82 49 C5 FE 44 CE 9B F8 06 86 C2 96 1E 1D 25 86 CE 63 E8 1A 33 BB 00 31 F9 C3 F6 D3 45 D5 95 DE CF -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1025 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 85 D6 51 D7 E8 1C 1A CD 15 1F 4E E6 D0 F9 8E 1E 88 45 F3 19 03 29 6C 43 04 34 46 12 93 D0 43 2E 64 E4 22 9C E7 F3 88 5D E5 40 7A 6A 0A 68 6E 67 1F 86 58 08 77 D8 40 65 7C 16 2D 79 8E A9 34 96 7E AC 30 78 B5 A2 DF 3C D4 4C 47 45 E4 CD A7 9D 81 70 16 BC A1 4A FD E6 12 04 6D 16 D2 36 C8 D4 08 EF 3B 91 B1 CC 03 4A 46 B1 44 42 7D B0 EC 2A 1D 75 8A 41 DC 47 35 D9 BD 15 75 70 09 14 03 06 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2047 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 6F FE 3F B8 4E CB D1 09 17 D8 71 3C 65 EE 99 E4 AE 5D BA 1D C2 88 B0 A7 0A 27 B1 86 C0 8B 0A 83 CD CE AE 23 5C C9 04 95 BA BB D6 E7 DB 1F D2 62 D5 CB 32 E7 27 8A 9F 36 3D FE 32 4E E3 E2 C3 51 18 E9 14 DF 17 BE 06 1A D9 97 72 34 E5 F5 10 8F 1C 47 BE BB 87 8C F1 26 CA 69 8A 60 DC EA A3 91 64 12 C3 FD 3C FF 63 EA 6E 4C 68 10 B1 E1 C9 C5 73 CA 40 9F 78 E0 1F F3 41 0C 24 46 45 EA 2B 1B -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2048 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: 4A C1 25 1B 3D 81 64 88 C7 81 71 D9 33 18 F1 44 C6 96 26 15 29 7F DD 33 7A C2 28 80 79 1C 41 90 99 F5 F7 A5 FC 8F F3 80 5C 39 81 02 73 27 CD 8C 63 3F 39 A6 FE 2B 5A EE E5 15 39 76 A3 6C 90 99 F6 00 AE 87 4E 9C 07 E5 7E 15 60 B8 D8 ED 91 35 26 3E 27 C2 02 7B 5F 71 20 A6 2D C3 26 67 E1 0B 10 E6 FD 23 0B 5B A1 A4 E0 4E 92 F5 18 2B BB 57 00 80 0B C2 68 4A 43 9A 78 E0 F9 25 EC E3 DE 86 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2049 bits, data = 'zero' Message data: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 Result: E0 61 E9 8E BA AF E4 C1 F1 DA A6 BA AA 75 69 F3 A9 BC 17 73 29 35 21 57 AB E7 C2 CB E2 CA 44 B6 6F 1A 4B 08 33 C1 30 B8 5C 28 AD E3 79 75 C8 26 44 70 C5 1A 83 A1 54 E1 4B 74 7B D2 23 AC E1 27 4F 68 02 08 D0 7D 0C 6D 5B 1A 31 D2 72 BF 94 D7 EC 70 20 BE F1 5D 24 2B E3 D8 0C C9 D9 E1 E4 AB F4 0D 31 19 97 22 91 EA A5 DE C6 A2 E2 66 5E 03 C5 BC DA F9 E9 AF F9 07 C8 A1 68 09 83 96 5A DE -------------------------------- :Skein-256: 256-bit hash, msgLen = 0 bits, data = 'incrementing' Message data: (none) Result: C8 87 70 87 DA 56 E0 72 87 0D AA 84 3F 17 6E 94 53 11 59 29 09 4C 3A 40 C4 63 A1 96 C2 9B F7 BA -------------------------------- :Skein-256: 256-bit hash, msgLen = 1 bits, data = 'incrementing' Message data: FF Result: C4 51 43 CC B1 24 11 FE AE 63 17 20 3D 67 D9 E0 77 69 B8 F7 20 C8 AE F6 17 A6 9E 69 D1 67 9E 53 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2 bits, data = 'incrementing' Message data: FF Result: 85 91 BE 2B 7A C2 89 42 E5 B8 D6 92 4D 4A 09 97 D6 8E 34 30 12 98 E6 7D F5 EE AB 6B CF E0 0D 96 -------------------------------- :Skein-256: 256-bit hash, msgLen = 3 bits, data = 'incrementing' Message data: FF Result: 26 9B 99 A8 EC F4 BF FA 1C 05 24 4E 2B 8F 9A 5E 74 5B 8D 47 A9 B5 A5 17 77 9F D8 29 7A 3F 8C 44 -------------------------------- :Skein-256: 256-bit hash, msgLen = 4 bits, data = 'incrementing' Message data: FF Result: 62 E6 E2 0A A6 AB 34 3F 99 73 F0 61 10 45 BD C1 E6 D1 CB AA 27 4A 7B A1 46 23 41 F4 95 33 B3 16 -------------------------------- :Skein-256: 256-bit hash, msgLen = 5 bits, data = 'incrementing' Message data: FF Result: 57 15 1F 10 D3 D4 96 9F 2D 3E 2C 93 E9 D7 EB 8E 85 26 53 E7 D8 8B 60 10 4B 18 3C 7B 4E 5D 65 BB -------------------------------- :Skein-256: 256-bit hash, msgLen = 6 bits, data = 'incrementing' Message data: FF Result: 76 24 DC F5 C1 86 34 05 CD E3 15 AC 07 94 1C 4D 15 F1 4F 00 49 0B A3 9E 81 7A F1 8B 1C 5B EB A8 -------------------------------- :Skein-256: 256-bit hash, msgLen = 7 bits, data = 'incrementing' Message data: FF Result: 24 36 18 CA E4 CD BB 9A F2 28 B8 C5 CE E9 D5 CF DB C4 56 65 6D 3C 26 4D 61 1A BC 19 4B 9E A4 C9 -------------------------------- :Skein-256: 256-bit hash, msgLen = 8 bits, data = 'incrementing' Message data: FF Result: 0B 98 DC D1 98 EA 0E 50 A7 A2 44 C4 44 E2 5C 23 DA 30 C1 0F C9 A1 F2 70 A6 63 7F 1F 34 E6 7E D2 -------------------------------- :Skein-256: 256-bit hash, msgLen = 9 bits, data = 'incrementing' Message data: FF FE Result: 3F 34 82 F7 78 88 DB 0E E6 04 51 65 30 8A 47 48 03 44 19 C8 C5 11 C4 94 AD 73 3D 4B 6F 7D 9D 11 -------------------------------- :Skein-256: 256-bit hash, msgLen = 10 bits, data = 'incrementing' Message data: FF FE Result: 52 38 6B D5 35 B0 57 66 AD 78 8E 6F 63 01 D2 D0 20 70 E5 E1 F1 36 E7 18 B3 2F 29 C6 BE 69 8B 0E -------------------------------- :Skein-256: 256-bit hash, msgLen = 32 bits, data = 'incrementing' Message data: FF FE FD FC Result: AF B9 2D 1E 32 FA 99 49 3D E9 27 6C 6C A5 28 CB 6B 33 FF 0A D2 00 F3 39 C0 78 10 02 A1 37 34 BF -------------------------------- :Skein-256: 256-bit hash, msgLen = 64 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 Result: 0B 5C A5 67 12 AC 0D 94 50 BD 83 98 47 9E 28 24 6C 32 96 47 13 8D 2B DB 45 E1 63 77 8F 83 08 D4 -------------------------------- :Skein-256: 256-bit hash, msgLen = 128 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 Result: 53 40 3B 16 A2 93 10 4A 51 7B CC CD D1 36 FF 71 F5 84 F7 FF B0 57 A8 49 13 3A F3 D2 50 02 A0 1D -------------------------------- :Skein-256: 256-bit hash, msgLen = 192 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 Result: 16 7D 17 E8 C2 06 EC 9A 30 D3 B7 09 CC 51 AD 33 D0 CE 4F 8D 0A 34 34 E6 02 A8 3F 62 12 10 28 F4 -------------------------------- :Skein-256: 256-bit hash, msgLen = 255 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 Result: BC 66 4D 67 AB 9B 98 F1 59 3B 09 0A E3 87 57 F4 25 BD 2C D8 57 29 03 64 20 88 4E 7E 6E 78 CC 07 -------------------------------- :Skein-256: 256-bit hash, msgLen = 256 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 Result: 8D 0F A4 EF 77 7F D7 59 DF D4 04 4E 6F 6A 5A C3 C7 74 AE C9 43 DC FC 07 92 7B 72 3B 5D BF 40 8B -------------------------------- :Skein-256: 256-bit hash, msgLen = 257 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF Result: 08 B1 03 AB 1E 01 50 37 9F 46 C4 B8 B1 84 1B 77 90 65 46 46 AB 59 1F 12 BF C4 76 E0 EA B9 E3 5A -------------------------------- :Skein-256: 256-bit hash, msgLen = 384 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 Result: 8A 48 42 D9 C1 E9 F2 4E 38 86 FC 0B 10 75 55 F9 ED A8 19 77 07 74 9C EC C7 77 24 02 B2 FE A0 C5 -------------------------------- :Skein-256: 256-bit hash, msgLen = 511 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 Result: 6B 82 22 72 BD B3 2A C8 43 4D 53 D0 DC 1B F6 DF D4 40 FD C7 37 C0 9C 1A 16 CA DA 1B 4F 3A 25 FD -------------------------------- :Skein-256: 256-bit hash, msgLen = 512 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 Result: DF 28 E9 16 63 0D 0B 44 C4 A8 49 DC 9A 02 F0 7A 07 CB 30 F7 32 31 82 56 B1 5D 86 5A C4 AE 16 2F -------------------------------- :Skein-256: 256-bit hash, msgLen = 513 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF Result: B3 38 C6 39 FA 42 E1 C8 F0 4B CF CD 44 25 2A 36 FE F1 1E 0E FE C4 59 61 29 1A 46 70 EB 0D 72 48 -------------------------------- :Skein-256: 256-bit hash, msgLen = 768 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 Result: 66 D5 C6 CA 0F 70 84 5E F6 01 EC CF 19 3D 1E CC C2 28 4D 03 B4 D2 46 10 92 85 21 44 8E 6C 4A 1B -------------------------------- :Skein-256: 256-bit hash, msgLen = 1023 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 65 54 DC C8 98 1B 21 3B 1C 0D BD A1 40 2A 3F 25 09 6C 85 A7 2D 94 EF 01 29 60 46 F7 8E 0B 96 54 -------------------------------- :Skein-256: 160-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 1F D3 08 86 A2 C3 15 DE 86 F6 7F FE 66 ED DD CF 73 BE 4F E4 -------------------------------- :Skein-256: 224-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: FA E2 43 AB 76 B4 14 FC 48 83 EE 73 10 2F DC F5 1C 2D 74 B9 8D F1 85 A0 BE 90 45 F6 -------------------------------- :Skein-256: 256-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 18 0D E1 06 A7 04 01 BA 38 F2 59 7C 25 CB EF C7 36 DF D8 8D 90 F2 D3 35 2E 0E B2 55 AF B6 DB 63 -------------------------------- :Skein-256: 384-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 9A 94 71 5F 16 0B 78 15 45 BC 7F F2 54 C9 7C D6 C1 4B A2 0C 94 E0 49 9B FC A5 8A B0 CF E8 31 1E 0B 85 87 01 4F 5C F0 1A 3B FE 4C D5 AE F8 EB 8B -------------------------------- :Skein-256: 512-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 1A ED AB 6F D2 8F D0 ED 62 B8 2A 6D 22 FA 3C 6A 71 AF F4 92 05 74 A0 D9 0F 4D 90 A3 B6 FF 96 F4 36 A0 AB DF 54 84 0F 33 6D F7 D7 90 A2 18 5F 61 1E 46 3F 40 B3 40 BE 82 11 06 27 FB 25 B8 02 AF -------------------------------- :Skein-256: 1024-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 62 E9 A6 C7 46 E5 2E 6E F8 2D 9E 48 EC EE 4B 96 59 9A A4 9B 29 F6 4D 3A 6D 97 EB 81 DC F5 6D BE 3C 70 81 36 5F 7D A9 5C 5C D0 79 5D C8 6B AF A5 3B DA 81 30 5C D9 B3 AA 6A 76 88 9D D8 67 94 EC FA 7B D9 DD F8 DB 98 19 B6 D4 AB D2 C1 E9 0B 33 12 A7 8E 06 EE 67 A6 F0 7D C6 31 44 63 B6 C9 CA 89 79 0F 17 57 3D 24 A8 B7 7E 03 CC 83 95 ED 74 2C 80 B0 97 C3 D5 CD FE 22 6E 77 84 C9 DE E5 2C -------------------------------- :Skein-256: 264-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 22 1B D0 20 EF 6A B4 6B CF 8E 0E 90 64 B9 6C 71 58 38 47 49 A6 FF 54 C9 75 9D E1 5E 68 9C FB 8C 6E -------------------------------- :Skein-256: 520-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 06 0F CA 88 AD 85 DE 37 DA 1A 17 17 01 CE E2 62 A3 43 BD DE 04 0D AC AA 0E ED A6 64 6E 0B DD 51 2F A2 4D 9D 1F 0C CC 6B D6 93 54 D3 46 B6 03 7E 1B F0 33 2A CD 14 E7 B2 00 CA 41 2E 09 E9 FE 79 E7 -------------------------------- :Skein-256: 1032-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 71 4E B7 5C 42 8E DF 27 E6 E2 2E 53 C4 C1 71 36 BB 8D 40 94 68 DA 06 1B 41 32 5F 09 F2 32 89 C1 07 B0 E4 00 AF 1C 12 A9 E1 56 A1 01 AD 2E A9 2A 29 B4 70 DF 2A D3 5B 7D 7E 27 B7 C7 7E 30 2D AE 4F 34 CE 0A E7 72 54 82 C6 4A C3 D4 14 21 33 E1 3A 92 4C B9 FB C2 E8 B8 95 5F 84 6E E9 17 3F 77 4E CE 4E 2D 1E 8E 5C 15 38 A4 C6 0A AE 01 8D 6E 71 13 9E 06 54 54 0F 9E 77 D6 01 49 E5 A6 2A 0D F0 -------------------------------- :Skein-256: 2056-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: B6 18 96 A9 C8 E9 39 F3 0B 55 48 11 22 17 32 17 49 A1 FE 88 F3 B1 81 48 97 BC 5D 47 09 85 FF 50 B6 F6 6B CF 73 AD 68 2B 49 7A E7 37 33 18 6A EA BF C1 93 8F 9B 43 8A F4 32 EF 91 DE 99 48 3F 3A B0 DC 71 B3 C9 09 31 1A 47 B6 DC 77 D9 74 DB 3A F6 83 47 0C 88 43 89 DB 6F A3 C2 19 D9 AD 82 2B 09 E2 44 48 12 52 E4 DA A9 CC CE 6A 3F 70 9C 57 F3 55 3C 6D 94 1F 70 26 57 0A D5 74 E5 82 99 B1 92 78 8C A8 76 05 D4 42 94 29 90 CC 88 35 AD 89 DE A3 50 47 95 34 4B B2 38 A9 11 35 69 1A A7 70 AE 6A DF E9 BC FC D6 C2 8C 78 0A 47 B7 8D 24 85 65 CE 49 F6 C2 DF EC B8 D8 C2 A4 E8 95 84 5B ED 0D C7 37 46 BD 56 A6 39 56 55 68 1C DE 63 68 AA 4C 58 03 29 BA F2 84 EF B3 10 4E D4 98 4E 4B 07 EA 8E 9C 78 FB 99 49 29 08 44 4F 4F 78 16 02 C3 79 2A 9B B1 51 26 C2 DA 28 D9 39 0E E5 6F F0 FC 22 -------------------------------- :Skein-256: 256-bit hash, msgLen = 1025 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F Result: 6F 6D B5 27 A6 05 8E FB 40 A8 1A EE 4B 5E 0A 3B B4 92 67 61 A4 7B 4D A9 BC 8B 15 5A 4A E7 08 91 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2047 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 Result: 36 A2 5D ED A5 BA 34 CF 59 2F 25 12 D9 86 9F C1 F1 7E 40 3E 66 80 3D AF 3A 49 20 25 FB 82 62 5A -------------------------------- :Skein-256: 256-bit hash, msgLen = 2048 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 Result: A0 88 EA C7 A7 25 6D F7 25 5E B5 73 37 79 26 7B 5D D7 F8 64 32 0B AB 3A B9 61 DA 5B EE 23 CB 35 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2049 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 FF Result: D0 EF D8 F7 18 84 FB 74 8A B0 E5 05 42 1B 4E 4C 55 7C 09 89 CD 28 6D C0 A6 D8 91 52 78 04 9E 78 -------------------------------- :Skein-512: 512-bit hash, msgLen = 0 bits, data = 'incrementing' Message data: (none) Result: BC 5B 4C 50 92 55 19 C2 90 CC 63 42 77 AE 3D 62 57 21 23 95 CB A7 33 BB AD 37 A4 AF 0F A0 6A F4 1F CA 79 03 D0 65 64 FE A7 A2 D3 73 0D BD B8 0C 1F 85 56 2D FC C0 70 33 4E A4 D1 D9 E7 2C BA 7A -------------------------------- :Skein-512: 512-bit hash, msgLen = 1 bits, data = 'incrementing' Message data: FF Result: 54 EA EA 3E D9 F3 34 01 BA 8A F6 45 B3 D3 80 FC 40 2E 61 B4 3B 84 ED 26 B3 D1 E9 80 72 A4 B0 29 CA D8 6E DB DC 17 34 3B AD A6 27 0D 9E EB B0 44 17 25 AF EA 51 AD 74 F0 43 CD 25 4B BC CE 2C B7 -------------------------------- :Skein-512: 512-bit hash, msgLen = 2 bits, data = 'incrementing' Message data: FF Result: B0 55 F4 35 FF 61 15 13 2E F7 71 BF F1 E3 82 04 3D 93 BE 94 AD 3E 2E 17 15 E6 15 86 32 2C 5E 25 99 C8 8B 1E 48 3C 22 2D EB 44 86 68 C4 1C BD 48 DE 27 03 93 1C 98 6D 3F C0 D6 8F B9 00 87 E3 40 -------------------------------- :Skein-512: 512-bit hash, msgLen = 3 bits, data = 'incrementing' Message data: FF Result: FC AB D6 46 33 C0 1B 1F 51 80 32 1C 3A 73 4D 37 58 CB D7 35 FC 4A 77 F4 32 E2 D0 C9 9E 5A F2 8D AF 26 9D CC B3 4A 74 35 E9 31 15 7E 49 B8 D2 E3 EE D0 FC FA B7 1F 16 33 D8 89 E6 54 28 D9 52 42 -------------------------------- :Skein-512: 512-bit hash, msgLen = 4 bits, data = 'incrementing' Message data: FF Result: 15 6E 61 BF 4C 11 04 6E 64 3B 86 86 C4 BD 85 B6 C7 85 DD A5 B4 66 94 3D DF D6 1E 4C AC 05 EC CC B9 B8 2B 27 77 69 29 F4 A3 39 AD 7F 9A 39 91 AF E3 E4 9A 3A 40 7E 0E 7A 75 E5 92 87 DE F2 F8 99 -------------------------------- :Skein-512: 512-bit hash, msgLen = 5 bits, data = 'incrementing' Message data: FF Result: 18 5C 59 DC 2F 1B 49 D3 92 04 20 41 CC F8 C3 B2 01 69 22 59 70 4A 90 F7 50 DA 33 DA E8 E6 01 61 9A 5E 7B CB 2A 72 31 97 D2 48 E8 05 AB 0F 20 9A 34 01 FB 6F B6 71 34 EE 3A 0F EC 77 F0 6F 41 6E -------------------------------- :Skein-512: 512-bit hash, msgLen = 6 bits, data = 'incrementing' Message data: FF Result: F1 55 57 F1 F8 37 E1 14 36 26 45 18 50 B9 35 45 41 68 A3 4A E0 A0 16 E5 BB AE EA 69 CE E2 F1 A5 51 A1 BB 9D F7 34 6E 5D D1 58 D5 95 86 A0 1D 5B CC 04 D2 2E 43 88 B9 C3 65 0D 12 EB 5B 5C 10 8A -------------------------------- :Skein-512: 512-bit hash, msgLen = 7 bits, data = 'incrementing' Message data: FF Result: 5F 01 A2 C2 63 45 0D CB F5 29 24 21 A9 D0 16 10 6B 3E DD 0D CF 79 61 41 DB CF 5D 5D E3 A1 8E A9 B6 65 07 DE A4 78 4A 7C 19 7B D1 47 69 63 8D 56 76 36 94 35 52 98 D3 0A 7D 45 77 72 9B F0 60 16 -------------------------------- :Skein-512: 512-bit hash, msgLen = 8 bits, data = 'incrementing' Message data: FF Result: 71 B7 BC E6 FE 64 52 22 7B 9C ED 60 14 24 9E 5B F9 A9 75 4C 3A D6 18 CC C4 E0 AA E1 6B 31 6C C8 CA 69 8D 86 43 07 ED 3E 80 B6 EF 15 70 81 2A C5 27 2D C4 09 B5 A0 12 DF 2A 57 91 02 F3 40 61 7A -------------------------------- :Skein-512: 512-bit hash, msgLen = 9 bits, data = 'incrementing' Message data: FF FE Result: F2 3B 93 DB E9 A9 0B 29 EB E8 B1 FE A0 D6 36 18 2B D6 CA F4 16 92 F0 37 71 45 24 F4 EE 3D 76 7E B7 D6 8D 39 F4 3E B8 F1 F9 26 4F 34 F5 1F 17 A7 95 90 6D D2 B6 18 3B 74 CB 75 E2 69 17 2D 4F 7D -------------------------------- :Skein-512: 512-bit hash, msgLen = 10 bits, data = 'incrementing' Message data: FF FE Result: CE EC E7 DB 01 69 B2 F8 DA 4B 84 EF 7A CF 0C 47 AA 6E C0 E2 34 32 E9 3B C1 CA 60 D8 3A 87 69 C1 9D 18 27 E5 DE 79 49 7F A2 BD FA 16 92 2C AE 02 09 88 EB D5 12 C3 FA 1F 5B 12 65 6B C8 8C B3 3E -------------------------------- :Skein-512: 512-bit hash, msgLen = 32 bits, data = 'incrementing' Message data: FF FE FD FC Result: 19 D5 9A AC 61 1C 22 B8 49 A7 79 00 46 7C 2A 58 B5 21 7C 5B 22 07 3C 95 18 27 88 B4 99 6E EB D5 F9 23 E6 37 A2 95 A7 AD 2B 35 E8 48 7A 7C EF F9 8B 23 CE 5A 52 11 D9 85 54 E6 38 13 C5 9F 84 06 -------------------------------- :Skein-512: 512-bit hash, msgLen = 64 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 Result: D7 4B 91 50 06 1C 93 83 9B C3 59 2C 3A 58 7D EC 86 1B D6 E2 4E 5E F8 92 88 B6 E9 9F 7E 0C A0 D2 11 55 D4 18 5D 7F F6 AC DC 71 06 99 9F 82 19 94 5E 61 F4 01 79 6B EC E9 82 14 05 9F A9 62 B3 73 -------------------------------- :Skein-512: 512-bit hash, msgLen = 128 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 Result: 8E AF 7A FC 9E 85 A2 3F 4E 46 BA 4C 55 13 06 64 09 A4 17 79 B4 71 AE 84 FA C5 F5 C0 D6 64 80 40 E1 93 37 E3 67 AD C7 AB 1F AC 2C 78 D3 79 B6 36 9D 90 5C D6 CD FA C2 B0 D9 8E 62 60 C4 71 93 F7 -------------------------------- :Skein-512: 512-bit hash, msgLen = 192 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 Result: B6 1A 89 1E 0C CF 17 9E 4E A8 73 E6 85 15 AF F6 A5 E4 C2 A1 9F ED 7F 02 B1 A9 1C 0F 97 81 AE 9D EA E4 AA 96 96 8D 54 4F F9 F9 D9 3B 55 CC 40 49 88 EF E5 8F 0E FF 0D AB B1 BD 2D 3C 8B 8D 46 7C -------------------------------- :Skein-512: 512-bit hash, msgLen = 255 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 Result: 6A 49 E9 21 03 3F 64 8D 4F A8 50 ED 8C 79 C5 4A D3 CB 06 32 96 AE 70 5C E1 41 39 04 31 2B A0 80 DE 38 7C B8 C8 CC 97 BE 55 58 29 D0 DF 9D CC 4E B2 62 99 B3 67 83 4C 85 10 7A 81 E0 7E F6 60 CF -------------------------------- :Skein-512: 512-bit hash, msgLen = 256 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 Result: 0B 7F D0 53 AE 63 5E E8 E5 19 64 6E B4 1E A0 CF 7E A3 40 15 23 78 06 2F B2 44 0A A0 25 0F F1 95 FE 32 D9 A0 69 1E 68 A0 FE B1 7D C2 85 AA 67 56 CE F1 94 04 E4 DB 92 BF 83 6C 4A E6 53 81 50 4A -------------------------------- :Skein-512: 512-bit hash, msgLen = 257 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF Result: AF 0C D5 66 DE B1 85 FD 0D 8C 95 8F 59 9D 4A 3D EB D0 A6 CE D1 33 37 AE 12 7A E0 FA C2 4F 8A 2C E1 1D 11 FE FA 77 46 B0 0B 5B FA EB FD 0C 1B 54 E8 59 65 22 EA 11 60 93 7F E2 2C C2 A7 F0 28 70 -------------------------------- :Skein-512: 512-bit hash, msgLen = 384 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 Result: 8E 48 B8 56 16 54 91 8A 72 E3 91 97 6B A9 75 DD 31 5F 25 1F CA BF 2D 4E 23 2E 59 50 FD 9E 67 DB 6E 88 BE 25 92 0C B6 5E D0 AB A5 A4 D3 1B 08 06 2C 68 88 EB 63 99 7A 17 6C E2 70 D0 5D F3 93 75 -------------------------------- :Skein-512: 512-bit hash, msgLen = 511 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 Result: 75 FA D5 6F 1C BE 41 51 CA DC F9 B7 C0 34 D8 B8 40 91 0B 46 A6 2B CF 26 62 67 CB C4 9D EC C2 3A AB 50 FC 37 5B 8C D0 5A 16 32 91 95 17 05 31 77 4F 17 46 E1 F1 F5 DB 78 F4 DC DD 12 10 AE 0E 69 -------------------------------- :Skein-512: 512-bit hash, msgLen = 512 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 Result: 45 86 3B A3 BE 0C 4D FC 27 E7 5D 35 84 96 F4 AC 9A 73 6A 50 5D 93 13 B4 2B 2F 5E AD A7 9F C1 7F 63 86 1E 94 7A FB 1D 05 6A A1 99 57 5A D3 F8 C9 A3 CC 17 80 B5 E5 FA 4C AE 05 0E 98 98 76 62 5B -------------------------------- :Skein-512: 512-bit hash, msgLen = 513 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF Result: 38 E8 A3 4D 90 A2 44 A6 D7 3F A6 A8 EC D5 E9 93 D1 AD D4 BB CB E3 D4 35 C8 FC EC 4B 39 7C 12 A8 38 A3 CD A4 58 6B AF B0 67 EB E8 D0 10 ED 02 FE BF F4 2D F2 A9 49 DF 03 0C FA 4C 78 0C 23 B2 34 -------------------------------- :Skein-512: 512-bit hash, msgLen = 768 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 Result: AC 8C 00 26 1D 7A 5A 79 CD 69 B5 AF 12 8D 77 EA 4E 60 0C 7A 82 52 C6 CC 1A DF 7D BC 95 72 C1 C6 13 C0 C9 0C D3 DD 87 A5 49 53 CB 87 96 20 9C 94 C0 16 5E E1 B3 CA 37 34 FF E3 6D D5 9E 3A 03 A4 -------------------------------- :Skein-512: 512-bit hash, msgLen = 1023 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 37 A1 B5 B5 14 41 15 A4 A5 8F 5D CA 9B 24 C5 3D 2C A1 9D 18 2E 15 E4 76 0B 1C C1 69 EF EE 05 AC F0 AA BC 07 70 8F 81 75 57 A9 0C 13 7C 44 54 A3 23 FE BA A4 2F 97 DE 84 68 65 39 0D 2E 71 C4 C3 -------------------------------- :Skein-512: 160-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 7D 59 D2 3F CF 38 FF 54 71 0F 0D 38 D3 A0 AC CE 7B 8D 64 F6 -------------------------------- :Skein-512: 224-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 21 52 1B 15 C8 A9 F0 5D 59 58 F9 97 00 8E 95 C5 0C 4E EE 35 FB 30 BA 81 D5 83 18 56 -------------------------------- :Skein-512: 256-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 1A 6A 5B A0 8E 74 A8 64 B5 CB 05 2C FB 9B 2F A1 28 20 32 30 A4 D9 92 3A 32 9F 54 27 C4 77 A4 DB -------------------------------- :Skein-512: 384-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: EE AF 4D C9 B6 68 C2 A2 70 B9 0C BD 2E 98 6C 85 7E 46 4B 08 90 3E 5B 6D DA 1F 15 73 6F 50 D1 BF 2B 6C 40 A3 98 B7 9C 67 53 35 92 EF D9 6B D8 DC -------------------------------- :Skein-512: 512-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 91 CC A5 10 C2 63 C4 DD D0 10 53 0A 33 07 33 09 62 86 31 F3 08 74 7E 1B CB AA 90 E4 51 CA B9 2E 51 88 08 7A F4 18 87 73 A3 32 30 3E 66 67 A7 A2 10 85 6F 74 21 39 00 00 71 F4 8E 8B A2 A5 AD B7 -------------------------------- :Skein-512: 1024-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: BE 71 89 13 53 E1 57 D8 55 70 07 E6 C4 DB 77 42 A8 E9 4D 26 77 B8 BF 13 8E 0E 74 7D 4F 70 24 BA 5E 9D 53 1D B0 B6 CB 41 26 77 68 5B 9F 9B 0A 7F CD 42 99 C5 D5 08 51 25 34 7B 59 A4 7B EA FD 6B D2 D7 C9 DE 07 CC E0 77 01 C5 D0 CE 3C 3A 8F 75 E0 A8 C1 6E 1A AD B2 92 98 21 99 69 DA 77 C5 2C BF 8D D8 CF 86 A9 E1 B0 BB 7D 18 15 3D 70 EE 5C 26 60 6D 92 2D 91 5C 05 DA 41 D6 4F DE B4 21 50 -------------------------------- :Skein-512: 264-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 7C FE EF 0B AE 71 26 20 48 0E F2 72 88 08 C9 B5 9F EE D9 8A DA 3C 0D 6F CF 89 4B 05 1F FB 50 2B F4 -------------------------------- :Skein-512: 520-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 9E 65 5B 72 5A C0 96 43 C4 49 C7 24 C6 B1 19 7D DC F7 D4 2B 8B C9 EF 80 47 63 0A B3 84 8C 39 C7 8E E5 F0 60 F7 01 86 39 E2 02 01 C7 D8 6E EF E9 84 52 D7 CF C2 43 5E DE CA 9A 4E 1A EC 3E 9D C9 3F -------------------------------- :Skein-512: 1032-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 23 B7 D7 8C BB 97 69 BD 23 B0 86 75 BD 87 F2 C7 AF 44 47 04 72 8A 1A F4 C8 5F E1 C0 84 9D BA 48 B3 6C 87 39 D2 41 A2 C6 D9 63 E7 E8 40 1B 8C E3 C9 BC 2F 1D 4F 93 69 98 85 B5 34 39 B9 06 AC EB 2E 9D 9B 11 56 E9 7E 3D 9B 9E 8E A9 46 88 D2 E5 F5 D9 9C 4C 64 19 67 C9 C0 26 ED F3 F9 E1 25 97 6E 1B 30 05 31 7B BE BC 84 A4 C1 A0 F6 4C 76 1C F8 69 66 0C C1 8D 3B A7 0F 8D B9 5E E5 F6 17 0B 16 -------------------------------- :Skein-512: 2056-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 49 16 E1 18 DC 63 C5 1A A2 DE AE 18 C5 C6 36 8F 17 44 41 D9 F3 B8 78 80 51 5B 9D 2B CD EE 3A C8 B2 89 F5 65 37 E1 EC 1C A2 52 08 76 2D 1D 5B 16 CC 0D A2 D5 28 03 81 5E 6B FB FC 28 DA FD EA E0 8C 67 98 DF B9 40 90 2E C0 0D B4 5C 19 9E 90 A2 0D FA FB D3 6A 1B C3 1C BC 5B 87 B6 3C F2 57 EA 3B 68 DF 86 65 39 AF 09 B1 29 1D 24 C7 48 AB 2A 3E 4F 34 7D 58 E5 1B C2 17 30 10 FF 73 F4 4F 6F 58 36 6D 8A DB 90 82 95 6D 99 26 A8 E8 0E EC B2 BF 4B 79 3F FB 31 EF D3 E1 46 CC 4E 14 DD 9F 34 D1 18 37 09 AF 9F D3 67 CA 45 B7 D8 98 F5 28 D5 21 E1 F3 AB E0 D3 EE 51 01 9D E2 4E 63 C9 4A 7E 51 27 53 3D 7A 47 BE AB CC F6 93 97 5E F5 94 96 74 07 32 2C FE 13 2F 31 BA C4 11 16 FA 6B D4 45 38 14 39 0A 02 88 D3 25 45 63 86 98 A5 EF B0 C2 83 A7 55 A4 34 55 F9 7E 73 6D 1A 2B C8 0E 59 4D 21 -------------------------------- :Skein-512: 512-bit hash, msgLen = 1025 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F Result: DB 70 D7 31 CB 54 F2 73 E5 09 B1 7C F3 8A 90 29 E7 48 51 A3 E1 33 5D D9 2E 93 A7 19 0E BB AB 55 04 EE 5D D5 C1 5D FA DB 64 60 91 2D CB 8D C1 83 72 F5 62 C8 61 47 7F 9C 43 CD DF 0F 6D 91 0E E1 -------------------------------- :Skein-512: 512-bit hash, msgLen = 2047 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 Result: BC 23 D9 21 8B 8A 18 58 D6 D3 47 FC 3C D6 D2 28 ED A4 F6 34 7F FF FF 93 EE 55 7C 59 2B 6F 42 CD B3 BB E4 61 DB 3C D3 74 EB F5 DA 6D 62 85 27 9A 2E 2A 21 E9 0E 37 9F B9 6B E2 19 6B 17 7D AA 5F -------------------------------- :Skein-512: 512-bit hash, msgLen = 2048 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 Result: A5 5C DA 09 FC 2D FB 35 CC 20 C1 C5 8D 8B 00 CC 68 F3 1D 26 D5 53 85 D8 FC 7A C2 A4 FC CD 45 22 1F EF 7C 1D 18 A9 00 B7 5A 22 14 EE 6F 07 EF 4E 5D 03 A3 E9 D7 29 4B 1A 5F A6 E3 42 EE C0 05 58 -------------------------------- :Skein-512: 512-bit hash, msgLen = 2049 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 FF Result: DA 80 0C B7 60 50 58 B2 C4 C3 19 65 5B 14 CC 4B 69 27 D8 96 C8 4B 5D 3A 8B 79 51 D9 8F 35 6E BF 38 36 BF AF 73 8E 5E B5 05 FA 5F 64 1A 21 C9 13 BD EA BD F4 E3 88 B3 A2 22 BA FA 9F D5 7A 62 FD -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 0 bits, data = 'incrementing' Message data: (none) Result: 0F FF 95 63 BB 32 79 28 92 27 AC 77 D3 19 B6 FF F8 D7 E9 F0 9D A1 24 7B 72 A0 A2 65 CD 6D 2A 62 64 5A D5 47 ED 81 93 DB 48 CF F8 47 C0 64 94 A0 3F 55 66 6D 3B 47 EB 4C 20 45 6C 93 73 C8 62 97 D6 30 D5 57 8E BD 34 CB 40 99 15 78 F9 F5 2B 18 00 3E FA 35 D3 DA 65 53 FF 35 DB 91 B8 1A B8 90 BE C1 B1 89 B7 F5 2C B2 A7 83 EB B7 D8 23 D7 25 B0 B4 A7 1F 68 24 E8 8F 68 F9 82 EE FC 6D 19 C6 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1 bits, data = 'incrementing' Message data: FF Result: 47 28 53 70 0A 4E B0 C7 28 CC 3A E7 84 A6 AE C9 CA FE 79 47 D7 E0 25 71 43 8D AF A5 0B D6 48 EC FC 4A AD C1 E4 8A EF EF 71 78 33 0F DE 72 53 94 C8 EC BC B4 8F 94 BC 4D 9F E6 02 AB AF 5A 36 B2 8F 27 2A 58 E0 3E 61 C9 4B F8 9C FE E2 7A D2 9D 8D 94 54 EE 7A 91 83 84 54 38 26 47 D0 ED 8D BA 1B CF 6C 95 97 3E 7C 5B 45 D2 22 82 78 AB 4E 5A 72 22 A5 C8 E2 41 43 F8 1D D6 EF 30 0D A8 8A BB -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2 bits, data = 'incrementing' Message data: FF Result: 11 42 5D 06 3A B0 3D BE 12 2A 4D B2 33 ED C0 38 15 38 67 D4 84 1A AB 3E 09 17 B8 1F C5 80 59 CA 92 8B D1 5E 0D D1 D0 80 AB D3 33 04 D7 B8 0B F9 FF 12 CE 39 1D 2D 13 C2 58 FF FC 3B 62 01 1B 47 F6 82 F4 4B 10 B4 E5 90 92 A9 07 C7 63 D3 A8 66 99 48 50 C9 E0 DD C2 40 05 99 70 0D 94 2B D4 91 3F D7 38 E7 1B 55 D7 9A 03 02 76 74 CE FF 3F 1B 89 9B 66 74 F4 21 C0 B7 EE 43 CF 00 9D F6 DC EA -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 3 bits, data = 'incrementing' Message data: FF Result: 2C 6B 60 FA 31 1B 79 21 D4 4D DC 99 AB CD 91 AA 29 93 43 2F 9B 14 92 8C E6 31 06 B5 FC 37 60 8D 1B 12 E7 EF AD 2E 76 93 7C A7 7B B5 AB B8 28 B3 BC 21 23 FE AA 49 F8 00 26 F4 E3 6F 88 CD AD 10 A2 83 AA 28 2E 09 D0 26 24 E9 BD 58 6D 4C C6 A0 F8 C9 0A 21 83 AF B7 1C DA A1 5A D0 58 84 5E 20 7B EB 12 A8 5C 3A 17 3A 61 69 48 FD 99 91 5B 69 35 C0 76 8B 23 D9 7C 0B A5 2A F9 85 E0 7B 87 AF -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 4 bits, data = 'incrementing' Message data: FF Result: FC CA 16 4A E7 D8 51 AC E6 F3 99 CB AB A4 09 FD 50 4C 43 52 C3 71 E0 7B 3E 19 B3 B2 6C 14 97 DD 27 FA 78 78 ED 26 4D C3 AA 09 78 91 8A 69 4F 44 AE 1E 78 8C B1 27 BF 82 09 72 00 BC 48 1B 47 AD 02 BD 56 73 6A 6A 5A BE C2 A4 D8 AD 64 8A 9C BC 13 AD FD BC 1F 8F D1 51 B8 88 F9 FF A1 38 7D B6 48 8B 1E 94 CB 4C D1 69 0D B2 DC 5C 8F 9D 89 99 C4 22 3F 74 F7 29 AA 36 19 D8 45 AB 0A 37 F9 50 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 5 bits, data = 'incrementing' Message data: FF Result: 0B B6 A8 33 4D F7 3C 46 09 24 B4 FB 20 40 19 56 73 A7 F0 86 08 16 A3 2A 93 9A C0 77 24 61 DD 20 E0 68 A3 A5 29 77 94 13 9A 9D 68 9B 91 22 A1 44 82 BD EA 22 4C B1 D6 88 95 A0 07 80 BF 55 46 BD B6 DF 01 BB 16 CA C2 5F 1B 0B F3 62 E6 B4 5B 01 F9 E4 E8 97 E4 60 CB 04 49 32 51 79 7B 65 48 FE 1C 97 48 ED 6C A5 52 62 36 68 A8 2E 0B A5 2C 5E 9A 99 F7 04 55 BC 12 76 10 86 DC A3 A5 30 59 EB -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 6 bits, data = 'incrementing' Message data: FF Result: 65 57 C3 70 F2 6F 79 72 05 1D BC 39 21 E8 44 0C F1 74 4C 48 2E DE 6C EB 96 A2 0B 2B 37 3B D1 27 2B A7 89 F3 3F 75 1F CD B9 2C 77 C1 6C B7 38 16 3C FB 40 39 73 08 7A 62 63 BA AC B3 CB 69 9D A6 CB 6D 56 CB 1B 1F 75 93 D3 00 31 72 97 E0 C0 C3 67 78 7A 75 DA 86 E0 66 58 D8 53 F3 15 88 8C F7 C4 B6 EE DF B2 3E E0 36 F8 4A 07 F3 56 E2 86 95 73 F0 FB 66 21 89 00 85 EF 7E FC 6D 95 BA 3A C5 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 7 bits, data = 'incrementing' Message data: FF Result: EF 00 0C B5 56 28 54 14 29 B3 D9 F2 8A 3D 43 62 D2 DA 41 4E C0 24 8E 76 4B 5B 34 57 B1 3A 88 50 04 6A 69 5F 6A F6 C8 07 73 D8 36 2C A9 84 A7 64 78 0F 99 A2 73 1F 40 98 B2 CD D4 15 07 03 2F 8A 96 20 B0 69 CC CF 61 59 B8 29 5E 9C 56 60 E3 20 D7 77 79 C4 21 B5 22 30 FF 14 9F 03 D2 1F B3 13 7E F6 7C 75 EA 4C 9D 5A DC F9 BD 42 A0 7B 7F 61 4B E7 2E C4 1E 77 CF F0 E4 BB 2A 68 32 AA E9 A2 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 8 bits, data = 'incrementing' Message data: FF Result: E6 2C 05 80 2E A0 15 24 07 CD D8 78 7F DA 9E 35 70 3D E8 62 A4 FB C1 19 CF F8 59 0A FE 79 25 0B CC C8 B3 FA F1 BD 24 22 AB 5C 0D 26 3F B2 F8 AF B3 F7 96 F0 48 00 03 81 53 1B 6F 00 D8 51 61 BC 0F FF 4B EF 24 86 B1 EB CD 37 73 FA BF 50 AD 4A D5 63 9A F9 04 0E 3F 29 C6 C9 31 30 1B F7 98 32 E9 DA 09 85 7E 83 1E 82 EF 8B 46 91 C2 35 65 65 15 D4 37 D2 BD A3 3B CE C0 01 C6 7F FD E1 5B A8 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 9 bits, data = 'incrementing' Message data: FF FE Result: 7E BB 72 1C C4 57 C7 85 E8 8F FF 59 D0 13 60 85 77 5C 76 66 13 0C F7 C0 D2 B1 B1 6F F1 95 4A 27 92 D6 1F F5 CF 2C 5A 46 1A 10 97 0F 99 98 61 E3 3A FE 92 14 DF DE 3F AA 7A 77 25 D6 B3 4F 62 F8 C7 38 66 EE FB 6F FC 95 22 85 6D C0 6C 80 5E 8B 64 38 42 55 25 EF 28 61 22 B8 3C E9 B8 9E 99 5C A9 D0 50 EC C2 EA C1 49 24 08 AE C8 4A 6A 16 30 91 54 3B 6E BE C3 E6 11 77 EA 21 D0 39 2C E6 25 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 10 bits, data = 'incrementing' Message data: FF FE Result: BF 8C E8 89 A9 DC 88 90 40 2D 56 99 A3 3A EE 4F CD EC F2 C9 BA 8A 7C 64 F7 FE 05 8D 38 4A BA 4C F7 AE 5D 29 A4 22 C4 F4 4B 51 8A AE 74 D0 B6 6B 39 0D DF F7 D7 03 57 68 01 FF 49 CC 68 02 A1 0C 8F 8C DC A0 4A 79 74 A9 E5 95 DA 8C A6 7F 0D 34 A8 28 29 F1 12 62 E6 B7 30 8D 97 65 C7 0D 0D 30 9D 90 8E C2 3C 52 AA FA 84 6B 12 EC 13 12 87 79 F2 FC E1 5A C5 FD 36 76 7D 6E 28 EA CB 45 19 A7 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 32 bits, data = 'incrementing' Message data: FF FE FD FC Result: F8 77 17 08 6D 37 BE 00 FA 04 50 48 F1 BF EC C8 CE 78 59 EE A8 50 B0 6D 38 11 48 94 9D 82 AC D7 A3 6F 5E F5 FD 41 E4 06 8B 7C D5 CE 87 0E 4B 58 9D 2B DA 4B B2 0A DF 82 8E 93 E5 3F BB 3E F4 86 D2 D0 AC CC 3E 1C 94 F7 36 EE AD 1A 2E A2 E1 A0 4D 08 1D 54 58 C3 FE D1 0C 8D B4 A2 39 82 C3 16 73 F0 CB 37 59 5F 16 4B C1 3E 97 61 00 23 6B 03 45 F1 E1 62 D1 75 61 F2 05 B7 E6 D2 E4 FD 9B F0 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 64 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 Result: AF CA E6 32 CB CD DE 0F 98 E6 E0 C0 2F 97 AA 12 90 33 04 2D 55 77 66 E8 31 9D 0F 1E 48 83 9C 38 BC 43 64 E2 34 E7 8B C9 7B C5 8D 11 03 6E CB 89 40 90 09 3F A3 48 C7 35 0A 78 B8 A4 0C 22 81 53 3C 8A A8 E4 EB F7 3A 2E 5D 98 AD 05 8C BD 8A 18 FE 4E 05 56 4B 00 02 D9 B0 67 2D 23 88 43 D6 4F 24 91 C0 2C 5D A2 60 49 B0 BD 43 67 7A BE 40 2B 5C 23 96 57 F6 B7 6C B8 4A 5B 30 C0 9D 85 D8 BB -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 128 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 Result: D7 36 BD 0E 3A 4E DA EF F1 3D 26 3C F2 78 4A 25 AA B0 CD 6A 1E FE 45 32 06 D7 28 FF FD 93 AE 8D 1E 0E 46 34 FF DE BE 56 7C AE DE 2B 25 34 6F 62 1A 38 69 A4 0F 7C 68 A7 9F 2F 82 B6 37 85 18 54 41 40 DC 2F 1E 5D E3 07 4D E7 4D A4 35 38 A8 1D 71 17 15 B2 D2 16 62 33 2B 33 C9 4C C5 F4 E7 A0 E9 CF 94 D0 F5 1D 1F C3 33 17 34 0D 2E 4D 2D 1A B2 E7 5A 81 5E 6F 0B EE 19 94 B7 60 8F 43 2E 2E -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 192 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 Result: 92 E1 A3 B1 D8 A3 0E 35 9A 93 81 00 68 B2 10 72 7C 5A 92 46 C2 DA E3 75 19 A2 63 26 6B 23 D7 E7 BF EF 81 16 89 DE E7 5E 93 7E D4 D3 E8 97 D9 2A 3C 46 23 90 4B F9 04 FE 65 8D 61 83 82 67 1A 06 E8 38 C4 2E 2C 87 B8 E1 D1 2F 70 73 CF 02 C9 5C B4 9B C0 BE 2B 4F A0 6B C2 77 5E 62 C4 48 76 C7 30 EF D8 05 98 50 9F 6D BA 83 3D B1 D1 7D 1F 03 E8 E5 F4 8C 33 B3 25 7E 5C 08 93 EA 8A 83 CE 0C -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 255 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 Result: 66 E9 14 15 F6 B5 12 01 F3 04 28 CD 21 E4 F5 41 F6 8B 8E 02 BC 7B 1D 50 AA 30 90 77 06 0F 99 9F 31 1D 75 8D EF 4D 40 46 28 79 46 B4 25 C9 4B D1 AD 53 F9 38 46 A8 31 F3 35 CE 60 6B 7E AE 72 9B 49 8F F9 5D 7F 9C 06 6A 3E 54 9D 2A A5 FB AB 80 92 80 C8 AF DB 6F E1 B7 75 C3 31 83 32 2F FB E7 F5 D7 FE 83 EA 3D 05 E3 16 D1 36 12 C8 4F 08 0C BB F8 C2 DE CD 45 DE 0F 8B 91 A3 63 9F 26 4E 1D -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 256 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 Result: D9 F3 81 EA AD A5 7D 8F 40 7A 01 D8 76 E6 B3 C2 09 34 18 A4 86 04 5F 7C E2 3A 90 15 0D 93 16 01 3B B5 4E 56 38 B3 72 E3 75 59 72 89 CF 74 50 EB 47 89 B5 55 3E 2B 29 47 D2 AA 81 09 7F 4A 8E 84 D3 9E 0F CA 2F 30 B5 EE 7A 8E D7 3C 31 F7 8B 58 04 B6 EF 79 F5 7F E4 43 AF BA 11 51 CC 48 E0 19 1A C6 25 E9 D5 F7 2B 84 3D 77 10 B2 9E 7F 98 9D 8D 3F C2 1B BA 49 D4 6B 9F 75 A0 7B 22 08 67 3C -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 257 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF Result: B9 46 AC C6 A2 FF CE E4 C9 C5 17 15 71 FB 04 22 15 2B 5C 62 71 F5 E0 13 42 89 A1 EA 4D 2D 2A D2 78 94 24 EC 7A F8 1C E7 72 E0 A8 6F C8 DF ED 70 18 2A 7C 81 C5 57 E0 33 C0 D4 7A 5B B5 2E EE E3 88 75 57 CE EA 31 E9 26 AC 72 1D 8D 81 F7 A4 05 47 86 05 D3 B3 B4 86 3C 8D B4 DD B5 EB 6E FF 79 09 C6 36 61 F6 5D 3C 5B DF 1A 1D AB E2 82 3F E9 70 7B AF B4 B5 59 82 74 34 0E 39 D2 DC A2 54 91 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 384 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 Result: B5 F8 F1 CE 3E 04 D0 90 7D 64 AD E6 41 D6 F4 E7 91 5A D7 74 58 24 02 1F 7C 68 F9 92 58 B8 42 50 22 B6 99 48 5A 0E 7C 40 5D 6F 5A 8F 4D 87 1B 21 15 E6 74 AE D0 7E 19 D6 42 8F A2 F0 5A 46 87 F7 1F B5 A4 92 C6 33 41 DC ED D7 CA 9E 66 9D 95 74 9D B7 5F E0 2C BF CD 0E 7E 0B E5 4B 3A FA AD 5A 28 3C 35 63 41 51 AF AE A1 F0 85 9F D0 3B 2A 4C 65 9E 2F D2 16 CE D2 58 DD 3C D3 78 1C 7C FA A2 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 511 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 Result: DF 39 A1 37 70 93 C0 DF 25 E9 4E 6E D6 EA B1 9C 37 04 8F 12 CF 17 A0 DE 91 7A 27 3A 3F E7 FA 09 F3 CE D7 7E E3 10 3F 73 3F 1B A2 09 27 ED 50 C2 3C BB 8A A2 2D 2F 3C 3E 25 9B 6E A1 3D 42 B1 09 B4 84 90 34 A7 4C 24 16 C6 33 4D 0D 11 7C 4F 3D 58 DB 5F 5B B9 A7 94 BF 27 85 E9 23 12 25 19 CE C9 7F 58 47 E7 B3 B0 D3 EA 9F 27 FD 22 33 2B 87 BF 27 3E BF AD 1B 80 A2 A2 C7 42 D3 C9 02 A2 D4 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 512 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 Result: 0E 10 EF DC 94 5E BE 7D 7C F0 07 3A 90 2D 9A 5B C0 D9 95 66 F7 FE AE D8 65 84 C6 53 B5 0F 71 CA 8B FC 50 1E 3D 26 E0 14 05 88 DE 50 E9 FB 2B 01 99 BF B4 18 95 D7 E3 33 86 B2 CC EE 46 CF 32 0E 38 4E AB B0 8C F4 16 22 1D 22 88 C5 8D 34 3F A3 BA 66 F4 DE ED EE 93 3F A8 9A 58 4D EE A3 22 84 11 AE EB 7F 56 4B BB DB 31 D1 FB 61 F2 DA 95 A7 43 2B B5 21 4E 4A 95 EB 16 0F 9A DF 20 A5 E8 06 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 513 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF Result: ED A8 CD C0 4A 1C 45 A9 F9 7E E4 FC 76 28 86 BC 83 13 0A 81 1D 84 7B 20 BA 4E 4A F9 00 9C 70 EA 9B 37 EA D9 F7 BF 32 1F BE 3A 67 53 DF CC 09 21 DF 3C 2F 49 58 2F F1 37 E3 F9 5C A1 6C FB 25 78 21 6E 4D 42 B0 5F 14 86 7A 42 4D A7 A3 ED C9 5B 67 D4 4D 78 8B D7 F8 4A CB 0A 66 04 56 20 45 A4 52 9F CC 7F 20 9E 11 F1 9E 16 FA 34 48 B1 5C A0 4F 37 43 CE 29 B4 CC 86 18 B0 4C EF 2D C8 4C A2 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 768 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 Result: DE 3E 11 3A 97 F0 83 BF 73 8A 88 8B 97 4D 11 DE BC F1 10 C0 A7 EE B6 C1 10 B3 D8 16 B8 92 50 B3 2D 1A C2 15 60 08 92 7D 4E E8 B7 E1 A1 83 31 7B 2E EB 85 0F 05 BC 86 82 A0 32 D4 28 85 08 A4 8D 6B 17 0A 81 9B 14 CB A9 8D 86 5B A7 91 9E 2C 27 F4 62 7A D5 41 2F 52 4B 9D E6 D7 0A C7 9F 5C 3E FB B2 A2 AB A4 AC 9E EE CD EF D3 37 E2 EC 9E 5D 3A 17 02 73 BB 47 66 FB 3E D0 14 79 F7 8D 63 AC -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1023 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: DD C4 A7 03 FE A6 66 F9 D2 8F CE 82 A6 FD 7F E1 8D D0 1B 3A 79 B2 64 DA 86 B0 5E ED 69 1A B7 22 61 E6 10 E5 85 AA BB 63 93 20 97 11 94 D8 14 1B 79 A1 94 08 3E BB 6F 96 C2 86 4F 65 7A 31 4F F9 C7 42 E4 2E 19 20 C0 EC C8 F9 86 5A 3F 94 F7 FE A9 40 9F B2 00 71 E2 18 46 02 05 DB 4A 0A B0 99 E0 52 3B 6D A0 C8 64 47 F6 BF 95 C2 86 DE 91 AB F3 03 8F 09 D7 2B 53 A6 20 6B 1A 02 37 AA 3D 92 -------------------------------- :Skein-1024: 160-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 79 91 DB 03 AC B0 8B AF 48 27 15 46 A6 83 67 7F 40 28 94 9E -------------------------------- :Skein-1024: 224-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: E7 31 C7 F1 4F 2B 85 64 99 2F 49 7B EF C1 46 B5 C0 0C 0F 64 F9 88 29 8F CE F0 FD 8B -------------------------------- :Skein-1024: 256-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: C0 4F F5 A3 0E E1 0A 53 EF 44 1C 39 82 D5 E2 F6 C7 A0 22 E2 D4 23 9E 6B B2 45 55 D0 3F 52 2A A3 -------------------------------- :Skein-1024: 384-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: A5 50 F3 07 1A 88 26 04 4F F5 F1 4E 88 AA 86 93 80 87 A1 0C 15 51 02 C0 9D 3B 3E 3B BF 5C 96 B0 FE 9C 1C 70 5E 5D 0B AC CD C9 8F ED 10 25 42 E5 -------------------------------- :Skein-1024: 512-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 57 E3 DE 8C A3 8A 69 C9 40 5A BF 2A 40 63 B4 85 5C 77 5B 6D 6C 46 47 25 D3 25 FA F2 7E B6 F1 5F 08 6B 11 DA 99 E2 52 AC FC F3 BB E6 2E 08 BC 10 25 28 50 C4 0B B4 76 6C 32 C1 0D 99 8D B2 7B 10 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 1F 3E 02 C4 6F B8 0A 3F CD 2D FB BC 7C 17 38 00 B4 0C 60 C2 35 4A F5 51 18 9E BF 43 3C 3D 85 F9 FF 18 03 E6 D9 20 49 31 79 ED 7A E7 FC E6 9C 35 81 A5 A2 F8 2D 3E 0C 7A 29 55 74 D0 CD 7D 21 7C 48 4D 2F 63 13 D5 9A 77 18 EA D0 7D 07 29 C2 48 51 D7 E7 D2 49 1B 90 2D 48 91 94 E6 B7 D3 69 DB 0A B7 AA 10 6F 0E E0 A3 9A 42 EF C5 4F 18 D9 37 76 08 09 85 F9 07 57 4F 99 5E C6 A3 71 53 A5 78 -------------------------------- :Skein-1024: 264-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: C3 4E E6 6B A6 42 63 EE 40 49 4B 52 1E C6 77 AD B6 15 B2 86 58 B5 A4 4E F3 F2 24 EF BC 12 C6 53 CB -------------------------------- :Skein-1024: 520-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: A9 97 7C 91 3A F6 B4 F9 32 F7 0C A2 42 E7 12 AA A1 23 93 A8 EB 2B EC C5 59 FC 0F 24 75 95 CC 9B 52 6C 33 89 D3 5B CC DE 8D 62 BD B2 28 52 56 D9 D8 5E 39 D9 B0 45 33 A6 44 16 CF 62 5F 00 58 24 6A -------------------------------- :Skein-1024: 1032-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 32 67 F5 B1 0B 8C 9E 76 9E 1A BF F5 C6 19 0C 14 02 FD 7A 1C 96 55 79 0D CA 63 9D 58 FE 31 B4 E8 73 ED D2 77 7F 1E 79 49 29 C8 B6 DE EF CF 66 6C 6A 51 C0 2A 58 04 65 A4 24 32 6A AF 21 C4 14 3F BE FA CA 4D E4 AB 7F FC 15 66 7D D9 5D 65 3C 34 DC 95 7C 45 1A 70 D6 19 CD C4 F1 10 50 25 9C 9D FC E7 5D 34 7E D4 53 B8 DF E4 33 02 EE 35 E5 47 BA 20 CE 72 CC 36 49 D7 F2 8B E6 97 3A 57 30 E1 6D -------------------------------- :Skein-1024: 2056-bit hash, msgLen = 1024 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 Result: 67 FD 23 E5 BF F8 4D 51 D8 EF 38 9C 83 39 48 CC F0 6A 65 8C 4D 7B 4E 5F 74 90 57 3C 3B D1 6D 08 F1 9B 7B CF 4A 78 2A F8 79 64 AE F0 51 C3 10 44 59 00 33 BF 24 86 9A BF 78 AB 71 03 8D 9A E7 BE 88 60 47 8E 44 E1 0D 27 9B 99 96 02 53 40 DF 9D 22 EB D1 BA D0 A2 96 B2 A1 20 C5 79 C0 85 71 B8 B9 60 38 B5 49 BE 94 31 A0 ED 64 03 8B D6 41 F9 02 E3 F8 2E AD BC 3F D1 28 16 9C 1A 18 5D F0 0E 23 97 7D C6 8E 3C CD D1 1E 81 EF 06 56 BF 54 75 4C 88 8D 4F AA 57 BB 9C 2F 41 EE 5D 6F 6D F2 7B B2 B2 C2 9C 4A 4F 02 6C DD 18 33 48 53 D6 34 62 05 96 7B 1C EA C2 FC F6 75 9B 1E 6E 76 D9 6E 22 E3 47 32 1E A7 AB 38 0F 81 83 EB 24 32 76 23 79 5C 9A 26 19 58 04 16 BC 24 2E ED A5 B5 BA 65 CB 2F DB F6 D3 4D 74 56 FC C8 0B 2A C0 AA B8 EE 80 73 61 C3 30 C1 C3 0B 77 9B 05 94 9A 53 94 E1 27 B9 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1025 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F Result: BD 3B 39 4C 96 59 F1 32 79 0E BA 95 3E 55 1A E7 DB D9 B3 8F 82 4A D8 8C BB 45 6A 9E 50 8D 8B 46 7B 36 BC 52 40 4F 1C 7C 19 87 A7 D8 24 3C 80 AC A4 68 E0 97 09 57 6B 9D 3B D3 31 CA 86 74 6B 41 EC B9 D6 C6 41 C7 15 D7 F9 76 08 89 EF 10 83 B9 70 B0 45 8E 99 5A 8E 82 90 6A D0 83 11 A5 35 36 92 78 CF 89 B0 34 8C 01 27 6B 61 FD 65 24 E7 B1 93 5B 9B 07 84 8D 69 12 11 EA FF 85 76 F7 DC 21 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2047 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 Result: 2B 79 07 EE D9 65 94 EF 7F 9F 6E D3 99 7D 9B DA 93 E9 68 DE D3 07 11 08 8C 06 AD A2 69 19 75 DC 64 0C FC D4 88 4B 95 92 FA 34 AF 73 25 22 66 36 4B F3 A9 5B C5 21 3E EA 6A 4D 5C 57 C7 D8 6B 91 9B EA 5F 82 EF F8 6A 73 9A 44 89 5B 6B 1A BA BF 8A 3B 0A 96 94 26 1F CF E9 55 EA 1F 9C 90 40 38 E4 69 1A FF 2E 2B D0 8D CB 86 C9 FC BB FC 46 61 BA BB A9 D6 35 27 08 EE 82 E8 95 6F 5F 69 B6 AA -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2048 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 Result: 84 2A 53 C9 9C 12 B0 CF 80 CF 69 49 1B E5 E2 F7 51 5D E8 73 3B 6E A9 42 2D FD 67 66 65 B5 FA 42 FF B3 A9 C4 8C 21 77 77 95 08 48 CE CD B4 8F 64 0F 81 FB 92 BE F6 F8 8F 7A 85 C1 F7 CD 14 46 C9 16 1C 0A FE 8F 25 AE 44 4F 40 D3 68 00 81 C3 5A A4 3F 64 0F D5 FA 3C 3C 03 0B CC 06 AB AC 01 D0 98 BC C9 84 EB D8 32 27 12 92 1E 00 B1 BA 07 D6 D0 1F 26 90 70 50 25 5E F2 C8 E2 4F 71 6C 52 A5 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2049 bits, data = 'incrementing' Message data: FF FE FD FC FB FA F9 F8 F7 F6 F5 F4 F3 F2 F1 F0 EF EE ED EC EB EA E9 E8 E7 E6 E5 E4 E3 E2 E1 E0 DF DE DD DC DB DA D9 D8 D7 D6 D5 D4 D3 D2 D1 D0 CF CE CD CC CB CA C9 C8 C7 C6 C5 C4 C3 C2 C1 C0 BF BE BD BC BB BA B9 B8 B7 B6 B5 B4 B3 B2 B1 B0 AF AE AD AC AB AA A9 A8 A7 A6 A5 A4 A3 A2 A1 A0 9F 9E 9D 9C 9B 9A 99 98 97 96 95 94 93 92 91 90 8F 8E 8D 8C 8B 8A 89 88 87 86 85 84 83 82 81 80 7F 7E 7D 7C 7B 7A 79 78 77 76 75 74 73 72 71 70 6F 6E 6D 6C 6B 6A 69 68 67 66 65 64 63 62 61 60 5F 5E 5D 5C 5B 5A 59 58 57 56 55 54 53 52 51 50 4F 4E 4D 4C 4B 4A 49 48 47 46 45 44 43 42 41 40 3F 3E 3D 3C 3B 3A 39 38 37 36 35 34 33 32 31 30 2F 2E 2D 2C 2B 2A 29 28 27 26 25 24 23 22 21 20 1F 1E 1D 1C 1B 1A 19 18 17 16 15 14 13 12 11 10 0F 0E 0D 0C 0B 0A 09 08 07 06 05 04 03 02 01 00 FF Result: 83 0E F4 BB 23 DD 6B 0B 38 E1 6D 5D E2 61 B4 87 36 6B CC C3 46 23 A1 5A 14 7F 42 FF 4A B8 CD 27 F9 D2 5A DA 5A F7 99 16 64 01 2A 87 FF 66 7A 1F 1A 4C 06 4F 8E 33 57 A8 FD F4 6A C2 A2 DC 0D C9 CE 29 EF AF D8 F4 5C EF 6B CB FE 76 EE D7 C6 96 4B BA E8 04 D4 AD 3F 61 CF C2 2B B4 24 08 29 8D 51 16 01 C0 4C 8B C0 72 CB 59 52 F3 75 A7 4A 1D 90 CD 4E E3 EE 6F 43 2A 6B F7 BD C4 4C C0 FC 78 -------------------------------- :Skein-256: 256-bit hash, msgLen = 0 bits, data = 'random' Message data: (none) Result: C8 87 70 87 DA 56 E0 72 87 0D AA 84 3F 17 6E 94 53 11 59 29 09 4C 3A 40 C4 63 A1 96 C2 9B F7 BA -------------------------------- :Skein-256: 256-bit hash, msgLen = 1 bits, data = 'random' Message data: FB Result: C4 51 43 CC B1 24 11 FE AE 63 17 20 3D 67 D9 E0 77 69 B8 F7 20 C8 AE F6 17 A6 9E 69 D1 67 9E 53 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2 bits, data = 'random' Message data: FB Result: 85 91 BE 2B 7A C2 89 42 E5 B8 D6 92 4D 4A 09 97 D6 8E 34 30 12 98 E6 7D F5 EE AB 6B CF E0 0D 96 -------------------------------- :Skein-256: 256-bit hash, msgLen = 3 bits, data = 'random' Message data: FB Result: 26 9B 99 A8 EC F4 BF FA 1C 05 24 4E 2B 8F 9A 5E 74 5B 8D 47 A9 B5 A5 17 77 9F D8 29 7A 3F 8C 44 -------------------------------- :Skein-256: 256-bit hash, msgLen = 4 bits, data = 'random' Message data: FB Result: 62 E6 E2 0A A6 AB 34 3F 99 73 F0 61 10 45 BD C1 E6 D1 CB AA 27 4A 7B A1 46 23 41 F4 95 33 B3 16 -------------------------------- :Skein-256: 256-bit hash, msgLen = 5 bits, data = 'random' Message data: FB Result: 57 15 1F 10 D3 D4 96 9F 2D 3E 2C 93 E9 D7 EB 8E 85 26 53 E7 D8 8B 60 10 4B 18 3C 7B 4E 5D 65 BB -------------------------------- :Skein-256: 256-bit hash, msgLen = 6 bits, data = 'random' Message data: FB Result: E2 8D 49 6C 0C B9 8D 58 CF 99 96 79 13 AA 23 1F 68 4D 7B 9F 4E 89 D6 B4 47 1D DF B0 5E B1 B5 3D -------------------------------- :Skein-256: 256-bit hash, msgLen = 7 bits, data = 'random' Message data: FB Result: 91 28 A7 A5 91 88 B7 8F FD 0A 84 B0 B6 33 5B 57 D0 96 35 1E 36 FD BC C2 05 04 CC C0 C2 B8 F6 46 -------------------------------- :Skein-256: 256-bit hash, msgLen = 8 bits, data = 'random' Message data: FB Result: 08 8E B2 3C C2 BC CF B8 17 1A A6 4E 96 6D 4A F9 37 32 51 67 DF CD 17 07 00 FF D2 1F 8A 4C BD AC -------------------------------- :Skein-256: 256-bit hash, msgLen = 9 bits, data = 'random' Message data: FB D1 Result: F8 83 B9 C6 1E 70 2E 35 47 E1 E7 15 50 ED A8 D5 94 E6 32 27 7C 83 ED 82 D4 CD 0E 3D AD B9 61 EB -------------------------------- :Skein-256: 256-bit hash, msgLen = 10 bits, data = 'random' Message data: FB D1 Result: 98 E3 EE 4F 7D 44 C0 C2 08 BB 16 FC 20 02 6C D9 9F 86 50 5F 01 86 26 45 6A 81 75 37 3C 37 2A F6 -------------------------------- :Skein-256: 256-bit hash, msgLen = 32 bits, data = 'random' Message data: FB D1 7C 26 Result: 2E 8B 4A 36 13 EE 4E B5 42 30 E1 4C C0 D8 40 56 C7 C2 E3 D9 1A E2 F9 43 5E 78 FB 3E 93 33 6B EC -------------------------------- :Skein-256: 256-bit hash, msgLen = 64 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 Result: B1 DD 13 CF 62 9C 2D 7B EF 08 E7 BD 09 75 36 6D D7 66 89 4E A3 4C 79 3F 9C D4 20 01 0D 25 86 4C -------------------------------- :Skein-256: 256-bit hash, msgLen = 128 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 Result: E0 EE A1 CB ED C2 6A A6 F6 B0 6A A6 BE 83 9C E4 B2 C7 25 CC B5 BC 0D 71 62 BB 1D 44 2E 58 25 03 -------------------------------- :Skein-256: 256-bit hash, msgLen = 192 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B Result: 9D 0B D9 75 A8 4E E3 65 CC A8 F2 E8 1A 82 90 C3 EC E8 D5 AC BA B8 CC 4D D3 BB 74 C4 03 A3 9C 8F -------------------------------- :Skein-256: 256-bit hash, msgLen = 255 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 Result: 36 3A C0 21 AC A3 DD BB 9C 59 2C D7 ED 42 89 03 6B 9A 49 AF 82 E2 1C 06 7A 57 9D F9 E2 86 3A 26 -------------------------------- :Skein-256: 256-bit hash, msgLen = 256 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 Result: 5C 30 02 FF 57 A6 27 08 9E A2 F9 7A 50 00 D5 67 84 16 38 90 19 E8 0E 45 A3 BB CA B1 18 31 5D 26 -------------------------------- :Skein-256: 256-bit hash, msgLen = 257 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 Result: F8 63 9D 50 E0 09 1D 6B AD A6 7C 93 5A 2E A7 AD 8D 26 A5 0E F6 23 D7 77 74 98 94 6E AC C4 E3 AB -------------------------------- :Skein-256: 256-bit hash, msgLen = 384 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 Result: 64 0C 89 4A 4B BA 65 74 C8 3E 92 0D DF 7D D2 98 2F C6 34 88 1B BB CB 9D 77 4E AE 0A 28 5E 89 CE -------------------------------- :Skein-256: 256-bit hash, msgLen = 511 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB Result: 9F 21 6A 60 26 A3 63 E8 77 22 C0 D6 BD 65 71 3F BF 6B 88 D3 03 F4 6F C3 B4 6D 15 E8 3B 7B 4B A5 -------------------------------- :Skein-256: 256-bit hash, msgLen = 512 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB Result: 34 BE 00 12 71 31 4E E5 9A 9D 66 F4 9B A8 01 AC 8D 08 2F 57 AF 1C 09 12 69 29 2C F1 F5 B6 9A 87 -------------------------------- :Skein-256: 256-bit hash, msgLen = 513 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 Result: 58 55 DB C0 6B 9D 71 A2 B9 DF 7B C3 46 EE DC 53 A1 8E BF 46 6D D3 FC 76 6F B5 EB 07 23 E5 FA 18 -------------------------------- :Skein-256: 256-bit hash, msgLen = 768 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A Result: 91 B9 D7 0C 97 63 FF 6D 36 49 EB 56 C8 7E 3A 2B E8 05 DF 19 CA 66 59 78 2C 12 73 CE 44 79 89 57 -------------------------------- :Skein-256: 256-bit hash, msgLen = 1023 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: A1 FF 69 F4 D0 6B 82 E7 11 9C 4C 3D 89 93 63 91 94 10 C8 52 00 F8 07 D0 76 B0 BD 34 0F B1 3B A1 -------------------------------- :Skein-256: 160-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 0C D4 91 B7 71 57 04 C3 A1 5A 45 A1 CA 8D 93 F8 F6 46 D3 A1 -------------------------------- :Skein-256: 224-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: AF D1 E2 D0 F5 B6 CD 4E 1F 8B 39 35 FA 24 97 D2 7E E9 7E 72 06 0A DA C0 99 54 34 87 -------------------------------- :Skein-256: 256-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 4D E6 FE 2B FD AA 37 17 A4 26 10 30 EF 0E 04 4C ED 92 25 D0 66 35 46 10 84 2A 24 A3 EA FD 1D CF -------------------------------- :Skein-256: 384-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 95 46 20 FB 31 E8 B7 82 A2 79 4C 65 42 82 70 26 FE 06 9D 71 5D F0 42 61 62 9F CB E8 1D 7D 52 9B 95 BA 02 1F A4 23 9F B0 0A FA A7 5F 5F D8 E7 8B -------------------------------- :Skein-256: 512-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 51 34 7E 27 C7 EA BB A5 14 95 9F 89 9A 67 15 EF 6A D5 CF 01 C2 31 70 59 0E 6A 8A F3 99 47 0B F9 0E A7 40 99 60 A7 08 C1 DB AA 90 E8 63 89 DF 25 4A BC 76 36 39 BB 8C DF 7F B6 63 B2 9D 95 57 C3 -------------------------------- :Skein-256: 1024-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 6C 9B 6F AC BA F1 16 B5 38 AA 65 5E 0B E0 16 80 84 AA 9F 1B E4 45 F7 E0 67 14 58 5E 59 99 A6 C9 84 FF FA 9D 41 A3 16 02 86 92 D4 AA D1 8F 57 3F BF 27 CF 78 E8 4D E2 6D A1 92 83 82 B0 23 98 7D CF E0 02 B6 20 1E A3 37 13 C5 4A 8A 5D 9E B3 46 F0 36 5E 04 33 0D 2F AA F7 BC 8A BA 92 A5 D7 FB 63 45 C6 FB 26 75 0B CE 65 AB 20 45 C2 33 62 76 79 AC 6E 9A CB 33 60 2E 26 FE 35 26 06 3E CC 8B -------------------------------- :Skein-256: 264-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: FD DA 04 6C 4B DB 38 5A E6 C7 BB 40 C6 0F 05 13 00 B4 92 D3 9B 16 05 40 8D 61 F5 E0 4E 0B 9D 2E 18 -------------------------------- :Skein-256: 520-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: C8 2F A6 90 11 48 34 5E F4 CD 3F 29 8D F4 EB 01 B9 D6 99 DE 05 22 4B 94 14 C4 BB 95 B2 45 F4 CC 8A AF AD 33 31 DB 49 2C B8 26 86 D5 80 BC 2E A0 3C 2A C5 B5 CF B2 92 68 C5 0E FB EF 5C FF CE F3 55 -------------------------------- :Skein-256: 1032-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: D1 68 2F 5E 9D 54 DE 50 5B D8 AC 68 A5 76 C9 E7 FB E0 91 05 4F 6B B7 14 F0 9B 2C 5D EC 08 8D 90 A4 D0 17 B7 6C 2A 82 F5 3D B7 41 CA 51 F5 D1 DA 22 98 33 1B 26 F3 8B 9D 93 F8 53 6B 93 C3 A9 27 56 B3 AD 45 53 22 18 07 38 10 71 EE DE 0E EF 82 D9 49 A2 EB C7 C1 07 78 08 35 8E 25 E9 47 30 92 1E 2A 88 BC 3E 0F 88 44 8E 16 A9 A1 2D 29 E2 9F F6 E4 62 6F A9 9E 45 F9 A3 DB 99 0C 50 37 5E CD 04 -------------------------------- :Skein-256: 2056-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: AE F6 DD 3B 35 1A 3D CA 5B 43 81 34 59 F0 A7 C4 1A 24 3C 3B 3B 60 8F C6 49 A5 21 45 59 28 87 46 A2 C9 54 8C 2D F3 1E 47 D2 C5 2B E8 CF 97 1C C5 A9 47 9E CE F3 88 B2 62 3C D2 92 FA 77 E5 AE B5 9B AF B8 82 29 36 9D 98 06 A0 A0 B1 DB 43 FE F7 D4 1F 96 7E 80 B0 CC E8 67 34 04 26 07 FD 75 C7 74 33 67 C9 8E DA 13 A6 A5 5C 6A 89 1F 86 9E 83 E7 3B 9D B4 13 FC CF C8 6F 79 04 CC D9 CC 39 84 EB 35 65 2E E6 28 0F D0 CD 71 EC 3E 97 B5 7C 42 55 B6 28 E6 4D 14 77 F1 E0 7B 76 CF FC D1 B1 D1 87 D3 1E 32 B1 C2 ED 0C 1F 15 A1 71 84 62 CF D3 C5 23 98 54 09 4C 90 BC 2A 7E 8F 84 94 8B BC BD 03 B7 31 D9 A7 F4 CE CE CA BC 11 9A 10 1F 6F 59 E4 B5 B7 B2 93 18 D8 48 7C 33 D5 10 57 ED 82 D6 D7 EA 31 14 F3 A4 3E 90 F0 06 0A 2D D9 D2 D5 F3 FE 5C 4B 53 6F 7D 17 2C DF 0C 31 87 46 C4 99 79 8D -------------------------------- :Skein-256: 256-bit hash, msgLen = 1025 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 Result: 97 B8 20 38 2F 83 2B 38 3A C3 FE 28 75 A4 9C 8F 41 78 42 43 A6 CF BF EC BC 12 76 60 5A E1 A8 69 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2047 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E Result: 0F DC 97 80 11 7A 68 3B 2E C6 43 B8 66 49 9C 3B 09 A5 4D 29 2A 39 AC AD 32 4A 59 E0 B1 38 05 6D -------------------------------- :Skein-256: 256-bit hash, msgLen = 2048 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E Result: 96 4A 3E E1 BD E5 9B 10 84 E6 4C 12 15 1D 92 DC F2 1B 7A 06 AA 3B 37 A5 02 99 CA 8D 76 04 CE 12 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2049 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E 4E Result: FE 9C 9C D1 67 11 AE 5F F0 5C E1 20 3F 7E 64 AF DF C5 63 73 C2 1F BE E2 D6 FB 1A 37 E8 26 1E 8B -------------------------------- :Skein-512: 512-bit hash, msgLen = 0 bits, data = 'random' Message data: (none) Result: BC 5B 4C 50 92 55 19 C2 90 CC 63 42 77 AE 3D 62 57 21 23 95 CB A7 33 BB AD 37 A4 AF 0F A0 6A F4 1F CA 79 03 D0 65 64 FE A7 A2 D3 73 0D BD B8 0C 1F 85 56 2D FC C0 70 33 4E A4 D1 D9 E7 2C BA 7A -------------------------------- :Skein-512: 512-bit hash, msgLen = 1 bits, data = 'random' Message data: FB Result: 54 EA EA 3E D9 F3 34 01 BA 8A F6 45 B3 D3 80 FC 40 2E 61 B4 3B 84 ED 26 B3 D1 E9 80 72 A4 B0 29 CA D8 6E DB DC 17 34 3B AD A6 27 0D 9E EB B0 44 17 25 AF EA 51 AD 74 F0 43 CD 25 4B BC CE 2C B7 -------------------------------- :Skein-512: 512-bit hash, msgLen = 2 bits, data = 'random' Message data: FB Result: B0 55 F4 35 FF 61 15 13 2E F7 71 BF F1 E3 82 04 3D 93 BE 94 AD 3E 2E 17 15 E6 15 86 32 2C 5E 25 99 C8 8B 1E 48 3C 22 2D EB 44 86 68 C4 1C BD 48 DE 27 03 93 1C 98 6D 3F C0 D6 8F B9 00 87 E3 40 -------------------------------- :Skein-512: 512-bit hash, msgLen = 3 bits, data = 'random' Message data: FB Result: FC AB D6 46 33 C0 1B 1F 51 80 32 1C 3A 73 4D 37 58 CB D7 35 FC 4A 77 F4 32 E2 D0 C9 9E 5A F2 8D AF 26 9D CC B3 4A 74 35 E9 31 15 7E 49 B8 D2 E3 EE D0 FC FA B7 1F 16 33 D8 89 E6 54 28 D9 52 42 -------------------------------- :Skein-512: 512-bit hash, msgLen = 4 bits, data = 'random' Message data: FB Result: 15 6E 61 BF 4C 11 04 6E 64 3B 86 86 C4 BD 85 B6 C7 85 DD A5 B4 66 94 3D DF D6 1E 4C AC 05 EC CC B9 B8 2B 27 77 69 29 F4 A3 39 AD 7F 9A 39 91 AF E3 E4 9A 3A 40 7E 0E 7A 75 E5 92 87 DE F2 F8 99 -------------------------------- :Skein-512: 512-bit hash, msgLen = 5 bits, data = 'random' Message data: FB Result: 18 5C 59 DC 2F 1B 49 D3 92 04 20 41 CC F8 C3 B2 01 69 22 59 70 4A 90 F7 50 DA 33 DA E8 E6 01 61 9A 5E 7B CB 2A 72 31 97 D2 48 E8 05 AB 0F 20 9A 34 01 FB 6F B6 71 34 EE 3A 0F EC 77 F0 6F 41 6E -------------------------------- :Skein-512: 512-bit hash, msgLen = 6 bits, data = 'random' Message data: FB Result: 8F 6B AD 82 4D 6B 89 F9 FE DA 70 1B 6B 7C 7D CB BB 0E 48 9E C3 2F F9 84 CB C7 60 AE 09 58 2E A1 C5 FC 06 2B BF DC B7 6D E5 D2 0C 8A 28 BF E5 38 5C 36 EC 6A 41 A5 E9 99 58 07 55 82 E4 24 CF 53 -------------------------------- :Skein-512: 512-bit hash, msgLen = 7 bits, data = 'random' Message data: FB Result: CD 21 76 A5 FE 82 3E D6 EF CB 6F 15 8F F3 5C 01 0F 86 4C C8 A9 14 6C CD F6 F1 90 41 4D D0 6B 82 51 54 0F 94 EF F5 80 A5 66 4D AE 3D F1 62 8F 84 01 B1 F2 DD 4B B5 FC 78 E9 FE 7E ED FA AC 35 9A -------------------------------- :Skein-512: 512-bit hash, msgLen = 8 bits, data = 'random' Message data: FB Result: C4 9E 03 D5 0B 4B 2C C4 6B D3 B7 EF 70 14 C8 A4 5B 01 63 99 FD 17 14 46 7B 75 96 C8 6D E9 82 40 E3 5B F7 F9 77 2B 7D 65 46 5C D4 CF FA B1 4E 6B C1 54 C5 4F C6 7B 8B C3 40 AB F0 8E FF 57 2B 9E -------------------------------- :Skein-512: 512-bit hash, msgLen = 9 bits, data = 'random' Message data: FB D1 Result: BF 89 C0 6D 49 57 EE 1B EE FB C5 1A CA 0A 49 A8 8B 7C 0F 8E FC B5 B8 8C 79 F5 E0 B9 18 3C CD F8 73 8B FE C1 CA B9 5A D2 EF 1E 6D 35 C2 54 CB 09 6E 00 A0 FD 94 FD B4 4F 62 F5 F8 FC 22 64 15 8D -------------------------------- :Skein-512: 512-bit hash, msgLen = 10 bits, data = 'random' Message data: FB D1 Result: B8 3B D8 9A 8D 79 26 71 BB 65 3B D5 4D 20 02 E0 31 6E F1 B9 D1 15 4C 24 CD E6 1A D3 3E 68 20 40 2E C5 A1 46 2A CA B2 AD 4F 4B 53 85 32 2F 5B E0 E5 9B D8 CD E5 86 96 12 94 CC 2E B3 7F 0D 3D 03 -------------------------------- :Skein-512: 512-bit hash, msgLen = 32 bits, data = 'random' Message data: FB D1 7C 26 Result: 92 B7 29 41 95 70 B2 2B B7 5B 50 CF 72 DB 16 8B 4C 73 56 94 BC 8A D4 43 3C 7C 18 7B 0B DD 48 9C C3 F6 7A E2 3E 50 18 EB F4 10 0C F6 AF B2 E1 DB 1F 17 5D C2 66 D9 25 75 E8 D8 26 1D 6E 6E 27 6E -------------------------------- :Skein-512: 512-bit hash, msgLen = 64 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 Result: B6 40 71 E6 8C B2 40 FB CC EA 60 39 F3 51 D8 0E 9A B3 31 4B 16 B5 88 8E C4 EE 82 93 32 37 4B 1A 57 AE DD E7 76 0B 39 09 9C 6D AD CC 1F 39 33 B9 AF 75 58 2F 62 3E B7 BD CF FA 33 B2 58 74 44 7C -------------------------------- :Skein-512: 512-bit hash, msgLen = 128 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 Result: 03 04 F6 E4 F2 EF 71 C9 53 9E 95 EB CE 42 A1 6B 45 1A D8 B5 2A 34 C2 B6 9E 53 69 78 F1 64 B7 C2 1F D5 2D 15 E3 82 5E 09 83 5A 41 AE 51 B7 F0 16 84 96 93 61 B7 50 62 74 C7 28 65 B8 A5 AE 3C EE -------------------------------- :Skein-512: 512-bit hash, msgLen = 192 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B Result: B4 29 70 F4 C4 58 28 5D 36 A6 7D 9D 9B 3D 8F 13 D2 F4 7F E5 E4 8A 03 74 B8 97 F4 7D 8A E0 D5 3B 72 CA 9C 32 1D F7 C1 FD B8 F7 55 1B DE 4D 3A C6 27 5F E0 2B E4 68 45 4B E4 2E FB F7 C4 3B 80 AE -------------------------------- :Skein-512: 512-bit hash, msgLen = 255 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 Result: D3 1E 6D 14 FE CB 57 16 BB 27 D3 DC 54 9B 59 C5 B6 09 63 A5 F1 6E EC 7F 73 7C 20 3A B7 ED E3 E2 12 F9 32 54 9B 89 27 C0 5A AA 1F 3B 17 60 0D A2 F3 02 3A 38 59 C7 A7 73 16 48 2C 0D F8 71 94 4E -------------------------------- :Skein-512: 512-bit hash, msgLen = 256 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 Result: AB EF B1 79 D5 2F 68 F8 69 41 AC BB E0 14 CC 67 EC 66 AD 78 B7 BA 95 08 EB 14 00 EE 2C BD B0 6F 9F E7 C2 A2 60 A0 27 2D 0D 80 E8 EF 5E 87 37 C0 C6 A5 F1 C0 2C EB 00 FB 27 46 F6 64 B8 5F CE F5 -------------------------------- :Skein-512: 512-bit hash, msgLen = 257 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 Result: B7 84 82 9E 16 52 C8 5C 94 60 22 71 27 27 62 07 BE D0 92 AE F6 BF B5 13 69 E4 CD 41 F7 DE 61 1B 9B DF 14 61 3E AA E6 FA 1C 16 D6 2A 5D 41 3F 40 B8 06 08 04 3E 0C 39 5F CC 05 3E D4 C0 10 62 3D -------------------------------- :Skein-512: 512-bit hash, msgLen = 384 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 Result: 5C 5B 79 56 F9 D9 73 C0 98 9A A4 0A 71 AA 9C 48 A6 5A F2 75 75 90 E9 A7 58 34 3C 7E 23 EA 2D F4 05 7C E0 B4 9F 95 14 98 7F EF F9 7F 64 8E 1D D0 65 92 6E 2C 37 1A 02 11 CA 97 7C 21 3F 14 14 9F -------------------------------- :Skein-512: 512-bit hash, msgLen = 511 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB Result: AC BE 18 5E BF 39 26 66 2C 4C 1F C9 84 3B 5B 28 F9 BA FA 91 57 04 31 0E EF 92 D7 AC 54 53 F1 05 D3 C1 ED EA C8 54 01 54 BD B4 7D 40 5F EC 02 A3 34 E6 50 72 C6 36 11 20 71 F3 41 02 46 7F E1 E8 -------------------------------- :Skein-512: 512-bit hash, msgLen = 512 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB Result: 02 D0 15 35 C2 DF 28 0F DE 92 14 6D F0 54 B0 60 92 73 C7 30 56 C9 3B 94 B8 2F 5E 7D CC 5B E6 97 99 78 C4 BE 24 33 1C AA 85 D8 92 D2 E7 10 C6 C9 B4 90 4C D0 56 A5 35 47 B8 66 BE E0 97 C0 FB 17 -------------------------------- :Skein-512: 512-bit hash, msgLen = 513 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 Result: 67 5B 04 15 63 C9 B1 29 3E 35 ED 53 4E 9F 86 E0 BB C3 7A 73 C1 B3 79 94 A9 41 30 93 E4 70 07 14 A9 E6 9E 6A 9F CB ED 7D 3A 21 3A C2 68 71 7B 41 9B 37 94 57 27 B1 14 07 5F 2F 87 22 6A 53 90 FB -------------------------------- :Skein-512: 512-bit hash, msgLen = 768 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A Result: E3 0E 94 6D 43 98 D1 02 C2 FD E5 6E F7 61 1D D1 33 D2 D3 06 6B A3 20 F2 0A 00 E8 A8 02 19 F5 4D 09 9F FD 5A EB E1 C9 4E 78 8B BC 8A DA C3 BA 3E 37 4E 0C EB 55 4C 4F A9 D4 C8 7A 79 B2 C6 49 AF -------------------------------- :Skein-512: 512-bit hash, msgLen = 1023 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: AF F9 C8 3D 03 72 41 CD 68 54 E7 F1 58 EB 2E 8F 89 B8 8C FB 71 6F D6 1F F0 04 19 93 6B 82 22 14 0C 4F 30 89 BD 50 5B CE 46 B9 25 94 95 CB B1 A5 AC 6E 0B EF 51 30 1C 3B E0 68 83 D2 C0 C5 5C ED -------------------------------- :Skein-512: 160-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: EF 03 07 9D 61 B5 7C 60 47 E1 5F A2 B3 5B 46 FA 24 27 95 39 -------------------------------- :Skein-512: 224-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: D9 E3 21 9B 21 4E 15 24 6A 20 38 F7 6A 57 3E 01 8E F6 9B 38 5B 3B D0 57 6B 55 82 31 -------------------------------- :Skein-512: 256-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 80 9D D3 F7 63 A1 1A F9 09 12 BB B9 2B C0 D9 43 61 CB AD AB 10 14 29 92 00 0C 88 B4 CE B8 86 48 -------------------------------- :Skein-512: 384-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 82 5F 5C BD 5D A8 80 7A 7B 4D 3E 7B D9 CD 08 9C A3 A2 56 BC C0 64 CD 73 A9 35 5B F3 AE 67 F2 BF 93 AC 70 74 B3 B1 99 07 A0 66 5B A3 A8 78 B2 62 -------------------------------- :Skein-512: 512-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 1A 0D 5A BF 44 32 E7 C6 12 D6 58 F8 DC FA 35 B0 D1 AB 68 B8 D6 BD 4D D1 15 C2 3C C5 7B 5C 5B CD DE 9B FF 0E CE 42 08 59 6E 49 9F 21 1B C0 75 94 D0 CB 6F 3C 12 B0 E1 10 17 4B 2A 9B 4B 2C B6 A9 -------------------------------- :Skein-512: 1024-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 8C 25 D3 14 11 0D 1C 0D 58 05 4C 96 A1 9D 57 1E 26 A4 5D 53 62 AA 8F 47 54 7E 53 E0 BE 4A 83 0A 5F 2C 29 CC D8 8E 21 85 FE BA D0 24 A4 69 6F 2D BE 83 07 DC 15 0E 7A 58 B3 79 3B 1A 93 FA E2 52 3E 2D 23 9C 59 A2 3A 1C C1 27 B3 C4 81 A9 80 91 62 E6 0B 4C B0 1C 01 1B 96 30 32 2C 8F E9 74 5D 56 D0 F3 AE D5 4B 34 90 57 8D B4 69 29 01 EA FC 19 60 C1 53 59 17 6A 9C 09 90 B3 2B 8C A8 F9 4B -------------------------------- :Skein-512: 264-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 90 8D D2 01 AF 09 F3 91 8C 63 76 E9 97 80 85 5E BF 08 23 00 8E 6C 35 3F B9 93 3F 63 34 24 FF 09 1F -------------------------------- :Skein-512: 520-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: F4 D2 49 3A 56 AE 27 E6 63 08 BE 82 26 1B F7 9F AE 6E A8 56 CB 1B 21 71 92 0A B3 2E 9C 2A 89 DE D1 DD 1B CA EB B2 A5 CF 31 9A 17 1A 2D 27 44 96 7B 30 63 A7 B3 C1 9B 0B 61 FB 1E 07 FA 8A 9A F0 AE -------------------------------- :Skein-512: 1032-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 38 93 B5 0A 4B AB 1C 04 50 02 D4 4D 8C 4E B2 E9 47 20 8C A5 1A BE 16 0B FD 8F E7 A0 80 95 BD 6A 69 21 95 99 EE 83 B5 B8 4D 96 68 CC BD 40 B3 53 C9 84 2D 9C 47 0C 03 EF 5A 06 87 36 8A C7 26 FB 18 7D 92 23 27 25 C8 5A FF CA 29 C1 EA F0 42 64 D7 56 9D D1 93 A6 29 99 91 91 AF 7B 4B BE D0 F0 6E 3B A3 ED 05 33 87 55 A3 83 A2 62 B4 78 19 38 A2 32 3F 23 05 D8 17 9C 39 A8 CA 64 AA 02 DE D3 F5 -------------------------------- :Skein-512: 2056-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 24 E8 09 F7 66 AC 61 6D DE 1A 5C 9E 8D C3 3F 25 23 A5 B7 E7 0C 33 77 32 79 B8 81 22 1E 13 C9 C5 6E 3F 88 F7 39 74 57 54 6A 1B 41 D4 FE AD A7 E5 23 1B 3B 4F 64 24 15 D1 52 8B B7 BE C3 21 3B 77 D3 E6 CC 00 6A 45 00 A3 38 4B 4C 40 E2 6C EC 4C B7 33 4E 03 5D 2B F9 02 60 C9 68 69 D0 B6 C3 9A 57 74 9E FB E4 E5 79 17 6C 32 CD C6 C1 D4 06 07 E3 66 D1 D5 0C 66 91 01 F9 C2 E5 32 A2 E8 04 0D 48 B6 63 1B E1 C1 2E 6D 04 E6 DA CB 5B 68 58 6F 98 A7 17 2E 64 DF 3A EF ED D3 87 C5 DD 56 FB D2 63 75 34 9E 5D 55 D9 FA BC 0E 91 F3 B3 0A 35 70 C5 C7 97 58 79 DD 28 96 81 CE 13 92 68 F8 A8 A1 00 81 A0 EB 36 89 5E 8D D0 B1 41 84 4A 00 4B A1 12 49 C9 1E 50 5C 9E 84 11 EA 37 6A 8C 41 07 85 53 59 BA 34 1D C7 FF 1B 1B B2 73 60 07 C1 F9 52 84 0C DF A5 21 C6 EB F0 F3 F3 53 31 33 F5 0C D1 AC -------------------------------- :Skein-512: 512-bit hash, msgLen = 1025 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 Result: 1B 4E FF F9 57 C4 FE CD CA E5 1A 90 3E 95 A8 D5 D0 C7 DF 2D 60 14 3A 42 76 80 E1 D4 9C 67 1D 4D FB 03 8F 36 46 44 48 DE B3 02 E4 98 34 D8 B2 3B 44 57 81 42 54 57 72 0E EC 7B AD 7A 21 17 F2 1C -------------------------------- :Skein-512: 512-bit hash, msgLen = 2047 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E Result: FA D7 20 CA 33 18 1E AB 15 4F 33 3A FA 19 20 9B 28 AB 77 B5 AE 15 FB E5 B0 C6 00 98 7C DE D5 BC 55 E2 9D 15 8D 41 BE 85 B7 74 11 D3 02 77 F6 16 F3 EA 8D 18 2B 82 8A EE 5A 94 1A FA 3A 81 55 5E -------------------------------- :Skein-512: 512-bit hash, msgLen = 2048 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E Result: 9B 29 A3 0B D2 13 DF C9 5C 86 78 CF 01 87 5F 68 CC 2A 22 35 0D 71 61 FB 99 86 15 9E EC 3D 3C 85 0C A0 6A 97 6C E6 95 87 1D 40 28 23 A4 E8 2F 1B 21 D3 59 6B CA B8 E0 4D 69 C4 5E 9C 7B EF C9 E3 -------------------------------- :Skein-512: 512-bit hash, msgLen = 2049 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E 4E Result: 68 59 FA E4 48 65 64 3F 75 2F D4 7F 90 BB 53 8A 90 4F E4 A6 80 68 D3 AD 5F AA 1D F6 0B 9D 7F 3D 28 E3 3B 5E AC 6D ED 08 16 00 A0 59 D2 49 8A 91 F4 0D 11 0B 84 67 CA 55 58 AD E5 CB DF 93 C6 9A -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 0 bits, data = 'random' Message data: (none) Result: 0F FF 95 63 BB 32 79 28 92 27 AC 77 D3 19 B6 FF F8 D7 E9 F0 9D A1 24 7B 72 A0 A2 65 CD 6D 2A 62 64 5A D5 47 ED 81 93 DB 48 CF F8 47 C0 64 94 A0 3F 55 66 6D 3B 47 EB 4C 20 45 6C 93 73 C8 62 97 D6 30 D5 57 8E BD 34 CB 40 99 15 78 F9 F5 2B 18 00 3E FA 35 D3 DA 65 53 FF 35 DB 91 B8 1A B8 90 BE C1 B1 89 B7 F5 2C B2 A7 83 EB B7 D8 23 D7 25 B0 B4 A7 1F 68 24 E8 8F 68 F9 82 EE FC 6D 19 C6 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1 bits, data = 'random' Message data: FB Result: 47 28 53 70 0A 4E B0 C7 28 CC 3A E7 84 A6 AE C9 CA FE 79 47 D7 E0 25 71 43 8D AF A5 0B D6 48 EC FC 4A AD C1 E4 8A EF EF 71 78 33 0F DE 72 53 94 C8 EC BC B4 8F 94 BC 4D 9F E6 02 AB AF 5A 36 B2 8F 27 2A 58 E0 3E 61 C9 4B F8 9C FE E2 7A D2 9D 8D 94 54 EE 7A 91 83 84 54 38 26 47 D0 ED 8D BA 1B CF 6C 95 97 3E 7C 5B 45 D2 22 82 78 AB 4E 5A 72 22 A5 C8 E2 41 43 F8 1D D6 EF 30 0D A8 8A BB -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2 bits, data = 'random' Message data: FB Result: 11 42 5D 06 3A B0 3D BE 12 2A 4D B2 33 ED C0 38 15 38 67 D4 84 1A AB 3E 09 17 B8 1F C5 80 59 CA 92 8B D1 5E 0D D1 D0 80 AB D3 33 04 D7 B8 0B F9 FF 12 CE 39 1D 2D 13 C2 58 FF FC 3B 62 01 1B 47 F6 82 F4 4B 10 B4 E5 90 92 A9 07 C7 63 D3 A8 66 99 48 50 C9 E0 DD C2 40 05 99 70 0D 94 2B D4 91 3F D7 38 E7 1B 55 D7 9A 03 02 76 74 CE FF 3F 1B 89 9B 66 74 F4 21 C0 B7 EE 43 CF 00 9D F6 DC EA -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 3 bits, data = 'random' Message data: FB Result: 2C 6B 60 FA 31 1B 79 21 D4 4D DC 99 AB CD 91 AA 29 93 43 2F 9B 14 92 8C E6 31 06 B5 FC 37 60 8D 1B 12 E7 EF AD 2E 76 93 7C A7 7B B5 AB B8 28 B3 BC 21 23 FE AA 49 F8 00 26 F4 E3 6F 88 CD AD 10 A2 83 AA 28 2E 09 D0 26 24 E9 BD 58 6D 4C C6 A0 F8 C9 0A 21 83 AF B7 1C DA A1 5A D0 58 84 5E 20 7B EB 12 A8 5C 3A 17 3A 61 69 48 FD 99 91 5B 69 35 C0 76 8B 23 D9 7C 0B A5 2A F9 85 E0 7B 87 AF -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 4 bits, data = 'random' Message data: FB Result: FC CA 16 4A E7 D8 51 AC E6 F3 99 CB AB A4 09 FD 50 4C 43 52 C3 71 E0 7B 3E 19 B3 B2 6C 14 97 DD 27 FA 78 78 ED 26 4D C3 AA 09 78 91 8A 69 4F 44 AE 1E 78 8C B1 27 BF 82 09 72 00 BC 48 1B 47 AD 02 BD 56 73 6A 6A 5A BE C2 A4 D8 AD 64 8A 9C BC 13 AD FD BC 1F 8F D1 51 B8 88 F9 FF A1 38 7D B6 48 8B 1E 94 CB 4C D1 69 0D B2 DC 5C 8F 9D 89 99 C4 22 3F 74 F7 29 AA 36 19 D8 45 AB 0A 37 F9 50 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 5 bits, data = 'random' Message data: FB Result: 0B B6 A8 33 4D F7 3C 46 09 24 B4 FB 20 40 19 56 73 A7 F0 86 08 16 A3 2A 93 9A C0 77 24 61 DD 20 E0 68 A3 A5 29 77 94 13 9A 9D 68 9B 91 22 A1 44 82 BD EA 22 4C B1 D6 88 95 A0 07 80 BF 55 46 BD B6 DF 01 BB 16 CA C2 5F 1B 0B F3 62 E6 B4 5B 01 F9 E4 E8 97 E4 60 CB 04 49 32 51 79 7B 65 48 FE 1C 97 48 ED 6C A5 52 62 36 68 A8 2E 0B A5 2C 5E 9A 99 F7 04 55 BC 12 76 10 86 DC A3 A5 30 59 EB -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 6 bits, data = 'random' Message data: FB Result: 44 4A AD BD 22 7F 00 E1 74 EC 80 14 43 1C FF E6 3A 08 D0 46 DF C9 62 6E 19 DF 31 EE 56 F7 B8 EC 5F 2B 95 30 3C 34 D4 FE B4 06 D8 56 0F 1B B5 14 5A CB 0A D2 9B EB 0F 6C D7 97 83 BB 91 B6 27 70 83 D8 9F 7F 4D 9A 82 EE 03 9F 96 64 7C BF B3 8A B0 FC D9 14 47 70 36 07 49 3C 68 FF 1F 4B F2 80 D5 69 AC B9 C9 D6 22 AB 61 03 95 2C 87 22 AC B6 F2 D5 08 6C 46 CB 2F FE 19 57 C1 15 37 A7 78 51 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 7 bits, data = 'random' Message data: FB Result: BD 1F AE 51 D5 0C 0A 00 B4 72 56 25 95 0D 74 FD 60 32 3E D9 76 40 D6 65 99 6F 87 61 79 30 04 23 12 A3 08 65 DB 31 0A 11 11 37 76 FC 52 4C 94 DB A4 01 8C BA 7B 9F 02 4D 25 F3 9B 36 BE ED 95 A2 73 99 85 D0 5E F5 F5 BF 28 F8 B4 7B BC 50 F6 CB D3 EE 4D 7B CF 1B 83 6B A6 8F 21 12 E1 A8 CC F5 F6 41 A7 3B C4 A8 D4 A2 51 DC DF F8 D6 EC 98 9B B9 D9 F8 5E 29 C2 BF 4E 7B 72 5B E2 98 E5 F4 D8 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 8 bits, data = 'random' Message data: FB Result: 64 26 BD C5 7B 27 71 A6 EF 1B 0D D3 9F 80 96 A9 A0 75 54 56 57 43 AC 3D E8 51 D2 82 58 FC FF 22 99 93 E1 1C 4E 6B EB C8 B6 EC B0 AD 1B 14 02 76 08 1A A3 90 EC 38 75 96 03 36 11 94 27 82 74 73 47 70 67 1B 79 F0 76 77 1E 2C FD AA F5 AD C9 B1 0C BA E4 3D 8E 6C D2 B1 C1 F5 D6 C8 2D C9 66 18 00 DD C4 76 F2 58 65 B8 74 82 53 17 31 87 D8 1D A9 71 C0 27 D9 1D 32 FB 39 03 01 C2 11 0D 2D B2 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 9 bits, data = 'random' Message data: FB D1 Result: 01 CF B1 34 26 1D FD 1F BB 63 68 06 B7 46 81 49 11 83 60 2E DA E2 C9 3F 07 22 9B 4D EF 4E BB A1 36 01 5A BE 12 E9 B7 8B 47 13 DE 2B 2A 5B 16 D0 07 79 13 9E 75 32 9A 06 48 41 07 FF 83 A6 1F 91 FD 35 34 CB 14 65 99 A7 81 3A 7E DA 94 07 22 B2 31 B2 CB C5 EB E1 FD 80 C0 15 1F DC 60 83 EA 65 63 C5 E0 C1 1D 4D 96 87 B2 F3 FF 41 AE 8B B2 38 72 2C 17 04 8D 08 CA E9 96 6C 1B 50 DD 3B C6 9F -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 10 bits, data = 'random' Message data: FB D1 Result: 44 2F E1 2E A3 0B 93 C7 F6 0C 8A 4B 78 C4 ED 59 F9 CB 63 93 4D 6A 20 74 67 DB E8 B7 4B CA FB 61 B1 0E DE 36 8C 7D 59 C9 49 54 5F F6 39 CC F3 96 CE 3A D6 BD 51 0B 56 76 00 0C 6F 6C FC B3 CB 0D B7 B2 22 6E 23 75 3B DF 51 D3 51 94 0F CE E0 A8 76 BB D4 52 80 67 EA 92 20 1D 46 C0 57 5C 7F 70 C4 85 25 07 42 93 28 0B 7A E8 A4 B4 EB A8 0B ED 43 53 AE 08 B6 06 3F 34 B7 D2 9E 8C CE 14 95 72 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 32 bits, data = 'random' Message data: FB D1 7C 26 Result: 8E 34 DD D7 07 13 DD E2 44 A6 E3 2B BA E2 96 6C 55 7B 64 31 59 E4 79 D1 1A 21 9D 87 36 B6 2E 86 80 29 92 31 07 48 4A EA E0 F2 88 14 A2 10 CF CE 03 CE EF 89 0E 44 8F C5 8F B7 5C D2 76 9A F2 87 7A 03 86 5D AD A0 F2 1D DB 80 2E 42 90 24 50 24 E3 D6 1F F2 AC FA 08 39 88 82 7A CB CB 21 91 7E D9 6C 0F 20 D6 2B 28 1D 0D B2 E4 7F CB EB 46 5E 42 23 12 5F 76 0A DD BF 89 CD C3 46 69 6D 5B 48 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 64 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 Result: 5A FA 09 A9 48 A7 32 FC BF EA 7C 05 CD 52 46 9B 5E A3 D7 2C EF 67 49 82 7F DF A1 BE 85 AE F4 D3 F0 F9 34 21 8F EA 7D 41 95 A7 6F A9 CF AD E4 10 75 8B 4E 93 68 07 FD A5 BB CC 76 01 27 C8 BC 38 4A 07 56 CC ED 82 34 F4 A2 98 B9 DF C9 D1 6A 00 48 CC 17 1F 32 49 52 7D 20 61 AC 93 C5 5D BF 80 72 6A 79 12 35 16 DE 07 74 4E 79 A2 FD E1 A6 45 21 B4 17 5F F6 8B F3 AA 2A CC 43 A7 DD 28 50 94 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 128 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 Result: 1B 47 DB A3 B9 71 45 18 05 DC 69 D2 A4 0B 3D A9 42 CE AD 2A 96 37 F7 AF D4 3F 90 2A E9 44 66 D1 CC 82 A4 C7 F3 5D FA F0 0F 32 BA 46 B8 FD 16 BC 2A 85 24 B0 D7 6B DB E3 2E B1 37 B9 72 1C 78 D1 32 67 EE F0 CE 7A 9B F9 8A 96 88 84 0C DE C6 7F 3E 61 58 9B 63 B0 85 29 D4 33 1F E2 2F 50 10 5A 44 A3 6E D6 54 CA 2E 61 13 C2 ED E4 CC 70 02 A7 9E B3 1F CD 65 FE 58 56 C7 30 76 12 EE CD DF 6B -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 192 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B Result: 30 49 95 06 2F EC 83 4F 07 A7 B3 CB 78 AF 73 E2 7B A0 95 61 1C 01 DE 2E A8 6D 7E 73 53 18 C2 FA B2 4E 64 59 44 7B 19 7C 95 EA 84 3E 8C 97 B7 5E B1 31 CB CB 00 54 CA 50 F9 67 69 85 44 D1 A1 35 46 2B 31 5F 72 79 C1 FA 0B 58 D6 D0 47 8A 48 16 80 07 B3 9D 7F 90 D8 04 1F 5B E8 2B 02 72 FE C0 F2 27 2B 61 C4 49 8D 5A 2E B8 4C 16 24 3B E9 6E 19 84 E9 47 23 E4 76 63 68 C6 58 FD 3B CC 1E 0A -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 255 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 Result: 21 0E 05 0B 03 60 93 40 A3 7B 98 A8 D9 70 F1 38 BC FF 12 05 E5 60 14 FF C3 79 6C 70 13 A3 42 10 47 6A 57 AD E8 AC 28 87 E9 90 66 B3 B4 92 65 EA 5B 59 EC 5A BC 75 19 79 33 C9 F4 7B EA 97 7E FC 99 4F 9F D4 58 2F FD 4F 80 9A FD 84 68 9C B7 5C 44 25 C9 CB 77 62 E4 8D 8A 45 C3 92 BD D4 BD 3C D8 7E 9A A6 DA 2C 5E B0 7E EC C0 4F ED 16 09 46 A1 45 8F E7 CC 43 08 D5 C1 BC DF 75 F6 EC 32 B7 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 256 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 Result: 14 0E 93 72 6A B0 B0 46 7C 0B 8A 83 4A D8 CD A4 D1 76 9D 27 36 61 90 2B 70 DB 0D CB 5E E6 92 AC B3 F8 52 D0 3B 11 F8 57 85 0F 24 28 43 28 11 30 9C 1D CB E5 72 4F 00 26 7E A3 66 7E 89 FA DB 4E 49 11 DA 6B 0B A8 A7 ED DF 87 C1 C6 71 52 EF 0F 07 B7 FE AD 35 57 31 84 78 BD EF 5A D1 E5 92 6D 70 71 FD D4 BF A5 07 6D 4B 32 53 F8 DE 47 9E BD F5 35 76 76 F1 64 1B 2F 09 7E 9B 78 5E 9E 52 8E -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 257 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 Result: D4 0F E4 49 8F CC 2F 68 E6 71 75 C7 A5 D6 9C B0 24 D5 84 3E 85 97 7D 0B AE EC 48 52 02 A9 09 90 FC 38 5A 13 08 97 3D 28 EF 2C FA 62 8F 1D CA CE 31 42 63 4F E0 3E 9F 78 01 A3 7D 11 61 72 27 E9 D8 CA 35 1F 1D 6A B4 6D 0A CA 6E 38 C1 51 68 59 63 9E DA E9 4A 9A 79 5C F8 15 AD E8 55 C9 3B 3A 8E D1 0D CE D9 68 3E 42 A5 6F 17 EE 04 A7 E5 9E A4 E7 94 AF 06 8C DB 47 28 B9 05 22 5E B2 81 70 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 384 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 Result: 31 10 5E 1E F0 42 C3 0B 95 B1 6E 0F 6E 6A 1A 19 17 2B B7 D5 4A 05 97 DD 0C 71 11 94 88 8E FE 1D BC E8 2D 47 41 6D F9 57 7C A3 87 21 9F 06 E4 5C D1 09 64 FF 36 F6 71 1E DB BE A0 E9 59 5B 0F 66 F7 2B 75 5D 70 A4 68 57 E0 AE C9 85 61 A7 43 D4 93 70 D8 E5 72 E2 12 81 12 73 12 5F 66 CC 30 BF 11 7D 32 21 89 4C 48 01 2B F6 E2 21 9D E9 1E 06 4B 01 52 35 17 42 0A 1E 00 F7 1C 4C C0 4B AB 62 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 511 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB Result: EA B0 FB 29 7F 63 D0 5A 39 64 5A 8A A4 E3 C6 B8 B2 01 29 C2 09 83 1D 77 1C E0 BF 03 53 80 A2 5A 92 23 D6 C4 E3 93 2D 9E 36 B7 4E C2 44 6C 75 DA 93 62 73 33 41 85 72 5E 52 84 83 0B 96 EE C4 7E 25 76 6F 7C DF 99 01 0F E0 BD DE E3 44 99 D3 25 D2 23 C6 51 E4 23 9B B2 E5 83 7C BA 82 32 33 D9 77 6F 49 F7 F8 E0 C3 1F F7 A2 34 3D E5 38 2B D3 D4 C8 B9 1C 44 99 88 EF C8 E8 C6 67 95 2C 38 8E -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 512 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB Result: 50 43 2D D0 01 D0 A0 24 D8 0A 0B B3 69 47 B7 03 86 AF F0 5F BB 88 72 46 6D C7 DF 34 B3 1B 09 C4 D5 E6 8C 72 96 83 07 F6 C3 43 AF 2E DB 0F 25 DC 64 31 23 C3 45 D3 5C 54 46 96 E5 D5 42 79 6E 92 91 E7 1B E5 9E D2 F9 05 0D 51 73 3A 44 FA 21 06 C7 F9 87 3B C3 C2 B2 6C DD 8B F7 7F 9A F3 06 F1 1B F3 92 32 70 CA 25 5B 26 8F 58 92 54 6C D7 51 54 BC 20 73 8E 8B B0 72 F3 A3 7D 9C DB 30 D0 80 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 513 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 Result: 09 E6 DA 49 00 8B F5 E5 DB 2B 3B 24 19 92 AA 5E 97 1D 55 6C C5 27 84 A7 C5 AE 43 6C 34 26 D9 37 F3 06 43 F9 12 35 D0 CD A7 F8 50 E3 3B DD 33 B4 78 93 4A 36 E6 90 19 21 61 4A D3 18 F9 35 4A 82 08 B9 EF F7 13 0C F5 A2 56 0E 8F BC F5 4D FA 15 58 98 51 05 82 9F FE 66 23 3C F4 DD D4 68 96 57 2D 6C 9B 06 F2 53 2C 77 CD 1C 5B DC 24 7D 84 97 0D 20 E1 2B 13 28 E8 67 49 23 8B 9F E9 B1 A5 23 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 768 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A Result: 14 E9 85 66 4C 42 1E 0F 90 CB 2E 6A 3E BB 95 A6 ED A9 C2 2B 5F 0E 3F D1 24 12 AA D2 50 DB D6 68 01 15 AF DF 38 BA F2 0B E4 55 01 2B 85 F5 B6 DC 06 41 78 68 91 3E 49 53 E3 D3 54 5B 95 60 39 EF 63 D5 6C 07 FA 0B EA FA 33 B2 06 2D 21 9B 93 49 8F 15 24 EE A7 64 CB 6A 5F 98 43 D4 51 A4 12 39 81 DB 52 4E B6 37 1F B8 63 10 A4 67 CF 69 62 D6 E4 29 04 57 8A D1 84 61 CF A0 7D D2 BE D3 2A 0B -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1023 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 54 2F 2A BC 55 55 8F B4 0D E3 68 8D 3C DA 41 D2 20 9B 9F 6C F7 B3 CB 47 B3 65 02 3C 14 E9 00 2F B2 D5 8D 83 5D B8 30 07 F5 8E 60 AA 15 03 C9 49 07 87 C0 B1 A1 E2 A9 21 8C 8B B1 D8 23 F9 05 D4 65 87 09 1E 99 A2 2C 55 36 12 0C 5F 1F DC 65 F7 75 22 90 AB A2 37 85 B9 31 E9 8D 99 BF D5 0D B8 E6 7E 93 40 4D 44 6F 50 AC CC 0B 79 11 84 8C 5D 5A 99 00 60 7B 18 A3 2A 90 5F 48 4A B2 52 B6 CF -------------------------------- :Skein-1024: 160-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 2E 6A 4C BF 2E F0 5E A9 C2 4B 93 E8 D1 DE 73 2D DF 27 39 EB -------------------------------- :Skein-1024: 224-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 1D 6D E1 9F 37 F7 A3 C2 65 44 0E EC B4 B9 FB D3 30 0B B5 AC 60 89 5C FC 0D 4D 3C 72 -------------------------------- :Skein-1024: 256-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 98 6A 4D 47 2B 12 3E 81 48 73 1A 8E AC 9D B2 33 25 F0 05 8C 4C CB C4 4A 5B B6 FE 3A 8D B6 72 D7 -------------------------------- :Skein-1024: 384-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 9C 3D 06 48 C1 1F 31 C1 83 95 D5 E6 C8 EB D7 3F 43 D1 89 84 3F C4 52 35 E2 C3 5E 34 5E 12 D6 2B C2 1A 41 F6 58 96 DD C6 A0 49 69 65 4C 2E 2C E9 -------------------------------- :Skein-1024: 512-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 5D 04 16 F4 9C 2D 08 DF D4 0A 14 46 16 9D C6 A1 D5 16 E2 3B 8B 85 3B E4 93 35 13 05 1D E8 D5 C2 6B AC CF FB 08 D3 B1 65 16 BA 3C 6C CF 3E 9A 6C 78 FF F6 EF 95 5F 2D BC 56 E1 45 9A 7C DB A9 A5 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 96 CA 81 F5 86 C8 25 D0 36 0A EF 5A CA EC 49 AD 55 28 9E 17 97 07 2E EE 19 8B 64 F3 49 CE 65 B6 E6 ED 80 4F E3 8F 05 13 5F E7 69 CC 56 24 0D DD A5 09 8F 62 08 65 CE 4A 42 78 C7 7F A2 EC 6B C3 1C 0F 35 4C A7 8C 7C A8 16 65 BF CC 5D C5 42 58 C3 B8 31 0E D4 21 D9 15 7F 36 C0 93 81 4D 9B 25 10 3D 83 E0 DD D8 9C 52 D0 05 0E 13 A6 4C 61 40 E6 38 84 31 96 16 85 73 4B 1F 13 8F E2 24 30 86 -------------------------------- :Skein-1024: 264-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 77 88 F7 FF DE 89 F1 0A 31 6A 2E 1B E3 B8 3C 45 52 85 26 2A C7 BD 61 79 22 EA 2C A3 56 9A CA 57 C5 -------------------------------- :Skein-1024: 520-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 4D D3 6D B8 FB BE 50 B1 EC FA 3B 99 1C 48 15 B2 CE 1C C1 37 DA DC DF 0F BA 7D F5 BD 02 0A 60 C5 12 BE EA 0E E3 F7 3D AD B0 A8 CD 0F 14 96 8D C1 FB 0D 8A B8 43 C3 C8 F6 AD 0E 6A 20 63 AC 7D 8B DC -------------------------------- :Skein-1024: 1032-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: F5 B7 ED EF 68 F3 41 03 41 F7 20 4A 41 56 78 A5 44 1E DF 90 E1 B5 03 D5 D2 A3 4E E6 3B B8 CF A3 AB 0E 42 C3 C6 F0 15 13 8C 03 3B 18 DB 16 63 C6 7F 6A 56 18 59 89 C2 AE 2C CE 8E 85 9E FD B1 AB 2D EC E2 3A B9 46 67 BE 97 BE 39 C4 A4 C3 57 27 7E DB 12 57 50 C6 50 B9 EA 63 8D 5C 9D 05 F1 E4 FD 25 42 1E AD 59 A8 F3 DD 14 B4 7A B1 E7 51 35 A3 8B 4C 87 96 2B C8 45 9F D5 B3 A9 80 41 87 B5 72 -------------------------------- :Skein-1024: 2056-bit hash, msgLen = 1024 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 Result: 56 A0 CA B1 AD 31 58 59 DA 7A 6C FC 35 80 7C BF E0 39 AF 06 CA 4B 86 71 C0 53 36 0B DA 0B 17 C1 4A 9E B5 EB 2A BB 01 B0 DB 3F 45 C0 3C D3 0C 69 D7 C1 B7 0C 5C 9E F7 4C 06 FB 3A EF 0C 84 3C E9 B4 C1 BA 22 94 DD B5 C7 1C AB 69 2C ED C1 E6 F9 08 C4 71 B3 8C 0C 58 34 18 B5 5A EF DD FE 08 AB A4 05 5D 0D 19 ED B5 CC BA 16 C3 E2 88 47 1E FE 46 3E 6B F6 CC 34 6C C7 4F 6C 01 3E 02 93 E6 DF D2 E4 AA 66 A9 22 42 FD 39 5B 6D 91 AA AD 5A 07 1C 44 9D 77 EA 00 E4 4E CC 75 07 38 90 AC 50 D4 F4 21 0E 8C 9D A4 53 85 A4 6D 21 4A 0F CC C1 31 DB 3F 84 2F 95 5E 6E 76 AC 31 1B 3B F4 39 DD 51 9B ED D6 91 78 5A DF 75 40 F3 16 3A D1 21 6C F2 AD B7 D4 BF 40 D9 3B E3 18 4A EF 51 B6 51 CA 26 C7 EC 44 07 3F 43 AD 68 9D 26 9E A9 FF 02 F8 D2 C8 93 2F E6 CE D0 29 2F 97 FB 5F 07 CA 27 6D 6B 43 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1025 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 Result: 56 8F C4 1E 4B F1 88 D7 F9 DF 9D A1 A1 AA BF 45 5E C9 8C 13 7D 5C BB 13 79 C3 6B BF E3 18 B4 64 EA 3A F9 0F 97 96 25 D3 B9 AC F0 EB 76 1B 1D 71 A1 A8 6E 41 35 8D D3 52 B8 E8 29 6E 6A 7E BF 77 86 17 2F 09 09 7F 27 EB 5C 22 A4 A0 A9 13 1C 9D D1 C4 DF DF E0 BE 6C 88 46 C9 DB A3 3B 87 52 CA 09 B3 58 C8 87 27 3D 87 63 6C 2C 37 2B 1A AD EE CD DA 1A 17 7A 68 8E 1A 08 2C 2B 75 35 49 CF BB -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2047 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E Result: 32 4E 70 F4 94 C9 CB D9 77 15 4C 07 68 37 F6 0A 39 A2 E8 8D 97 BA 5F E0 80 E2 BE 42 0F E7 0E 50 CC 51 9C 81 39 26 C4 48 5C 16 DB 4A 88 DB 3B 11 C4 C6 B8 B1 4C 97 36 25 23 33 55 1B CE 2C 23 0D EA 07 CA F2 DC AA 15 7A F1 F2 BD 6F 57 99 FD BB 31 8E E1 40 2C 93 A5 67 26 85 12 E1 CD 13 45 DA 54 DA 1D EF 98 9F 89 91 3A D6 A1 2E B9 8C 23 11 2E A5 67 BB F5 11 AE 6A 6A B4 27 8B 1F 97 61 3F -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2048 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E Result: 9A C0 1B 49 82 55 E8 B2 8D BB B9 EF 72 17 82 FF A9 A2 A9 5C A6 D8 E3 47 26 30 88 C4 4D 0F 96 26 F9 1B A4 56 73 D0 2E EF 8A C5 EC 6B 33 EE B8 F5 26 A9 1C BC E2 91 3D 67 C2 75 25 FC FD B7 9B 62 6B C0 D6 B6 E9 49 56 DF F2 86 F4 9D 31 52 0C 3A 9E 39 D6 28 1E 94 41 4F 17 89 7B 18 D0 55 36 48 37 FB DE B6 00 6A 19 2D BC AB 72 5D 80 D3 B0 0B 50 CD 02 CA F6 5D 7E D6 55 AE FB 28 3B 03 3F C5 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2049 bits, data = 'random' Message data: FB D1 7C 26 B6 1A 82 E1 2E 12 5F 0D 45 9B 96 C9 1A B4 83 7D FF 22 B3 9B 78 43 94 30 CD FC 5D C8 78 BB 39 3A 1A 5F 79 BE F3 09 95 A8 5A 12 92 33 39 BA 8A B7 D8 FC 6D C5 FE C6 F4 ED 22 C1 22 BB E7 EB 61 98 18 92 96 6D E5 CE F5 76 F7 1F C7 A8 0D 14 DA B2 D0 C0 39 40 B9 5B 9F B3 A7 27 C6 6A 6E 1F F0 DC 31 1B 9A A2 1A 30 54 48 48 02 15 4C 18 26 C2 A2 7A 09 14 15 2A EB 76 F1 16 8D 44 10 E1 14 AA 47 F7 C5 C6 15 43 C4 D9 59 18 82 34 F7 97 F4 5A 1D 16 65 E3 76 46 D8 12 9A 45 EE 70 78 09 91 BB 6B 10 02 39 E4 66 D5 8D 4C DD 9D 9D 01 90 AB 64 47 0D DC 87 F5 E5 09 E9 A8 CF 82 4F 58 EF 04 73 2E AB 28 09 2D 18 A5 AD A4 5B 6D 49 FB 0F 33 F4 CC 07 E3 9E C6 44 9E 8C 0A BB 17 C6 58 66 00 9A 3D 9C 31 C0 D7 65 E4 AF 88 B8 60 23 E9 A0 67 E3 32 0C 09 24 6A 3F AE 8A 3F D9 7C 48 7E 4E Result: 0F 60 96 AC DC E1 0F 72 04 48 F6 15 78 A7 87 A3 A2 9C 3E F3 43 D8 19 23 C1 2C 4D C0 73 7E 05 A9 71 3B A0 1E 8C 41 86 B3 3B 87 7D 55 E1 3E 38 FE 2D F5 06 45 6A F1 74 FE B8 B9 80 EB 9D 80 BA 2C 96 30 BC CF BD 9B 4C F5 01 DD 68 E2 3E 55 6D AD 61 39 09 E1 08 30 7E AA 8C B6 25 22 21 01 A4 B2 D1 B1 1E 7F 44 16 60 85 43 53 7C 27 4E F4 82 BC 76 98 86 35 8A 73 0A 1B 5A 8F 17 30 C8 B6 71 C0 -------------------------------- :Skein-256: 256-bit hash, msgLen = 0 bits, data = 'random+MAC' Message data: (none) MAC key = 16 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 Result: 88 6E 4E FE FC 15 F0 6A A2 98 96 39 71 D7 A2 53 98 FF FE 56 81 C8 4D B3 9B D0 08 51 F6 4A E2 9D -------------------------------- :Skein-256: 256-bit hash, msgLen = 1 bits, data = 'random+MAC' Message data: D3 MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: 6F 1A EF 07 4E 32 44 5E F3 06 6D F3 8E D4 6D D2 B4 A4 B6 EE CB AB CD 12 4E 92 F6 52 04 68 EA 02 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2 bits, data = 'random+MAC' Message data: D3 MAC key = 33 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 Result: 19 95 72 E5 A0 8F B9 94 71 22 67 D2 91 D8 8C FD B9 AE 26 8E 6F FC C1 F2 48 0E 97 B9 D4 A7 08 00 -------------------------------- :Skein-256: 256-bit hash, msgLen = 3 bits, data = 'random+MAC' Message data: D3 MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: EB C9 61 2F 20 64 D8 D8 98 02 4B B3 29 4B C7 14 29 13 C3 12 38 87 6B 89 46 60 FA 52 EB 67 B7 84 -------------------------------- :Skein-256: 256-bit hash, msgLen = 4 bits, data = 'random+MAC' Message data: D3 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: D7 51 BA D4 D9 4F 07 49 39 E6 A1 63 E9 3A 71 E3 21 7F EA 7F 7B AE 05 0F 48 94 3A AE B7 59 E6 86 -------------------------------- :Skein-256: 256-bit hash, msgLen = 5 bits, data = 'random+MAC' Message data: D3 MAC key = 16 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 Result: 2D F6 B2 87 CA BC 25 EA 98 AB 3C F9 20 15 32 16 9F 7D 84 B2 13 2A 1C 78 12 CA 41 BC 01 61 8E 90 -------------------------------- :Skein-256: 256-bit hash, msgLen = 6 bits, data = 'random+MAC' Message data: D3 MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: 84 77 27 D4 62 A4 05 8F 5D 69 58 29 B1 50 04 1D 28 E6 D2 30 26 89 7F AD 87 26 89 5B 22 C8 3A D4 -------------------------------- :Skein-256: 256-bit hash, msgLen = 7 bits, data = 'random+MAC' Message data: D3 MAC key = 33 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 Result: 30 E4 1F 05 17 37 73 FF D3 98 CA A7 80 10 70 F7 01 C6 12 BF D0 35 F5 55 12 81 5C A8 91 28 18 CD -------------------------------- :Skein-256: 256-bit hash, msgLen = 8 bits, data = 'random+MAC' Message data: D3 MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: 97 94 22 A9 4E 3A FA A4 66 64 12 4D 4E 5E 8B 94 22 B1 D8 BA F1 1C 6A E6 72 59 92 AC 72 A1 12 CA -------------------------------- :Skein-256: 256-bit hash, msgLen = 9 bits, data = 'random+MAC' Message data: D3 09 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 5F 07 9A 98 3F 3C 22 2B 89 52 BF 6B 75 62 3E A4 E6 4A 35 3B 0F 8F A0 66 F8 E3 FF 0F 78 B6 0F 2D -------------------------------- :Skein-256: 256-bit hash, msgLen = 10 bits, data = 'random+MAC' Message data: D3 09 MAC key = 16 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 Result: 9D 85 D6 FC F8 DF 1F 78 CB 60 27 F1 D5 2D FF F9 D5 B5 D1 98 73 B6 6C 6F 4D F9 5B 77 B1 4E 47 CB -------------------------------- :Skein-256: 256-bit hash, msgLen = 32 bits, data = 'random+MAC' Message data: D3 09 0C 72 MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: 1D 65 83 72 CB EA 2F 99 28 49 3C C4 75 99 D6 F4 AD 8C E3 35 36 BE DF A2 0B 73 9F 07 51 65 19 D5 -------------------------------- :Skein-256: 256-bit hash, msgLen = 64 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 MAC key = 33 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 Result: 41 EF 6B 0F 0F AD 81 C0 40 28 4F 3B 1A 91 E9 C4 4E 4C 26 A6 D7 20 7F 3A AC 43 62 85 6E F1 2A CA -------------------------------- :Skein-256: 256-bit hash, msgLen = 128 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: CA 82 08 11 9B 9E 4E 40 57 63 1A B3 10 15 CF D2 56 F6 76 3A 0A 34 38 16 33 D9 7F 64 08 99 B8 4F -------------------------------- :Skein-256: 256-bit hash, msgLen = 192 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: DC BD 5C 8B D0 90 21 A8 40 B0 EA 4A AA 2F 06 E6 7D 7E EB E8 82 B4 9D E6 B7 4B DC 56 B6 0C C4 8F -------------------------------- :Skein-256: 256-bit hash, msgLen = 255 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 MAC key = 16 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 Result: 5C 62 1E 94 C8 74 15 F2 C2 18 29 E8 04 C3 94 15 EB 6C AA EC 28 DA F4 12 62 CC 25 62 E9 F7 F5 71 -------------------------------- :Skein-256: 256-bit hash, msgLen = 256 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: 9E 99 80 FC C1 6E E0 82 CF 16 4A 51 47 D0 E0 69 2A EF FE 3D CB 8D 62 0E 2B B5 42 09 11 62 E2 E9 -------------------------------- :Skein-256: 256-bit hash, msgLen = 257 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA MAC key = 33 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 Result: 22 E2 2B 53 88 E3 CA BC CE 3D 34 52 9B 2E BE D7 6F 89 33 27 9C 05 3B F8 2B 97 31 F6 7D 1C 1F 83 -------------------------------- :Skein-256: 256-bit hash, msgLen = 384 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: C3 53 A3 16 55 8E C3 4F 82 45 DD 2F 9C 2C 49 61 FB C7 DE CC 3B 69 05 3C 10 3E 4B 8A AA F2 03 94 -------------------------------- :Skein-256: 256-bit hash, msgLen = 511 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 94 0D FA A7 36 D4 1F 6C C9 73 0A 74 2F EC 44 44 6E 1F 42 C5 37 D7 A4 13 17 23 5A 04 C6 B0 0B A0 -------------------------------- :Skein-256: 256-bit hash, msgLen = 512 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF MAC key = 16 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 Result: B1 B8 C1 81 88 E6 9A 6E CA E0 B6 01 8E 6B 63 8C 6A 91 E6 DE 68 81 E3 2A 60 85 84 68 C1 7B 52 0D -------------------------------- :Skein-256: 256-bit hash, msgLen = 513 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: 7F 72 5A 25 79 36 F6 19 09 28 94 1F 75 D2 83 AB B6 11 88 64 52 F1 65 76 8F B5 EE 7E 5F A6 B4 98 -------------------------------- :Skein-256: 256-bit hash, msgLen = 768 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 MAC key = 33 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 Result: 1D FD 25 15 A4 12 E7 88 52 CD 81 A7 F2 16 77 11 B4 CA 19 B2 89 1C 2E A3 6B A9 4F 84 51 94 47 93 -------------------------------- :Skein-256: 256-bit hash, msgLen = 1023 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: 5E 33 17 92 1D B4 1B 2C F1 82 87 F4 0E 74 DA 5D C4 45 9E 1E F2 90 3E D3 7D 13 A8 DE 0F FF 9F 2A -------------------------------- :Skein-256: 160-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 49 82 E9 E2 81 C1 3F 11 17 13 48 16 A7 B8 58 E8 F1 2F B7 29 -------------------------------- :Skein-256: 224-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 16 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 Result: A0 97 34 07 09 B4 43 ED 2C 0A 92 1F 5D CE FE F3 EA D6 5C 4F 0B CD 5F 13 DA 54 D7 ED -------------------------------- :Skein-256: 256-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: AC 1B 4F AB 65 61 C9 2D 0C 48 7E 08 2D AE C5 3E 0D B4 F5 05 E0 8B F5 1C AE 4F D5 37 5E 37 FC 04 -------------------------------- :Skein-256: 384-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 33 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 Result: 96 E6 CE BB 23 57 3D 0A 70 CE 36 A6 7A A0 5D 24 03 14 80 93 F2 5C 69 5E 12 54 88 7C C9 7F 97 71 D2 51 84 13 AF 42 86 BF 2A 06 B6 1A 53 F7 FC EC -------------------------------- :Skein-256: 512-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: 0E 95 E5 97 E7 1D 63 50 F2 0B 99 C4 17 9F 54 F4 3A 47 22 70 5C 06 BA 76 5A 82 CB 0A 31 4F E2 FE 87 EF 80 90 06 3B 75 7E 53 18 27 06 ED 18 73 7D AD C0 DA 1E 1C 66 51 8F 08 33 40 52 70 2C 5E D7 -------------------------------- :Skein-256: 1024-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 0 bytes: (none) /* use InitExt() call */ Result: CA 1A FA C5 76 2D A7 C2 CC 66 8C 71 A4 D9 85 5E F1 B7 9C E0 C5 5A 19 BD 34 6D B3 13 73 0B 0B B7 36 21 D7 7F 78 87 57 3C 6C 08 72 4B 95 08 D6 FD 6C E3 34 60 D6 2C 0D 53 E2 60 D8 D4 D4 34 66 84 9E F8 72 31 03 29 F6 3C 2C 64 87 4A BC 64 3F 30 33 8A 2A 49 63 C2 22 99 BC 1A 85 E4 B3 E5 03 DF 39 44 2A EA B7 E5 12 6F 20 96 4E 00 A7 1D A8 34 45 C5 57 F4 5F 05 45 8E E9 8F 94 92 FE F5 41 F5 -------------------------------- :Skein-256: 264-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 16 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 Result: 06 4A BD 48 96 F4 60 B1 95 3F 5A 35 7E 7F 7C 52 56 E2 9C DB 62 B8 74 0D 0B 52 29 5C FA 2E F4 C7 A2 -------------------------------- :Skein-256: 520-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: ED F2 20 E4 3E 04 86 03 BD 16 19 7D 59 B6 73 B9 97 4D E5 B8 BC F7 CB 15 58 A4 79 9F 6F D3 74 3E B5 FB 40 0C D6 12 9A FC 0C 60 E7 B7 41 B7 E5 80 6F 0E 0B 93 EB 84 29 FB C7 EF A2 22 17 5A 9C 80 FD -------------------------------- :Skein-256: 1032-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 33 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 Result: F3 F5 9F B0 73 99 C7 B7 3A AE 02 A8 59 08 83 CB 2F DF DE 75 C5 56 54 E7 18 46 52 23 01 BD E4 8D 26 71 69 AD CC 55 9E 03 8E 8C 2F 28 FA A5 52 B5 50 D5 18 74 05 53 84 AD EA 93 C0 36 C7 1A 1F 0A F0 C7 BC C3 BC 92 37 38 D5 30 7B 9D A7 CB 42 3D 4E 61 5C 62 9C 4A BA 71 F7 0D 4C 9D 1F A0 08 17 68 25 E5 1B FA 02 03 44 5A 40 83 94 7E C1 9F 6A 0F BD 08 2B 5B 97 0F 23 96 FB 67 42 06 39 41 04 47 -------------------------------- :Skein-256: 2056-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: 80 EB 80 D9 B8 83 6B 32 FA 57 6F C8 4B A0 8E DF BD FD 69 79 12 3D 61 91 4E 61 0A 70 A3 72 B3 7F 56 0A 10 90 94 84 F9 F4 A3 77 C9 3E 29 BA 68 1D FE 52 2C 41 DC 83 B5 EE 05 67 E5 37 00 07 C7 BB E4 DF 0B 2B 4A 25 E0 88 F8 0D 72 FC 30 73 4C DC D7 6D 81 7B 42 FB D4 4D CA 88 10 19 AF B2 53 06 F1 9D 4E 91 84 87 78 AF 30 65 17 D2 07 2C EF 72 CA A3 27 E8 77 C5 B6 55 4F 83 CE C3 D0 08 77 13 1B 47 C4 D3 B5 57 F5 A1 35 41 C4 D5 08 0E E3 CE 7A 65 89 93 D0 83 EF D0 DB 34 96 A8 75 20 60 C3 C8 55 2F 44 B2 90 CA BD CC 86 7F 69 1A D6 05 83 6C 08 DB D5 9C 95 28 D8 85 B6 00 B8 5F DF C8 A9 D0 E6 36 AC 3A D8 B4 29 5B CB 01 69 E7 8D C3 58 E7 7E AC C8 C4 B6 1B DD FA 9E 5F 32 D2 26 8A 00 6C FE 05 C5 71 50 FE 8E 68 CA BD 21 CF 6C F6 03 5A A1 FE 4D B3 6C 92 2B 76 5A AD 0B 64 E8 2A 2C 37 -------------------------------- :Skein-256: 256-bit hash, msgLen = 1025 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 49 65 F9 5E F1 D8 8C BD 0A EF 94 95 3B 83 7C B5 52 EA E1 CF 92 2D EA 32 E9 93 4B EC 34 3B D9 27 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2047 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 MAC key = 16 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 Result: 7B 1E 7D 0B EE 84 BD 74 E0 46 1A 4F 1A 04 8A F0 95 FD 22 74 3C 52 27 20 CF 95 EA 0F 46 00 D6 D2 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2048 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: 8F 88 DE 68 F0 3C D2 F3 96 CC DD 49 C3 A0 F4 FF 15 BC DA 7E B3 57 DA 97 53 F6 11 6B 12 4D E9 1D -------------------------------- :Skein-256: 256-bit hash, msgLen = 2049 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 FD MAC key = 33 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 Result: 4F FB B8 1F 77 D5 0C 12 32 A0 C9 E8 E0 CE 5A BD 3A 7C B3 84 96 4F 81 6B 7C 41 FC 74 6B C9 A3 0C -------------------------------- :Skein-512: 512-bit hash, msgLen = 0 bits, data = 'random+MAC' Message data: (none) MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: 9B D4 3D 2A 2F CF A9 2B EC B9 F6 9F AA B3 93 69 78 F1 B8 65 B7 E4 43 38 FC 9C 8F 16 AB A9 49 BA 34 02 91 08 28 34 A1 FC 5A A8 16 49 E1 3D 50 CD 98 64 1A 1D 08 83 06 2B FE 2C 16 D1 FA A7 E3 AA -------------------------------- :Skein-512: 512-bit hash, msgLen = 1 bits, data = 'random+MAC' Message data: D3 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 54 EA EA 3E D9 F3 34 01 BA 8A F6 45 B3 D3 80 FC 40 2E 61 B4 3B 84 ED 26 B3 D1 E9 80 72 A4 B0 29 CA D8 6E DB DC 17 34 3B AD A6 27 0D 9E EB B0 44 17 25 AF EA 51 AD 74 F0 43 CD 25 4B BC CE 2C B7 -------------------------------- :Skein-512: 512-bit hash, msgLen = 2 bits, data = 'random+MAC' Message data: D3 MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: F2 5C F3 31 24 D4 D1 D7 19 F4 3F BF 4E F4 F3 4B F2 5B 54 63 CD C6 8C B5 00 30 4C D5 CC 20 57 FC 5A 3F 67 2E 7C 5C 2A C8 E9 17 CA CB 30 8F 46 AB 97 00 D4 43 DE BF 61 36 13 31 A6 C7 94 2E 11 11 -------------------------------- :Skein-512: 512-bit hash, msgLen = 3 bits, data = 'random+MAC' Message data: D3 MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 9A B9 1B BE B1 56 18 9A AA 8C 26 86 E5 07 56 83 86 AE B6 38 70 D6 8B 0A 64 D3 C9 6B C3 A5 10 33 81 A3 DB 2D EA 47 E6 A1 DE 5B 90 04 BC 62 57 68 74 CD AF B0 5B 66 97 E3 5F 53 E2 2E 59 E9 0B FE -------------------------------- :Skein-512: 512-bit hash, msgLen = 4 bits, data = 'random+MAC' Message data: D3 MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: BB 66 8A B9 EC 0E 7C 28 94 78 75 66 49 BB AA C0 0A D4 2F DB E2 2C DE 8E DD E7 E0 49 6A 02 B5 16 0A 12 FE FB BB E3 F0 70 10 04 77 01 69 42 86 D5 25 17 C8 2C 87 EB 9C 0F 49 0F 8D 57 DB 6A 9A 99 -------------------------------- :Skein-512: 512-bit hash, msgLen = 5 bits, data = 'random+MAC' Message data: D3 MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: 1F FC F4 3B 12 50 42 A2 79 0C A4 5D 9C E7 F0 81 30 FB 17 F8 A0 C2 87 7A 7E 1A 67 70 6A 51 91 0E A2 18 6A 81 49 2A 23 C2 65 77 8C F5 69 D9 32 42 57 B6 52 DD 3D 36 A4 A7 DB 21 92 08 D1 A8 90 91 -------------------------------- :Skein-512: 512-bit hash, msgLen = 6 bits, data = 'random+MAC' Message data: D3 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 05 B7 34 EF 18 FE 9F 4E B8 46 D9 3B 34 21 82 56 28 DE 97 FE F4 F6 D9 B4 4D 6A F9 DA A1 9C DC E5 5D A3 91 92 26 8A 48 42 3E 84 B0 42 93 F0 C2 76 00 67 E5 51 A3 BC 2B F4 15 EA 77 64 1A 34 9B D7 -------------------------------- :Skein-512: 512-bit hash, msgLen = 7 bits, data = 'random+MAC' Message data: D3 MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: B1 AB EB 7D 24 4E D1 84 98 87 52 18 85 76 78 BA CC 0C F2 99 17 42 E3 7F 36 3B 8C B8 ED 7F 70 46 42 8C 07 9C 02 69 D0 C7 13 D8 A5 CD F2 EE 23 D6 A9 DE D6 E2 AF 48 EB 04 0D FA 5F 64 FD B4 D4 79 -------------------------------- :Skein-512: 512-bit hash, msgLen = 8 bits, data = 'random+MAC' Message data: D3 MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: F0 C0 A1 0F 03 1C 8F C6 9C FA BC D5 41 54 C3 18 B5 D6 CD 95 D0 6B 12 CF 20 26 44 02 49 22 11 EE 01 0D 5C EC C2 DC 37 FD 77 2A FA C0 59 6B 2B F7 1E 60 20 EF 2D EE 7C 86 06 28 B6 E6 43 ED 9F F6 -------------------------------- :Skein-512: 512-bit hash, msgLen = 9 bits, data = 'random+MAC' Message data: D3 09 MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: 55 8C C9 9D D6 C6 41 06 2F 0C 0A 11 D4 1F 1D 08 EA 28 D7 45 B6 91 37 46 D1 21 97 FC 3A BC C2 10 45 BF A5 95 30 76 CE 5F 5C ED 95 9A 61 C0 03 D2 45 CC FC AE 12 6F 76 5D D4 75 FA B4 6C A8 9A A6 -------------------------------- :Skein-512: 512-bit hash, msgLen = 10 bits, data = 'random+MAC' Message data: D3 09 MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: C0 B0 D9 9D 0F 00 F5 20 39 B9 DC D8 B7 00 13 37 7E 86 90 AF DD 18 97 09 C7 2A 02 29 E6 8D 01 CC 06 59 82 D0 DB 6A 8C FC 29 82 F7 DD 74 7C A3 73 A8 41 34 9C 42 25 B9 EA FF 9F B7 6E 03 8B B9 4E -------------------------------- :Skein-512: 512-bit hash, msgLen = 32 bits, data = 'random+MAC' Message data: D3 09 0C 72 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 12 59 AF C2 CB 02 5E EF 2F 68 1E 12 8F 88 9B BC E5 7F 9A 50 2D 57 D1 A1 72 39 A1 2E 71 60 35 59 16 B7 22 23 79 0F D9 A8 B3 67 EC 96 21 2A 3E D2 39 33 1E D7 2E F3 DE B1 76 85 A8 D5 FD 75 15 8D -------------------------------- :Skein-512: 512-bit hash, msgLen = 64 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: 0C 1F 19 21 25 3D D8 E5 C2 D4 C5 F4 09 9F 85 10 42 D9 11 47 89 27 05 82 91 61 F5 FC 64 D8 97 85 22 6E B6 E1 87 06 84 93 EE 4C 78 A4 B7 C0 F5 5A 8C BB B1 A5 98 2C 2D AF 63 8F C6 A7 4B 16 B0 D7 -------------------------------- :Skein-512: 512-bit hash, msgLen = 128 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 47 8D 7B 6C 0C C6 E3 5D 9E BB DE DF 39 12 8E 5A 36 58 5D B6 22 28 91 69 2D 17 47 D4 01 DE 34 CE 3D B6 FC BA B6 C9 68 B7 F2 62 0F 4A 84 4A 29 03 B5 47 77 55 79 99 37 36 D2 49 3A 75 FF 67 52 A1 -------------------------------- :Skein-512: 512-bit hash, msgLen = 192 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: 13 C1 70 BA C1 DE 35 E5 FB 84 3F 65 FA BE CF 21 4A 54 A6 E0 45 8A 4F F6 EA 5D F9 19 15 46 8F 4E FC D3 71 EF FA 89 65 A9 E8 2C 53 88 D8 47 30 49 0D CF 39 76 AF 15 7B 8B AF 55 06 55 A5 A6 AB 78 -------------------------------- :Skein-512: 512-bit hash, msgLen = 255 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: 4A 02 CE 60 81 8D C9 48 60 6C 10 4F 0A 4D 59 8F E1 95 60 B6 BE 1D 37 C8 22 E2 C8 D5 B5 40 E1 FD B8 EC D0 A1 9B 58 26 77 97 B8 F8 1F 37 3E ED C6 C7 92 6E 48 3A 4F E0 BC F1 A9 85 DD 3E 0B AD E7 -------------------------------- :Skein-512: 512-bit hash, msgLen = 256 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 71 CB 34 2E 5A BE 90 A4 06 7D 5C E3 1F 8A 67 BF A1 B9 39 87 49 30 6F 1B 02 D4 E4 32 32 25 A9 98 02 8A 43 0C F4 76 5F 76 90 0D A2 6C 22 40 57 49 03 9B 1D A3 78 30 22 4D 0F A0 74 1B 0D A0 45 58 -------------------------------- :Skein-512: 512-bit hash, msgLen = 257 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: B9 85 4E 1C 92 3E 52 12 D9 C1 13 DC 46 A5 11 0A 75 44 16 EB 48 74 86 50 73 9F 3E D7 A2 41 AD BF 71 8B 53 4A 59 16 35 F7 55 A8 1E ED C2 BD 28 7D 40 E3 D6 6D F7 43 25 FA 2E DA 9B BB 01 E4 1B 17 -------------------------------- :Skein-512: 512-bit hash, msgLen = 384 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: A9 47 81 25 29 A7 2F D3 B8 96 7E C3 91 B2 98 BE E8 91 BA BC 84 87 A1 EC 4E A3 D8 8F 6B 2B 5B E0 9A C6 A7 80 F3 0F 8E 8C 3B BB 4F 18 BC 30 2A 28 F3 E8 7D 17 0B A0 F8 58 A8 FE FE 34 87 47 8C CA -------------------------------- :Skein-512: 512-bit hash, msgLen = 511 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: 95 E2 CE 7D 27 28 D2 A8 C3 F7 FB F9 4C F9 F8 EB E3 CA DD DE 9B EA CE DE 1E 3E 68 E9 2A 01 9B 5F 16 25 41 D9 4C 2A 9C 6F 26 31 06 78 12 CA 75 9E 86 6A 7B D0 23 1E DC AB DA E0 D9 6B 1E B1 F6 9B -------------------------------- :Skein-512: 512-bit hash, msgLen = 512 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: 76 90 BA 61 F1 0E 0B BA 31 29 80 B0 21 2E 6A 9A 51 B0 E9 AA DF DE 7C A5 35 75 4A 70 6E 04 23 35 B2 91 72 AA E2 9D 8B AD 18 EF AF 92 D4 3E 64 06 F3 09 8E 25 3F 41 F2 93 1E DA 59 11 DC 74 03 52 -------------------------------- :Skein-512: 512-bit hash, msgLen = 513 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 0F 12 07 D6 E6 BD F5 0C B6 53 98 24 B2 83 C6 94 02 0C 71 2B 39 F9 68 87 C2 04 38 A5 6E E6 A0 87 65 56 B2 29 FF DE FC 39 F3 FF 4E 07 0B 37 A3 5E 30 0D 95 92 6A 75 18 1C B3 CC 3E B1 48 4D 73 53 -------------------------------- :Skein-512: 512-bit hash, msgLen = 768 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: D1 0E 3B A8 18 55 AC 08 7F BF 5A 3B C1 F9 9B 27 D0 5F 98 BA 22 44 11 38 02 62 25 D3 4A 41 8B 93 FD 9E 8D FA F5 12 07 57 45 1A DA BE 05 0D 0E B5 9D 27 1B 0F E1 BB F0 4B AD BC F9 BA 25 A8 79 1B -------------------------------- :Skein-512: 512-bit hash, msgLen = 1023 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 78 8B 87 2E B2 53 EA 46 DC 09 58 74 5F F9 95 53 0C 96 4E 28 5D D7 F4 9E CA E6 77 9E 57 CD 72 48 63 A6 FB 7C 62 81 F8 7A E4 4F 79 DF 3D 8E 34 58 EF 7E 52 6D B2 28 CA 09 77 86 E5 06 0E C9 AA 10 -------------------------------- :Skein-512: 160-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: 56 70 B2 26 15 65 70 DF F3 EF E1 66 61 AB 86 EB 24 98 2C DF -------------------------------- :Skein-512: 224-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: C4 1B 9F F9 75 3E 6C 0F 8E D8 88 66 E3 20 53 5E 92 7F E4 DA 55 2C 28 98 41 A9 20 DB -------------------------------- :Skein-512: 256-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 0 bytes: (none) /* use InitExt() call */ Result: AA 70 3B 79 8B 6F 47 2B AA 9D 1E 16 89 FA 0F 70 F8 DC A2 5A 60 46 BB 2C 8F B7 F3 44 07 93 4A E4 -------------------------------- :Skein-512: 384-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: DF BF 5C 13 19 A1 D9 D7 0E FB 2F 16 00 FB CF 69 4F 93 59 07 F3 1D 24 A1 6D 6C D2 FB 2D 78 55 A7 69 68 17 66 C0 A2 9D A7 78 EE D3 46 CD 1D 74 0F -------------------------------- :Skein-512: 512-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 04 D8 CD DB 0A D9 31 D5 4D 19 58 99 A0 94 68 43 44 E9 02 28 60 37 27 28 90 BC E9 8A 41 81 3E DC 37 A3 CE E1 90 A6 93 FC CA 61 3E E3 00 49 CE 7E C2 BD FF 96 13 F5 67 78 A1 3F 8C 28 A2 1D 16 7A -------------------------------- :Skein-512: 1024-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: 08 FC A3 68 B3 B1 4A C4 06 67 6A DF 37 AC 9B E2 DB B8 70 4E 69 40 55 A0 C6 33 11 84 D4 F0 07 00 98 F2 3F 09 63 EE 29 00 24 95 77 1B F5 6F B4 D3 D9 FF 35 06 AB CD 80 BE 92 73 79 F7 88 0D 5D 77 03 91 9F BF 92 18 4F 49 8A C4 4F 47 F0 15 CE 67 6E DE D9 16 5D 47 D5 37 33 F5 A2 7A BB C0 5F 45 AC D9 8B 97 CC 15 FF DC ED 64 1D EF D1 A5 11 9E F8 41 B4 52 A1 B8 F9 4E E6 90 04 46 6C CD C1 43 -------------------------------- :Skein-512: 264-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: 66 9E 77 0E BE 7E AC C2 B6 4C AA F0 49 92 3A D2 97 A5 B3 7C FA 61 C2 83 39 2D 81 CC FC B9 BB BC 09 -------------------------------- :Skein-512: 520-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 94 AB 5C 2D 09 BC B9 8E FE 25 49 79 9D C2 59 DD FE 16 E5 67 57 E0 4A 9A F9 39 CA FC D8 78 2B 46 02 6B 42 A5 17 8A 53 F6 32 09 26 73 57 86 04 72 4C CC C7 23 BE 50 A3 69 02 EE 00 48 D6 CD BC 9B 43 -------------------------------- :Skein-512: 1032-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: AC C2 E0 3F 07 F3 3E 98 20 A6 03 84 21 08 94 29 AD CD 6A 7A 83 F7 33 BE EC 04 8C 05 BF 37 53 1A 17 0A 55 37 FC B5 65 C3 48 A7 0A 83 21 7F 8B E7 68 FF 6F 95 FD 2B 3D 89 CB 7D 8A 3D C8 49 50 5E 37 10 EB 4E 65 A8 E7 13 4B BF 58 0D 92 FE 18 C9 AA 98 75 63 66 9B 1F 01 4A A5 E0 92 51 90 89 35 55 34 EA A9 F0 BD C9 9F 68 39 F5 40 80 FF E7 46 23 25 4C 90 6E CB 88 96 B4 34 6C 31 78 A0 BC 28 98 -------------------------------- :Skein-512: 2056-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 9F 3E 08 22 23 C4 30 90 A4 A3 FF BD CD 46 9C BA BF E0 C1 39 9D 1E DF 45 A5 DF C1 8F 4D B5 42 89 28 A7 6E 97 9B 8D 0D 5D FF EC 0E 6A 59 AD A4 48 C1 FF BC 06 CC 80 A2 00 6F 00 2A DC 0C 6D BF 45 85 63 76 22 28 DC E4 38 19 44 E4 60 EB EB FE 06 F1 23 70 93 63 46 25 10 74 69 A2 2A 18 9A 47 F8 B0 25 89 92 65 D8 89 0A 1B 39 DF 64 55 23 94 37 7E 88 BA 2A D4 4A 8C 8D 17 4F 88 4A C8 C3 AE 24 DD B0 AF FC A5 FC EB 6A A7 6E 09 70 68 81 E8 37 17 74 B9 B0 50 A6 9B 96 EF 5E 97 E8 10 43 F8 B7 E9 47 9E 28 7A B4 41 BA CD 62 CA F7 68 A8 2C 8C 3E 31 07 BE 70 EB 87 99 A3 98 56 FE 29 84 2A 04 E2 5D E0 EF 9D E1 B7 E6 5B D0 F1 F7 30 68 35 28 7F C9 57 38 8E 20 35 B7 D2 2D 3A A9 C0 6A 9F EF BC A1 6F 3F 60 E1 C4 DE F8 90 38 D9 18 94 21 52 A0 69 AA 2E 0B E8 AE 74 75 D8 59 03 1A DE C8 45 83 -------------------------------- :Skein-512: 512-bit hash, msgLen = 1025 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 MAC key = 65 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 Result: 5B F0 83 3B 11 C5 4D DE 59 35 44 09 33 21 62 25 E9 38 74 E1 04 80 E8 31 B4 C1 EB B5 93 B6 94 7C 17 E7 57 EF 7F FC E5 84 1E 03 28 05 00 71 84 87 44 3E 11 AE 57 18 84 03 C1 C6 15 64 DE 10 36 F0 -------------------------------- :Skein-512: 512-bit hash, msgLen = 2047 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: 51 65 C7 CF 26 A5 38 67 2A FB 26 99 12 34 82 EF 66 7C AE F9 12 84 1C 06 5A 58 7E 33 36 07 88 C0 CF 6F 29 E2 A2 C9 19 D9 2D 40 AB 9A D1 EC 90 1F 0B 9C 81 05 FC 08 52 AD 51 FD CD 11 FF D6 D0 B2 -------------------------------- :Skein-512: 512-bit hash, msgLen = 2048 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: FF 20 E5 C4 CA C9 AC 1E B8 91 13 00 D4 AD AA AD 55 F6 B0 6E A1 86 4F AA 76 A6 25 C1 C5 8A 03 02 3D 8B 99 9C 85 77 58 17 F3 4A 02 66 0F 9C 33 DD 4D B5 D4 99 0B A2 F5 7C 15 C1 A5 6D 77 40 78 82 -------------------------------- :Skein-512: 512-bit hash, msgLen = 2049 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 FD MAC key = 32 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E Result: C7 85 B3 78 A7 37 60 8B C6 74 63 D7 83 F8 2F A6 50 72 56 DA D2 10 5A 10 0C C3 6B DC 6A ED F3 60 16 D3 77 7A EA 62 B1 B1 78 EE 9B 8B 5C 91 DB 66 A2 FC B9 5E 1A A0 9C 65 42 8F 26 EA F0 21 BB E0 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 0 bits, data = 'random+MAC' Message data: (none) MAC key = 128 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 Result: BC F3 7B 34 59 C8 89 59 D6 B6 B5 8B 2B FE 14 2C EF 60 C6 F4 EC 56 B0 70 24 80 D7 89 3A 2B 05 95 AA 35 4E 87 10 2A 78 8B 61 99 6B 9C BC 1E AD E7 DA FB F6 58 11 35 57 2C 09 66 6D 84 4C 90 F0 66 B8 00 FC 4F 5F D1 73 76 44 89 4E F7 D5 88 AF C5 C3 8F 5D 92 0B DB D3 B7 38 AE A3 A3 26 7D 16 1E D6 52 84 D1 F5 7D A7 3B 68 81 7E 17 E3 81 CA 16 91 15 15 2B 86 9C 66 B8 12 BB 9A 84 27 53 03 F0 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1 bits, data = 'random+MAC' Message data: D3 MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: CC D2 D1 DE BF 11 C7 01 5E FE EE EC 0D 81 CF 83 80 C5 4F 26 B4 DD EB B1 EC 3F 86 48 4C B6 E1 A0 B0 6B A2 D7 B5 5A 99 BD 8C 89 06 09 91 EF E7 E9 A9 B3 ED FD E0 C1 10 C3 48 43 94 09 92 6B 8D D3 C7 94 A1 4D FA AB AA AA 6E EA 48 3B C4 BF 66 51 BD DC BA 43 70 8B 3A 83 FA 8F CD AA 2A 26 0B 61 9F 07 A8 CA AD 67 BB F6 3F BA 7B 2C 71 56 83 18 20 9B AA BE 7A FC 79 89 69 DF 30 6C 39 77 72 22 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2 bits, data = 'random+MAC' Message data: D3 MAC key = 257 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 44 Result: A5 40 17 16 DF 05 E9 38 EB F8 E1 15 9E 9C 9E DE 10 6D B9 8B 60 1D 1B 29 7A 04 3F 36 D1 A0 32 F1 CA 35 11 53 9D A9 84 79 E0 7D 0D 03 B9 50 18 39 AB 54 69 66 9E 5D 92 F8 34 96 C8 D1 66 53 7B BC 57 F7 04 3B D8 A6 DD 21 BB 13 09 EB 77 DB BA 94 C0 E3 ED 54 97 FF D7 B8 57 E2 ED FF 5A 57 A4 33 01 67 7E BD 58 06 C5 1F 1F 88 6C 47 5A 4D EA D1 38 37 6A 4E 88 C4 AE 8C C4 9D B7 26 5E 37 88 35 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 3 bits, data = 'random+MAC' Message data: D3 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 33 01 92 3D F9 97 D0 A4 A4 93 D6 BB 75 B0 1D 89 62 8F F9 A3 9F F9 40 04 5B 52 28 C7 0D 41 6B 50 CC 00 D5 6A E0 93 04 56 D3 1A 43 6A 3C C9 CF E8 B1 4E 0D 71 58 B4 26 E5 63 12 30 D5 CC 41 35 C2 66 72 33 0F 94 FC 14 36 56 9A FE 52 72 6F 7F ED 46 0C 7D F7 FF 41 FC 7F 17 9E 87 E9 98 52 94 58 E3 78 6D F9 64 99 6D 9F 70 88 4B 9C BC 4A 71 CC E3 EF 32 1F BE C2 8E E1 FF C3 EB 75 D3 D6 D6 06 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 4 bits, data = 'random+MAC' Message data: D3 MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 0F 4E 9F D0 68 52 58 51 F1 10 F1 8A 87 58 8B 9E 62 8D F5 D6 98 25 2E 7C 13 6C 06 9B 7A 99 5F 27 FE 0E C3 A6 DD CD 64 38 17 9D 5E 09 6F 97 8B 3D EB 0A 9D 8B E2 6E 8F 0E 98 B2 C9 CB 5A AA F0 F0 D0 25 FA 38 AC E8 9E 69 07 05 DF F0 03 44 28 17 F7 49 6D B6 37 4F 44 CE 87 ED 29 07 35 6D 83 D6 DF 2D 2C 3A 9F DF 5B 01 7C 2C B0 DA E2 5A CB DE 39 A5 58 C8 5F 64 11 83 61 7B 7B 10 D4 5D 87 20 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 5 bits, data = 'random+MAC' Message data: D3 MAC key = 128 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 Result: 83 94 B0 2E 76 4C 3A FC A6 56 94 92 BA B4 29 29 2E C2 5B 37 E4 66 AD 99 64 40 44 45 20 BC 5A 4D CF AF AA 8A C7 68 16 5D 6E E3 31 68 63 FD 06 97 FC 0F CF EA A6 51 C9 D8 E8 6D 13 7E 9B F4 72 F7 54 71 F9 D9 CA 07 BE 4E CB 85 B2 45 DE 5E 80 5C F0 C6 11 07 98 79 62 19 A0 EC 63 41 72 05 33 B7 25 2A 9B 37 57 80 F3 3C 82 33 9C A5 8B 5E E4 5A E3 84 E3 5C FC BE 2C 94 4C E7 7A 2B 81 9B 33 F6 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 6 bits, data = 'random+MAC' Message data: D3 MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: 28 B2 7E A5 19 48 BC C2 4F CB 5D 52 63 08 72 0A EB 4D A0 8F 49 2A 9C 83 20 4E EF E7 DF 73 92 E9 A4 11 34 12 47 E0 EA C7 9B AD 8D FC 18 19 3B 6A 12 38 DE 8A 8F 7D 1A 55 7E 1F 43 53 AC 32 84 53 70 C2 EB 31 21 01 82 F9 C3 DE 8C 8D 29 60 35 B4 5F 71 8D E7 BB 2A F6 C3 ED 83 52 0B 0A A8 F2 10 D6 52 28 AA 09 AC 30 58 53 CC 97 34 CB 7D 20 AD 74 5D 54 1B 59 12 8C C1 16 8C 83 8D 2C 81 42 C2 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 7 bits, data = 'random+MAC' Message data: D3 MAC key = 257 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 44 Result: 76 C2 D6 D3 D2 B8 EA 41 F9 73 C8 47 C0 FA B7 73 58 49 C3 25 33 85 CA 85 33 23 3C 6F 6F 54 79 59 E4 AA 8D 9E 94 39 03 73 A1 10 57 4D EB 38 F4 12 6B E3 8D 76 C4 EF B6 A9 07 0B 9F CE A4 68 FD 93 B6 29 39 37 C7 7A 09 6C 17 AC EB B6 87 23 78 AD DF 11 74 4C D1 53 CA 6F 2D 7F D0 A0 AE F5 4C BC 09 D6 50 7E 45 78 40 83 7C 0E 3A 25 0B 33 19 AD 85 62 4B DD 35 9B 2E BA 9C CC 2B E2 B9 8C 1F 76 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 8 bits, data = 'random+MAC' Message data: D3 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: F1 FB B5 4F 26 0D 0F B9 D4 9A 29 EE C1 84 B2 65 ED C6 63 66 8A 97 20 AA 61 66 1E 43 65 9B 3C D6 97 C7 00 CE 1E 3E 53 5E 0C 69 80 12 20 B5 DA 97 51 38 E7 CB 1E C8 D8 E3 01 8F 07 8A 32 CA E2 8B C1 89 35 0B 68 EE 67 78 56 23 B3 72 EF 78 11 BB 06 BA 6C 67 E5 84 75 96 FB 72 F2 B5 19 94 EB 8E E0 79 B9 60 E2 28 F7 02 6E 1B FE 8C EA 08 77 49 6F 98 6F D1 3D B8 2E 13 2C C4 5F 70 BB 01 0F 27 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 9 bits, data = 'random+MAC' Message data: D3 09 MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 0B D5 38 5E 0E 2A 7B 6E 58 90 38 2B D3 18 7D 2D 44 C3 AB A1 71 1B 80 44 0D B8 75 2D 79 E8 5D 80 B7 E1 71 71 06 8A B7 C1 D2 B0 77 A1 69 6E F7 5E 42 73 9E 7E 04 9B E5 DE 24 A7 64 AF CB 54 A8 1A D4 59 66 91 E5 43 EB 16 1D F4 6A CA 06 FA 25 C5 7B 24 5F BB C8 D7 41 B7 A9 41 E0 00 A4 8E C6 09 CB 00 6A 42 B2 EE 8A 90 8B DC 0C 3F 96 07 87 FF 31 EE 0C AD 74 5A 86 AF E0 CE 0D F6 C1 50 D3 6B -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 10 bits, data = 'random+MAC' Message data: D3 09 MAC key = 128 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 Result: E6 7B B7 6E A8 00 50 1C BD AF 74 F1 E4 14 98 9B 35 33 3F 8A CF A2 41 F0 CA 2C 9A 82 4E D8 97 05 1A E8 A5 7F CE 19 98 30 78 10 61 0C 74 F1 2B 9D 1A B6 04 03 24 88 EA 02 D8 27 A1 02 75 CE FB 7D 7E DA 9E 63 AA 04 48 CE 95 36 89 F4 B7 0C D0 0D B3 94 CC 89 7B 28 B3 01 79 95 38 81 97 68 D4 C1 ED 9A 29 77 5B F5 BE FB 66 F9 C2 34 96 29 25 E0 0A EA 1A 16 4B AF 8C 9E D2 A5 C7 0F 49 DE 67 34 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 32 bits, data = 'random+MAC' Message data: D3 09 0C 72 MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: DF 05 96 E5 80 88 35 A3 E3 04 AA 27 92 3D B0 5F 61 DA C5 7C 06 96 A1 D1 9A BF 18 8E 70 AA 9D BC C6 59 E9 51 0F 7C 9A 37 FB C0 25 BD 4E 5E A2 93 E7 8E D7 83 8D D0 B0 88 64 E8 AD 40 DD B3 A8 80 31 EB EF C2 15 72 A8 99 60 D1 91 61 07 A7 DA 7A C0 C0 67 E3 4E C4 6A 86 A2 9C A6 3F A2 50 BD 39 8E B3 2E C1 ED 0F 8A C8 32 9F 26 DA 01 8B 02 9E 41 E2 E5 8D 1D FC 44 DE 81 61 5E 6C 98 7E D9 C9 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 64 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 MAC key = 257 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 44 Result: 3C FB B7 9C D8 8A F8 EE 09 C7 67 0B CB AB 69 07 A3 1F 80 FA 31 D9 D7 C9 D5 08 26 C9 56 8F 30 7A 78 BD 25 49 61 39 8C 76 B6 E3 38 FD 9C A5 F3 51 05 93 50 D3 09 63 C3 32 06 59 B2 23 B9 91 FC 46 D1 30 76 86 FE 2B 47 63 D9 F5 93 C5 7A D5 AD BC 45 CA F2 EA 3D C6 09 0F 5A 74 FA 5F A6 D9 E9 83 89 64 EA 0A 2A A2 16 83 1A B0 69 B0 06 29 A1 A9 B0 37 08 34 03 BD B2 5D 3D 06 A2 1C 43 0C 87 DD -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 128 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: F2 BB A8 38 00 C1 1A 59 1F 21 13 8B 2B 5A 3F E1 14 82 00 83 A7 92 CD 10 B9 73 51 65 93 E6 DF 4E 30 4B 75 FC C5 14 14 76 13 CA 19 83 40 61 22 15 14 7F D6 56 5C 73 C7 43 08 B4 3A F8 3C 0C FF A1 59 4F 81 6F BD AA C8 F5 9D 39 9F 28 73 D7 19 C2 FD 67 B0 07 54 4D B2 BB DB AB AF 7C 98 11 48 ED AB 95 EF 94 CC 9D 3C 6E 09 CD F2 30 D3 C3 C2 F6 6F 12 8D F2 E5 D1 B6 B2 6B 1A 58 FF 3B 1C BB 47 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 192 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 0A 1B 96 00 99 FC 9D 65 3B 0F D1 F5 B6 B9 72 FB 36 69 07 B7 72 CB CE 5A 59 B6 17 1D 79 35 50 6F 70 C2 12 BD 16 9D 68 C5 CF D8 61 83 43 61 1B 7E B2 E6 86 FF 1D C7 C0 3A 57 E1 A5 5E D1 07 26 84 81 61 EE A9 03 D5 3B 58 45 9B E4 2D 95 DF 98 9C 66 C2 EE A4 E5 1C DE 27 2C 2D 8B E6 7B F3 BC A2 AE E6 33 77 7E B8 48 67 81 EA A0 60 D0 F5 38 AB D6 C9 3D BD 2D 1B F6 6E 6F 50 BF DC AC 37 25 A4 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 255 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 MAC key = 128 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 Result: E1 4A 1A 89 EB 44 89 5C BA 34 64 79 94 31 FB 90 0C FC 32 2C 5F EB CB A1 66 47 37 C4 A2 C5 1D 99 97 B4 4C 7F 84 60 AA DD E2 AB 59 88 83 3A D7 F1 30 B3 04 D5 67 2C E5 D9 FC 60 F1 60 39 74 06 59 F5 11 61 4D DA CF 4C 2B 1E 68 8A 7F 4E 7A 8D 95 EB 1D 54 03 7B 36 13 1F A8 44 92 7B 74 04 AD 06 38 46 B3 EA CC A7 FA CA 24 35 FD 6B 96 CD 39 9D 45 F1 B0 43 42 70 85 60 0D 86 C5 B6 90 20 22 AA -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 256 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: 3E 0C D7 93 8D 71 C3 9F FB B0 8A 6B A7 99 5A DE 3A D1 40 E2 C0 C4 5C DB AF B0 99 24 7E 08 E4 C2 0B 61 C1 F8 85 CE D5 ED 2F 81 66 80 92 50 34 91 82 36 E5 80 7F 0E EC F3 F2 7E 9C FC A3 66 75 EB 75 87 3E FA 1F B4 1F 17 54 1D C2 F7 C2 46 9E AE CB 35 CC 7C A5 8E 48 98 04 CA F5 6F 09 FB 97 C9 F6 89 C6 4A D4 9C 68 88 F8 6C 48 3E 90 1B D3 D2 57 98 B3 94 EF 93 FA F9 15 49 00 F9 2F 31 F4 33 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 257 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA MAC key = 257 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 44 Result: 00 D4 4B 25 83 C9 4C E0 7C 38 C9 17 B6 94 AF 50 7A CB 81 9D B5 1E 08 72 97 17 A0 6F C4 45 E7 61 27 F8 4A 4A AE B8 7A F8 D5 17 45 3F 7B F8 44 26 76 3D C9 46 CD 19 78 78 3A 80 C9 63 41 B6 00 36 1D 1D 5E 9F EF 0D 31 0A 8B C3 56 6B 66 52 F4 9E BC 89 81 F7 89 05 CA 65 C7 76 DD 45 2F C1 14 5C 3C D1 2B B9 38 20 96 E4 B7 84 82 5B 5F C2 50 1E B9 0C CB A1 A6 92 E5 77 93 E1 04 3E 81 15 4C 60 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 384 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 MAC key = 0 bytes: (none) /* use InitExt() call */ Result: CD FC 5F A0 A8 44 1A D1 4E 0F 27 10 68 64 E7 FF 3A 24 2A AA A5 53 D0 0E 7B 46 5F B6 DB 4A 24 B3 CD 02 25 93 54 2F 48 26 C5 9B 65 A0 79 ED E3 8C A6 AC 99 AC B1 A2 40 C4 B5 FD 3C 06 03 77 42 36 95 24 29 31 2E 2E FA 77 75 75 4A 96 98 91 57 FE 57 84 BD A2 54 78 88 F9 76 B2 3C BE D7 7E 1E 27 BC D7 50 AA D4 45 44 8C D7 EA 69 EB 94 AA 90 77 45 12 33 5F 13 ED 73 AF D4 F5 9D 01 59 0B 1C E1 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 511 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 97 36 F6 95 CE DF 2B 0B C1 14 FA CE A3 30 20 97 93 24 2B 55 2B 74 D8 28 41 83 F8 17 5D 60 51 21 6B 0C 37 DD C8 B1 CE 7C C5 99 18 05 84 19 AD 1B 70 BF EA B9 E2 18 DC F5 28 89 1E 8C B7 DC 61 E7 B0 F2 47 42 14 26 08 EC 5A 70 0C AF 7D 62 EC 73 E4 47 06 A5 73 ED C2 14 DD E3 B7 49 7A 1F 67 E2 14 9A 79 B6 9C 1A A1 4F 06 39 E0 ED FF 1C 37 72 A2 74 91 CE D1 1E 0F 02 FF C9 A0 20 87 DC B1 C4 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 512 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF MAC key = 128 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 Result: 72 66 75 2F 7E 9A A0 4B D7 D8 A1 B1 60 30 67 7D E6 02 13 01 F6 A6 24 73 C7 6B AE 2B 98 BB F8 AA D7 3B D0 0A 4B 50 35 F7 41 CA F2 31 7A B8 0E 4E 97 F5 C5 BB E8 AC C0 E8 B4 24 BC B1 3C 7C 67 40 A9 85 80 1F BA 54 AD DD E8 D4 F1 3F 69 D2 BF C9 8A E1 04 D4 6A 21 11 45 21 7E 51 D5 10 EA 84 6C EC 95 81 D1 4F DA 07 9F 77 5C 8B 18 D6 6C B3 1B F7 06 09 96 EE 8A 69 EE E7 F1 07 90 9C E5 9A 97 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 513 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: 61 62 FD ED D4 E0 D4 52 09 66 9B 1A 8A B4 A4 51 DF 72 2A E7 B7 FF C1 46 C2 1B 95 A4 75 15 DE DC 96 0E CE 67 19 6D 9C CC 4E 0F BA 5A B7 E0 CC D4 02 FC 8F D1 8B B8 AD B5 2C 78 4C EF 88 EE FF E5 48 48 87 A5 01 FB C1 A0 6B 91 2B 0E BD 48 B7 BD 61 91 17 40 F2 C5 9B EA 71 80 93 F5 F0 C7 C8 8E C5 1D E8 3D F0 B8 7D 1F B5 84 42 A6 C1 9B F1 B7 2F 08 28 75 97 EC EE B6 2B A3 33 C9 DA EF 97 B8 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 768 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 MAC key = 257 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 44 Result: 71 F4 0B F2 AA 63 51 25 EF 83 C8 DF 0D 4E 9E A1 8B 73 B5 6B E4 F4 5E 89 B9 10 A7 C6 8D 39 6B 65 B0 9D 18 AB C7 D1 B6 DE 3F 53 FD 5D E5 83 E6 F2 2E 61 2D D1 7B 29 20 68 AF 60 27 DA AF 8B 4C D6 0A CF 5B C8 50 44 74 1E 9F 7A 1F 42 3F 58 27 F5 E3 60 93 0A 2E 71 91 22 39 AF 9F C6 34 36 04 FD CF 3F 35 69 85 4F 2B B8 D2 5A 81 E3 B3 F5 26 1A 02 FE 82 92 AA AA 50 C3 24 10 1A B2 C7 A2 F3 49 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1023 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 2E 38 C3 60 02 64 5B 43 3A CD A2 03 4B EB 02 BB 6E 10 BC 97 86 ED DD F3 96 A5 97 B6 64 FD EF EE D0 6F 9C 64 EC 1E 2E AB 71 60 C9 0F 74 E0 6B A8 00 10 00 81 A7 74 93 43 65 EC EA B0 AA CA A1 FA 7C 38 BF F8 27 40 E1 4A 61 22 74 E7 2A F9 DB 87 51 10 7B 73 5C B0 74 C7 3D 3E BF 2C 53 A5 4D AF 68 04 FF 30 F7 1C 97 FE 47 38 B6 2F 79 39 D7 83 8D 31 06 3A 6E B5 D8 C0 62 B0 2C 3E 82 3B C5 F3 -------------------------------- :Skein-1024: 160-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 17 C3 C5 33 B2 7D 66 6D A5 56 AE 58 6E 64 1B 7A 3A 0B CC 45 -------------------------------- :Skein-1024: 224-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 128 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 Result: 66 25 DF 98 01 58 10 09 12 5E A4 E5 C9 4A D6 F1 A2 D6 92 C2 78 82 2C CB 6E B6 72 35 -------------------------------- :Skein-1024: 256-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: 6C 5B 67 1C 17 66 F6 EE CE A6 D2 4B 64 1D 4A 6B F8 4B BA 13 A1 97 6F 8F 80 B3 F3 0E E2 F9 3D E6 -------------------------------- :Skein-1024: 384-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 257 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 44 Result: 98 AF 45 4D 7F A3 70 6D FA AF BF 58 C3 F9 94 48 68 B5 7F 68 F4 93 98 73 47 A6 9F CE 19 86 5F EB BA 04 07 A1 6B 4E 82 06 50 35 65 1F 0B 1E 03 27 -------------------------------- :Skein-1024: 512-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 0B 50 65 8B 7F 45 EC C7 CF 21 1D 5E 2D 16 A8 AE 57 64 B2 82 71 C1 36 C8 B0 3C 1C C3 08 AB AC E9 EE CA FF 85 84 CC E9 7A 9A B7 58 04 B1 25 0A 30 A7 6D 69 13 9B 47 A4 33 E9 FA EB E6 A4 B7 DD 10 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 21 1A C4 79 E9 96 11 41 DA 3A AC 19 D3 20 A1 DB BB FA D5 5D 2D CE 87 E6 A3 45 FC D5 8E 36 82 75 97 37 84 32 B4 82 D8 9B AD 44 DD DB 13 E6 AD 86 E0 EE 1E 08 82 B4 EB 0C D6 A1 81 E9 68 5E 18 DD 30 2E BB 3A A7 45 02 C0 62 54 DC AD FB 2B D4 5D 28 8F 82 36 6B 7A FC 3B C0 F6 B1 A3 C2 E8 F8 4D 37 FB ED D0 7A 3F 8F CF F8 4F AF 24 C5 3C 11 DA 60 0A AA 11 8E 76 CF DC B3 66 D0 B3 F7 72 9D CE -------------------------------- :Skein-1024: 264-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 128 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 Result: DC 1D 25 3B 7C AD BD AE F1 85 03 B1 80 9A 7F 1D 4F 8C 32 3B 7F 6F 8C A5 0B 76 D3 86 46 49 CE 1C 7D -------------------------------- :Skein-1024: 520-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: DE CD 79 57 8D 12 BF 68 06 53 0C 38 22 30 A2 C7 83 64 29 C7 0C AC 94 11 79 E1 DD 98 29 38 BA B9 1F B6 F3 63 8D F1 CC 1E F6 15 EC FC 42 49 E5 AC A8 A7 3C 4C 1E EB EF 66 2A 83 6D 0B E9 03 B0 01 46 -------------------------------- :Skein-1024: 1032-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 257 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 44 Result: 44 0F E6 91 E0 4F 1F ED 8C 25 3D 6C 46 70 64 61 56 F3 3F FF AE A7 02 DE 94 45 DF 57 39 EB 96 0C EC F8 5D 56 E2 E6 86 0A 61 02 11 A5 C9 09 93 2A B7 74 B9 78 AA 0B 0D 5B BC E8 27 75 17 2A B1 2D CE DD D5 1D 1E B0 30 05 7C E6 1B EA 6C 18 F6 BB 36 8D 26 AE 76 A9 E4 4A 96 2E B1 32 E6 C4 2C 25 D9 FE CC 4F 13 34 83 00 CA 55 C7 8E 09 90 DE 96 C1 AE 24 EB 3E E3 32 47 82 C9 3D D6 28 26 0A 2C 8D -------------------------------- :Skein-1024: 2056-bit hash, msgLen = 1024 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED MAC key = 0 bytes: (none) /* use InitExt() call */ Result: 17 30 BD 2F EB D5 90 95 C8 01 A4 37 60 58 DD 04 77 14 52 50 6F 3E BF 8F 22 CE 86 61 D2 BD 7E 16 17 CC 9C C8 81 33 C4 D8 CC 22 F4 C2 0F 09 B8 8E 64 30 48 E0 64 CE 19 3D 08 8C 4C D8 BE AD 28 92 0E 08 5B E8 5E DF E9 1D A7 54 F0 AB 4A 4A 35 AA D8 28 52 35 31 C5 96 C1 2C 2A 5A A8 23 57 35 71 3A CD 61 77 76 00 6E 0A 9E 8B EC 14 2F 49 FA 59 EE C7 53 BB 5F EA 3C 8D 9F D5 B1 B8 C1 D9 3F 7D 04 0D 24 17 D3 A3 77 8F 75 06 74 D4 38 E1 B5 0C 01 4C 96 85 61 86 1C 79 F4 2B BC 60 C2 3C 83 54 13 A5 9C E3 8A 2D 81 DE 03 8B 44 85 1D 5E 8C 37 47 BA E1 4C D3 D8 D4 AD 46 3C 79 69 41 FA 54 C6 D9 65 30 84 67 A5 AA 08 64 DA 95 9F D6 DC 17 F9 94 4E 35 9E 41 5B 72 F7 FA 31 E4 05 30 F1 65 02 24 1A A5 2B 1C 83 F5 41 7E C8 D9 B2 08 98 63 EA 3E EE D1 72 04 6B 32 8E EC 17 6F 1E 13 3F 13 4C A5 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 1025 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 MAC key = 64 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 Result: 4B 65 27 2F B7 49 FC 39 2D 33 D9 22 15 21 62 21 C0 0B 3A FF 19 58 09 A1 26 D3 4E AA 09 BD 94 D5 D5 9D 3C 39 7F FF 08 A2 BC 6B 72 94 68 AE 0A F7 69 4A AB 96 96 E0 9A 96 2C A5 D4 EE DE 14 64 7C 17 9A 26 BB 19 38 CA D3 7D 49 37 15 25 5D 87 24 5E 86 97 F2 D8 B0 6C 29 F9 7C 56 68 ED 51 9D D5 0F 9B 36 9C DA 14 B8 04 32 FE EA 63 CD B0 81 1F 29 B2 EA 2B 49 63 61 77 4E DE 43 04 18 5B B8 3D -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2047 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 MAC key = 128 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 Result: 99 6E 53 41 9B C4 D9 47 47 CE 63 07 13 53 F5 46 6A CB C4 14 81 F3 5C 69 8D EB DB 9B AF F4 19 88 13 0E 80 96 09 4A 44 05 06 99 84 A5 49 35 1E 61 D6 AF EC 4C CD 76 6D 77 6C 28 6B CA 14 ED 31 6A 94 9E 73 6C 91 07 89 40 1C 1F 84 0E 21 31 28 1D C5 12 CF DB 7A 6A 8A AD 02 87 57 80 EA 30 6D DD 14 1F E8 5A 4F BC BF B0 CE C6 00 6D E4 C8 3F E7 A5 61 37 6F 4A 2F 16 0F F9 A6 CA 37 06 B7 F4 84 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2048 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 MAC key = 129 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C Result: 46 A4 2B 0D 7B 86 79 F8 FC EA 15 6C 07 2C F9 83 3C 46 8A 7D 59 AC 5E 5D 32 69 57 D6 0D FE 1C DF B2 7E B5 4C 76 0B 9E 04 9F DA 47 F0 B8 47 AC 68 D6 B3 40 C0 2C 39 D4 A1 8C 1B DF EC E3 F4 05 FA E8 AA 84 8B DB EF E3 A4 C2 77 A0 95 E9 21 22 86 18 D3 BE 8B D1 99 9A 07 16 82 81 0D E7 48 44 0A D4 16 A9 77 42 CC 9E 8A 9B 85 45 5B 1D 76 47 2C F5 62 F5 25 11 66 98 D5 CD 0A 35 DD F8 6E 7F 8A -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2049 bits, data = 'random+MAC' Message data: D3 09 0C 72 16 75 17 F7 C7 AD 82 A7 0C 2F D3 F6 44 3F 60 83 01 59 1E 59 8E AD B1 95 E8 35 71 35 BA 26 FE DE 2E E1 87 41 7F 81 60 48 D0 0F C2 35 12 73 7A 21 13 70 9A 77 E4 17 0C 49 A9 4B 7F DF F4 5F F5 79 A7 22 87 74 31 02 E7 76 6C 35 CA 5A BC 5D FE 2F 63 A1 E7 26 CE 5F BD 29 26 DB 03 A2 DD 18 B0 3F C1 50 8A 9A AC 45 EB 36 24 40 20 3A 32 3E 09 ED EE 63 24 EE 2E 37 B4 43 2C 18 67 ED 69 6E 6C 9D B1 E6 AB EA 02 62 88 95 4A 9C 2D 57 58 D7 C5 DB 7C 9E 48 AA 3D 21 CA E3 D9 77 A7 C3 92 60 66 AA 39 3D BD 53 8D D0 C3 0D A8 91 6C 87 57 F2 4C 18 48 80 14 66 8A 26 27 16 3A 37 B2 61 83 3D C2 F8 C3 C5 6B 1B 2E 0B E2 1F D3 FB DB 50 7B 29 50 B7 7A 6C C0 2E FB 39 3E 57 41 93 83 A9 20 76 7B CA 2C 97 21 07 AA 61 38 45 42 D4 7C BF B8 2C FE 5C 41 53 89 D1 B0 A2 D7 4E 2C 5D A8 51 FD MAC key = 257 bytes: CB 41 F1 70 6C DE 09 65 12 03 C2 D0 EF BA DD F8 47 A0 D3 15 CB 2E 53 FF 8B AC 41 DA 00 02 67 2E 92 02 44 C6 6E 02 D5 F0 DA D3 E9 4C 42 BB 65 F0 D1 41 57 DE CF 41 05 EF 56 09 D5 B0 98 44 57 C1 93 5D F3 06 1F F0 6E 9F 20 41 92 BA 11 E5 BB 2C AC 04 30 C1 C3 70 CB 3D 11 3F EA 5E C1 02 1E B8 75 E5 94 6D 7A 96 AC 69 A1 62 6C 62 06 B7 25 27 36 F2 42 53 C9 EE 9B 85 EB 85 2D FC 81 46 31 34 6C 04 2E B4 18 7A A1 C0 15 A4 76 70 32 C0 BB 28 F0 76 B6 64 85 F5 15 31 C1 2E 94 8F 47 DB C2 CB 90 4A 4B 75 D1 E8 A6 D9 31 DA B4 A0 7E 0A 54 D1 BB 5B 55 E6 02 14 17 46 BD 09 FB 15 E8 F0 1A 8D 74 E9 E6 39 59 CB 37 33 6B C1 B8 96 EC 78 DA 73 4C 15 E3 62 DB 04 36 8F BB A2 80 F2 0A 04 3E 0D 09 41 E9 F5 19 3E 1B 36 0A 33 C4 3B 26 65 24 88 01 25 22 2E 64 8F 05 F2 8B E3 4B A3 CA BF C9 C5 44 Result: ED 9D C9 D7 0C 14 9D 79 64 4D B4 53 D8 AA A5 B0 22 9B 4E F9 3D A3 7F 26 8C 14 35 0D 6C 2A 42 F5 EA DC FC 10 A9 47 BE C9 7A C5 05 76 0C DA 75 0A 7E EC D9 C9 00 24 73 B9 8F B1 CE F7 0E 4D 68 24 FA 8F CF A3 20 6D 30 EE B4 2A 29 D4 63 89 FE B5 89 E8 E0 51 A5 6F AE 2E 74 1D F0 8C 17 A4 12 C2 97 5C DB BF 8A 4D 7B BE 39 2A 38 22 57 8E 56 D0 27 69 CF 73 F4 14 54 99 74 77 C9 50 C9 12 73 15 -------------------------------- :Skein-256: 224-bit hash, msgLen = 1016 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E Result: 71 0E 06 18 B0 98 14 5A D8 1F 53 F3 74 8D C1 73 92 1E B4 5F 35 88 01 D5 94 DA 25 41 -------------------------------- :Skein-256: 256-bit hash, msgLen = 1008 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 Result: E3 CF 8F CD D2 0B FE 85 D1 75 44 80 07 22 6C 20 FF 22 A6 5D C9 DF 75 88 BE 30 5E 5C CC 3F 49 41 -------------------------------- :Skein-256: 256-bit hash, msgLen = 2024 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC Result: EB 24 AA 89 19 CD CF 94 5E F1 FD F0 CC 11 57 95 A3 E2 9E 43 56 D8 A7 87 0E 7A 0B 33 83 84 F7 F1 -------------------------------- :Skein-256: 256-bit hash, msgLen = 4064 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC 01 FE 01 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 Result: ED E8 0A BC 9D E7 50 7B 8A 13 4F 0F 56 09 5A 72 97 26 19 3B E5 55 F8 AD 1D 35 8C 56 B0 C8 F1 1B -------------------------------- :Skein-256: 256-bit hash, msgLen = 472 bits. Tree: leaf=01, node=02, maxLevels=03 Message data: 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A Result: BD 94 AA E8 02 32 88 0C 35 AE 38 EE 9A C7 E4 D7 2E E7 16 E7 0F 47 2A 7C 4D 59 11 32 BF 00 A4 CA -------------------------------- :Skein-256: 256-bit hash, msgLen = 976 bits. Tree: leaf=01, node=02, maxLevels=03 Message data: 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 Result: 56 A4 A6 8C CA 8E 35 80 1F 1F C8 FB 89 6A CA 3C C6 C1 2E 9D 00 E5 91 29 23 1D FC 01 55 90 6C BC -------------------------------- :Skein-256: 256-bit hash, msgLen = 1992 bits. Tree: leaf=01, node=02, maxLevels=03 Message data: 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 F0 01 F2 01 F4 01 F6 01 F8 Result: F6 39 74 FD 34 C0 C4 5E B6 DE DF E3 19 CB 7B 36 3F CE E0 17 0A 79 49 78 27 28 9F 1F F7 28 4D 06 -------------------------------- :Skein-256: 256-bit hash, msgLen = 960 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 Result: 54 39 36 F0 6E CF 9A 8F DD 08 C7 B9 FE D7 76 DF F0 FE 3D 88 FB 28 DC 8C B0 91 EA 50 DD 1A E1 B1 -------------------------------- :Skein-256: 256-bit hash, msgLen = 1976 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 F0 01 F2 01 F4 01 F6 Result: 89 8B CB B8 D2 19 1B 82 71 55 CC EA 3A 60 DF D0 C5 17 73 BC 2C 30 69 E5 62 44 40 3D 71 FA 80 7A -------------------------------- :Skein-256: 256-bit hash, msgLen = 2992 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC 01 FE 01 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 70 00 72 00 74 00 Result: AF EE B1 E4 61 40 2E DD 3C 54 EB 58 21 66 22 3A 5E D5 43 3A B2 39 D5 0A 57 15 AF 46 65 51 15 E2 -------------------------------- :Skein-256: 256-bit hash, msgLen = 4008 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC 01 FE 01 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 F0 00 F2 00 F4 Result: 25 3C 30 D6 3B F7 07 F1 77 F1 BA 8F B8 B1 4D 7F 59 CD 3A 9B 37 69 95 C3 EA A0 4B E6 74 92 C6 A3 -------------------------------- :Skein-512: 256-bit hash, msgLen = 2040 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE Result: 59 F1 C8 19 1D 26 B9 D9 F1 0B 87 F1 73 71 65 BC B4 E5 1D 40 13 D8 42 46 82 11 AB 2C E5 21 CB 64 -------------------------------- :Skein-512: 384-bit hash, msgLen = 2032 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 Result: D9 D8 E3 B0 64 6F D7 20 21 A8 51 F9 E9 C8 F8 3C A0 E3 76 E0 FC A7 67 09 F4 99 DB C5 38 30 DA 3B 48 7B 8D 1D 88 5E A2 5A 00 FF CA B7 5C 7A 52 5B -------------------------------- :Skein-512: 512-bit hash, msgLen = 2024 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC Result: BF CE 83 FB 97 24 E4 6E 51 DF 06 F7 1D 91 2C 64 E4 57 A9 41 BA 24 41 8C E8 3B 2C 51 61 FC 12 81 B1 11 46 32 E7 AB DC A5 60 30 E6 10 A0 DC 33 E0 04 2C E8 19 44 2C 2B C5 3B 09 7F 96 59 39 0B 37 -------------------------------- :Skein-512: 512-bit hash, msgLen = 4064 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 F0 03 F2 03 F4 03 F6 03 F8 03 FA 03 Result: 8A C1 82 11 ED 12 23 4D F0 02 08 8E E7 B1 4C C1 53 C0 8B 5B 1D 2F A4 B6 8D 11 42 57 12 EA 77 7B C8 86 1D C8 9B A4 EF 65 69 9E C9 F1 F1 98 0F 12 1B EF 87 8B 44 EF 37 3B 68 C3 B6 A7 40 60 1B A0 -------------------------------- :Skein-512: 512-bit hash, msgLen = 8152 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 F0 03 F2 03 F4 03 F6 03 F8 03 FA 03 FC 03 FE 03 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 FC 00 FE 00 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 F0 01 F2 01 F4 01 F6 01 F8 01 FA Result: AF B4 CC 53 DD 8E CE DC C5 B0 6C CD 1B C0 8B F5 9D 06 39 2E 71 0C E9 51 3B E0 0F 04 26 CF CE 29 F6 E1 C1 99 3D BD A8 EF 7C 6F C3 FF FD AB A4 11 4B DF 21 76 6B 27 7D 9E 91 28 E9 AE F5 C5 27 AF -------------------------------- :Skein-512: 512-bit hash, msgLen = 976 bits. Tree: leaf=01, node=02, maxLevels=03 Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 Result: F6 D3 3F 5C 70 A3 FA ED CC 43 61 A0 D9 32 CD 53 B0 58 EA CB 1A 2F 77 24 A3 59 97 7D 86 48 23 8A 39 13 A5 0F 5C 5F A4 84 B7 D2 90 F1 66 D8 AA EA 9F D0 F9 AF 28 B9 49 E2 3E B5 1F C8 88 F3 F6 B3 -------------------------------- :Skein-512: 512-bit hash, msgLen = 1992 bits. Tree: leaf=01, node=02, maxLevels=03 Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 Result: A7 EE 79 EF 5A B7 1A 74 D7 0A 70 DD 6E 13 2C 8E 0F F3 91 68 6A D6 94 A3 9A 46 64 6F D3 33 39 34 9E E6 E1 2F AA 4C 00 B5 D0 47 A5 1F 3E 15 1F 03 8F A3 71 C3 8D FA D4 55 60 AF 8B 8B C6 BC DB 6B -------------------------------- :Skein-512: 512-bit hash, msgLen = 4032 bits. Tree: leaf=01, node=02, maxLevels=03 Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 F0 03 F2 03 F4 03 F6 03 Result: C8 5C BA 31 23 18 0E 31 13 B0 41 31 44 15 9E A0 22 DA 15 B6 2E DC E1 3E 56 B6 52 6B 5F 99 6F F2 FB 77 79 46 F0 92 44 BB 78 F1 CC F8 C8 E8 E5 9A D0 94 29 70 9E CD 6D E9 5D C6 10 8B 69 32 BD E0 -------------------------------- :Skein-512: 512-bit hash, msgLen = 1976 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 Result: 10 1D E1 CD 8B F5 82 E1 9B B6 3D DC 4F 11 0F 1C 75 A3 04 A6 AC 8D 45 14 FB B1 35 E4 4B DB 8D 02 77 0D E8 1B 2F BA BD B2 5E 81 E9 EE 70 69 0A 1C 6F E9 E2 12 2D 0B E3 BA 0A 3A E2 15 D8 02 5A BE -------------------------------- :Skein-512: 512-bit hash, msgLen = 4016 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 F0 03 F2 03 F4 03 Result: 68 F0 42 77 19 E9 BC 05 9D 77 37 35 06 3F 97 90 26 8F 60 9B FD FC 63 AB F2 38 66 AC AD E9 66 13 91 F2 04 94 B8 02 83 3E 6B 0E 7D 7F 49 E3 B5 5E F6 CD 37 69 49 80 CD 2A B7 BE 32 B3 54 95 95 76 -------------------------------- :Skein-512: 512-bit hash, msgLen = 6056 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 F0 03 F2 03 F4 03 F6 03 F8 03 FA 03 FC 03 FE 03 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 F0 00 F2 00 F4 Result: B5 57 D2 FF 7D 69 2A 33 71 1D AE 17 14 BA D7 1E 81 BD DC 98 60 6F 37 CE B2 60 94 AD F9 6F 58 EA ED 97 82 D1 DD 47 73 D3 94 69 08 77 43 AC 3E 2E 2F 36 FE 10 EF 0D 6B 37 01 01 3C 9A 7A 05 5C 43 -------------------------------- :Skein-512: 512-bit hash, msgLen = 8096 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 F0 03 F2 03 F4 03 F6 03 F8 03 FA 03 FC 03 FE 03 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 FC 00 FE 00 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 F0 01 F2 01 Result: F3 13 3D F7 97 5B FC 36 01 99 BB 4A 54 3D EE 0E 76 1E B2 FB CC 7C 22 30 60 86 9C F6 30 0A 6E E7 C6 BC 08 6A BB 72 A7 1D 73 07 F7 99 CC E3 71 C8 8C DC A7 16 75 BD 25 F7 72 FA 4B 97 5C C2 35 DA -------------------------------- :Skein-1024: 384-bit hash, msgLen = 4088 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE Result: FE 98 94 9D 9C 9A 25 3C 96 C5 14 F5 78 8B 57 EF 47 3C C6 A5 AB B3 BA 1E 8B 32 F7 BF E2 AE 5A 6F 06 D7 00 47 ED 50 3B DD D3 E8 01 01 14 2D 8D CB -------------------------------- :Skein-1024: 512-bit hash, msgLen = 4080 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 Result: 90 40 5C 17 3A DC AD 13 91 D6 BF C1 01 84 47 8A FA 10 F5 10 68 DE A1 92 3B 66 F2 BC B9 20 2A 12 95 41 52 02 F5 C7 A0 4E 3B 1E 47 46 80 D3 88 88 6F C0 CF 6E 41 CB CC 98 CB 42 99 17 54 A6 13 10 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 4072 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC Result: 03 86 89 6D 34 0D 32 80 F6 02 A6 BA 97 0B B8 5E 1F D3 E5 C4 AA FC 60 EF 1D E6 36 39 E5 EB F7 9F 52 A3 3D EB 80 35 5E F6 2F 9B 6B 6F D7 6E DC 6D FD CE 57 61 C6 3E DA 0C 23 09 2A AC BB 22 96 69 8D C9 AD F8 8C 2D 99 DD EF D5 F8 5F 39 CF C6 2D 66 6D 1B 5A EA 56 0D C9 96 6B 4F 6C F2 86 D8 C3 B3 DD A2 6E B9 C8 E3 93 D1 A6 21 DD 22 D7 FE 5F 9D 52 71 F3 5B E3 71 5E 39 98 11 5D 14 0A 7B 78 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 8160 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 F0 07 F2 07 F4 07 F6 07 F8 07 FA 07 Result: 5D 7D 02 26 CA F1 AF 8A 22 2D A3 1E 3C 0A BF 59 5E 39 B7 89 59 80 E8 A1 F7 41 91 37 0E 9D DD 7A 3F 73 C7 52 EB 2F 75 30 1E E7 00 C9 E2 F6 14 3A 9C DE 3A 1E 46 DB 0E 19 86 DF 9F D7 82 0E 85 00 E8 DA C1 0A 42 BF 51 E8 6B E4 AD 5F BF 4F 39 4A 59 3B 36 46 FE 49 3A 90 0A D2 D2 19 8C 34 70 66 E9 C5 FB 38 E1 00 A0 CF A8 71 2B 53 2A A2 02 7C F8 EB 6A 3A 95 BA 77 F8 01 1A BA CD CE 22 0D B0 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 16344 bits. Tree: leaf=02, node=02, maxLevels=02 Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 F0 07 F2 07 F4 07 F6 07 F8 07 FA 07 FC 07 FE 07 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 FC 00 FE 00 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC 01 FE 01 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 F0 03 F2 03 F4 03 F6 03 F8 03 FA Result: 8C D8 DF AC C7 3F DD 71 48 9A 73 23 64 79 22 BE 0D CC A0 0C BF 0A 7B 27 A3 6B D4 B8 8A ED EB FE 6C B8 57 4A 71 08 1F BE 44 AD EA F5 46 F2 02 7A 95 5F DA 4E ED B3 B9 05 A4 BE FF C9 3B 33 E6 86 E9 C6 2B 6E BF 1F 03 70 B2 7E 8D 50 20 C9 6C 6D 2F 8E 19 17 B2 81 08 13 02 C6 8C 7C 27 25 EF 45 B4 29 B3 74 E8 BB 8C 6D 3A A9 18 57 5D 6F 7F 45 BE DB 40 6C 9A 2A 9E D3 67 C9 9C 27 08 2B D4 AA -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 2000 bits. Tree: leaf=01, node=02, maxLevels=03 Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 Result: 2A 91 95 D1 8D FF 14 32 71 1D C2 54 5D 9F 0F 14 44 0A 7E 99 51 14 4F E3 46 77 4A 8A 8E 1F 81 5A B7 61 1C 0F B7 A6 F4 5E 51 A4 8C 3B 4A 57 79 F7 47 00 F6 0B 52 9C E1 64 CC 65 48 52 77 55 46 69 52 06 46 2F 64 4A 7F 1D A0 56 B6 33 8E 40 25 C1 25 EC 31 C4 2F 45 57 85 71 5A 50 02 49 58 E4 A6 12 82 46 8C 0A 81 14 C7 A2 5F 3E 79 22 BC 20 66 CB AD 31 20 A8 16 8F 92 78 68 09 22 E3 A0 4B 04 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 4040 bits. Tree: leaf=01, node=02, maxLevels=03 Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 F0 05 F2 05 F4 05 F6 05 F8 Result: 07 7C 01 2C 76 B1 35 0F 9F 2F 7C A9 18 E8 22 6A 2F DA 9E 6B CC A3 D6 B7 28 9E 5F CD CF 1F 50 F2 42 A3 2E 49 74 B8 C2 94 49 5D 7C 34 5F BE 92 66 6D B7 36 BB 26 C7 DA B6 54 B5 4B 34 E6 7C FE F1 1F 41 5A C2 90 5E 6D 8F 9A EF 64 60 10 11 2E 29 69 EF BA 15 5A 2F 14 F8 E7 A6 61 5B 36 EB C0 9B 21 A1 F5 3B CA FE 5D 79 F7 2C 8B BF A2 51 D3 B8 DB 93 52 11 4B 06 14 A2 5B A9 60 AF 60 5C C3 FD -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 8128 bits. Tree: leaf=01, node=02, maxLevels=03 Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 F0 07 F2 07 F4 07 F6 07 Result: 24 DC 2C 01 35 C7 2A 16 34 F8 8F D1 C3 D6 26 1C 4D 17 23 61 9C 0A 92 42 AE C3 7E CB F6 1C 14 89 79 17 0F 3B 41 5C EC D0 C9 2C 76 5D 79 9D BE A6 CA 5E 81 D5 7A BA 13 31 76 97 FA ED 11 ED 9A 85 6A 3E 8F 35 1C BD D8 F7 46 B4 3F 61 0A 31 E5 DD 09 C8 19 0D 78 AD 2E BB 95 23 30 F7 99 2C A6 8A 68 35 2F 90 60 68 A3 A9 B1 F0 19 BA 50 DF 84 87 70 84 6E 18 BD 10 D1 9C CE F9 FB FA 22 F5 52 30 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 4024 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 F0 05 F2 05 F4 05 F6 Result: 4E 60 48 0D DF 1C 03 9D 2C B4 FA 9F 69 4E 5D D7 38 D0 EF 3C 70 1A 59 25 E7 A5 AE 10 FD 93 3D E9 21 0A 9D 70 1F D2 7D D2 E9 E2 28 F7 9C A3 35 96 84 6E CD A3 EB 4F 66 DE 6C 60 D7 35 77 B7 9B 8A AA 08 08 5B 2B 1E 89 1B 33 96 FB 3C A7 B8 FB E5 1B E6 8F 3E B9 7D 2F 77 50 39 24 E3 CB 38 F6 EF 1D AE 68 38 D9 1E 03 4E DE E2 2B 03 3A 11 94 D1 30 D3 E0 16 12 46 9C CE 4B 87 9E 23 29 3F 1C 5D -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 8112 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 F0 07 F2 07 F4 07 Result: 26 15 10 9A CA 5E FC 58 5F EB BD 52 A4 17 A6 69 1D 44 84 78 F2 1D 38 2F 6D 49 8D 9B A4 79 E0 9C 64 AF 6C 4B 03 1C 1D FF 14 07 2F 43 0D CC 0A D8 CE 0B 3A B7 2E F2 99 63 FE 53 1A 8A 00 A8 1F 3C 69 22 23 3C 3E 64 A7 ED 37 15 07 1B E9 C4 50 E4 5A BD B5 B5 05 E4 C0 C1 63 88 3C 77 75 52 83 75 3F 99 F6 D6 A0 AA 77 52 B2 42 FD EB 60 2A 43 DC 82 7F 6E 01 48 BD E9 A9 EA D4 81 23 6E 2E EF 91 -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 12200 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 F0 07 F2 07 F4 07 F6 07 F8 07 FA 07 FC 07 FE 07 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 FC 00 FE 00 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 F0 01 F2 01 F4 Result: FF EA B5 84 33 AF 16 43 0B A3 21 38 DD D1 02 44 1C 66 8B 64 4F C3 AC 43 24 C4 09 CE 5A 59 AB 35 65 12 07 A1 04 AB 43 D2 4A 6B 0D 8D 31 02 03 21 5B 71 EC 4B A4 BB 41 D1 96 04 CF 63 A7 DA DD AC B3 73 05 1B 1F C4 BD 8A 73 40 63 0A B9 D0 1D 86 0E 8E A2 49 B7 06 B3 E6 F3 15 63 2A 2D A7 91 C9 60 7E F1 95 C2 01 9C AD 99 9B 2F E7 2D 58 D0 03 11 40 07 A9 85 82 FA D6 E2 EF E6 2E 80 BE 51 5F -------------------------------- :Skein-1024: 1024-bit hash, msgLen = 16288 bits. Tree: leaf=02, node=01, maxLevels=FF Message data: 00 04 02 04 04 04 06 04 08 04 0A 04 0C 04 0E 04 10 04 12 04 14 04 16 04 18 04 1A 04 1C 04 1E 04 20 04 22 04 24 04 26 04 28 04 2A 04 2C 04 2E 04 30 04 32 04 34 04 36 04 38 04 3A 04 3C 04 3E 04 40 04 42 04 44 04 46 04 48 04 4A 04 4C 04 4E 04 50 04 52 04 54 04 56 04 58 04 5A 04 5C 04 5E 04 60 04 62 04 64 04 66 04 68 04 6A 04 6C 04 6E 04 70 04 72 04 74 04 76 04 78 04 7A 04 7C 04 7E 04 80 04 82 04 84 04 86 04 88 04 8A 04 8C 04 8E 04 90 04 92 04 94 04 96 04 98 04 9A 04 9C 04 9E 04 A0 04 A2 04 A4 04 A6 04 A8 04 AA 04 AC 04 AE 04 B0 04 B2 04 B4 04 B6 04 B8 04 BA 04 BC 04 BE 04 C0 04 C2 04 C4 04 C6 04 C8 04 CA 04 CC 04 CE 04 D0 04 D2 04 D4 04 D6 04 D8 04 DA 04 DC 04 DE 04 E0 04 E2 04 E4 04 E6 04 E8 04 EA 04 EC 04 EE 04 F0 04 F2 04 F4 04 F6 04 F8 04 FA 04 FC 04 FE 04 00 05 02 05 04 05 06 05 08 05 0A 05 0C 05 0E 05 10 05 12 05 14 05 16 05 18 05 1A 05 1C 05 1E 05 20 05 22 05 24 05 26 05 28 05 2A 05 2C 05 2E 05 30 05 32 05 34 05 36 05 38 05 3A 05 3C 05 3E 05 40 05 42 05 44 05 46 05 48 05 4A 05 4C 05 4E 05 50 05 52 05 54 05 56 05 58 05 5A 05 5C 05 5E 05 60 05 62 05 64 05 66 05 68 05 6A 05 6C 05 6E 05 70 05 72 05 74 05 76 05 78 05 7A 05 7C 05 7E 05 80 05 82 05 84 05 86 05 88 05 8A 05 8C 05 8E 05 90 05 92 05 94 05 96 05 98 05 9A 05 9C 05 9E 05 A0 05 A2 05 A4 05 A6 05 A8 05 AA 05 AC 05 AE 05 B0 05 B2 05 B4 05 B6 05 B8 05 BA 05 BC 05 BE 05 C0 05 C2 05 C4 05 C6 05 C8 05 CA 05 CC 05 CE 05 D0 05 D2 05 D4 05 D6 05 D8 05 DA 05 DC 05 DE 05 E0 05 E2 05 E4 05 E6 05 E8 05 EA 05 EC 05 EE 05 F0 05 F2 05 F4 05 F6 05 F8 05 FA 05 FC 05 FE 05 00 06 02 06 04 06 06 06 08 06 0A 06 0C 06 0E 06 10 06 12 06 14 06 16 06 18 06 1A 06 1C 06 1E 06 20 06 22 06 24 06 26 06 28 06 2A 06 2C 06 2E 06 30 06 32 06 34 06 36 06 38 06 3A 06 3C 06 3E 06 40 06 42 06 44 06 46 06 48 06 4A 06 4C 06 4E 06 50 06 52 06 54 06 56 06 58 06 5A 06 5C 06 5E 06 60 06 62 06 64 06 66 06 68 06 6A 06 6C 06 6E 06 70 06 72 06 74 06 76 06 78 06 7A 06 7C 06 7E 06 80 06 82 06 84 06 86 06 88 06 8A 06 8C 06 8E 06 90 06 92 06 94 06 96 06 98 06 9A 06 9C 06 9E 06 A0 06 A2 06 A4 06 A6 06 A8 06 AA 06 AC 06 AE 06 B0 06 B2 06 B4 06 B6 06 B8 06 BA 06 BC 06 BE 06 C0 06 C2 06 C4 06 C6 06 C8 06 CA 06 CC 06 CE 06 D0 06 D2 06 D4 06 D6 06 D8 06 DA 06 DC 06 DE 06 E0 06 E2 06 E4 06 E6 06 E8 06 EA 06 EC 06 EE 06 F0 06 F2 06 F4 06 F6 06 F8 06 FA 06 FC 06 FE 06 00 07 02 07 04 07 06 07 08 07 0A 07 0C 07 0E 07 10 07 12 07 14 07 16 07 18 07 1A 07 1C 07 1E 07 20 07 22 07 24 07 26 07 28 07 2A 07 2C 07 2E 07 30 07 32 07 34 07 36 07 38 07 3A 07 3C 07 3E 07 40 07 42 07 44 07 46 07 48 07 4A 07 4C 07 4E 07 50 07 52 07 54 07 56 07 58 07 5A 07 5C 07 5E 07 60 07 62 07 64 07 66 07 68 07 6A 07 6C 07 6E 07 70 07 72 07 74 07 76 07 78 07 7A 07 7C 07 7E 07 80 07 82 07 84 07 86 07 88 07 8A 07 8C 07 8E 07 90 07 92 07 94 07 96 07 98 07 9A 07 9C 07 9E 07 A0 07 A2 07 A4 07 A6 07 A8 07 AA 07 AC 07 AE 07 B0 07 B2 07 B4 07 B6 07 B8 07 BA 07 BC 07 BE 07 C0 07 C2 07 C4 07 C6 07 C8 07 CA 07 CC 07 CE 07 D0 07 D2 07 D4 07 D6 07 D8 07 DA 07 DC 07 DE 07 E0 07 E2 07 E4 07 E6 07 E8 07 EA 07 EC 07 EE 07 F0 07 F2 07 F4 07 F6 07 F8 07 FA 07 FC 07 FE 07 00 00 02 00 04 00 06 00 08 00 0A 00 0C 00 0E 00 10 00 12 00 14 00 16 00 18 00 1A 00 1C 00 1E 00 20 00 22 00 24 00 26 00 28 00 2A 00 2C 00 2E 00 30 00 32 00 34 00 36 00 38 00 3A 00 3C 00 3E 00 40 00 42 00 44 00 46 00 48 00 4A 00 4C 00 4E 00 50 00 52 00 54 00 56 00 58 00 5A 00 5C 00 5E 00 60 00 62 00 64 00 66 00 68 00 6A 00 6C 00 6E 00 70 00 72 00 74 00 76 00 78 00 7A 00 7C 00 7E 00 80 00 82 00 84 00 86 00 88 00 8A 00 8C 00 8E 00 90 00 92 00 94 00 96 00 98 00 9A 00 9C 00 9E 00 A0 00 A2 00 A4 00 A6 00 A8 00 AA 00 AC 00 AE 00 B0 00 B2 00 B4 00 B6 00 B8 00 BA 00 BC 00 BE 00 C0 00 C2 00 C4 00 C6 00 C8 00 CA 00 CC 00 CE 00 D0 00 D2 00 D4 00 D6 00 D8 00 DA 00 DC 00 DE 00 E0 00 E2 00 E4 00 E6 00 E8 00 EA 00 EC 00 EE 00 F0 00 F2 00 F4 00 F6 00 F8 00 FA 00 FC 00 FE 00 00 01 02 01 04 01 06 01 08 01 0A 01 0C 01 0E 01 10 01 12 01 14 01 16 01 18 01 1A 01 1C 01 1E 01 20 01 22 01 24 01 26 01 28 01 2A 01 2C 01 2E 01 30 01 32 01 34 01 36 01 38 01 3A 01 3C 01 3E 01 40 01 42 01 44 01 46 01 48 01 4A 01 4C 01 4E 01 50 01 52 01 54 01 56 01 58 01 5A 01 5C 01 5E 01 60 01 62 01 64 01 66 01 68 01 6A 01 6C 01 6E 01 70 01 72 01 74 01 76 01 78 01 7A 01 7C 01 7E 01 80 01 82 01 84 01 86 01 88 01 8A 01 8C 01 8E 01 90 01 92 01 94 01 96 01 98 01 9A 01 9C 01 9E 01 A0 01 A2 01 A4 01 A6 01 A8 01 AA 01 AC 01 AE 01 B0 01 B2 01 B4 01 B6 01 B8 01 BA 01 BC 01 BE 01 C0 01 C2 01 C4 01 C6 01 C8 01 CA 01 CC 01 CE 01 D0 01 D2 01 D4 01 D6 01 D8 01 DA 01 DC 01 DE 01 E0 01 E2 01 E4 01 E6 01 E8 01 EA 01 EC 01 EE 01 F0 01 F2 01 F4 01 F6 01 F8 01 FA 01 FC 01 FE 01 00 02 02 02 04 02 06 02 08 02 0A 02 0C 02 0E 02 10 02 12 02 14 02 16 02 18 02 1A 02 1C 02 1E 02 20 02 22 02 24 02 26 02 28 02 2A 02 2C 02 2E 02 30 02 32 02 34 02 36 02 38 02 3A 02 3C 02 3E 02 40 02 42 02 44 02 46 02 48 02 4A 02 4C 02 4E 02 50 02 52 02 54 02 56 02 58 02 5A 02 5C 02 5E 02 60 02 62 02 64 02 66 02 68 02 6A 02 6C 02 6E 02 70 02 72 02 74 02 76 02 78 02 7A 02 7C 02 7E 02 80 02 82 02 84 02 86 02 88 02 8A 02 8C 02 8E 02 90 02 92 02 94 02 96 02 98 02 9A 02 9C 02 9E 02 A0 02 A2 02 A4 02 A6 02 A8 02 AA 02 AC 02 AE 02 B0 02 B2 02 B4 02 B6 02 B8 02 BA 02 BC 02 BE 02 C0 02 C2 02 C4 02 C6 02 C8 02 CA 02 CC 02 CE 02 D0 02 D2 02 D4 02 D6 02 D8 02 DA 02 DC 02 DE 02 E0 02 E2 02 E4 02 E6 02 E8 02 EA 02 EC 02 EE 02 F0 02 F2 02 F4 02 F6 02 F8 02 FA 02 FC 02 FE 02 00 03 02 03 04 03 06 03 08 03 0A 03 0C 03 0E 03 10 03 12 03 14 03 16 03 18 03 1A 03 1C 03 1E 03 20 03 22 03 24 03 26 03 28 03 2A 03 2C 03 2E 03 30 03 32 03 34 03 36 03 38 03 3A 03 3C 03 3E 03 40 03 42 03 44 03 46 03 48 03 4A 03 4C 03 4E 03 50 03 52 03 54 03 56 03 58 03 5A 03 5C 03 5E 03 60 03 62 03 64 03 66 03 68 03 6A 03 6C 03 6E 03 70 03 72 03 74 03 76 03 78 03 7A 03 7C 03 7E 03 80 03 82 03 84 03 86 03 88 03 8A 03 8C 03 8E 03 90 03 92 03 94 03 96 03 98 03 9A 03 9C 03 9E 03 A0 03 A2 03 A4 03 A6 03 A8 03 AA 03 AC 03 AE 03 B0 03 B2 03 B4 03 B6 03 B8 03 BA 03 BC 03 BE 03 C0 03 C2 03 C4 03 C6 03 C8 03 CA 03 CC 03 CE 03 D0 03 D2 03 D4 03 D6 03 D8 03 DA 03 DC 03 DE 03 E0 03 E2 03 E4 03 E6 03 E8 03 EA 03 EC 03 EE 03 F0 03 F2 03 Result: DA 32 6E 2B 09 53 38 F7 95 C8 C1 F1 45 BE 19 94 93 C9 7B 00 3A CC 4C 2D 28 75 C6 25 5E 6B 71 62 37 4E F1 AA 09 AD D3 43 E4 90 DA 09 E1 D7 A0 03 75 98 CE 0C 85 3F 2A 76 FC 7F 59 11 BE FF 75 5B EC C1 7F 8F 6D A9 79 47 B2 6E 51 0A 40 C0 12 1C 63 61 BF 27 EE 36 A9 5A E5 01 FD F0 5D 39 90 69 21 B4 FF 3A 05 DF 83 F8 5F 81 1D 82 5C 8E 94 E9 1A 26 71 1C E7 FF 6C B2 2F 51 90 38 68 67 79 FB --------------------------------