public SMSInitialMessage(IMORZEAccount account, IMORZEContact contact)
        {
            BufferBuilder bb = new BufferBuilder();

            m_account = account;
            bb.AddByte(1);//- init message
            m_newExt = contact.getInitalData();
            bb.AddByte((byte)m_newExt.HashID);
            bb.AddBytes(m_newExt.Ext);

            bb.AddByte((byte)m_newExt.SyncID);
            bb.AddBytes(m_newExt.SyncKey);
            bb.AddBytes(m_newExt.SyncIV);
            bb.AddUshort(0);//или CRC16
            byte [] data = bb.GetAllBytes();
            data = contact.EncryptPK(data);
            byte[] addressdata = m_newExt.SyncEncrypt(account.GetMyAccount());
            bb = new BufferBuilder();

            bb.AddByte(contact.XOR((byte)data.Length, 0x10));
            bb.AddBytes(data);

            bb.AddBytes(addressdata);
            AddMessageBody(bb.GetAllBytes(), m_newExt.HashID, null);
        }
 public dlgMessage(IMORZEContact cnt, IMORZEAccount acc, SMSNet net)
 {
     m_cnt = cnt;
     m_acc = acc;
     m_net = net;
     m_lastLoadedMessage = null;
     InitializeComponent();
 }
Beispiel #3
0
 public dlgAccount(IMORZEAccount acc) : base()
 {
     Text = acc.ToString();
     btnRefresh.Enabled = false;
     tbName.ReadOnly    = true;
     tbAddress.ReadOnly = true;
     tbName.Text        = acc.ToString();
     tbAddress.Text     = acc.GetMyAccount();
 }
Beispiel #4
0
 public SMSNet(IMORZEAccount account)
 {
     m_stop = false;
     //m_rspHello = null;
     m_rnd          = new Random();
     m_netStream    = null;
     m_morze        = null;
     m_helloSign    = new byte[4];
     m_sendAsyngCmd = null;
     m_rnd.NextBytes(m_helloSign);
     //        m_InitalMessages = null;
     m_account = account;
 }
        public MORZERecvMessages(IMORZEAccount acc, byte[] data) : base(data)
        {
            int off = 0;

            byte[] msg;

            byte[] hash;
            byte[] ext;

            m_responses = null;
            byte[] addascii = Encoding.ASCII.GetBytes(acc.GetMyAccount());

            m_acc = acc;
            bool    err     = false;
            SMSHash mrzhash = SMSHash.None;

            while (off < data.Length && err == false)
            {
                msg  = null;
                hash = null;
                ext  = null;

                off++;             //ttl
                ushort msglen = 0;
                switch (data[off]) //hash
                {
                case 0x01:         //md5
                    hash    = new byte[0x10];
                    mrzhash = SMSHash.MD5;
                    break;

                case 0x81:
                    hash    = new byte[0x10];
                    mrzhash = SMSHash.MD5;
                    ext     = new byte[0x10];
                    break;

                default:
                    err = true;
                    break;
                }
                if (err == false)
                {
                    off++;
                    Array.Copy(data, off, hash, 0, hash.Length);
                    off += hash.Length;
                    if (ext != null)
                    {
                        Array.Copy(data, off, ext, 0, ext.Length);
                        off += ext.Length;
                    }
                    msglen = BitConverter.ToUInt16(data, off);
                    off   += 2;
                    if (msglen + off <= data.Length)
                    {
                        msg = new byte[msglen];
                        Array.Copy(data, off, msg, 0, msg.Length);
                        off += msg.Length;
                    }
                    else
                    {
                        err = true;
                    }
                }
                if (err == false)
                {
                    bool add = false;
                    if (checkHash(mrzhash, hash, msg) == true)
                    {
                        if (ext == null)
                        {//данные зашифрованные открытым ключем
                            byte   asynclen = 0;
                            byte[] smsg     = null;
                            byte[] async    = null;
                            asynclen = (byte)((int)addascii[0x10] ^ (int)msg[0]);
                            if (asynclen > 0)
                            {
                                async = new byte[asynclen];
                                Array.Copy(msg, 1, async, 0, async.Length);
                                if ((int)asynclen < msg.Length)
                                {
                                    smsg = new byte[msg.Length - (1 + asynclen)];
                                    Array.Copy(msg, 1 + asynclen, smsg, 0, smsg.Length);
                                }
                                else
                                {
                                    if (msg.Length < asynclen)
                                    {
                                        err = true;
                                    }
                                }
                                if (err == false)
                                {
                                    byte[] dec;
                                    byte[] tail       = null;
                                    int    taillength = msg.Length - asynclen - 1;
                                    if (taillength < 0)
                                    {
                                        err = true;
                                    }
                                    else
                                    {
                                        tail = new byte[taillength];
                                        Array.Copy(msg, async.Length + 1, tail, 0, taillength);
                                        if (acc.decodeAsync(async, out dec) == true)
                                        {
                                            err = !operateAsync(dec, tail);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                err = true;
                            }
                        }
                        else
                        {
                            add = true;
                        }

                        if (add == true)
                        {
                            if (m_msgData == null)
                            {
                                m_msgData = new List <byte[]>();
                            }
                            if (m_msgHash == null)
                            {
                                m_msgHash = new List <byte[]>();
                            }
                            if (m_msgExt == null)
                            {
                                m_msgExt = new List <byte[]>();
                            }
                            m_msgData.Add(msg);
                            m_msgHash.Add(hash);
                            m_msgExt.Add(ext);

                            IMORZEContact mc = m_acc.GetAddressBook().GetContact(ext);

                            if (mc != null)
                            {
                                if (mc.PutReciveMessage(msg, hash, mrzhash, ext) == true)
                                {
                                    MORZEContact cc = mc as MORZEContact;
                                    if (cc != null)
                                    {
                                        List <byte[]> r = cc.Responses;
                                        if (r != null)
                                        {
                                            foreach (byte[] i in r)
                                            {
                                                MORZESendMessage cmdMsgTyp2 = new MORZESendMessage();
                                                cmdMsgTyp2.AddMessageBody(i, mrzhash, ext);
                                                if (m_responses == null)
                                                {
                                                    m_responses = new List <SMSSendCommand>();
                                                }
                                                m_responses.Add(cmdMsgTyp2);
                                            }
                                            cc.Responses.Clear();
                                        }
                                    }
                                }
                            }
                        }
                    } //if (checkHash(mrzhash, hash, msg) == true)
                }
            }         //while (off<data.Length && err==false)
            if (err == true || off != data.Length)
            {
                m_msgData = null;
                m_msgHash = null;
                m_msgExt  = null;
            }
        }
 public MORZERecvCommand(IMORZEAccount account, NetworkStream netstream)
 {
     m_account   = account;
     m_header    = new byte[4];
     m_netStream = netstream;
 }