示例#1
0
		}// DeriveKey()

		internal static void DeriveKey(HMAC keyedHmac, ArraySegment<byte> bufferSegment, ArraySegment<byte> derivedOutput, uint counter = 1)
		{
			int derivedOutputCount = derivedOutput.Count, derivedOutputOffset = derivedOutput.Offset;
			byte[] K_i = null;
			HMAC2 keyedHmac2 = keyedHmac as HMAC2;
			checked
			{
				// Calculate each K_i value and copy the leftmost bits to the output buffer as appropriate.
				for (var counterStruct = new Utils.IntStruct { UintValue = counter }; derivedOutputCount > 0; ++counterStruct.UintValue)
				{
					counterStruct.ToBEBytes(bufferSegment.Array, bufferSegment.Offset); // update the counter within the buffer

					if (keyedHmac2 == null)
					{
						K_i = keyedHmac.ComputeHash(bufferSegment.Array, bufferSegment.Offset, bufferSegment.Count);
					}
					else
					{
						keyedHmac2.TransformBlock(bufferSegment.Array, bufferSegment.Offset, bufferSegment.Count, null, 0);
						keyedHmac2.TransformFinalBlock(bufferSegment.Array, 0, 0);
						K_i = keyedHmac2.HashInner;
					}

					// copy the leftmost bits of K_i into the output buffer
					int numBytesToCopy = derivedOutputCount > K_i.Length ? K_i.Length : derivedOutputCount;//Math.Min(derivedOutputCount, K_i.Length);
					Utils.BlockCopy(K_i, 0, derivedOutput.Array, derivedOutputOffset, numBytesToCopy);
					derivedOutputOffset += numBytesToCopy;
					derivedOutputCount -= numBytesToCopy;
				}// for
			}// checked
			if (keyedHmac2 == null && K_i != null) Array.Clear(K_i, 0, K_i.Length); /* clean up needed only when HMAC implementation is not HMAC2 */
		}// DeriveKey()
示例#2
0
		public override byte[] GetBytes(int countBytes)
		{
			var okm = new byte[countBytes];
			if (k_unused > 0)
			{
				var min = k_unused > countBytes ? countBytes : k_unused;//Math.Min(k_unused, countBytes);
				Utils.BlockCopy(k, hashLength - k_unused, okm, 0, min);
				countBytes -= min;
				k_unused -= min;
			}
			if (countBytes == 0) return okm;

			int n = countBytes / hashLength + 1;
			int contextLength = context != null ? context.Length : 0;
			byte[] hmac_msg = new byte[hashLength + contextLength + 1];

			for (var i = 1; i <= n; ++i)
			{
				Utils.BlockCopy(k, 0, hmac_msg, 0, k.Length);
				if (contextLength > 0)
					Utils.BlockCopy(context, 0, hmac_msg, k.Length, contextLength);

				hmac_msg[k.Length + contextLength] = checked(++counter);

				if (hmac2 != null)
				{
					hmac2.TransformBlock(hmac_msg, 0, k.Length + contextLength + 1, null, 0);
					hmac2.TransformFinalBlock(hmac_msg, 0, 0);
					k = hmac2.HashInner;
				}
				else
					k = hmac.ComputeHash(hmac_msg, 0, k.Length + contextLength + 1);

				Utils.BlockCopy(k, 0, okm, okm.Length - countBytes, i < n ? hashLength : countBytes);
				countBytes -= hashLength;
			}
			k_unused = -countBytes;
			return okm;
		}// GetBytes()
示例#3
0
		byte[] Func()
		{
			new Utils.IntStruct { UintValue = this.block }.ToBEBytes(inputBuffer);
			this.hmac.TransformBlock(inputBuffer: this.salt, inputOffset: 0, inputCount: this.salt.Length, outputBuffer: null, outputOffset: 0);
			this.hmac.TransformBlock(inputBuffer: inputBuffer, inputOffset: 0, inputCount: inputBuffer.Length, outputBuffer: null, outputOffset: 0);
			this.hmac.TransformFinalBlock(inputBuffer: inputBuffer, inputOffset: 0, inputCount: 0);
			byte[] hash = this.hmac.Hash; // creates a copy
			this.hmac.Initialize();
			byte[] buffer3 = hash;

			for (int i = 2; i <= this.iterations; i++)
			{
				if (hmac2 != null)
				{
					hmac2.TransformBlock(hash, 0, BlockSize, null, 0);
					hmac2.TransformFinalBlock(hash, 0, 0);
					hash = hmac2.HashInner;
				}
				else hash = this.hmac.ComputeHash(hash);
				Utils.Xor(dest: buffer3, destOffset: 0, left: hash, leftOffset: 0, byteCount: BlockSize);
			}
			this.block++;
			return buffer3;
		}