예제 #1
0
        private static IMessage GetMessage(JObject msg)
        {
            try
            {
                var msgType = msg["type"].ToObject <int>();
                var payload = msg["payload"].ToObject <string>().FromHex();

                switch (MessageTypeExtension.GetRawValue(msgType))
                {
                case MessageType.PLAIN_MESSAGE:
                    if (payload.Length <= 0)
                    {
                        return(EmptyMessage.Create());
                    }
                    return(PlainMessage.Create(Encoding.UTF8.GetString(payload)));

                case MessageType.SECURED_MESSAGE:
                    return(SecureMessage.CreateFromEncodedPayload(payload));

                default:
                    return(EmptyMessage.Create());
                }
            }
            catch (Exception)
            {
                return(EmptyMessage.Create());
            }
        }
예제 #2
0
        public static async Task getResponse()
        {
            try
            {
                Account sender   = Account.CreateFromPrivateKey("5cd5a454be8045056bd3c5e67c20dea92a8eb4921351d850f0249983a804a903", NetworkType.Types.TEST_NET);
                KeyPair keyPair1 = sender.KeyPair;

                Account reciever = Account.CreateFromPrivateKey("5cd5a454be8045056bd3c5e67c20dea92a8eb4921351d850f0249983a804a903", NetworkType.Types.TEST_NET);
                KeyPair keyPair2 = reciever.KeyPair;


                var transaction = TransferTransaction.Create(
                    NetworkType.Types.TEST_NET,
                    Deadline.CreateHours(2),
                    Address.CreateFromEncoded("TB2Z7J-R2K3BZ-2TRS6D-H5747F-Y3XKUM-BNWCI4-BPDJ"),
                    new List <Mosaic> {
                    Xem.CreateRelative(1)
                },
                    SecureMessage.Create("Well shit. W/ mosaic", sender.PrivateKey, reciever.PublicKey)
                    );


                SignedTransaction signedTransaction = transaction.SignWith(keyPair1);

                TransactionResponse response = await new TransactionHttp(host).Announce(signedTransaction);
                Console.WriteLine(response.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                Console.WriteLine(e.StackTrace);
            }
        }
예제 #3
0
        public override void Init(MyObjectBuilder_SessionComponent sessionComponent)
        {
            base.Init(sessionComponent);


            if (MyAPIGateway.Multiplayer.MultiplayerActive)
            {
                modid        = ulong.Parse(this.ModContext.ModId.Substring(0, this.ModContext.ModId.Length - 4));
                m_registered = true;
                MyAPIGateway.Multiplayer.RegisterMessageHandler(SECURECHANNEL_ID, receiveSecureMessage);
                MyAPIGateway.Multiplayer.RegisterMessageHandler(UNSECURECHANNEL_ID, receiveMessage);
                rgen = new Random();
                if (!MyAPIGateway.Session.IsServer)
                {
                    rgen.NextBytes(selfkey);

                    var hello = new SecureMessage()
                    {
                        steamid = MyAPIGateway.Multiplayer.MyId,
                        data    = MyAPIGateway.Utilities.SerializeToBinary <MessageData>(new MessageData()
                        {
                            modid     = this.modid,
                            messageid = 0,
                            message   = selfkey
                        })
                    };
                    MyAPIGateway.Multiplayer.SendMessageToServer(UNSECURECHANNEL_ID, MyAPIGateway.Utilities.SerializeToBinary <SecureMessage>(hello));
                }
            }
        }
예제 #4
0
        public void IncludeNewPlayer(Socket socket)
        {
            var sendRsa = Config.CreateRsa();

            var export        = sendRsa.ExportParameters(false);
            var secureMessage = new SecureMessage().WithRsaParameters(export);

            socket.Send(secureMessage);

            var reply = socket.ReceiveRSA <SecureReplyMessage>(sendRsa);

            var symmetric = new TripleDESCryptoServiceProvider
            {
                IV  = reply.IV,
                Key = reply.Key
            };

            var player = new Player
            {
                Nick   = reply.Nick,
                Socket = socket,
                Crypt  = symmetric
            };

            WaitingPlayers.Enqueue(player);

            Console.WriteLine(player.Nick);

            ConsolidatePlayersIntoGames();
        }
예제 #5
0
        public static async Task <bool> SendFromNewAccount(String message, Account newAcc)
        {
            KeyPair keyPair = KeyPair.CreateFromPrivateKey(newAcc.PrivateKey);

            var transaction = TransferTransaction.Create(
                NetworkType.Types.TEST_NET,
                Deadline.CreateHours(2),
                Address.CreateFromEncoded(Config.Address),
                new List <Mosaic> {
                Mosaic.CreateFromIdentifier("nem:xem", 10)
            },
                SecureMessage.Create(message, newAcc.PrivateKey, Config.PublicKey)
                );

            TransactionHttp   transactionHttp   = new TransactionHttp("http://" + Config.Domain + ":7890");
            SignedTransaction signedTransaction = transaction.SignWith(keyPair);

            Thread.Sleep(2000);
            await transactionHttp.Announce(signedTransaction);

            Thread.Sleep(2000);
            Console.WriteLine(signedTransaction.Hash);
            Console.WriteLine(Config.Address + " recve something from : " + newAcc.Address.Plain);

            return(true);
        }
예제 #6
0
        private void receiveMessage(byte[] obj)
        {
            try
            {
                var message = MyAPIGateway.Utilities.SerializeFromBinary <SecureMessage>(obj);

                var data = MyAPIGateway.Utilities.SerializeFromBinary <MessageData>(message.data);
                if (data.modid != modid)
                {
                    return;
                }
                if (data.messageid == 0)
                {
                    if (MyAPIGateway.Session.IsServer)
                    {
                        //add key from client to dictionary.
                        if (encryptlookuptable.ContainsKey(message.steamid))
                        {
                            encryptlookuptable.Remove(message.steamid);
                        }
                        rgen.NextBytes(selfkey);

                        byte[] mdata = MyAPIGateway.Utilities.SerializeToBinary <MessageData>(new MessageData()
                        {
                            modid     = this.modid,
                            messageid = 0,
                            message   = selfkey
                        });

                        EncryptDecrypt(ref mdata, ref data.message);

                        var hello = new SecureMessage()
                        {
                            steamid = 0,
                            data    = mdata
                        };

                        //we could send this secure?
                        MyAPIGateway.Multiplayer.SendMessageTo(SECURECHANNEL_ID, MyAPIGateway.Utilities.SerializeToBinary <SecureMessage>(hello), message.steamid);
                        EncryptDecrypt(ref data.message, ref selfkey);
                        encryptlookuptable.Add(message.steamid, data.message);
                    }

                    return;
                }
                Action <ulong, byte[]> handle;
                if (messageHandlers.TryGetValue(data.messageid, out handle))
                {
                    handle(message.steamid, data.message);
                }
            }
            catch
            {
                //do nothing
            }
        }
예제 #7
0
        public void CanCreateSecureMessage()
        {
            var secureMessage = SecureMessage.Create("Hello", "5949fc564c90ac186cd4f9d2b8298b677bca300b9d8f926ca04e1739e4ed0cba", "2ecf1decef6818bd9c38985afd6efc1c981e64e9a1ecc1e7b6b25eb30454cce0");

            var decoded = secureMessage.GetDecodedPayload(
                "5949fc564c90ac186cd4f9d2b8298b677bca300b9d8f926ca04e1739e4ed0cba",
                "2ecf1decef6818bd9c38985afd6efc1c981e64e9a1ecc1e7b6b25eb30454cce0");

            Assert.AreEqual("Hello", decoded);
        }
        private void HandleSecureMessage(SecureMessage msg)
        {
            if (msg.PublicKey.Length == 32)
            {
                this.recipentEPK = msg.PublicKey;
            }

            if (msg.Payload.Length > 0)
            {
                base.OnMessageAssembled(msg.Payload);
            }
        }
예제 #9
0
        /// <summary>
        /// Created Message with information from database
        /// </summary>
        /// <param name="dbMsg"></param>
        /// <param name="aesKey"></param>
        internal Message(SecureMessage dbMsg, byte[] aesKey)
        {
            byte[] msgEncrypted = dbMsg.Message;
            byte[] msgIv        = dbMsg.EncryptionIV;
            byte[] msgBytes     = Crypt.Instance.DecryptAes(dbMsg.Message, aesKey, msgIv);
            string msgString    = Encoding.UTF8.GetString(msgBytes);

            SenderId       = dbMsg.SenderId;
            Content        = msgString;
            Timestamp      = dbMsg.Timestamp;
            ConversationId = dbMsg.ConId;
        }
        public async Task GetTransactionWithEncryptedMessage()
        {
            const string HASH = "fc60dbe36b99769261b86dc562e7dd2189a440cf878511e2e310208335bc5e9d";

            var tx = await new TransactionHttp(host).GetTransaction(HASH);

            Assert.AreEqual(PUBKEYMESS, tx.Signer.PublicKey);
            Assert.AreEqual(TransactionTypes.Types.Transfer, tx.TransactionType);
            var ttx = (TransferTransaction)tx;

            Assert.AreEqual(HASH, ttx.TransactionInfo.Hash);
            Assert.AreEqual(MessageType.Type.ENCRYPTED, ttx.Message.GetMessageType());
            SecureMessage smsg = (SecureMessage)ttx.Message;
            //Assert.AreEqual("Decrypted message", smsg.GetDecodedPayload("PRIVATE KEY", PUBKEYMESS));
        }
예제 #11
0
        internal SecureMessage ToDatabase(int recipientId, byte[] aesKeyBytes)
        {
            byte[] contentBytes = Encoding.UTF8.GetBytes(Content);
            byte[] generatedIv  = Crypt.Instance.GenerateIv("AES");

            SecureMessage dbMsg = new SecureMessage()
            {
                SenderId     = SenderId,
                Message      = Crypt.Instance.EncryptAes(contentBytes, aesKeyBytes, generatedIv),
                ConId        = ConversationId,
                Timestamp    = Timestamp,
                EncryptionIV = generatedIv,
            };

            return(dbMsg);
        }
        public async Task Should_Announce_Transfer_Transaction_With_NetworkCurrencyMosaic_SecureMessage()
        {
            var account = Account.GenerateNewAccount(Fixture.NetworkType);

            Log.WriteLine($"Reciever private key {account.KeyPair.PrivateKeyString}, reciever public key {account.PublicAccount.PublicKey}");
            var mosaic = NetworkCurrencyMosaic.CreateRelative(10);

            Log.WriteLine($"Sender private key {Fixture.SeedAccount.KeyPair.PrivateKeyString}, sender public key {Fixture.SeedAccount.PublicAccount.PublicKey}");
            var message = SecureMessage.Create("Test secure message", Fixture.SeedAccount.KeyPair.PrivateKeyString, account.PublicAccount.PublicKey);
            var result  = await Fixture.Transfer(Fixture.SeedAccount, account.Address, mosaic, message, Fixture.GenerationHash);

            Log.WriteLine($"Transaction confirmed {result.TransactionInfo.Hash}");
            result.TransactionInfo.Hash.Should().NotBeNullOrWhiteSpace();
            //result.TransactionType.Should().Be(EntityType.TRANSFER);
            ((TransferTransaction)result).Message.GetMessageType().Should().Be(MessageType.SECURED_MESSAGE.GetValueInByte());
        }
        public async Task AnnounceTransferTransactionWithMosaicWithSecureMessage()
        {
            var keyPair = new KeyPair(Config.PrivateKeyMain);

            var transaction = TransferTransaction.Create(
                NetworkType.Types.TEST_NET,
                Deadline.CreateHours(2),
                new Address("TAVPDJ-DR3R3X-4FJUKN-PY2IQB-NNRFV2-QR5NJZ-J3WR"),
                new List <MosaicAmount> {
                new MosaicAmount("nem:xem", 10)
            },
                SecureMessage.Create("hello2", Config.PrivateKeyMain, "4cc7409929a72019240065c9e53aa339f87ba889238ff9fbe978251fdbb05d9f")
                ).SignWith(keyPair);

            var response = await new TransactionHttp(host).Announce(transaction);

            Assert.AreEqual("SUCCESS", response.Message);
        }
예제 #14
0
 internal override void ChangeState(PipeState newState)
 {
     if (_state == PipeState.AwaitingAck && newState == PipeState.Connected)
     {
         //we need to do a key exchange before we can be ready to send anything.
         if (keyPair == null)
         {
             keyPair = Sodium.PublicKeyBox.GenerateKeyPair();
             SecureMessage message = new SecureMessage();
             message.PublicKey = keyPair.PublicKey;
             base.Send(MessagePackSerializer.Get <SecureMessage> ().PackSingleObject(message));
             this._secureState = SecureDuplexState.AwaitingKeyResponse;
         }
     }
     else
     {
         base.ChangeState(newState);
     }
 }
예제 #15
0
        public IMessage CreateMessage(ProximaxMessagePayloadModel messagePayload, string senderPrivateKey,
                                      string recipientPublicKeyRaw,
                                      string recipientAddress, bool useBlockchainSecureMessage)
        {
            CheckParameter(messagePayload != null, "messagePayload is required");

            var jsonPayload = messagePayload.ToJson();

            if (useBlockchainSecureMessage)
            {
                var recipientPublicKey =
                    this.GetRecipientPublicKey(senderPrivateKey, recipientPublicKeyRaw, recipientAddress);
                return(SecureMessage.Create(jsonPayload, senderPrivateKey, recipientPublicKey));
            }
            else
            {
                return(PlainMessage.Create(jsonPayload));
            }
        }
예제 #16
0
        internal override void OnMessageAssembled(byte[] message)
        {
            switch (_secureState)
            {
            case SecureDuplexState.Initializing:
                //should be a key
                this.recipentEPK = MessagePackSerializer.Get <SecureMessage> ().UnpackSingleObject(message).PublicKey;
                break;

            case SecureDuplexState.AwaitingKeyResponse:
                this.recipentEPK = MessagePackSerializer.Get <SecureMessage> ().UnpackSingleObject(message).PublicKey;
                break;

            case SecureDuplexState.PipeSecure:
                //should be data (but can be a key)
                SecureMessage smsg = MessagePackSerializer.Get <SecureMessage> ().UnpackSingleObject(message);
                this.HandleSecureMessage(smsg);
                break;
            }
        }
        public async Task AnnounceTransferTransactionWithMultipleMosaicsWithSecureMessage()
        {
            var keyPair =
                new KeyPair(Config.PrivateKeyMain);

            var transaction = TransferTransaction.Create(
                NetworkType.Types.TEST_NET,
                Deadline.CreateHours(2),
                new Address("TALICE-ROONSJ-CPHC63-F52V6F-Y3SDMS-VAEUGH-MB7C"),
                new List <MosaicAmount>()
            {
                new MosaicAmount("nem:xem", 1000),
                //Mosaic.CreateFromIdentifier("nis1porttest:test", 10), TODO: fix multiple mosaic transfer
            },
                SecureMessage.Create("hello2", Config.PrivateKeyMain, "5D8BEBBE80D7EA3B0088E59308D8671099781429B449A0BBCA6D950A709BA068")
                ).SignWith(keyPair);

            var response = await new TransactionHttp(host).Announce(transaction);

            Assert.AreEqual("SUCCESS", response.Message);
        }
예제 #18
0
 private void recieve()
 {
     try
     {
         while (true)
         {
             SecureMessage m = cryptTCP.Read();
             if (m.isSecure)
             {
                 Console.WriteLine("Recieved Secure Message: " + m.Message);
             }
             else
             {
                 Console.WriteLine("INSECURE MESSAGE. ERROR: " + m.Error);
             }
         }
     }
     catch (Exception)
     {
         dropConnection();
     }
 }
        public async Task AnnounceTransferTransactionWithMosaicWithSecureMessage()
        {
            var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);

            var transaction = TransferTransaction.Create(
                NetworkType.Types.MIJIN_TEST,
                Deadline.CreateHours(2),
                Address.CreateFromEncoded("SAAA57-DREOPY-KUFX4O-G7IQXK-ITMBWK-D6KXTV-BBQP"),
                new List <Mosaic> {
                Mosaic.CreateFromIdentifier("nem:xem", 10)
            },
                SecureMessage.Create("hello2", Config.PrivateKeyMain, "5D8BEBBE80D7EA3B0088E59308D8671099781429B449A0BBCA6D950A709BA068")
                ).SignWith(keyPair);

            await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(transaction);

            listener.TransactionStatus(Address.CreateFromPublicKey(keyPair.PublicKeyString, NetworkType.Types.MIJIN_TEST))
            .Subscribe(e => Console.WriteLine(e.Status));

            var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)).Take(1);

            Assert.AreEqual(keyPair.PublicKeyString, status.Signer.PublicKey);
        }
        public void Should_Correcntly_Populate_Request()
        {
            WebPayIntegration wpi = new WebPayIntegration(new Configuration
            {
                AuthenticityToken = "7db11ea5d4a1af32421b564caaa946d1ead3daf0",
                Key           = null,
                WebPayRootUrl = null
            });
            var secureMessage = new SecureMessage
            {
                AcsUrl            = "dsjdsj",
                AuthenticityToken = "aa",
                Id    = "nn",
                Pareq = "cc"
            };
            _3DSecureHandler       _3dSecureHandler = new _3DSecureHandler(secureMessage, wpi);
            Mock <I3DSecureClient> _3dSecureClient  = new Mock <I3DSecureClient>();
            // _3dSecureClient.Setup(x => x.FinishTransaction(secureMessage).
            var response = _3dSecureHandler.FinishTransaction(_3dSecureClient.Object);

            Assert.AreEqual(_3dSecureHandler.smRequest.PaRes, secureMessage.Pareq);
            Assert.AreEqual(_3dSecureHandler.smRequest.MD, secureMessage.AuthenticityToken);
        }
예제 #21
0
        public static async void CreateTransaction(Account receiverAcc, String message)
        {
            KeyPair keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);

            var transaction = TransferTransaction.Create(
                NetworkType.Types.TEST_NET,
                Deadline.CreateHours(2),
                Address.CreateFromEncoded(receiverAcc.Address.Plain),
                new List <Mosaic> {
                Mosaic.CreateFromIdentifier("nem:xem", 2000000)
            },
                SecureMessage.Create(message, Config.PrivateKeyMain, receiverAcc.PublicKey)
                );
            TransactionHttp   transactionHttp   = new TransactionHttp("http://" + Config.Domain + ":7890");
            SignedTransaction signedTransaction = transaction.SignWith(keyPair);

            Thread.Sleep(2000);
            await transactionHttp.Announce(signedTransaction);

            Console.WriteLine(signedTransaction.Hash);
            Console.WriteLine(receiverAcc.Address.Plain + " recve something from : " + Config.Address);
            Thread.Sleep(2000);
        }
        public async Task AnnounceTransferTransactionWithMultipleMosaicsWithSecureMessage()
        {
            var keyPair =
                KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);

            var transaction = TransferTransaction.Create(
                NetworkType.Types.MIJIN_TEST,
                Deadline.CreateHours(2),
                Address.CreateFromEncoded("SAOV4Y5W627UXLIYS5O43SVU23DD6VNRCFP222P2"),
                new List <Mosaic>()
            {
                Mosaic.CreateFromIdentifier("nem:xem", 1000000000000),
                //Mosaic.CreateFromIdentifier("happy:test2", 10),
            },
                SecureMessage.Create("hello2", Config.PrivateKeyMain, "5D8BEBBE80D7EA3B0088E59308D8671099781429B449A0BBCA6D950A709BA068")

                ).SignWith(keyPair);

            await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(transaction);

            var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)).Take(1);

            Assert.AreEqual(keyPair.PublicKeyString, status.Signer.PublicKey);
        }
예제 #23
0
        public static void SendMessage(Message msg, KeyStore ks)
        {
            byte[] convAesKey  = null;
            int    recipientId = -1;

            using (DataContext db = new DataContext())
            {
                var conv = GetConversation(msg.SenderId, msg.RecipientId, db);
                msg.ConversationId = conv.ConId;

                // Non-blocking execution of setting unread
                Task.Run(() => SetUnread(conv.ConId, msg.RecipientId));

                if (msg.SenderId == conv.UserAId)
                {
                    convAesKey  = Crypt.Instance.DecryptRsa(conv.KeyA, ks.rsaPrivate);
                    recipientId = conv.UserBId;
                }
                else if (msg.SenderId == conv.UserBId)
                {
                    convAesKey  = Crypt.Instance.DecryptRsa(conv.KeyB, ks.rsaPrivate);
                    recipientId = conv.UserAId;
                }

                SecureMessage dbMsg = msg.ToDatabase(recipientId, convAesKey);

                if (convAesKey == null || recipientId == -1)
                {
                    throw new ChatException("Recipient invalid or message could not be encrypted");
                }

                // Add to database
                db.SecureMessage.Add(dbMsg);
                db.SaveChanges();
            }
        }
예제 #24
0
        public static async Task <bool> CreateTransaction()
        {
            KeyPair keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);

            var transaction = TransferTransaction.Create(
                NetworkType.Types.TEST_NET,
                Deadline.CreateHours(2),
                Address.CreateFromEncoded("TCPCAZ-7XJ2X4-SWR6AG-6BUEKS-6DQ7DL-Z2D6QB-5M2V"),
                new List <Mosaic> {
                Mosaic.CreateFromIdentifier("nem:xem", 10)
            },
                SecureMessage.Create("hello", Config.PrivateKeyMain, "d72f89db8d0a3655168c9d2abe8de2910aaf4506a47d46e22ca48c7e0442e8ef")
                );

            TransactionHttp   transactionHttp   = new TransactionHttp("http://" + Config.Domain + ":7890");
            SignedTransaction signedTransaction = transaction.SignWith(keyPair);

            Thread.Sleep(2000);
            await transactionHttp.Announce(signedTransaction);

            Console.WriteLine(signedTransaction.Hash);
            Thread.Sleep(2000);
            return(true);
        }
예제 #25
0
 public _3DSecureHandler(SecureMessage secureMessage, WebPayIntegration integation)
 {
     _secureMessage = secureMessage;
     _integation    = integation;
 }