コード例 #1
0
        public static TLString EncryptMessage(TLObject decryptedMessage, TLEncryptedChatCommon chat)
        {
            var random = new Random();

            var key            = chat.Key.Data;
            var keyHash        = Utils.ComputeSHA1(key);
            var keyFingerprint = new TLLong(BitConverter.ToInt64(keyHash, 12));
            var decryptedBytes = decryptedMessage.ToBytes();
            var bytes          = Combine(BitConverter.GetBytes(decryptedBytes.Length), decryptedBytes);
            var sha1Hash       = Utils.ComputeSHA1(bytes);
            var msgKey         = sha1Hash.SubArray(sha1Hash.Length - 16, 16);

            var padding      = (bytes.Length % 16 == 0) ? 0 : (16 - (bytes.Length % 16));
            var paddingBytes = new byte[padding];

            random.NextBytes(paddingBytes);
            var bytesWithPadding = Combine(bytes, paddingBytes);

            var x      = 0;
            var sha1_a = Utils.ComputeSHA1(Combine(msgKey, key.SubArray(x, 32)));
            var sha1_b = Utils.ComputeSHA1(Combine(key.SubArray(32 + x, 16), msgKey, key.SubArray(48 + x, 16)));
            var sha1_c = Utils.ComputeSHA1(Combine(key.SubArray(64 + x, 32), msgKey));
            var sha1_d = Utils.ComputeSHA1(Combine(msgKey, key.SubArray(96 + x, 32)));

            var aesKey = Combine(sha1_a.SubArray(0, 8), sha1_b.SubArray(8, 12), sha1_c.SubArray(4, 12));
            var aesIV  = Combine(sha1_a.SubArray(8, 12), sha1_b.SubArray(0, 8), sha1_c.SubArray(16, 4), sha1_d.SubArray(0, 8));

            var encryptedBytes = Utils.AesIge(bytesWithPadding, aesKey, aesIV, true);

            var resultBytes = Combine(keyFingerprint.ToBytes(), msgKey, encryptedBytes);

            return(TLString.FromBigEndianData(resultBytes));
        }
コード例 #2
0
 public static void ToStream(Stream input, TLObject obj, TLLong customFlags, int flag)
 {
     if (IsSet(customFlags, flag))
     {
         obj.ToStream(input);
     }
 }
コード例 #3
0
 public static void ToStream(Stream input, TLObject obj, TLInt flags, int flag)
 {
     if (IsSet(flags, flag))
     {
         obj.ToStream(input);
     }
 }
コード例 #4
0
        public override TLObject FromBytes(byte[] bytes, ref int position)
        {
            MessageId         = GetObject <TLLong>(bytes, ref position);
            SeqNo             = GetObject <TLInt>(bytes, ref position);
            MessageDataLength = GetObject <TLInt>(bytes, ref position);
            MessageData       = GetObject <TLObject>(bytes, ref position);

            return(this);
        }
コード例 #5
0
        public override TLObject FromBytes(byte[] bytes, ref int position)
        {
            MessageId         = GetObject <TLLong>(bytes, ref position);
            SeqNo             = GetObject <TLInt>(bytes, ref position);
            MessageDataLength = GetObject <TLInt>(bytes, ref position);
            MessageData       = GetObject <TLObject>(bytes, ref position);

            Debug.WriteLine("  <<{0, -28} MsgId {1} SeqNo {2, 4}", "containerMessage", MessageId, SeqNo);

            return(this);
        }
コード例 #6
0
        public override void Read(TLBinaryReader from)
        {
            AuthKeyId = from.ReadInt64();
            MsgId     = from.ReadInt64();

            var length    = from.ReadInt32();
            var innerType = (TLType)from.ReadInt32();

            Query = TLFactory.Read <TLObject>(from, innerType);
            //Query = TLFactory.Read<TLObject>(from, (TLType)from.ReadInt32());
        }
コード例 #7
0
        public static void ToStream(Stream output, TLObject obj, TLLong customFlags, int flag)
        {
            if (IsSet(customFlags, flag))
            {
                if (obj == null)
                {
                }

                obj.ToStream(output);
            }
        }
コード例 #8
0
ファイル: TLBinaryWriter.cs プロジェクト: Fart03/lau
 public void WriteObject(TLObject obj)
 {
     if (obj != null)
     {
         obj.Write(this);
     }
     else
     {
         // TLNull
         Write(0x56730BCC);
     }
 }
コード例 #9
0
ファイル: TLResponse.cs プロジェクト: TelegramOrg/Telegram-wp
        public static TLResponse Parse(byte[] bytes, byte[] authKey)
        {
            TLUtils.WriteLine("-------------------");
            TLUtils.WriteLine("--Parse response --");
            TLUtils.WriteLine("-------------------");


            int position = 0;
            var response = new TLResponse();

            response.AuthKeyId = bytes.SubArray(0, 8);
            TLUtils.WriteLine("AuthKeyId: " + BitConverter.ToString(response.AuthKeyId));
            response.MessageKey = bytes.SubArray(8, 16);
            TLUtils.WriteLine("MessageKey: " + BitConverter.ToString(response.MessageKey));

            response.EncryptedData = bytes.SubArray(24, bytes.Length - 24);
            //TLUtils.WriteLine("Encrypted data: " + BitConverter.ToString(response.Data));

            var keyIV = Utils.GetDecryptKeyIV(authKey, response.MessageKey);

            response.DecryptedData = Utils.AesIge(response.EncryptedData, keyIV.Item1, keyIV.Item2, false);
            //TLUtils.WriteLine("Decrypted data: " + BitConverter.ToString(response.DecryptedData));

            response.Salt = response.DecryptedData.SubArray(0, 8);
            TLUtils.WriteLine("Salt: " + BitConverter.ToString(response.Salt));

            response.SessionId = response.DecryptedData.SubArray(8, 8);
            TLUtils.WriteLine("SessionId: " + BitConverter.ToString(response.SessionId));

            position           = 0;
            response.MessageId = TLObject.GetObject <TLLong>(response.DecryptedData.SubArray(16, 8), ref position);
            TLUtils.WriteLine("<-MESSAGEID: " + TLUtils.MessageIdString(response.MessageId));

            position = 0;
            response.SequenceNumber = TLObject.GetObject <TLInt>(response.DecryptedData.SubArray(24, 4), ref position);
            TLUtils.WriteLine("  SEQUENCENUMBER: " + response.SequenceNumber);

            response.MessageLength = BitConverter.ToInt32(response.DecryptedData.SubArray(28, 4), 0);
            TLUtils.WriteLine("MessageLength: " + response.MessageLength);

            response.MessageData = response.DecryptedData.SubArray(32, response.MessageLength);
            TLUtils.WriteLine("MessageData: " + BitConverter.ToString(response.MessageData));

            position      = 0;
            response.Data = TLObject.GetObject <TLObject>(response.MessageData, ref position);

            return(response);
        }
コード例 #10
0
 public static T OpenObjectFromMTProtoFile <T>(object syncRoot, string fileName)
     where T : TLObject
 {
     try
     {
         lock (syncRoot)
         {
             using (var fileStream = FileUtils.GetLocalFileStreamForRead(fileName))
             {
                 if (fileStream.Length > 0)
                 {
                     return(TLObject.GetObject <T>(fileStream));
                 }
             }
         }
     }
     catch (Exception e)
     {
         WriteLine("MTPROTO FILE ERROR: cannot read " + typeof(T) + " from file " + fileName, LogSeverity.Error);
         WriteException(e);
     }
     return(default(T));
 }
コード例 #11
0
ファイル: TLActionInfo.cs プロジェクト: nazzi88ua/Unigram
 public override void Read(TLBinaryReader from)
 {
     SendBefore = from.ReadInt32();
     Action     = TLFactory.Read <TLObject>(from);
 }
コード例 #12
0
ファイル: TLUtils.cs プロジェクト: mykolasglinskis/Unigram
        public static bool IsValidAction(TLObject obj)
        {
            var readHistoryAction = obj as TLMessagesReadHistory;

            if (readHistoryAction != null)
            {
                return(true);
            }

            var sendMessageAction = obj as TLMessagesSendMessage;

            if (sendMessageAction != null)
            {
                return(true);
            }

            var sendMediaAction = obj as TLMessagesSendMedia;

            if (sendMediaAction != null)
            {
                var mediaContact = sendMediaAction.Media as TLInputMediaContact;
                if (mediaContact != null)
                {
                    return(true);
                }

                var mediaGeoPoint = sendMediaAction.Media as TLInputMediaGeoPoint;
                if (mediaGeoPoint != null)
                {
                    return(true);
                }

                var mediaVenue = sendMediaAction.Media as TLInputMediaVenue;
                if (mediaVenue != null)
                {
                    return(true);
                }
            }

            var forwardMessagesAction = obj as TLMessagesForwardMessages;

            if (forwardMessagesAction != null)
            {
                return(true);
            }

            var forwardMessageAction = obj as TLMessagesForwardMessage;

            if (forwardMessageAction != null)
            {
                return(true);
            }

            var startBotAction = obj as TLMessagesStartBot;

            if (startBotAction != null)
            {
                return(true);
            }

            var sendEncryptedAction = obj as TLMessagesSendEncrypted;

            if (sendEncryptedAction != null)
            {
                return(true);
            }

            var sendEncryptedFileAction = obj as TLMessagesSendEncryptedFile;

            if (sendEncryptedFileAction != null)
            {
                return(true);
            }

            var sendEncryptedServiceAction = obj as TLMessagesSendEncryptedService;

            if (sendEncryptedServiceAction != null)
            {
                return(true);
            }

            var readEncryptedHistoryAction = obj as TLMessagesReadEncryptedHistory;

            if (readEncryptedHistoryAction != null)
            {
                return(true);
            }

            return(false);
        }
コード例 #13
0
        public static TLDecryptedMessageBase DecryptMessage(TLString data, TLEncryptedChat chat, out bool commitChat)
        {
            commitChat = false;

            var bytes = data.Data;

            var keyFingerprint           = BitConverter.ToInt64(bytes, 0);
            var msgKey                   = bytes.SubArray(8, 16);
            var key                      = chat.Key.Data;
            var keyHash                  = Utils.ComputeSHA1(key);
            var calculatedKeyFingerprint = BitConverter.ToInt64(keyHash, keyHash.Length - 8);

            if (keyFingerprint != calculatedKeyFingerprint)
            {
                var chat20 = chat as TLEncryptedChat20;
                if (chat20 != null && chat20.PFS_Key != null)
                {
                    var pfsKeyHash        = Utils.ComputeSHA1(chat20.PFS_Key.Data);
                    var pfsKeyFingerprint = BitConverter.ToInt64(pfsKeyHash, pfsKeyHash.Length - 8);
                    if (pfsKeyFingerprint == keyFingerprint)
                    {
                        chat20.Key                = chat20.PFS_Key;
                        chat20.PFS_Key            = null;
                        chat20.PFS_KeyFingerprint = null;
                        chat20.PFS_A              = null;
                        chat20.PFS_ExchangeId     = null;
                        commitChat                = true;
                    }
                    else
                    {
                        return(null);
                    }
                }
                else
                {
                    return(null);
                }
            }

            var x      = 0;
            var sha1_a = Utils.ComputeSHA1(Combine(msgKey, key.SubArray(x, 32)));
            var sha1_b = Utils.ComputeSHA1(Combine(key.SubArray(32 + x, 16), msgKey, key.SubArray(48 + x, 16)));
            var sha1_c = Utils.ComputeSHA1(Combine(key.SubArray(64 + x, 32), msgKey));
            var sha1_d = Utils.ComputeSHA1(Combine(msgKey, key.SubArray(96 + x, 32)));

            var aesKey = Combine(sha1_a.SubArray(0, 8), sha1_b.SubArray(8, 12), sha1_c.SubArray(4, 12));
            var aesIV  = Combine(sha1_a.SubArray(8, 12), sha1_b.SubArray(0, 8), sha1_c.SubArray(16, 4), sha1_d.SubArray(0, 8));

            var encryptedBytes = bytes.SubArray(24, bytes.Length - 24);
            var decryptedBytes = Utils.AesIge(encryptedBytes, aesKey, aesIV, false);

            var length = BitConverter.ToInt32(decryptedBytes, 0);

            if (length <= 0 || (4 + length) > decryptedBytes.Length)
            {
                return(null);
            }

            var calculatedMsgKey = Utils.ComputeSHA1(decryptedBytes.SubArray(0, 4 + length));

            for (var i = 0; i < 16; i++)
            {
                if (msgKey[i] != calculatedMsgKey[i + 4])
                {
                    return(null);
                }
            }

            var position                            = 4;
            var decryptedObject                     = TLObject.GetObject <TLObject>(decryptedBytes, ref position);
            var decryptedMessageLayer               = decryptedObject as TLDecryptedMessageLayer;
            var decryptedMessageLayer17             = decryptedObject as TLDecryptedMessageLayer17;
            TLDecryptedMessageBase decryptedMessage = null;

            if (decryptedMessageLayer17 != null)
            {
                decryptedMessage = decryptedMessageLayer17.Message;
                var decryptedMessage17 = decryptedMessage as ISeqNo;
                if (decryptedMessage17 != null)
                {
                    decryptedMessage17.InSeqNo  = decryptedMessageLayer17.InSeqNo;
                    decryptedMessage17.OutSeqNo = decryptedMessageLayer17.OutSeqNo;
                }
            }
            else if (decryptedMessageLayer != null)
            {
                decryptedMessage = decryptedMessageLayer.Message;
            }
            else if (decryptedObject is TLDecryptedMessageBase)
            {
                decryptedMessage = (TLDecryptedMessageBase)decryptedObject;
            }

            return(decryptedMessage);
        }
コード例 #14
0
 public static byte[] ToBytes(TLObject obj, TLInt flags, int flag)
 {
     return(obj != null && IsSet(flags, flag) ? obj.ToBytes() : new byte[] {});
 }