public static byte[] DoFinal(
			IMac mac)
        {
            byte[] b = new byte[mac.GetMacSize()];
            mac.DoFinal(b, 0);
            return b;
        }

 /**
 * set up for use with stream mode, where the key derivation function
 * is used to provide a stream of bytes to xor with the message.
 *
 * @param agree the key agreement used as the basis for the encryption
 * @param kdf the key derivation function used for byte generation
 * @param mac the message authentication code generator for the message
 */
 public IesEngine(IBasicAgreement agree, IDerivationFunction kdf, IMac mac)
 {
     _agree = agree;
     _kdf = kdf;
     _mac = mac;
     _macBuf = new byte[mac.GetMacSize()];
     //            this.cipher = null;
 }

        public MacStream(
			Stream	stream,
			IMac	readMac,
			IMac	writeMac)
        {
            this.stream = stream;
            this.inMac = readMac;
            this.outMac = writeMac;
        }

        public NetworkLayer(IMac mac)
        {
            _mac = mac;
            _mgmt = new NetworkMgmt(this);
            _route = new Routing(this, mac, this);

#if USE_FRAG
            int mtu, head, tail;
            _route.GetMtuSize(out mtu, out head, out tail);
            _frag = new Fragmentation.Fragmentation(10, _route.DataRequest, mtu, head, tail);
#endif

            _mac.BeaconNotifyIndication = MacBeaconNotifyIndication;
            _mac.ResetRequest(true, null);
        }

        /**
	     * Construct a SP800-90A Hash DRBG.
	     * <p>
	     * Minimum entropy requirement is the security strength requested.
	     * </p>
	     * @param hMac Hash MAC to base the DRBG on.
	     * @param securityStrength security strength required (in bits)
	     * @param entropySource source of entropy to use for seeding/reseeding.
	     * @param personalizationString personalization string to distinguish this DRBG (may be null).
	     * @param nonce nonce to further distinguish this DRBG (may be null).
	     */
	    public HMacSP800Drbg(IMac hMac, int securityStrength, IEntropySource entropySource, byte[] personalizationString, byte[] nonce)
	    {
	        if (securityStrength > DrbgUtilities.GetMaxSecurityStrength(hMac))
	            throw new ArgumentException("Requested security strength is not supported by the derivation function");
	        if (entropySource.EntropySize < securityStrength)
	            throw new ArgumentException("Not enough entropy for security strength required");

            mHMac = hMac;
            mSecurityStrength = securityStrength;
	        mEntropySource = entropySource;

            byte[] entropy = GetEntropy();
	        byte[] seedMaterial = Arrays.ConcatenateAll(entropy, nonce, personalizationString);

            mK = new byte[hMac.GetMacSize()];
	        mV = new byte[mK.Length];
	        Arrays.Fill(mV, (byte)1);

            hmac_DRBG_Update(seedMaterial);

            mReseedCounter = 1;
	    }

		private void testSingleByte(IMac mac, TestCase testCase)
		{
			byte[] ad = testCase.getAd();
			for (int i = 0; i < ad.Length; i++)
			{
				mac.Update(ad[i]);
			}
			checkMac(mac, testCase);
		}

		private void checkMac(IMac mac, TestCase testCase)
		{
			byte[] generatedMac = new byte[mac.GetMacSize()];
			mac.DoFinal(generatedMac, 0);
			if (!AreEqual(testCase.getTag(), generatedMac))
			{
				Fail("Failed " + testCase.getName() + " - expected " + Hex.ToHexString(testCase.getTag()) + " got "
				     + Hex.ToHexString(generatedMac));
			}
		}

		private void testMultibyte(IMac mac, TestCase testCase)
		{
			mac.BlockUpdate(testCase.getAd(), 0, testCase.getAd().Length);
			checkMac(mac, testCase);
		}

 public HMacDrbgProvider(IMac hMac, byte[] nonce, byte[] personalizationString, int securityStrength)
 {
     this.mHMac = hMac;
     this.mNonce = nonce;
     this.mPersonalizationString = personalizationString;
     this.mSecurityStrength = securityStrength;
 }

        private AutoResetEvent _getAddressEvent; // event raised when we got an address

        public Routing(INetworkLayer net, IMac mac, IDataCallbacks data)
        {
            _net = net;
            _mac = mac;
            _data = data;

            _mac.GetMtuSize(out _macMtu, out _macHeader, out _macTailer);

            // calculate the header sizes for 6LoWPAN
            // private encapsulation requires one byte (Message.Data.cLength) additional header space
            int myHeader = Messages6LoWPAN.MeshHeader.cLengthMax + Messages6LoWPAN.BroadcastHeader.cLength;
            _netHeader6Low = _macHeader + myHeader;
            _netMtu6Low = _macMtu - myHeader;
            _netTailer6Low = _macTailer;

            _neighbourTable = new NeighborTable(this, _macHeader, _macTailer);
            _routingTable = new RoutingTable(this);
            _messageContext = new MessageContext();

            _seqNoDYMO = 0;
            _seqNoBroadcast = 0;
            _panId = 0;
            _addrShort = cInvalidShortAddr;
            _addrExt = 0; // to be set at start
            _isRunning = false;
            _getAddressEvent = new AutoResetEvent(false);
        }

 private static void UpdateMac(IMac mac, byte[] bytes)
 {
     mac.BlockUpdate(bytes, 0, bytes.Length);
     Arrays.Fill(bytes, (byte)0);
 }

		internal MacOutputStream(IMac mac)
		{
			this.mac = mac;
		}

 public static byte[] DoFinal(IMac mac, byte[] input)
 {
     mac.BlockUpdate(input, 0, input.Length);
     return DoFinal(mac);
 }

        /// <summary>
        /// Initialize the class with a digest enumeration
        /// </summary>
        /// 
        /// <param name="Mac">The initialized <see cref="IMac"/> instance</param>
        /// <param name="DisposeEngine">Dispose of digest engine when <see cref="Dispose()"/> on this class is called; default is false</param>
        /// 
        /// <exception cref="CryptoProcessingException">Thrown if an uninitialized Mac is used</exception>
        public StreamMac(IMac Mac, bool DisposeEngine = false)
        {
            if (Mac == null)
                throw new CryptoProcessingException("StreamMac:CTor", "The Mac can not be null!", new ArgumentNullException());
            if (!Mac.IsInitialized)
                throw new CryptoProcessingException("StreamMac:CTor", "The Mac has not been initialized!", new ArgumentException());

            _macEngine = Mac;
            _blockSize = _macEngine.BlockSize;
            _disposeEngine = DisposeEngine;
        }

        protected virtual void UpdateRecordMac(IMac mac, byte[] buf, int off, int len)
        {
            mac.BlockUpdate(buf, off, len);

            byte[] longLen = Pack.UInt64_To_LE((ulong)len);
            mac.BlockUpdate(longLen, 0, longLen.Length);
        }

 protected virtual void UpdateRecordMacLength(IMac mac, int len)
 {
     byte[] longLen = Pack.UInt64_To_LE((ulong)len);
     mac.BlockUpdate(longLen, 0, longLen.Length);
 }

 /**
  * Build a SecureRandom based on a SP 800-90A HMAC DRBG.
  *
  * @param hMac HMAC algorithm to use in the DRBG underneath the SecureRandom.
  * @param nonce  nonce value to use in DRBG construction.
  * @param predictionResistant specify whether the underlying DRBG in the resulting SecureRandom should reseed on each request for bytes.
  * @return a SecureRandom supported by a HMAC DRBG.
  */
 public SP800SecureRandom BuildHMac(IMac hMac, byte[] nonce, bool predictionResistant)
 {
     return new SP800SecureRandom(mRandom, mEntropySourceProvider.Get(mEntropyBitsRequired),
         new HMacDrbgProvider(hMac, nonce, mPersonalizationString, mSecurityStrength), predictionResistant);
 }

        protected virtual void UpdateRecordMacText(IMac mac, byte[] buf, int off, int len)
        {
            mac.BlockUpdate(buf, off, len);

            int partial = len % 16;
            if (partial != 0)
            {
                mac.BlockUpdate(Zeroes, 0, 16 - partial);
            }
        }

			public CmsAuthenticatedDataOutputStream(
				Stream					macStream,
				IMac					mac,
				BerSequenceGenerator	cGen,
				BerSequenceGenerator	authGen,
				BerSequenceGenerator	eiGen)
			{
				this.macStream = macStream;
				this.mac = mac;
				this.cGen = cGen;
				this.authGen = authGen;
				this.eiGen = eiGen;
			}

        internal static int GetMaxSecurityStrength(IMac m)
	    {
	        string name = m.AlgorithmName;

            return (int)maxSecurityStrengths[name.Substring(0, name.IndexOf("/"))];
	    }