Example #1
0
        public async Task <database_response> SendRequestToSocket(byte[] req)
        {
            byte[] response = null;
            bool   failed   = false;
            Utils  utils    = new Utils();

            using (var ws = new WebSocket(url))
            {
                ws.OnError += (sender, e) =>
                {
                    failed = true;
                };

                ws.OnMessage += (sender, e) =>
                {
                    response = e.RawData;
                };

                ws.OnClose += (sender, e) =>
                {
                };

                ws.Connect();

                try
                {
                    ws.Send(req);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                    return(null);
                }

                while (response == null)
                {
                    await Task.Delay(100);

                    if (failed)
                    {
                        return(null);
                    }
                }

                bzn_envelope      env    = new bzn_envelope();
                database_response dbresp = new database_response();

                using (var stream = new MemoryStream(response))
                {
                    env    = bzn_envelope.Parser.ParseFrom(stream);
                    dbresp = database_response.Parser.ParseFrom(env.DatabaseResponse);
                    if (dbresp.Redirect != null)
                    {
                        this.url = $"ws://{dbresp.Redirect.LeaderHost}:{dbresp.Redirect.LeaderPort}";
                        return(await SendRequestToSocket(req));
                    }
                    return(dbresp);
                }
            }
        }
Example #2
0
        public async Task <database_response> DoRequest(bzn_envelope req, string uuid)
        {
            // request_id++;
            // var req = BuildRequest(msg, request_id, uuid);

            var response = await SendRequestToSocket(req.ToByteArray());

            return(response);
        }
Example #3
0
        public bzn_envelope BuildRequest(bzn_msg msg, string uuid)
        {
            var env = new bzn_envelope()
            {
                DatabaseMsg = msg.Db.ToByteString(),
            };

            return(env);
        }
Example #4
0
        public bzn_envelope SignEnvelope(bzn_envelope env)
        {
            DateTime upper = DateTime.UtcNow;
            DateTime lower = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

            ulong timestamp = (ulong)(upper - lower).TotalMilliseconds;

            // determine public key from provided key
            var sender      = GetPublicKey(Convert.FromBase64String(this.private_pem));
            var payloadCase = 0;

            switch (env.PayloadCase.ToString())
            {
            case "DatabaseMsg":
            {
                payloadCase = 10;
                break;
            }

            case "PbftInternalRequest":
            {
                payloadCase = 11;
                break;
            }

            case "DatabaseResponse":
            {
                payloadCase = 12;
                break;
            }

            case "Json":
            {
                payloadCase = 13;
                break;
            }

            case "Audit":
            {
                payloadCase = 14;
                break;
            }

            case "Pbft":
            {
                payloadCase = 15;
                break;
            }

            case "PbftMembership":
            {
                payloadCase = 16;
                break;
            }

            case "StatusRequest":
            {
                payloadCase = 17;
                break;
            }

            case "StatusResponse":
            {
                payloadCase = 18;
                break;
            }
            }

            String[] binForTheWin = new String[]
            {
                sender,
                payloadCase.ToString(),
                env.DatabaseMsg.ToStringUtf8(),
                timestamp.ToString()
            };

            // data for serializing
            env.Sender = sender;
            var signer  = new Utils();
            var hexHash = BitConverter.ToString(Encoding.ASCII.GetBytes(DeterministicSerialize(binForTheWin))).Replace("-", "");

            env.Signature = ByteString.CopyFrom(signer.SignData(StringToByteArray(hexHash), this.privateKeyParameters));
            env.Timestamp = (ulong)timestamp;

            // Console.WriteLine(DeterministicSerialize(binForTheWin));

            if (VerifySignature(this.pubKeyParameters,
                                env.Signature.ToByteArray(),
                                DeterministicSerialize(binForTheWin)))
            {
                // var sigHex = BitConverter.ToString(env.ToByteArray()).Replace("-","");
                // Console.WriteLine(sigHex);
                return(env);
            }
            else
            {
                Console.WriteLine("Error in signature.");
                return(null);
            }
        }