Example #1
0
        private Blake2S Blake2SPCreateRoot()
        {
            IBlake2SConfig blake2SConfig = new Blake2SConfig(HashSize);

            blake2SConfig.Key = Key.DeepCopy();

            IBlake2STreeConfig blake2STreeConfig = new Blake2STreeConfig();

            blake2STreeConfig.FanOut        = (byte)ParallelismDegree;
            blake2STreeConfig.MaxDepth      = 2;
            blake2STreeConfig.NodeDepth     = 1;
            blake2STreeConfig.LeafSize      = 0;
            blake2STreeConfig.NodeOffset    = 0;
            blake2STreeConfig.InnerHashSize = (byte)OutSizeInBytes;
            blake2STreeConfig.IsLastNode    = true;

            return(new Blake2S(blake2SConfig, blake2STreeConfig, false));
        }
Example #2
0
        private Blake2S Blake2SPCreateRoot()
        {
            var config = new Blake2SConfig(HashSize)
            {
                Key = _key
            };

            var treeConfig = new Blake2STreeConfig
            {
                FanOut        = ParallelismDegree,
                MaxDepth      = 2,
                NodeDepth     = 1,
                LeafSize      = 0,
                NodeOffset    = 0,
                InnerHashSize = OutSizeInBytes,
                IsLastNode    = true
            };

            return(new Blake2S(config, treeConfig, false));
        }
Example #3
0
        private Blake2S Blake2SPCreateLeaf(UInt64 a_Offset)
        {
            IBlake2SConfig blake2SConfig = new Blake2SConfig(HashSize);

            blake2SConfig.Key = Key.DeepCopy();

            IBlake2STreeConfig blake2STreeConfig = new Blake2STreeConfig();

            blake2STreeConfig.FanOut        = (byte)ParallelismDegree;
            blake2STreeConfig.MaxDepth      = 2;
            blake2STreeConfig.NodeDepth     = 0;
            blake2STreeConfig.LeafSize      = 0;
            blake2STreeConfig.NodeOffset    = a_Offset;
            blake2STreeConfig.InnerHashSize = (byte)OutSizeInBytes;

            if (a_Offset == (UInt64)(ParallelismDegree - 1))
            {
                blake2STreeConfig.IsLastNode = true;
            }

            return(Blake2SPCreateLeafParam(blake2SConfig, blake2STreeConfig));
        }
Example #4
0
        private Blake2S Blake2SPCreateLeaf(ulong offset)
        {
            var config = new Blake2SConfig(OutSizeInBytes)
            {
                Key = _key
            };

            var treeConfig = new Blake2STreeConfig
            {
                FanOut        = ParallelismDegree,
                MaxDepth      = 2,
                NodeDepth     = 0,
                LeafSize      = 0,
                NodeOffset    = offset,
                InnerHashSize = OutSizeInBytes
            };

            if (offset == ParallelismDegree - 1)
            {
                treeConfig.IsLastNode = true;
            }

            return(Blake2SPCreateLeafParam(config, treeConfig));
        }
Example #5
0
 /// <summary>
 /// <br />Blake2S defaults to setting the expected output length <br />
 /// from <c>Config.HashSize</c>. <br />In some cases, however,
 /// we do not want this, as the output length <br />
 /// of these instances is given by <c>TreeConfig.InnerSize</c>
 /// instead. <br />
 /// </summary>
 private static Blake2S Blake2SPCreateLeafParam(Blake2SConfig config, Blake2STreeConfig treeConfig) =>
 new Blake2S(config, treeConfig);
Example #6
0
 public static IHash CreateBlake2S(Blake2SConfig config = null, Blake2STreeConfig treeConfig = null) =>
 new Blake2S(config ?? Blake2SConfig.DefaultConfig, treeConfig);
Example #7
0
        // https://docs.python.org/3/library/hashlib.html#tree-mode modified for Blake2s
        public void TestBlake2STreeHashingMode()
        {
            const byte   FAN_OUT    = 2;
            const byte   DEPTH      = 2; // MaxDepth
            const UInt32 LEAF_SIZE  = 4096;
            const byte   INNER_SIZE = 32;

            IBlake2STreeConfig Blake2STreeConfigh00, Blake2STreeConfigh01, Blake2STreeConfigh10;
            IHash h00, h01, h10;

            byte[] LBuffer = new byte[6000];

            // Left leaf
            Blake2STreeConfigh00               = new Blake2STreeConfig();
            Blake2STreeConfigh00.FanOut        = FAN_OUT;
            Blake2STreeConfigh00.MaxDepth      = DEPTH;
            Blake2STreeConfigh00.LeafSize      = LEAF_SIZE;
            Blake2STreeConfigh00.InnerHashSize = INNER_SIZE;
            Blake2STreeConfigh00.NodeOffset    = 0;
            Blake2STreeConfigh00.NodeDepth     = 0;
            Blake2STreeConfigh00.IsLastNode    = false;
            h00 = HashFactory.Crypto.CreateBlake2S(new Blake2SConfig() as IBlake2SConfig, Blake2STreeConfigh00);
            h00.Initialize();

            // Right leaf
            Blake2STreeConfigh01               = new Blake2STreeConfig();
            Blake2STreeConfigh01.FanOut        = FAN_OUT;
            Blake2STreeConfigh01.MaxDepth      = DEPTH;
            Blake2STreeConfigh01.LeafSize      = LEAF_SIZE;
            Blake2STreeConfigh01.InnerHashSize = INNER_SIZE;
            Blake2STreeConfigh01.NodeOffset    = 1;
            Blake2STreeConfigh01.NodeDepth     = 0;
            Blake2STreeConfigh01.IsLastNode    = true;
            h01 = HashFactory.Crypto.CreateBlake2S(new Blake2SConfig() as IBlake2SConfig, Blake2STreeConfigh01);
            h01.Initialize();

            // Root node
            Blake2STreeConfigh10               = new Blake2STreeConfig();
            Blake2STreeConfigh10.FanOut        = FAN_OUT;
            Blake2STreeConfigh10.MaxDepth      = DEPTH;
            Blake2STreeConfigh10.LeafSize      = LEAF_SIZE;
            Blake2STreeConfigh10.InnerHashSize = INNER_SIZE;
            Blake2STreeConfigh10.NodeOffset    = 0;
            Blake2STreeConfigh10.NodeDepth     = 1;
            Blake2STreeConfigh10.IsLastNode    = true;
            h10 = HashFactory.Crypto.CreateBlake2S(new Blake2SConfig(16) as IBlake2SConfig, Blake2STreeConfigh10);
            h10.Initialize();

            byte[] temp = new byte[LEAF_SIZE];
            Utils.Utils.Memcopy(ref temp, LBuffer, (Int32)LEAF_SIZE);

            h10.TransformBytes(h00.ComputeBytes(temp).GetBytes());

            temp = new byte[LBuffer.Length - LEAF_SIZE];
            Utils.Utils.Memcopy(ref temp, LBuffer, (Int32)(LBuffer.Length - LEAF_SIZE), (Int32)LEAF_SIZE);

            h10.TransformBytes(h01.ComputeBytes(temp).GetBytes());

            string ActualString   = h10.TransformFinal().ToString();
            string ExpectedString = Blake2STreeHashingMode;

            Assert.AreEqual(ExpectedString, ActualString,
                            String.Format("Expected {0} but got {1}.",
                                          ExpectedString, ActualString));
        }
 public static Blake2XSConfig CreateBlake2XSConfig(Blake2SConfig config, Blake2STreeConfig treeConfig) =>
 new Blake2XSConfig(config, treeConfig);
 private Blake2XSConfig(Blake2SConfig config, Blake2STreeConfig treeConfig)
 {
     Config     = config;
     TreeConfig = treeConfig;
 }