Example #1
0
        internal SmppQuerySmReq(ByteBuilder bb)
        {
            int startPosition = 0x10;

            _Header = new SmppHeader(bb);
            _Body   = new BodyPdu(bb, ref startPosition);
        }
Example #2
0
 public override void WriteOffsets(ByteBuilder bb)
 {
     foreach (ExportRef exp in Exports)
     {
         exp?.WriteOffset(bb);
     }
 }
        private void buttonUpdateTable_Click(object sender, EventArgs e)
        {
            m_aChannel = new byte[this.listViewEx1.Items.Count];

            for (int i = 0; i < this.listViewEx1.Items.Count; i++)
            {
                try
                {
                    m_aChannel[i] = byte.Parse(this.listViewEx1.Items[i].SubItems[1].Text);
                }
                catch
                {
                }
            }

            ByteBuilder bb = new ByteBuilder();

            bb.Clear();

            bb.Append((byte)this.GetChannelTable().Length);
            bb.Append(this.GetChannelTable());

            if (!RcpProtocol.Instance.SendBytePkt(RcpProtocol.Instance.BuildCmdPacketByte(RcpProtocol.RCP_MSG_CMD, RcpProtocol.RCP_CMD_SET_HOPPING_TBL, bb.GetByteArray())))
            {
            }
            bb.Clear();
        }
Example #4
0
        /// <summary>
        /// Computes the 16-bit checksum of the specified IPv4 packet.
        /// </summary>
        /// <param name="packet">The packet to compute the checksum for.</param>
        /// <param name="withChecksumField">true to include the packet's
        /// checksum field in the calculation; otherwise false.</param>
        /// <returns>The checksum of the specified IPv4 packet.</returns>
        /// <exception cref="ArgumentNullException">Thrown if the packet
        /// argument is null.</exception>
        public static ushort ComputeChecksum(IpPacket packet,
                                             bool withChecksumField = false)
        {
            packet.ThrowIfNull("packet");
            // The version and IHL fields are 4 bit wide each.
            var vi = (byte)(((packet.Ihl & 0x0F) << 4) |
                            (((int)packet.Version) & 0x0F));
            // The flags field is 3 bits and the fragment offset 13 bits wide.
            var ffo = (ushort)(((packet.FragmentOffset & 0x1FFF) << 3) |
                               ((int)packet.Flags & 0x07));
            var bytes = new ByteBuilder()
                        .Append(vi)
                        .Append(packet.Dscp)
                        .Append(packet.TotalLength)
                        .Append(packet.Identification)
                        .Append(ffo)
                        .Append(packet.TimeToLive)
                        .Append((byte)packet.Protocol)
                        .Append(withChecksumField ? packet.Checksum : (ushort)0)
                        .Append(packet.Source.Bytes)
                        .Append(packet.Destination.Bytes)
                        .ToArray();
            var sum = 0;

            // Treat the header bytes as a sequence of unsigned 16-bit values and
            // sum them up.
            for (var n = 0; n < bytes.Length; n += 2)
            {
                sum += BitConverter.ToUInt16(bytes, n);
            }
            // Use carries to compute the 1's complement sum.
            sum = (sum >> 16) + (sum & 0xFFFF);
            // Return the inverted 16-bit result.
            return((ushort)(~sum));
        }
        public void WriteOffset(int rel, ByteBuilder bb)
        {
            IsOffsetWrited = true;

            if (Reference != null)
            {
                TargetOffset = Reference.Address;
            }

            int val = TargetOffset;

            if (Relative)
            {
                val -= rel;
            }

            switch (Size)
            {
            case 1: bb.SetByte(Address, (byte)val); break;

            case 2: bb.SetShortBE(Address, (ushort)val); break;

            default: throw new NotImplementedException();
            }
        }
    /// <summary>
    /// Waits until the connected client sends a SOCKS5 request.
    /// </summary>
    /// <returns>The SOCKS5 request sent by the client.</returns>
    /// <exception cref="Socks5Exception">The data sent by the client
    /// is not a valid SOCKS5 request.</exception>
    private SocksRequest WaitForRequest()
    {
        ByteBuilder b = new ByteBuilder();

        using (var r = new BinaryReader(stream, Encoding.UTF8, true))
        {
            byte[] bytes = r.ReadBytes(4);
            b.Append(bytes);
            ATyp atyp = (ATyp)bytes[3];
            switch (atyp)
            {
            case ATyp.IPv4:
            case ATyp.IPv6:
                b.Append(r.ReadBytes(atyp == ATyp.IPv4 ? 4 : 16));
                break;

            case ATyp.Domain:
                byte length = r.ReadByte();
                b.Append(length).Append(r.ReadBytes(length));
                break;
            }
            b.Append(r.ReadBytes(2));
        }
        try
        {
            return(SocksRequest.Deserialize(b.ToArray()));
        }
        catch (Exception e)
        {
            throw new Socks5Exception("The request could not be serialized.", e);
        }
    }
Example #7
0
    /*登录 */
    public void LogIn()
    {
        if (isInLogIn || isInRegister)
        {
            return;                             //若已点击了登陆按钮或注册按钮则不响应
        }
        StopCoroutine("ResetPrompt");
        promptText.text = "";

        userNameInput.interactable = false;
        passwordInput.interactable = false;
        isInLogIn = true;
        //test
        // LogInSuccess();
        ByteBuilder builder = new ByteBuilder();

        builder.Add(System.BitConverter.GetBytes(Network.LOGIN));
        builder.Add(System.BitConverter.GetBytes(userNameInput.text.Length));
        builder.Add(System.BitConverter.GetBytes(passwordInput.text.Length));
        builder.Add(System.Text.Encoding.ASCII.GetBytes(userNameInput.text));
        builder.Add(System.Text.Encoding.ASCII.GetBytes(passwordInput.text));
        Global.network.Send(builder.GetByes());
        // Debug.Log("Set");
        LogInOutCor = StartCoroutine(LogInTimeout());
    }
Example #8
0
        /// <summary>
        /// Computes the server evidence from the given parameters.
        /// </summary>
        /// <param name="clientPublicKey">The client's ephemeral public key.</param>
        /// <param name="clientProof"></param>
        /// <param name="sharedKey">The shared context key.</param>
        /// <param name="authId">The authorization identity.</param>
        /// <param name="options">The raw options string as sent by the
        /// client.</param>
        /// <param name="sid">The session id sent by the server.</param>
        /// <param name="ttl">The time-to-live value for the session id sent
        /// by the server.</param>
        /// <param name="hashAlgorithm">The message digest algorithm to use for
        /// calculating the server proof.</param>
        /// <returns>The server proof as an array of bytes.</returns>
        public static byte[] ComputeServerProof(Mpi clientPublicKey, byte[] clientProof,
                                                Mpi sharedKey, string authId, string options, string sid, uint ttl,
                                                HashAlgorithm hashAlgorithm)
        {
            byte[] A = clientPublicKey.ToBytes(), M1 = clientProof,
            K = sharedKey.ToBytes(), I = Encoding.UTF8.GetBytes(authId),
            o = Encoding.UTF8.GetBytes(options), _sid = Encoding.UTF8.GetBytes(sid);
            HashAlgorithm H = hashAlgorithm;

            // The proof is calculated as follows:
            //
            // H( bytes(A)
            //  | bytes(M1)
            //  | bytes(K)
            //  | bytes(H( bytes(I) ))
            //  | bytes(H( bytes(o) ))
            //  | bytes(sid)
            //  | ttl
            // )
            byte[] seq = new ByteBuilder()
                         .Append(A)
                         .Append(M1)
                         .Append(K)
                         .Append(H.ComputeHash(I))
                         .Append(H.ComputeHash(o))
                         .Append(_sid)
                         .Append(ttl, true)
                         .ToArray();
            return(H.ComputeHash(seq));
        }
Example #9
0
        /// <summary>
        /// Computes the client evidence from the given parameters.
        /// </summary>
        /// <param name="safePrimeModulus">The safe prime modulus sent by the
        /// server.</param>
        /// <param name="generator">The generator sent by the server.</param>
        /// <param name="username">The username to authenticate with.</param>
        /// <param name="salt">The client's password salt.</param>
        /// <param name="clientPublicKey">The client's ephemeral public key.</param>
        /// <param name="serverPublicKey">The server's ephemeral public key.</param>
        /// <param name="sharedKey">The shared context key.</param>
        /// <param name="authId">The authorization identity.</param>
        /// <param name="options">The raw options string as received from the
        /// server.</param>
        /// <param name="hashAlgorithm">The message digest algorithm to use for
        /// calculating the client proof.</param>
        /// <returns>The client proof as an array of bytes.</returns>
        public static byte[] ComputeClientProof(Mpi safePrimeModulus, Mpi generator,
                                                string username, byte[] salt, Mpi clientPublicKey, Mpi serverPublicKey,
                                                Mpi sharedKey, string authId, string options, HashAlgorithm hashAlgorithm)
        {
            byte[] N = safePrimeModulus.ToBytes(), g = generator.ToBytes(),
            U = Encoding.UTF8.GetBytes(username), s = salt,
            A = clientPublicKey.ToBytes(), B = serverPublicKey.ToBytes(),
            K = sharedKey.ToBytes(), I = Encoding.UTF8.GetBytes(authId),
            L = Encoding.UTF8.GetBytes(options);
            HashAlgorithm H = hashAlgorithm;

            // The proof is calculated as follows:
            //
            // H( bytes(H( bytes(N) )) ^ bytes( H( bytes(g) ))
            //  | bytes(H( bytes(U) ))
            //  | bytes(s)
            //  | bytes(A)
            //  | bytes(B)
            //  | bytes(K)
            //  | bytes(H( bytes(I) ))
            //  | bytes(H( bytes(L) ))
            // )
            byte[] seq = new ByteBuilder()
                         .Append(Xor(H.ComputeHash(N), H.ComputeHash(g)))
                         .Append(H.ComputeHash(U))
                         .Append(s)
                         .Append(A)
                         .Append(B)
                         .Append(K)
                         .Append(H.ComputeHash(I))
                         .Append(H.ComputeHash(L))
                         .ToArray();
            return(H.ComputeHash(seq));
        }
Example #10
0
 private static void ReadMessage(ClientInfo ci, uint code, byte[] buf, int len)
 {
     Console.WriteLine("Message, code " + code.ToString("X8") + ", content:");
     byte[] ba = new byte[len];
     Array.Copy(buf, ba, len);
     Console.WriteLine("  " + ByteBuilder.FormatParameter(new Parameter(ba, ParameterType.Byte)));
 }
Example #11
0
        public override void Write(ByteBuilder bb)
        {
            Address = (ushort)bb.Position;
            bb.AddByte(Type);
            foreach (object arg in Arguments)
            {
                switch (arg)
                {
                case byte b:
                    bb.AddByte(b);
                    break;

                case ushort s:
                    bb.AddShortBE(s);
                    break;

                case RefToElement r:
                    r.Write(bb);
                    break;

                case LinkToExport l:
                    l.Write(bb);
                    break;

                default:
                    throw new NotImplementedException();
                }
            }
        }
Example #12
0
        /// <summary>
        /// 转换为ByteRange
        /// </summary>
        /// <exception cref="ProtocolException"></exception>
        /// <returns></returns>
        public ByteRange ToByteRange()
        {
            var apiNameBytes = Encoding.UTF8.GetBytes(this.ApiName);
            var headLength   = apiNameBytes.Length + 15;

            this.TotalBytes = this.Body == null ? headLength : headLength + this.Body.Length;

            const int packegMaxSize = 10 * 1204 * 1024; // 10M

            if (this.TotalBytes > packegMaxSize)
            {
                throw new ProtocolException("数据包太大");
            }

            this.ApiNameLength = (byte)apiNameBytes.Length;
            var builder = new ByteBuilder(Endians.Big);

            builder.Add(this.TotalBytes);
            builder.Add(this.ApiNameLength);
            builder.Add(apiNameBytes);
            builder.Add(this.Id);
            builder.Add(this.IsFromClient);
            builder.Add(this.IsException);
            builder.Add(this.Body);
            return(builder.ToByteRange());
        }
Example #13
0
            internal BodyPdu(ByteBuilder bb, ref int StartPosition)
            {
                _ServiceType        = SmppServiceType.Default;
                _SourceAddress      = string.Empty;
                _DestinationAddress = string.Empty;
                _EsmClass           = new BitBuilder();
                _RegisteredDelivery = new BitBuilder();
                _ShortMessage       = new SmppString();
                _ServiceType        =
                    SmppServiceType.FromValue(
                        SmppDataCoding.BaseEncoding.GetString(bb.ReadBytesUntil(ref StartPosition, 0)));
                _SourceAddressTon      = bb.ReadByte(ref StartPosition);
                _SourceAddressNpi      = bb.ReadByte(ref StartPosition);
                _SourceAddress         = SmppDataCoding.BaseEncoding.GetString(bb.ReadBytesUntil(ref StartPosition, 0));
                _DestinationAddressTon = bb.ReadByte(ref StartPosition);
                _DestinationAddressNpi = bb.ReadByte(ref StartPosition);
                _DestinationAddress    = SmppDataCoding.BaseEncoding.GetString(bb.ReadBytesUntil(ref StartPosition, 0));
                _EsmClass.Value        = bb.ReadByte(ref StartPosition);
                _ProtocolId            = bb.ReadByte(ref StartPosition);
                _PriorityFlag          = bb.ReadByte(ref StartPosition);
                _ScheduleDeliveryTime  =
                    new SmppDateTime(SmppDataCoding.BaseEncoding.GetString(bb.ReadBytesUntil(ref StartPosition, 0)));
                _ValidityPeriod =
                    new SmppDateTime(SmppDataCoding.BaseEncoding.GetString(bb.ReadBytesUntil(ref StartPosition, 0)));
                _RegisteredDelivery.Value = bb.ReadByte(ref StartPosition);
                _ReplaceIfPresent         = bb.ReadByte(ref StartPosition);
                _ShortMessage.DataCoding  = SmppDataCoding.FromValue(bb.ReadByte(ref StartPosition));
                _SmDefaultMessageId       = bb.ReadByte(ref StartPosition);
                byte length = bb.ReadByte(ref StartPosition);

                _ShortMessage.Value = bb.ReadBytes(ref StartPosition, length);
            }
Example #14
0
        public override void SetTranslate(string[] strings)
        {
            var oldStrings = GetStrings(true);

            if (strings.Length != oldStrings.Length)
            {
                throw new Exception("Line count mismatch");
            }

            ByteBuilder bb = new ByteBuilder();

            for (int r = 0; r < strings.Length; r++)
            {
                var tr = strings[r];
                if (tr == null)
                {
                    tr = oldStrings[r];
                }

                var bytes = GameEncoding.GetBytes(tr);
                bb.AddBytes(bytes);
                bb.AddByte(0);
            }

            SaveTranslate(bb.GetArray());
        }
Example #15
0
        /// <summary>
        /// 当接收到远程端的数据时,将触发此方法
        /// 此方法用于处理和分析收到的数据
        /// 如果得到一个数据包,将触发OnRecvComplete方法
        /// [注]这里只需处理一个数据包的流程
        /// </summary>
        /// <param name="client">客户端</param>
        /// <param name="recvBuilder">接收到的历史数据</param>
        /// <returns>如果不够一个数据包,则请返回null</returns>
        protected override Hybi13Packet OnReceive(SocketAsync <Hybi13Packet> client, ByteBuilder recvBuilder)
        {
            if (client.IsConnected == false)
            {
                return(null);
            }

            // 获取处理接收的数据的容器
            var resultBuilder = client.TagBag.ResultBuilder as ByteBuilder;

            // 说明不是第一次握手请求
            if (resultBuilder != null)
            {
                return(RequestPacket.GetPacket(recvBuilder, resultBuilder));
            }

            // 设置ResultBuilder
            client.TagBag.ResultBuilder = new ByteBuilder();

            // 处理握手请求
            var request = HandshakeRequest.Parse(recvBuilder.ToArrayThenClear());

            if (request == null || this.CheckHandshake(client, request) == false)
            {
                this.CloseClient(client, CloseStatus.ProtocolError);
            }
            else
            {
                var packet = new ResponsePacket();
                packet.SetHandshake(request.ToHandshake());
                client.Send(packet);
            }
            return(null);
        }
Example #16
0
        internal SmppQuerySmRes(ByteBuilder bb)
        {
            _Header = new SmppHeader(bb);
            int lastBytePosition = 0x10;

            _Body = new BodyPdu(bb, ref lastBytePosition);
        }
Example #17
0
 public override void WriteOffsets(ByteBuilder bb)
 {
     foreach (Code c in Operators)
     {
         c.WriteOffset(bb);
     }
 }
Example #18
0
        // Note: if you use this, make sure to set the builder to have enough bytes
        // Returns: offset to the data (end of headers), UInt32.MaxValue if end of headers not found yet
        public static UInt32 ReadHttpHeaders(Socket socket, ByteBuilder builder)
        {
            Int32 bytesReceived = socket.Receive(builder.bytes, (int)builder.contentLength,
                                                 (int)(builder.bytes.Length - builder.contentLength), 0);

            if (bytesReceived <= 0)
            {
                throw new FormatException(String.Format("socket closed before all HTTP headers were received ({0} bytes received)'", bytesReceived));
            }

            UInt32 checkOffset = builder.contentLength;

            builder.contentLength += (UInt32)bytesReceived;

            // Search for the ending \r\n\r\n
            Byte[] checkBuffer = builder.bytes;
            if (checkOffset >= 3)
            {
                checkOffset -= 3; // Reverse 3 chars in case the last request had the partial end of double newline
            }
            for (; checkOffset + 3 < builder.contentLength; checkOffset++)
            {
                if (checkBuffer[checkOffset] == (Byte)'\r' &&
                    checkBuffer[checkOffset + 1] == (Byte)'\n' &&
                    checkBuffer[checkOffset + 2] == (Byte)'\r' &&
                    checkBuffer[checkOffset + 3] == (Byte)'\n')
                {
                    return(checkOffset + 4);
                }
            }

            return(UInt32.MaxValue);
        }
 public override void Write(ByteBuilder bb)
 {
     foreach (var r in Refs)
     {
         bb.AddShortBE(r);
     }
 }
Example #20
0
        private void SetFrequncyHopppingChannelTable(byte[] data)
        {
            int size = data[5];

            if (size > data.Length - 9)
            {
                return;
            }

            ByteBuilder ba = new ByteBuilder();

            for (int i = 6; i < size + 6; i++)
            {
                ba.Append(data[i]);
            }

            formChannelTable.SetChannel(ba.GetByteArray());

            if (formChannelTable.isDisplayed)
            {
            }
            else
            {
                formChannelTable.ShowDialog();
            }
        }
Example #21
0
        public byte[] GetBytes()
        {
            ByteBuilder bb = new ByteBuilder();

            WriteExt(bb);
            return(bb.GetArray());
        }
Example #22
0
 public virtual void Write(ByteBuilder bb)
 {
     if (Args != null)
     {
         bb.AddBytes(Args);
     }
 }
Example #23
0
 public override void WriteOffsets(ByteBuilder bb)
 {
     foreach (StringConst str in Strings)
     {
         str.WriteOffset(bb);
     }
 }
Example #24
0
        public override void Write(ByteBuilder bb)
        {
            bb.AddShortBE(0x1234);
            bb.AddShortBE(0);
            bb.AddShortBE(funcList);
            bb.AddShortBE((ushort)Selectors.Length);

            for (int i = 0; i < Selectors.Length; i++)
            {
                Selectors[i].Write(bb);
            }

            if (Type == SectionType.Class)
            {
                foreach (ushort vs in varselectors)
                {
                    bb.AddShortBE(vs);
                }
            }

            bb.AddShortBE((ushort)FuncNames.Length);
            foreach (ushort val in FuncNames)
            {
                bb.AddShortBE(val);
            }

            bb.AddShortBE(0);

            foreach (RefToElement r in FuncCode)
            {
                r.Write(bb);
            }
        }
Example #25
0
 internal SmppHeader(ByteBuilder bb)
 {
     _CommandLength  = SmppConverter.FromByteArrayToInt32(bb.ToArray(0, 4));
     _CommandId      = SmppConverter.FromByteArrayToInt32(bb.ToArray(4, 4));
     _CommandStatus  = SmppConverter.FromByteArrayToInt32(bb.ToArray(8, 4));
     _SequenceNumber = SmppConverter.FromByteArrayToInt32(bb.ToArray(12, 4));
 }
Example #26
0
    /// <summary>
    /// Performs the specified SOCKS5 request.
    /// </summary>
    /// <param name="request">The SOCKS5 request to issue to the server.</param>
    /// <returns>The SOCKS5 reply sent by the server.</returns>
    /// <exception cref="ArgumentNullException">The request parameter is
    /// null.</exception>
    /// <exception cref="ObjectDisposedException">The object has been
    /// disposed.</exception>
    /// <exception cref="Socks5Exception">The request could not be performed.
    /// Consult the InnerException property of the Socks5Exception to learn
    /// the reason.</exception>
    public SocksReply Request(SocksRequest request)
    {
        AssertValid();
        try
        {
            byte[] bytes = request.Serialize();
            stream.Write(bytes, 0, bytes.Length);
            ByteBuilder b = new ByteBuilder();
            using (var r = new BinaryReader(stream, Encoding.UTF8, true))
            {
                bytes = r.ReadBytes(4);
                b.Append(bytes);
                ATyp atyp = (ATyp)bytes[3];
                switch (atyp)
                {
                case ATyp.IPv4:
                case ATyp.IPv6:
                    b.Append(r.ReadBytes(atyp == ATyp.IPv4 ? 4 : 16));
                    break;

                case ATyp.Domain:
                    byte length = r.ReadByte();
                    b.Append(length).Append(r.ReadBytes(length));
                    break;
                }
                b.Append(r.ReadBytes(2));
            }
            return(SocksReply.Deserialize(b.ToArray()));
        }
        catch (Exception e)
        {
            throw new Socks5Exception("The request could not be performed.", e);
        }
    }
        private void fb_param_set(string[] fb_parm)
        {
            ByteBuilder bb = new ByteBuilder();

            byte txLPF;
            byte fb_res1;
            byte fb_res2;


            try
            {
                txLPF   = Convert.ToByte(fb_parm[0]);
                fb_res1 = Convert.ToByte(fb_parm[1]);
                fb_res2 = Convert.ToByte(fb_parm[2]);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            bb.Append(txLPF);
            bb.Append(fb_res1);
            bb.Append(fb_res2);


            if (!RcpProtocol.Instance.SendBytePkt(RcpProtocol.Instance.BuildCmdPacketByte(RcpProtocol.RCP_MSG_CMD, RcpProtocol.RCP_CMD_SET_FB_PARAM, bb.GetByteArray())))
            {
            }
        }
 public override void WriteOffsets(ByteBuilder bb)
 {
     foreach (var r in Refs)
     {
         r.WriteOffset(bb);
     }
 }
Example #29
0
        /// <summary>
        /// 解析一个数据包
        /// 不足一个封包时返回null
        /// </summary>
        /// <param name="builder">接收到的历史数据</param>
        /// <returns></returns>
        public static FastPacket GetPacket(ByteBuilder builder)
        {
            // 包头长度
            const int headLength = 12;

            // 不会少于12
            if (builder.Length < headLength)
            {
                return(null);
            }

            // 包长
            int totalLength = builder.ToInt32(0, Endians.Big);

            // 包长要小于等于数据长度
            if (totalLength > builder.Length || totalLength < headLength)
            {
                return(null);
            }

            // cmd
            int cmd = builder.ToInt32(4, Endians.Big);
            // 哈希值
            int hashCode = builder.ToInt32(8, Endians.Big);

            // 实体数据
            byte[] body = builder.ToArray(12, totalLength - headLength);

            // 清空本条数据
            builder.Remove(totalLength);
            return(new FastPacket(cmd, hashCode, body));
        }
 public override void WriteOffsets(ByteBuilder bb)
 {
     foreach (var v in Vars)
     {
         (v as RefToElement)?.WriteOffset(bb);
     }
 }
Example #31
0
		/// <summary>
		/// Serializes the instance into an array of bytes.
		/// </summary>
		/// <returns>An array of bytes representing the instance of the
		/// ClientGreeting class.</returns>
		public byte[] Serialize() {
			ByteBuilder b = new ByteBuilder()
				.Append(version)
				.Append((byte) methods.Count);
			foreach (AuthMethod m in Methods)
				b.Append((byte) m);
			return b.ToArray();
		}
Example #32
0
        public static byte[] ComputeClientProof(Mpi safePrimeModulus, Mpi generator, string username, byte[] salt, Mpi clientPublicKey, Mpi serverPublicKey, Mpi sharedKey, string authId, string options, HashAlgorithm hashAlgorithm)
        {
            byte[] n = safePrimeModulus.ToBytes(),
                g = generator.ToBytes(),
                u = Encoding.UTF8.GetBytes(username), s = salt,
                a = clientPublicKey.ToBytes(), b = serverPublicKey.ToBytes(),
                k = sharedKey.ToBytes(), i = Encoding.UTF8.GetBytes(authId),
                l = Encoding.UTF8.GetBytes(options);
            HashAlgorithm h = hashAlgorithm;

            byte[] seq = new ByteBuilder()
                .Append(Xor(h.ComputeHash(n), h.ComputeHash(g)))
                .Append(h.ComputeHash(u))
                .Append(s)
                .Append(a)
                .Append(b)
                .Append(k)
                .Append(h.ComputeHash(i))
                .Append(h.ComputeHash(l))
                .ToArray();
            return h.ComputeHash(seq);
        }
        /// <summary>
        /// 转换为ByteRange
        /// </summary>
        /// <returns></returns>
        public override ByteRange ToByteRange()
        {
            var builder = new ByteBuilder(Endians.Big);

            builder.Add((byte)((byte)this.Frame + 128));

            if (this.Content.Length > UInt16.MaxValue)
            {
                builder.Add((byte)127);
                builder.Add((ulong)this.Content.Length);
            }
            else if (this.Content.Length > 125)
            {
                builder.Add((byte)126);
                builder.Add((ushort)this.Content.Length);
            }
            else
            {
                builder.Add((byte)this.Content.Length);
            }
            builder.Add(this.Content);
            return builder.ToByteRange();
        }
Example #34
0
        public static byte[] ComputeServerProof(Mpi clientPublicKey, byte[] clientProof, Mpi sharedKey, string authId, string options, string sid, uint ttl, HashAlgorithm hashAlgorithm)
        {
            byte[] a =
                clientPublicKey.ToBytes(),
                m1 = clientProof,
                k = sharedKey.ToBytes(),
                i = Encoding.UTF8.GetBytes(authId),
                o = Encoding.UTF8.GetBytes(options),
                sid_ = Encoding.UTF8.GetBytes(sid);
            HashAlgorithm h = hashAlgorithm;

            byte[] seq = new ByteBuilder()
                .Append(a)
                .Append(m1)
                .Append(k)
                .Append(h.ComputeHash(i))
                .Append(h.ComputeHash(o))
                .Append(sid_)
                .Append(ttl, true)
                .ToArray();
            return h.ComputeHash(seq);
        }
Example #35
0
 /// <summary>
 /// 将参数序列化并写入为Body
 /// </summary>
 /// <param name="serializer">序列化工具</param>
 /// <param name="parameters">参数</param>
 /// <exception cref="SerializerException"></exception>
 public void SetBodyParameters(ISerializer serializer, params object[] parameters)
 {
     if (parameters == null || parameters.Length == 0)
     {
         return;
     }
     var builder = new ByteBuilder(Endians.Big);
     foreach (var item in parameters)
     {
         // 序列化参数为二进制内容
         var paramBytes = serializer.Serialize(item);
         // 添加参数内容长度
         builder.Add(paramBytes == null ? 0 : paramBytes.Length);
         // 添加参数内容
         builder.Add(paramBytes);
     }
     this.Body = builder.ToArray();
 }
Example #36
0
        /// <summary>
        /// 转换为ByteRange
        /// </summary>
        /// <exception cref="ProtocolException"></exception>
        /// <returns></returns>
        public ByteRange ToByteRange()
        {
            var apiNameBytes = Encoding.UTF8.GetBytes(this.ApiName);
            var headLength = apiNameBytes.Length + 15;
            this.TotalBytes = this.Body == null ? headLength : headLength + this.Body.Length;

            const int packegMaxSize = 10 * 1204 * 1024; // 10M
            if (this.TotalBytes > packegMaxSize)
            {
                throw new ProtocolException();
            }

            this.ApiNameLength = (byte)apiNameBytes.Length;
            var builder = new ByteBuilder(Endians.Big);
            builder.Add(this.TotalBytes);
            builder.Add(this.ApiNameLength);
            builder.Add(apiNameBytes);
            builder.Add(this.Id);
            builder.Add(this.IsFromClient);
            builder.Add(this.IsException);
            builder.Add(this.Body);
            return builder.ToByteRange();
        }
        /// <summary>
        /// 输出文本内容
        /// </summary>      
        /// <param name="content">内容</param>
        public bool Write(string content)
        {
            if (content == null)
            {
                content = string.Empty;
            }
            var buffer = new ByteBuilder(Endians.Little);
            var contentBytes = this.Charset.GetBytes(content);

            if (this.wroteHeader == false)
            {
                this.wroteHeader = true;
                var headerByes = this.GetHeaderBytes(contentBytes.Length);
                buffer.Add(headerByes);
            }

            buffer.Add(contentBytes);
            return this.TrySend(buffer.ToByteRange());
        }
        /// <summary>
        /// Converts the notification information into a packet of data to be sent 
        /// to the Growl receiving application.
        /// </summary>
        /// <returns>byte array</returns>
        private byte[] PrepareData()
        {
            int flags = ConvertPriorityToFlag(this.priority);
            if (this.sticky) flags = flags | 1;

            ByteBuilder bb = new ByteBuilder();
            bb.Append((byte)this.protocolVersion);
            bb.Append((byte)this.packetType);
            bb.Append((short)flags);
            bb.Append(ByteBuilder.GetStringLengthAsShort(this.notificationType.Name));
            bb.Append(ByteBuilder.GetStringLengthAsShort(this.title));
            bb.Append(ByteBuilder.GetStringLengthAsShort(this.description));
            bb.Append(ByteBuilder.GetStringLengthAsShort(this.applicationName));
            bb.Append(this.notificationType.Name);
            bb.Append(this.title);
            bb.Append(this.description);
            bb.Append(this.applicationName);

            // handle the password
            ByteBuilder pb = new ByteBuilder();
            pb.Append(this.password);
            ByteBuilder bpb = new ByteBuilder();
            bpb.Append(bb.GetBytes());
            bpb.Append(pb.GetBytes());

            byte[] checksum = Cryptography.ComputeHash(bpb.GetBytes(), Cryptography.HashAlgorithmType.MD5);
            ByteBuilder fb = new ByteBuilder();
            fb.Append(bb.GetBytes());
            fb.Append(checksum);
            byte[] data = fb.GetBytes();

            return data;
        }
Example #39
0
		/// <summary>
		/// Performs the initial greeting.
		/// </summary>
		/// <exception cref="Socks5Exception">The client sent invalid data, or
		/// requires authentication.</exception>
		/// <exception cref="IOException">The stream could not be read, or the
		/// operation timed out.</exception>
		void PerformGreeting() {
			ByteBuilder b = new ByteBuilder();
			using (var r = new BinaryReader(stream, Encoding.UTF8, true)) {
				byte[] bytes = r.ReadBytes(2);
				b.Append(bytes);
				// The number of method-bytes following is contained in the second byte.
				b.Append(r.ReadBytes(bytes[1]));
			}
			ClientGreeting greeting = ClientGreeting.Deserialize(b.ToArray());
			// We only accept an authentication method of 'none'.
			if (!greeting.Methods.Contains(AuthMethod.None)) {
				Dispose();
				throw new Socks5Exception("Client requires authentication.");
			}
			// Send back our greeting response.
			var response = new ServerGreeting(AuthMethod.None).Serialize();
			stream.Write(response, 0, response.Length);
		}
Example #40
0
		/// <summary>
		/// Waits until the connected client sends a SOCKS5 request.
		/// </summary>
		/// <returns>The SOCKS5 request sent by the client.</returns>
		/// <exception cref="Socks5Exception">The data sent by the client
		/// is not a valid SOCKS5 request.</exception>
		SocksRequest WaitForRequest() {
			ByteBuilder b = new ByteBuilder();
			using (var r = new BinaryReader(stream, Encoding.UTF8, true)) {
				byte[] bytes = r.ReadBytes(4);
				b.Append(bytes);
				ATyp atyp = (ATyp) bytes[3];
				switch (atyp) {
					case ATyp.IPv4:
					case ATyp.IPv6:
						b.Append(r.ReadBytes(atyp == ATyp.IPv4 ? 4 : 16));
						break;
					case ATyp.Domain:
						byte length = r.ReadByte();
						b.Append(length).Append(r.ReadBytes(length));
						break;
				}
				b.Append(r.ReadBytes(2));
			}
			try {
				return SocksRequest.Deserialize(b.ToArray());
			} catch (Exception e) {
				throw new Socks5Exception("The request could not be serialized.", e);
			}
		}
Example #41
0
 private static byte[] LMv2Response(byte[] hash, byte[] clientData, byte[] challenge)
 {
     byte[] data = new ByteBuilder()
         .Append(challenge)
         .Append(clientData)
         .ToArray();
     using (var hmac = new HMACMD5(hash))
     {
         return new ByteBuilder()
             .Append(hmac.ComputeHash(data))
             .Append(clientData)
             .ToArray();
     }
 }
Example #42
0
        private static object getRealValue(IDataReader datareader, int ordinal, Type t)
        {

            if (t == typeof(Int16)) return !datareader.IsDBNull(ordinal) ? (object)datareader.GetInt16(ordinal) : null;
            
            if (t == typeof(Int32)) return !datareader.IsDBNull(ordinal) ? (object)datareader.GetInt32(ordinal) : null;
            
            if (t == typeof(Int64)) return !datareader.IsDBNull(ordinal) ? (object)datareader.GetInt32(ordinal) : null;
            
            if (t == typeof(Byte[]))
            {
                if (datareader.IsDBNull(ordinal)) return null;
                int bufferSize = 1024;
                int startIndex = 0;
                byte[] outbyte = new byte[bufferSize];
                ByteBuilder bb = new ByteBuilder();
                long retval = datareader.GetBytes(ordinal, startIndex, outbyte, 0, bufferSize);
                while (retval == bufferSize)
                {
                    bb.Append(outbyte);
                    startIndex += bufferSize;
                    retval = datareader.GetBytes(ordinal, startIndex, outbyte, 0, bufferSize);
                }
                if (retval > 0)
                    bb.Append(outbyte);
                return bb.GetBytes();
            }
            
            if (t == typeof(String)) return !datareader.IsDBNull(ordinal) ? datareader.GetString(ordinal) : null;
            
            if (t == typeof(DateTime)) return !datareader.IsDBNull(ordinal) ? (object)datareader.GetDateTime(ordinal) : null;
            
            if (t == typeof(Boolean)) return !datareader.IsDBNull(ordinal) ? (object)datareader.GetBoolean(ordinal) : null;

            if (t == typeof(Double)) return !datareader.IsDBNull(ordinal) ? (object)datareader.GetDouble(ordinal) : null;

            if (t == typeof(Single)) return !datareader.IsDBNull(ordinal) ? (object)datareader.GetFloat(ordinal) : null;

            if (t == typeof(Guid)) return !datareader.IsDBNull(ordinal) ? (object)datareader.GetGuid(ordinal) : null;

            if (t == typeof(Decimal)) return !datareader.IsDBNull(ordinal) ? (object)datareader.GetDecimal(ordinal) : null;

            if (t == typeof(Byte)) return !datareader.IsDBNull(ordinal) ? (object)datareader.GetByte(ordinal) : null;

            return null;
        }
Example #43
0
		/// <summary>
		/// Performs the specified SOCKS5 request.
		/// </summary>
		/// <param name="request">The SOCKS5 request to issue to the server.</param>
		/// <returns>The SOCKS5 reply sent by the server.</returns>
		/// <exception cref="ArgumentNullException">The request parameter is
		/// null.</exception>
		/// <exception cref="ObjectDisposedException">The object has been
		/// disposed.</exception>
		/// <exception cref="Socks5Exception">The request could not be performed.
		/// Consult the InnerException property of the Socks5Exception to learn
		/// the reason.</exception>
		public SocksReply Request(SocksRequest request) {
			request.ThrowIfNull("request");
			AssertValid();
			try {
				byte[] bytes = request.Serialize();
				stream.Write(bytes, 0, bytes.Length);
				ByteBuilder b = new ByteBuilder();
				using (var r = new BinaryReader(stream, Encoding.UTF8, true)) {
					bytes = r.ReadBytes(4);
					b.Append(bytes);
					ATyp atyp = (ATyp) bytes[3];
					switch (atyp) {
						case ATyp.IPv4:
						case ATyp.IPv6:
							b.Append(r.ReadBytes(atyp == ATyp.IPv4 ? 4 : 16));
							break;
						case ATyp.Domain:
							byte length = r.ReadByte();
							b.Append(length).Append(r.ReadBytes(length));
							break;
					}
					b.Append(r.ReadBytes(2));
				}
				return SocksReply.Deserialize(b.ToArray());
			} catch (Exception e) {
				throw new Socks5Exception("The request could not be performed.", e);
			}
		}
Example #44
0
		/// <summary>
		/// Computes the client evidence from the given parameters.
		/// </summary>
		/// <param name="safePrimeModulus">The safe prime modulus sent by the
		/// server.</param>
		/// <param name="generator">The generator sent by the server.</param>
		/// <param name="username">The username to authenticate with.</param>
		/// <param name="salt">The client's password salt.</param>
		/// <param name="clientPublicKey">The client's ephemeral public key.</param>
		/// <param name="serverPublicKey">The server's ephemeral public key.</param>
		/// <param name="sharedKey">The shared context key.</param>
		/// <param name="authId">The authorization identity.</param>
		/// <param name="options">The raw options string as received from the
		/// server.</param>
		/// <param name="hashAlgorithm">The message digest algorithm to use for
		/// calculating the client proof.</param>
		/// <returns>The client proof as an array of bytes.</returns>
		public static byte[] ComputeClientProof(Mpi safePrimeModulus, Mpi generator,
			string username, byte[] salt, Mpi clientPublicKey, Mpi serverPublicKey,
			Mpi sharedKey, string authId, string options, HashAlgorithm hashAlgorithm) {
			byte[] N = safePrimeModulus.ToBytes(), g = generator.ToBytes(),
				U = Encoding.UTF8.GetBytes(username), s = salt,
				A = clientPublicKey.ToBytes(), B = serverPublicKey.ToBytes(),
				K = sharedKey.ToBytes(), I = Encoding.UTF8.GetBytes(authId),
				L = Encoding.UTF8.GetBytes(options);
			HashAlgorithm H = hashAlgorithm;
			// The proof is calculated as follows:
			//
			// H( bytes(H( bytes(N) )) ^ bytes( H( bytes(g) ))
			//  | bytes(H( bytes(U) ))
			//  | bytes(s)
			//  | bytes(A)
			//  | bytes(B)
			//  | bytes(K)
			//  | bytes(H( bytes(I) ))
			//  | bytes(H( bytes(L) ))
			// )
			byte[] seq = new ByteBuilder()
				.Append(Xor(H.ComputeHash(N), H.ComputeHash(g)))
				.Append(H.ComputeHash(U))
				.Append(s)
				.Append(A)
				.Append(B)
				.Append(K)
				.Append(H.ComputeHash(I))
				.Append(H.ComputeHash(L))
				.ToArray();
			return H.ComputeHash(seq);
		}
        /// <summary>
        /// Checks to see if a given packets data matches a password
        /// provided by the receiving client and returns the matching password if found.
        /// </summary>
        /// <param name="bytes">The packets data</param>
        /// <param name="passwordManager">The receiving client's list of passwords</param>
        /// <param name="passwordRequired">Indicates if the request must supply a valid password</param>
        /// <param name="password">Returns the matching password if found; null otherwise</param>
        /// <returns><c>true</c> if the password matches, <c>false</c> otherwise</returns>
        protected static bool IsPasswordValid(byte[] bytes, PasswordManager passwordManager, bool passwordRequired, out string password)
        {
            password = null;

            byte[] packetWithoutPassword = new byte[bytes.Length - 16];
            Array.Copy(bytes, 0, packetWithoutPassword, 0, packetWithoutPassword.Length);
            byte[] thatChecksum = new byte[16];
            Array.Copy(bytes, bytes.Length - 16, thatChecksum, 0, 16);
            string thatChecksumString = Encoding.UTF8.GetString(thatChecksum);

            ByteBuilder bpb = new ByteBuilder();
            bpb.Append(packetWithoutPassword);

            Queue<string> validPasswords = new Queue<string>();
            foreach (KeyValuePair<string, Password> item in passwordManager.Passwords)
            {
                validPasswords.Enqueue(item.Key);
            }
            // if the request does not require a password, then
            // we can also try no (blank) password
            if (!passwordRequired) validPasswords.Enqueue(String.Empty);

            while(validPasswords.Count > 0)
            {
                string p = validPasswords.Dequeue();
                ByteBuilder pb = new ByteBuilder();
                pb.Append(bpb.GetBytes());
                pb.Append(p);
                byte[] thisChecksum = Cryptography.ComputeHash(pb.GetBytes(), Cryptography.HashAlgorithmType.MD5);
                string thisChecksumString = Encoding.UTF8.GetString(thisChecksum);

                if (thisChecksumString == thatChecksumString)
                {
                    password = p;
                    return true;
                }
            }

            return false;
        }
Example #46
0
		/// <summary>
		/// Calculates the shared context key K from the given parameters.
		/// </summary>
		/// <param name="salt">The user's password salt.</param>
		/// <param name="username">The username to authenticate with.</param>
		/// <param name="password">The password to authenticate with.</param>
		/// <param name="clientPublicKey">The client's ephemeral public key.</param>
		/// <param name="serverPublicKey">The server's ephemeral public key.</param>
		/// <param name="clientPrivateKey">The client's private key.</param>
		/// <param name="generator">The generator sent by the server.</param>
		/// <param name="safePrimeModulus">The safe prime modulus sent by the
		/// server.</param>
		/// <param name="hashAlgorithm">The negotiated hash algorithm to use
		/// for the calculations.</param>
		/// <returns>The shared context key K as a "multi-precision
		/// integer".</returns>
		/// <remarks>
		/// A = Client Public Key
		/// B = Server Public Key
		/// N = Safe Prime Modulus
		/// U = Username
		/// p = Password
		/// s = User's Password Salt
		/// a = Client Private Key
		/// g = Generator
		/// K = Shared Public Key
		/// </remarks>
		public static Mpi ComputeSharedKey(byte[] salt, string username,
			string password, Mpi clientPublicKey, Mpi serverPublicKey,
			Mpi clientPrivateKey, Mpi generator, Mpi safePrimeModulus,
			HashAlgorithm hashAlgorithm) {
			// u = H(A | B)
			byte[] u = hashAlgorithm.ComputeHash(new ByteBuilder()
				.Append(clientPublicKey.ToBytes())
				.Append(serverPublicKey.ToBytes())
				.ToArray());
			// x = H(s | H(U | ":" | p))
			byte[] up = hashAlgorithm.ComputeHash(
				Encoding.UTF8.GetBytes(username + ":" + password)),
				sup = new ByteBuilder().Append(salt).Append(up).ToArray(),
				x = hashAlgorithm.ComputeHash(sup);
			// S = ((B - (3 * g ^ x)) ^ (a + u * x)) % N
			Mpi _u = new Mpi(u), _x = new Mpi(x);
			ts.TraceInformation("ComputeSharedKey: _u = " + _u.Value.ToString("X"));
			ts.TraceInformation("ComputeSharedKey: _x = " + _x.Value.ToString("X"));
			// base = B - (3 * (g ^ x))
			
			BigInteger _base = BigInteger.Subtract(serverPublicKey.Value,
				BigInteger.Multiply(new BigInteger(3),
				BigInteger.ModPow(generator.Value, _x.Value, safePrimeModulus.Value)) %
				safePrimeModulus.Value);
			if (_base.Sign < 0)
				_base = BigInteger.Add(_base, safePrimeModulus.Value);
			ts.TraceInformation("ComputeSharedKey: _base = " + _base.ToString("X"));

			// Alternative way to calculate base; This is not being used in actual calculations
			// but still here to ease debugging.
			BigInteger gx = BigInteger.ModPow(generator.Value, _x.Value, safePrimeModulus.Value),
				gx3 = BigInteger.Multiply(new BigInteger(3), gx) % safePrimeModulus.Value;
			ts.TraceInformation("ComputeSharedKey: gx = " + gx.ToString("X"));
			BigInteger @base = BigInteger.Subtract(serverPublicKey.Value, gx3) % safePrimeModulus.Value;
			if (@base.Sign < 0)
				@base = BigInteger.Add(@base, safePrimeModulus.Value);
			ts.TraceInformation("ComputeSharedKey: @base = " + @base.ToString("X"));

			// exp = a + u * x
			BigInteger exp = BigInteger.Add(clientPrivateKey.Value,
				BigInteger.Multiply(_u.Value, _x.Value)),
			S = BigInteger.ModPow(_base, exp, safePrimeModulus.Value);
			ts.TraceInformation("ComputeSharedKey: exp = " + exp.ToString("X"));
			ts.TraceInformation("ComputeSharedKey: S = " + S.ToString("X"));

			// K = H(S)
			return new Mpi(hashAlgorithm.ComputeHash(new Mpi(S).ToBytes()));
		}
Example #47
0
        public static Mpi ComputeSharedKey(byte[] salt, string username, string password, Mpi clientPublicKey, Mpi serverPublicKey, Mpi clientPrivateKey, Mpi generator, Mpi safePrimeModulus, HashAlgorithm hashAlgorithm)
        {
            byte[] u = hashAlgorithm.ComputeHash(new ByteBuilder()
                .Append(clientPublicKey.ToBytes())
                .Append(serverPublicKey.ToBytes())
                .ToArray());

            byte[] up = hashAlgorithm.ComputeHash(Encoding.UTF8.GetBytes(username + ":" + password)), sup = new ByteBuilder().Append(salt).Append(up).ToArray(), x = hashAlgorithm.ComputeHash(sup);

            Mpi u_ = new Mpi(u), x_ = new Mpi(x);
            ts.TraceInformation("ComputeSharedKey: _u = " + u_.Value.ToString("X"));
            ts.TraceInformation("ComputeSharedKey: _x = " + x_.Value.ToString("X"));
            BigInteger base_ = BigInteger.Subtract(serverPublicKey.Value, BigInteger.Multiply(new BigInteger(3), BigInteger.ModPow(generator.Value, x_.Value, safePrimeModulus.Value)) % safePrimeModulus.Value);
            if (base_.Sign < 0)
            {
                base_ = BigInteger.Add(base_, safePrimeModulus.Value);
            }

            ts.TraceInformation("ComputeSharedKey: _base = " + base_.ToString("X"));

            BigInteger gx = BigInteger.ModPow(generator.Value, x_.Value, safePrimeModulus.Value), gx3 = BigInteger.Multiply(new BigInteger(3), gx) % safePrimeModulus.Value;
            ts.TraceInformation("ComputeSharedKey: gx = " + gx.ToString("X"));
            BigInteger @base = BigInteger.Subtract(serverPublicKey.Value, gx3) % safePrimeModulus.Value;
            if (@base.Sign < 0)
            {
                @base = BigInteger.Add(@base, safePrimeModulus.Value);
            }

            ts.TraceInformation("ComputeSharedKey: @base = " + @base.ToString("X"));

            BigInteger exp = BigInteger.Add(clientPrivateKey.Value, BigInteger.Multiply(u_.Value, x_.Value)),
            s = BigInteger.ModPow(base_, exp, safePrimeModulus.Value);
            ts.TraceInformation("ComputeSharedKey: exp = " + exp.ToString("X"));
            ts.TraceInformation("ComputeSharedKey: S = " + s.ToString("X"));

            return new Mpi(hashAlgorithm.ComputeHash(new Mpi(s).ToBytes()));
        }
Example #48
0
		/// <summary>
		/// Computes the server evidence from the given parameters.
		/// </summary>
		/// <param name="clientPublicKey">The client's ephemeral public key.</param>
		/// <param name="clientProof"></param>
		/// <param name="sharedKey">The shared context key.</param>
		/// <param name="authId">The authorization identity.</param>
		/// <param name="options">The raw options string as sent by the
		/// client.</param>
		/// <param name="sid">The session id sent by the server.</param>
		/// <param name="ttl">The time-to-live value for the session id sent
		/// by the server.</param>
		/// <param name="hashAlgorithm">The message digest algorithm to use for
		/// calculating the server proof.</param>
		/// <returns>The server proof as an array of bytes.</returns>
		public static byte[] ComputeServerProof(Mpi clientPublicKey, byte[] clientProof,
			Mpi sharedKey, string authId, string options, string sid, uint ttl,
			HashAlgorithm hashAlgorithm) {
			byte[] A = clientPublicKey.ToBytes(), M1 = clientProof,
				K = sharedKey.ToBytes(), I = Encoding.UTF8.GetBytes(authId),
				o = Encoding.UTF8.GetBytes(options), _sid = Encoding.UTF8.GetBytes(sid);
			HashAlgorithm H = hashAlgorithm;
			// The proof is calculated as follows:
			//
			// H( bytes(A)
			//  | bytes(M1)
			//  | bytes(K)
			//  | bytes(H( bytes(I) ))
			//  | bytes(H( bytes(o) ))
			//  | bytes(sid)
			//  | ttl
			// )
			byte[] seq = new ByteBuilder()
				.Append(A)
				.Append(M1)
				.Append(K)
				.Append(H.ComputeHash(I))
				.Append(H.ComputeHash(o))
				.Append(_sid)
				.Append(ttl, true)
				.ToArray();
			return H.ComputeHash(seq);
		}
        /// <summary>
        /// Converts the notification information into a packet of data to be sent 
        /// to the Growl receiving application.
        /// </summary>
        /// <returns>byte array</returns>
        private byte[] PrepareData()
        {
            ByteBuilder nb = new ByteBuilder();
            ByteBuilder db = new ByteBuilder();
            int index = 0;
            int notificationTypeCount = 0;
            int notificationTypeEnabledCount = 0;
            foreach (NotificationType notificationType in this.notificationTypes)
            {
                nb.Append(notificationType.Name.Length);
                nb.Append(notificationType.Name);

                notificationTypeCount++;
                if (notificationType.Enabled)
                {
                    notificationTypeEnabledCount++;
                    db.Append((byte)index);
                }
                index++;
            }

            ByteBuilder bb = new ByteBuilder();
            bb.Append((byte)this.protocolVersion);
            bb.Append((byte)this.packetType);
            bb.Append(ByteBuilder.GetStringLengthAsShort(this.applicationName));
            bb.Append((byte)notificationTypeCount);
            bb.Append((byte)notificationTypeEnabledCount);
            bb.Append(this.applicationName);
            bb.Append(nb.GetBytes());
            bb.Append(db.GetBytes());

            // handle the password
            ByteBuilder pb = new ByteBuilder();
            pb.Append(this.password);
            ByteBuilder bpb = new ByteBuilder();
            bpb.Append(bb.GetBytes());
            bpb.Append(pb.GetBytes());

            byte[] checksum = Cryptography.ComputeHash(bpb.GetBytes(), Cryptography.HashAlgorithmType.MD5);
            ByteBuilder fb = new ByteBuilder();
            fb.Append(bb.GetBytes());
            fb.Append(checksum);
            byte[] data = fb.GetBytes();

            return data;
        }