Esempio n. 1
0
        public async Task given_valid_consumer_address_delivery_receipt_should_be_processed()
        {
            _signer.RecoverPublicKey(Arg.Any <Signature>(), Arg.Any <Keccak>()).ReturnsForAnyArgs(_publicKey);
            _peer.ConsumerAddress.Returns(_publicKey.Address);

            var currentReceiptRequestUnitsRange = new UnitsRange(0, 9);
            var receiptRequest  = new DataDeliveryReceiptRequest(1, Keccak.Zero, currentReceiptRequestUnitsRange);
            var deliveryReceipt = new DataDeliveryReceipt(StatusCodes.Ok, 0, 0, new Signature(new byte[65]));

            var wasProcessed = await _processor.TryProcessAsync(_session, _publicKey.Address, _peer, receiptRequest,
                                                                deliveryReceipt);

            wasProcessed.Should().BeTrue();
            _session.DataAvailability.Should().NotBe(DataAvailability.DataDeliveryReceiptInvalid);
        }
Esempio n. 2
0
        public void handling_hi_message_should_succeed()
        {
            _verifySignature = true;
            InitSubprotocol();
            var hiMessage = new HiMessage(1, TestItem.AddressC, TestItem.AddressD, TestItem.PublicKeyA,
                                          new Signature(1, 1, 27));
            var hiPacket = new Packet(hiMessage.Protocol, hiMessage.PacketType,
                                      _messageSerializationService.Serialize(hiMessage));

            _messageSerializationService.Deserialize <HiMessage>(hiPacket.Data).Returns(hiMessage);
            var hash = Keccak.Compute(hiMessage.NodeId.Bytes);

            _ecdsa.RecoverPublicKey(hiMessage.Signature, hash).Returns(TestItem.PublicKeyA);
            _subprotocol.HandleMessage(hiPacket);
            _ecdsa.Received().RecoverPublicKey(hiMessage.Signature, hash);
            _subprotocol.ProviderAddress.Should().Be(hiMessage.ProviderAddress);
            _subprotocol.ConsumerAddress.Should().Be(hiMessage.ConsumerAddress);
            _consumerService.Received().AddProviderPeer(_subprotocol);
            var getDataAssetsMessage = new GetDataAssetsMessage();

            _messageSerializationService.Serialize(getDataAssetsMessage).Returns(Array.Empty <byte>());
            var getDataAssetsPacket = new Packet(getDataAssetsMessage.Protocol, getDataAssetsMessage.PacketType,
                                                 _messageSerializationService.Serialize(getDataAssetsMessage));

            _messageSerializationService.Deserialize <GetDataAssetsMessage>(getDataAssetsPacket.Data)
            .Returns(getDataAssetsMessage);

            Received.InOrder(() =>
            {
                _session.DeliverMessage(Arg.Any <GetDataAssetsMessage>());
                _session.DeliverMessage(Arg.Any <GetDepositApprovalsMessage>());
            });
        }
Esempio n. 3
0
        public ResultWrapper <Address> personal_ecRecover(byte[] message, byte[] signature)
        {
            message = ToEthSignedMessage(message);
            Keccak    msgHash   = Keccak.Compute(message);
            PublicKey publicKey = _ecdsa.RecoverPublicKey(new Signature(signature), msgHash);

            return(ResultWrapper <Address> .Success(publicKey.Address));
        }
Esempio n. 4
0
 public ResultWrapper <ParityTransaction[]> parity_pendingTransactions()
 => ResultWrapper <ParityTransaction[]> .Success(_txPool.GetPendingTransactions().Where(pt => pt.SenderAddress != null)
                                                 .Select(t => new ParityTransaction(t, Rlp.Encode(t).Bytes,
                                                                                    t.IsSigned ? _ecdsa.RecoverPublicKey(t.Signature, t.Hash) : null)).ToArray());
Esempio n. 5
0
        public Packet Ack(EncryptionHandshake handshake, Packet auth)
        {
            handshake.AuthPacket = auth;

            AuthMessageBase authMessage;
            bool            preEip8Format = false;

            byte[] plainText = null;
            try
            {
                if (_logger.IsTrace)
                {
                    _logger.Trace($"Trying to decrypt an old version of {nameof(AuthMessage)}");
                }
                (preEip8Format, plainText) = _eciesCipher.Decrypt(_privateKey, auth.Data);
            }
            catch (Exception ex)
            {
                if (_logger.IsTrace)
                {
                    _logger.Trace($"Exception when decrypting ack {ex.Message}");
                }
            }

            if (preEip8Format)
            {
                authMessage = _messageSerializationService.Deserialize <AuthMessage>(plainText);
            }
            else
            {
                if (_logger.IsTrace)
                {
                    _logger.Trace($"Trying to decrypt version 4 of {nameof(AuthEip8Message)}");
                }
                byte[] sizeData = auth.Data.Slice(0, 2);
                (_, plainText) = _eciesCipher.Decrypt(_privateKey, auth.Data.Slice(2), sizeData);
                authMessage    = _messageSerializationService.Deserialize <AuthEip8Message>(plainText);
            }

            var nodeId = authMessage.PublicKey;

            if (_logger.IsTrace)
            {
                _logger.Trace($"Received AUTH v{authMessage.Version} from {nodeId}");
            }

            handshake.RemoteNodeId        = nodeId;
            handshake.RecipientNonce      = _cryptoRandom.GenerateRandomBytes(32);
            handshake.EphemeralPrivateKey = _ephemeralGenerator.Generate();

            handshake.InitiatorNonce = authMessage.Nonce;
            byte[] staticSharedSecret = Proxy.EcdhSerialized(handshake.RemoteNodeId.Bytes, _privateKey.KeyBytes);
            byte[] forSigning         = staticSharedSecret.Xor(handshake.InitiatorNonce);

            handshake.RemoteEphemeralPublicKey = _ecdsa.RecoverPublicKey(authMessage.Signature, new Keccak(forSigning));

            byte[] data;
            if (preEip8Format)
            {
                if (_logger.IsTrace)
                {
                    _logger.Trace($"Building an {nameof(AckMessage)}");
                }
                AckMessage ackMessage = new AckMessage();
                ackMessage.EphemeralPublicKey = handshake.EphemeralPrivateKey.PublicKey;
                ackMessage.Nonce = handshake.RecipientNonce;
                var ackData = _messageSerializationService.Serialize(ackMessage);

                data = _eciesCipher.Encrypt(handshake.RemoteNodeId, ackData, Array.Empty <byte>());
            }
            else
            {
                if (_logger.IsTrace)
                {
                    _logger.Trace($"Building an {nameof(AckEip8Message)}");
                }
                AckEip8Message ackMessage = new AckEip8Message();
                ackMessage.EphemeralPublicKey = handshake.EphemeralPrivateKey.PublicKey;
                ackMessage.Nonce = handshake.RecipientNonce;
                var ackData = _messageSerializationService.Serialize(ackMessage);

                int    size      = ackData.Length + 32 + 16 + 65; // data + MAC + IV + pub
                byte[] sizeBytes = size.ToBigEndianByteArray().Slice(2, 2);
                data = Bytes.Concat(sizeBytes, _eciesCipher.Encrypt(handshake.RemoteNodeId, ackData, sizeBytes));
            }

            handshake.AckPacket = new Packet(data);
            SetSecrets(handshake, HandshakeRole.Recipient);
            return(handshake.AckPacket);
        }
Esempio n. 6
0
 public PublicKey GetNodeId(byte[] signature, int recoveryId, Span <byte> typeAndData)
 {
     return(_ecdsa.RecoverPublicKey(new Signature(signature, recoveryId), Keccak.Compute(typeAndData)));
 }
Esempio n. 7
0
 public PublicKey GetNodeId(byte[] signature, int recoveryId, byte[] messageType, byte[] data)
 {
     return(_ecdsa.RecoverPublicKey(new Signature(signature, recoveryId), Keccak.Compute(Bytes.Concat(messageType, data))));
 }
        public async Task <bool> TryProcessAsync(ProviderSession session, Address consumer, INdmProviderPeer peer,
                                                 DataDeliveryReceiptRequest receiptRequest, DataDeliveryReceipt deliveryReceipt)
        {
            var depositId  = session.DepositId;
            var unitsRange = receiptRequest.UnitsRange;
            var abiHash    = _abiEncoder.Encode(AbiEncodingStyle.Packed, _dataDeliveryReceiptAbiSig,
                                                receiptRequest.DepositId.Bytes, new[] { unitsRange.From, unitsRange.To });
            var address = _ecdsa.RecoverPublicKey(deliveryReceipt.Signature, Keccak.Compute(abiHash)).Address;

            if (!consumer.Equals(address))
            {
                if (_logger.IsWarn)
                {
                    _logger.Warn($"Recovered an invalid address: '{address}' (should be: '{consumer}') for delivery receipt for deposit: '{depositId}', consumer: '{session.ConsumerAddress}', session: '{session.Id}'.");
                }
                session.SetDataAvailability(DataAvailability.DataDeliveryReceiptInvalid);
                await _sessionRepository.UpdateAsync(session);

                peer.SendDataAvailability(depositId, DataAvailability.DataDeliveryReceiptInvalid);

                return(false);
            }

            var paidUnits = unitsRange.To - unitsRange.From + 1;

            if (_logger.IsInfo)
            {
                _logger.Info($"Consumer: '{consumer}' has provided a valid receipt for deposit: '{receiptRequest.DepositId}', range: [{unitsRange.From}, {unitsRange.To}], paid units: {paidUnits}");
            }
            if (receiptRequest.ReceiptsToMerge.Any())
            {
                if (_logger.IsInfo)
                {
                    _logger.Info($"Processing a merged receipt request for consumer: {session.ConsumerAddress}, session: '{session.Id} - units will not be updated.");
                }
            }
            else
            {
                if (_logger.IsInfo)
                {
                    _logger.Info($"Processing a receipt request for deposit: '{receiptRequest.DepositId}', consumer: {session.ConsumerAddress}, session: '{session.Id} - units will be updated.");
                }
                var unpaidUnits = session.UnpaidUnits > paidUnits ? session.UnpaidUnits - paidUnits : 0;
                session.SetUnpaidUnits(unpaidUnits);
                session.AddPaidUnits(paidUnits);
                if (receiptRequest.IsSettlement)
                {
                    session.SetPaidUnits(paidUnits);
                    session.SettleUnits(paidUnits);
                    if (_logger.IsInfo)
                    {
                        _logger.Info($"Settled {paidUnits} units for deposit: '{receiptRequest.DepositId}', consumer: {session.ConsumerAddress}, session: '{session.Id}'.");
                    }
                }

                await _sessionRepository.UpdateAsync(session);
            }

            var dataAvailability = session.DataAvailability;

            if (dataAvailability == DataAvailability.DataDeliveryReceiptInvalid ||
                dataAvailability == DataAvailability.DataDeliveryReceiptNotProvided)
            {
                session.SetDataAvailability(DataAvailability.Available);
                await _sessionRepository.UpdateAsync(session);

                if (_logger.IsInfo)
                {
                    _logger.Info($"Updated previously set data availability: '{dataAvailability}' -> '{DataAvailability.Available}', consumer: {session.ConsumerAddress}, session: '{session.Id}'.");
                }
            }

            return(true);
        }