WriteUInt64() public static method

public static WriteUInt64 ( ulong value, byte buffer, int offset ) : int
value ulong
buffer byte
offset int
return int
Example #1
0
        ushort WriteCipherMessage(ContentType type, TLSMessage msg)
        {
            if (_ver == ProtocolVersion.TLS11 || _ver == ProtocolVersion.TLS12)
            {
                throw new NotImplementedException();
            }
            int    offset      = 5;
            int    init_offset = 5;
            ushort length      = WritePlainMessage(type, msg, offset);

            _sendHMAC.Initialize();
            if (_ver == ProtocolVersion.SSL30)
            {
                byte[] temp = new byte[11];
                BitConverterBE.WriteUInt64(_sendSeq, temp, 0);
                temp[8] = (byte)type;
                BitConverterBE.WriteUInt16((ushort)length, temp, 9);
                _sendHMAC.TransformBlock(temp, 0, temp.Length, temp, 0);
            }
            else
            {
                byte[] temp = new byte[13];
                BitConverterBE.WriteUInt64(_sendSeq, temp, 0);
                temp[8] = (byte)type;
                BitConverterBE.WriteUInt16((ushort)_ver, temp, 9);
                BitConverterBE.WriteUInt16((ushort)length, temp, 11);
                _sendHMAC.TransformBlock(temp, 0, temp.Length, temp, 0);
            }
            _sendHMAC.TransformBlock(_sendBuffer, offset, length, _sendBuffer, offset);
            _sendHMAC.TransformFinalBlock(Utility.EmptyByteArray, 0, 0);
            offset += length;
            Buffer.BlockCopy(_sendHMAC.Hash, 0, _sendBuffer, offset, _sparams.MACLength);
            Console.WriteLine("Record MAC");
            Utility.Dump(_sendBuffer, offset, _sparams.MACLength);
            offset += _sparams.MACLength;
            byte padding_length = (byte)((_sparams.BlockLength - ((length + _sparams.MACLength + 1) % _sparams.BlockLength)) % _sparams.BlockLength);

            for (int i = 0; i < padding_length; i++)
            {
                _sendBuffer[offset++] = padding_length;
            }
            _sendBuffer[offset++] = padding_length;
            length += (ushort)(_sparams.MACLength + padding_length + 1);

            int encrypted = 0;

            while (encrypted < length)
            {
                int tmp = _encryptor.TransformBlock(_sendBuffer, init_offset + encrypted, length - encrypted, _sendBuffer, init_offset + encrypted);
                if (tmp == 0)
                {
                    throw new CryptographicException();
                }
                encrypted += tmp;
            }

            _sendSeq++;

            return(length);
        }
Example #2
0
        TLSMessage ReadCipherText(ContentType type, ProtocolVersion ver, int offset, ushort length)
        {
            if (ver == ProtocolVersion.TLS11 && ver == ProtocolVersion.TLS12)
            {
                throw new NotImplementedException();
            }

            Console.WriteLine("Encrypted");
            Utility.Dump(_recvBuffer, offset, length);

            int decrypted = 0;

            while (decrypted < length)
            {
                int tmp = _decryptor.TransformBlock(_recvBuffer, offset + decrypted, length - decrypted, _recvBuffer, decrypted);
                if (tmp == 0)
                {
                    throw new CryptographicException();
                }
                decrypted += tmp;
            }
            Console.WriteLine("Decrypted");
            Utility.Dump(_recvBuffer, 0, length);

            int fragLen = length - _recvBuffer[length - 1] - _sparams.MACLength - 1;

            if (fragLen < 0)
            {
                throw new Exception();                           // Decrypt Error
            }
            Console.WriteLine("Fragment");
            Utility.Dump(_recvBuffer, 0, fragLen);

            Console.WriteLine("HMAC");
            Utility.Dump(_recvBuffer, fragLen, _sparams.MACLength);

            _recvHMAC.Initialize();
            if (_ver == ProtocolVersion.SSL30)
            {
                byte[] temp = new byte[11];
                BitConverterBE.WriteUInt64(_recvSeq, temp, 0);
                temp[8] = (byte)type;
                BitConverterBE.WriteUInt16((ushort)fragLen, temp, 9);
                _recvHMAC.TransformBlock(temp, 0, temp.Length, temp, 0);
            }
            else
            {
                byte[] temp = new byte[13];
                BitConverterBE.WriteUInt64(_recvSeq, temp, 0);
                temp[8] = (byte)type;
                BitConverterBE.WriteUInt16((ushort)ver, temp, 9);
                BitConverterBE.WriteUInt16((ushort)fragLen, temp, 11);
                _recvHMAC.TransformBlock(temp, 0, temp.Length, temp, 0);
            }
            _recvHMAC.TransformBlock(_recvBuffer, 0, fragLen, _recvBuffer, 0);
            _recvHMAC.TransformFinalBlock(Utility.EmptyByteArray, 0, 0);

            Console.WriteLine("Comaputed HMAC");
            Utility.Dump(_recvHMAC.Hash);

            _recvSeq++;

            return(ReadPlainText(type, ver, 0, (ushort)fragLen));
        }