From d910f0205136c1bd388e555c2267d4d37ecdee37 Mon Sep 17 00:00:00 2001 From: wb Date: Mon, 21 Sep 2026 15:53:26 +0800 Subject: [PATCH] fix(net): harden peer message handling Validate inbound HELLO messages before logging or handshake processing, and tolerate optional node identity data. Handle concurrent sync queue changes, missing connection failure causes, and accurate transaction diagnostics. Correct the default QPS parameter type so fallback configuration remains usable. --- .../tron/core/net/P2pEventHandlerImpl.java | 11 +- .../net/message/handshake/HelloMessage.java | 10 +- .../ChainInventoryMsgHandler.java | 27 ++--- .../TransactionsMsgHandler.java | 4 +- .../effective/EffectiveCheckService.java | 5 +- .../service/handshake/HandshakeService.java | 19 +--- .../ratelimiter/strategy/QpsStrategy.java | 4 +- .../core/net/P2pEventHandlerImplTest.java | 14 +++ .../ChainInventoryMsgHandlerTest.java | 38 +++++++ .../TransactionsMsgHandlerTest.java | 22 ++++ .../net/services/HandShakeServiceTest.java | 101 ++++++++++-------- .../ratelimiter/adaptor/AdaptorTest.java | 15 ++- 12 files changed, 176 insertions(+), 94 deletions(-) diff --git a/framework/src/main/java/org/tron/core/net/P2pEventHandlerImpl.java b/framework/src/main/java/org/tron/core/net/P2pEventHandlerImpl.java index 9dd950ae57b..01cfbb6b141 100644 --- a/framework/src/main/java/org/tron/core/net/P2pEventHandlerImpl.java +++ b/framework/src/main/java/org/tron/core/net/P2pEventHandlerImpl.java @@ -157,7 +157,7 @@ private void processMessage(PeerConnection peer, byte[] data) { peer.getPeerStatistics().messageStatistics.addTcpInMessage(msg); if (PeerConnection.needToLog(msg)) { - logger.info("Receive message from peer: {}, {}", peer.getInetSocketAddress(), msg); + logger.info("Receive message from peer: {}, {}", peer.getInetSocketAddress(), msg); } switch (type) { @@ -300,13 +300,8 @@ private void processException(PeerConnection peer, TronMessage msg, Exception ex code = Protocol.ReasonCode.UNKNOWN; break; } - if (type.equals(P2pException.TypeEnum.BAD_MESSAGE)) { - logger.error("Message from {} process failed, {} \n type: ({})", - peer.getInetSocketAddress(), msg, type, ex); - } else { - logger.warn("Message from {} process failed, {} \n type: ({}), detail: {}", - peer.getInetSocketAddress(), msg, type, ex.getMessage()); - } + logger.warn("Message from {} process failed, {} \n type: ({}), detail: {}", + peer.getInetSocketAddress(), msg, type, ex.getMessage()); } else { code = Protocol.ReasonCode.UNKNOWN; logger.warn("Message from {} process failed, {}", diff --git a/framework/src/main/java/org/tron/core/net/message/handshake/HelloMessage.java b/framework/src/main/java/org/tron/core/net/message/handshake/HelloMessage.java index 68123c93db6..e20fca59fe5 100755 --- a/framework/src/main/java/org/tron/core/net/message/handshake/HelloMessage.java +++ b/framework/src/main/java/org/tron/core/net/message/handshake/HelloMessage.java @@ -10,9 +10,11 @@ import org.tron.core.ChainBaseManager; import org.tron.core.capsule.BlockCapsule; import org.tron.core.config.args.Args; +import org.tron.core.exception.P2pException; import org.tron.core.net.message.MessageTypes; import org.tron.core.net.message.TronMessage; import org.tron.p2p.discover.Node; +import org.tron.p2p.utils.NetUtil; import org.tron.program.Version; import org.tron.protos.Discover.Endpoint; import org.tron.protos.Protocol; @@ -31,6 +33,9 @@ public HelloMessage(byte type, byte[] rawData) throws Exception { public HelloMessage(byte[] data) throws Exception { super(MessageTypes.P2P_HELLO.asByte(), data); this.helloMessage = Protocol.HelloMessage.parseFrom(data); + if (!valid()) { + throw new P2pException(P2pException.TypeEnum.BAD_MESSAGE, "invalid hello message"); + } } public HelloMessage(Node from, long timestamp, ChainBaseManager chainBaseManager) { @@ -124,7 +129,6 @@ public String toString() { StringBuilder builder = new StringBuilder(); builder.append(super.toString()) - .append("from: ").append(getFrom().getPreferInetSocketAddress()).append("\n") .append("timestamp: ").append(getTimestamp()).append("\n") .append("headBlockId: ").append(getHeadBlockId().getString()).append("\n") .append("nodeType: ").append(helloMessage.getNodeType()).append("\n") @@ -156,6 +160,10 @@ public Protocol.HelloMessage getInstance() { } public boolean valid() { + if (helloMessage.hasFrom() && !NetUtil.validNode(getFrom())) { + return false; + } + byte[] genesisBlockByte = this.helloMessage.getGenesisBlockId().getHash().toByteArray(); if (genesisBlockByte.length != Sha256Hash.LENGTH) { return false; diff --git a/framework/src/main/java/org/tron/core/net/messagehandler/ChainInventoryMsgHandler.java b/framework/src/main/java/org/tron/core/net/messagehandler/ChainInventoryMsgHandler.java index bd2e428418c..c01ef7d92f4 100644 --- a/framework/src/main/java/org/tron/core/net/messagehandler/ChainInventoryMsgHandler.java +++ b/framework/src/main/java/org/tron/core/net/messagehandler/ChainInventoryMsgHandler.java @@ -5,7 +5,6 @@ import java.util.Deque; import java.util.LinkedList; import java.util.List; -import java.util.NoSuchElementException; import lombok.extern.slf4j.Slf4j; import org.apache.commons.collections4.CollectionUtils; import org.springframework.beans.factory.annotation.Autowired; @@ -57,7 +56,7 @@ public void processMessage(PeerConnection peer, TronMessage msg) throws P2pExcep } while (!peer.getSyncBlockToFetch().isEmpty()) { - if (peer.getSyncBlockToFetch().peekLast().equals(blockIdWeGet.peekFirst())) { + if (blockIdWeGet.peekFirst().equals(peer.getSyncBlockToFetch().peekLast())) { break; } peer.getSyncBlockToFetch().pollLast(); @@ -69,22 +68,18 @@ public void processMessage(PeerConnection peer, TronMessage msg) throws P2pExcep peer.getSyncBlockToFetch().addAll(blockIdWeGet); synchronized (tronNetDelegate.getBlockLock()) { - try { - BlockId blockId = null; - while (!peer.getSyncBlockToFetch().isEmpty() && tronNetDelegate - .containBlock(peer.getSyncBlockToFetch().peek())) { - blockId = peer.getSyncBlockToFetch().pop(); + Deque toFetch = peer.getSyncBlockToFetch(); + BlockId blockId = null; + BlockId next; + while ((next = toFetch.peek()) != null && tronNetDelegate.containBlock(next)) { + if (toFetch.remove(next)) { + blockId = next; peer.setBlockBothHave(blockId); } - if (blockId != null) { - logger.info("Block {} from {} is processed", - blockId.getString(), peer.getInetAddress()); - } - } catch (NoSuchElementException e) { - logger.warn("Process ChainInventoryMessage failed, peer {}, isDisconnect:{}", - peer.getInetAddress(), peer.isDisconnect()); - peer.setFetchAble(true); - return; + } + if (blockId != null) { + logger.info("Block {} from {} is processed", + blockId.getString(), peer.getInetAddress()); } } diff --git a/framework/src/main/java/org/tron/core/net/messagehandler/TransactionsMsgHandler.java b/framework/src/main/java/org/tron/core/net/messagehandler/TransactionsMsgHandler.java index 52137c5881c..e55385bdb0b 100644 --- a/framework/src/main/java/org/tron/core/net/messagehandler/TransactionsMsgHandler.java +++ b/framework/src/main/java/org/tron/core/net/messagehandler/TransactionsMsgHandler.java @@ -138,7 +138,7 @@ private void check(PeerConnection peer, TransactionsMessage msg) throws P2pExcep Item item = new Item(id, InventoryType.TRX); if (!peer.getAdvInvRequest().containsKey(item)) { throw new P2pException(TypeEnum.BAD_MESSAGE, - "trx: " + msg.getMessageId() + " without request."); + "trx: " + id + " without request."); } if (trx.getRawData().getContractCount() < 1) { throw new P2pException(TypeEnum.BAD_TRX, @@ -216,4 +216,4 @@ public TrxEvent(PeerConnection peer, TransactionMessage msg) { this.time = System.currentTimeMillis(); } } -} \ No newline at end of file +} diff --git a/framework/src/main/java/org/tron/core/net/service/effective/EffectiveCheckService.java b/framework/src/main/java/org/tron/core/net/service/effective/EffectiveCheckService.java index a4e89412bae..c17ff6020ce 100644 --- a/framework/src/main/java/org/tron/core/net/service/effective/EffectiveCheckService.java +++ b/framework/src/main/java/org/tron/core/net/service/effective/EffectiveCheckService.java @@ -127,8 +127,9 @@ private void findEffectiveNode() { // Connection attempt cancelled by user cur = null; } else if (!future.isSuccess()) { - // You might get a NullPointerException here because the future might not be completed yet. - logger.warn("Connect to chosen peer {} fail, cause:{}", cur, future.cause().getMessage()); + Throwable cause = future.cause(); + logger.warn("Connect to chosen peer {} fail, cause:{}", cur, + cause == null ? "unknown" : cause.getMessage()); future.channel().close(); cur = null; triggerNext(); diff --git a/framework/src/main/java/org/tron/core/net/service/handshake/HandshakeService.java b/framework/src/main/java/org/tron/core/net/service/handshake/HandshakeService.java index 070a9f56406..6153dab9aa7 100644 --- a/framework/src/main/java/org/tron/core/net/service/handshake/HandshakeService.java +++ b/framework/src/main/java/org/tron/core/net/service/handshake/HandshakeService.java @@ -4,7 +4,6 @@ import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; -import org.tron.common.utils.ByteArray; import org.tron.core.ChainBaseManager; import org.tron.core.ChainBaseManager.NodeType; import org.tron.core.config.args.Args; @@ -41,27 +40,15 @@ public void processHelloMessage(PeerConnection peer, HelloMessage msg) { return; } - TronNetService.getP2pService().updateNodeId(peer.getChannel(), msg.getFrom().getHexId()); + if (msg.getHelloMessage().hasFrom()) { + TronNetService.getP2pService().updateNodeId(peer.getChannel(), msg.getFrom().getHexId()); + } if (peer.isDisconnect()) { logger.info("Duplicate Peer {}", peer.getInetSocketAddress()); peer.disconnect(ReasonCode.DUPLICATE_PEER); return; } - if (!msg.valid()) { - logger.warn("Peer {} invalid hello message parameters, GenesisBlockId: {}, SolidBlockId: {}, " - + "HeadBlockId: {}, address: {}, sig: {}, codeVersion: {}", - peer.getInetSocketAddress(), - ByteArray.toHexString(msg.getInstance().getGenesisBlockId().getHash().toByteArray()), - ByteArray.toHexString(msg.getInstance().getSolidBlockId().getHash().toByteArray()), - ByteArray.toHexString(msg.getInstance().getHeadBlockId().getHash().toByteArray()), - msg.getInstance().getAddress().toByteArray().length, - msg.getInstance().getSignature().toByteArray().length, - msg.getInstance().getCodeVersion().toByteArray().length); - peer.disconnect(ReasonCode.INCOMPATIBLE_PROTOCOL); - return; - } - peer.setAddress(msg.getHelloMessage().getAddress()); if (!relayService.checkHelloMessage(msg, peer.getChannel())) { diff --git a/framework/src/main/java/org/tron/core/services/ratelimiter/strategy/QpsStrategy.java b/framework/src/main/java/org/tron/core/services/ratelimiter/strategy/QpsStrategy.java index 9116af1b7da..f1d65d30a5c 100644 --- a/framework/src/main/java/org/tron/core/services/ratelimiter/strategy/QpsStrategy.java +++ b/framework/src/main/java/org/tron/core/services/ratelimiter/strategy/QpsStrategy.java @@ -22,7 +22,7 @@ public QpsStrategy(String paramString) { @Override protected Map defaultParam() { Map map = new HashMap<>(); - map.put(STRATEGY_PARAM_QPS, new ParamItem(Double.class, DEFAULT_QPS)); + map.put(STRATEGY_PARAM_QPS, new ParamItem(Double.class, (double) DEFAULT_QPS)); return map; } @@ -34,4 +34,4 @@ public boolean acquire() { rateLimiter.acquire(); return true; } -} \ No newline at end of file +} diff --git a/framework/src/test/java/org/tron/core/net/P2pEventHandlerImplTest.java b/framework/src/test/java/org/tron/core/net/P2pEventHandlerImplTest.java index 52cdfa9c826..506d2a2b265 100644 --- a/framework/src/test/java/org/tron/core/net/P2pEventHandlerImplTest.java +++ b/framework/src/test/java/org/tron/core/net/P2pEventHandlerImplTest.java @@ -18,6 +18,7 @@ import org.tron.common.utils.Sha256Hash; import org.tron.core.config.args.Args; import org.tron.core.exception.P2pException; +import org.tron.core.net.message.MessageTypes; import org.tron.core.net.message.TronMessage; import org.tron.core.net.message.adv.FetchInvDataMessage; import org.tron.core.net.message.adv.InventoryMessage; @@ -34,6 +35,19 @@ public static void init() throws Exception { TestConstants.TEST_CONF); } + @Test + public void testInvalidHelloRejectedBeforeLoggingAndHandshake() throws Exception { + PeerConnection peer = mock(PeerConnection.class); + P2pEventHandlerImpl handler = new P2pEventHandlerImpl(); + Method method = handler.getClass() + .getDeclaredMethod("processMessage", PeerConnection.class, byte[].class); + method.setAccessible(true); + method.invoke(handler, peer, new byte[]{MessageTypes.P2P_HELLO.asByte()}); + + verify(peer).disconnect(Protocol.ReasonCode.BAD_PROTOCOL); + Mockito.verify(peer, Mockito.never()).getPeerStatistics(); + } + @Test public void testProcessInventoryMessage() throws Exception { CommonParameter parameter = CommonParameter.getInstance(); diff --git a/framework/src/test/java/org/tron/core/net/messagehandler/ChainInventoryMsgHandlerTest.java b/framework/src/test/java/org/tron/core/net/messagehandler/ChainInventoryMsgHandlerTest.java index 56853c3dbb7..f5e123d4bc9 100644 --- a/framework/src/test/java/org/tron/core/net/messagehandler/ChainInventoryMsgHandlerTest.java +++ b/framework/src/test/java/org/tron/core/net/messagehandler/ChainInventoryMsgHandlerTest.java @@ -1,21 +1,27 @@ package org.tron.core.net.messagehandler; import java.util.ArrayList; +import java.util.Deque; import java.util.LinkedList; import java.util.List; import org.junit.AfterClass; import org.junit.Assert; import org.junit.BeforeClass; import org.junit.Test; +import org.mockito.Mockito; import org.tron.common.TestConstants; import org.tron.common.utils.Pair; +import org.tron.common.utils.ReflectUtils; +import org.tron.common.utils.Sha256Hash; import org.tron.core.capsule.BlockCapsule.BlockId; import org.tron.core.config.Parameter.NetConstants; import org.tron.core.config.args.Args; import org.tron.core.exception.P2pException; +import org.tron.core.net.TronNetDelegate; import org.tron.core.net.message.keepalive.PingMessage; import org.tron.core.net.message.sync.ChainInventoryMessage; import org.tron.core.net.peer.PeerConnection; +import org.tron.core.net.service.sync.SyncService; public class ChainInventoryMsgHandlerTest { @@ -34,6 +40,38 @@ public static void destroy() { private ChainInventoryMessage msg = new ChainInventoryMessage(new ArrayList<>(), 0L); private List blockIds = new ArrayList<>(); + @Test + public void testQueueChangedDuringProcessing() throws Exception { + ChainInventoryMsgHandler handler = new ChainInventoryMsgHandler(); + TronNetDelegate delegate = Mockito.mock(TronNetDelegate.class); + SyncService syncService = Mockito.mock(SyncService.class); + ReflectUtils.setFieldValue(handler, "tronNetDelegate", delegate); + ReflectUtils.setFieldValue(handler, "syncService", syncService); + + BlockId parent = new BlockId(Sha256Hash.ZERO_HASH, 0); + BlockId next = new BlockId(Sha256Hash.ZERO_HASH, 1); + PeerConnection peer = Mockito.mock(PeerConnection.class); + Deque toFetch = Mockito.mock(Deque.class); + LinkedList requested = new LinkedList<>(); + requested.add(parent); + Mockito.when(peer.getSyncChainRequested()) + .thenReturn(new Pair<>(requested, System.currentTimeMillis())); + Mockito.when(peer.getSyncBlockToFetch()).thenReturn(toFetch); + Mockito.when(toFetch.peek()).thenReturn(next, (BlockId) null); + Mockito.when(toFetch.isEmpty()).thenReturn(false, true); + Mockito.when(toFetch.peekLast()).thenReturn(null); + Mockito.when(delegate.getHeadBlockId()).thenReturn(parent); + Mockito.when(delegate.getBlockLock()).thenReturn(new Object()); + Mockito.when(delegate.containBlock(next)).thenReturn(true); + Mockito.when(toFetch.remove(next)).thenReturn(false); + + handler.processMessage(peer, new ChainInventoryMessage( + java.util.Arrays.asList(parent, next), 0L)); + + Mockito.verify(toFetch).pollLast(); + Mockito.verify(peer, Mockito.never()).setBlockBothHave(Mockito.any()); + } + @Test public void testProcessMessage() throws Exception { try { diff --git a/framework/src/test/java/org/tron/core/net/messagehandler/TransactionsMsgHandlerTest.java b/framework/src/test/java/org/tron/core/net/messagehandler/TransactionsMsgHandlerTest.java index 78af06e64bc..a286805c697 100644 --- a/framework/src/test/java/org/tron/core/net/messagehandler/TransactionsMsgHandlerTest.java +++ b/framework/src/test/java/org/tron/core/net/messagehandler/TransactionsMsgHandlerTest.java @@ -337,6 +337,28 @@ public void testDuplicateTransactionRejected() throws Exception { } } + @Test + public void testUnrequestedTransactionReportsTransactionId() throws Exception { + TransactionsMsgHandler handler = new TransactionsMsgHandler(); + try { + PeerConnection peer = Mockito.mock(PeerConnection.class); + Mockito.when(peer.getAdvInvRequest()).thenReturn(new ConcurrentHashMap<>()); + TransactionsMessage msg = buildTransferMessage(1); + Protocol.Transaction trx = msg.getTransactions().getTransactions(0); + String transactionId = new TransactionMessage(trx).getMessageId().toString(); + + try { + handler.processMessage(peer, msg); + Assert.fail("Expected an unrequested transaction to be rejected"); + } catch (P2pException e) { + Assert.assertEquals(P2pException.TypeEnum.BAD_MESSAGE, e.getType()); + Assert.assertTrue(e.getMessage().contains(transactionId)); + } + } finally { + handler.close(); + } + } + @Test public void testInvalidSigLength() throws Exception { TransactionsMsgHandler handler = new TransactionsMsgHandler(); diff --git a/framework/src/test/java/org/tron/core/net/services/HandShakeServiceTest.java b/framework/src/test/java/org/tron/core/net/services/HandShakeServiceTest.java index b8b0d5f6deb..edecfd387e2 100644 --- a/framework/src/test/java/org/tron/core/net/services/HandShakeServiceTest.java +++ b/framework/src/test/java/org/tron/core/net/services/HandShakeServiceTest.java @@ -129,18 +129,15 @@ public void testInvalidHelloMessage() { .setNumber(hid.getNum()) .build(); builder.setHeadBlockId(invalidBlockId); - HelloMessage helloMessage = new HelloMessage(builder.build().toByteArray()); - Assert.assertFalse(helloMessage.valid()); + assertInvalidHello(builder); builder.setHeadBlockId(okBlockId); builder.setGenesisBlockId(invalidBlockId); - HelloMessage helloMessage2 = new HelloMessage(builder.build().toByteArray()); - Assert.assertFalse(helloMessage2.valid()); + assertInvalidHello(builder); builder.setGenesisBlockId(okBlockId); builder.setSolidBlockId(invalidBlockId); - HelloMessage helloMessage3 = new HelloMessage(builder.build().toByteArray()); - Assert.assertFalse(helloMessage3.valid()); + assertInvalidHello(builder); } catch (Exception e) { Assert.fail(); } @@ -152,31 +149,66 @@ public void testInvalidHelloMessage2() throws Exception { Assert.assertTrue(new HelloMessage(builder.build().toByteArray()).valid()); builder.setAddress(ByteString.copyFrom(new byte[201])); - HelloMessage helloMessage = new HelloMessage(builder.build().toByteArray()); - Assert.assertFalse(helloMessage.valid()); + assertInvalidHello(builder); builder.setAddress(ByteString.copyFrom(new byte[200])); - helloMessage = new HelloMessage(builder.build().toByteArray()); - Assert.assertTrue(helloMessage.valid()); + Assert.assertTrue(new HelloMessage(builder.build().toByteArray()).valid()); builder.setSignature(ByteString.copyFrom(new byte[201])); - helloMessage = new HelloMessage(builder.build().toByteArray()); - Assert.assertFalse(helloMessage.valid()); + assertInvalidHello(builder); builder.setSignature(ByteString.copyFrom(new byte[200])); - helloMessage = new HelloMessage(builder.build().toByteArray()); - Assert.assertTrue(helloMessage.valid()); + Assert.assertTrue(new HelloMessage(builder.build().toByteArray()).valid()); builder.setCodeVersion(ByteString.copyFrom(new byte[201])); - helloMessage = new HelloMessage(builder.build().toByteArray()); - Assert.assertFalse(helloMessage.valid()); + assertInvalidHello(builder); builder.setCodeVersion(ByteString.copyFrom(new byte[200])); - helloMessage = new HelloMessage(builder.build().toByteArray()); - Assert.assertTrue(helloMessage.valid()); + Assert.assertTrue(new HelloMessage(builder.build().toByteArray()).valid()); } + @Test + public void testInvalidHelloNode() throws Exception { + Protocol.HelloMessage.Builder builder = getTestHelloMessageBuilder(); + Assert.assertTrue(new HelloMessage(builder.build().toByteArray()).valid()); + + Protocol.HelloMessage original = builder.build(); + builder.setFrom(original.getFrom().toBuilder() + .setNodeId(ByteString.copyFrom(new byte[1]))); + assertInvalidHello(builder); + + builder.setFrom(original.getFrom().toBuilder() + .setAddress(ByteString.copyFromUtf8("not-an-ip"))); + assertInvalidHello(builder); + + builder.setFrom(original.getFrom()); + builder.setAddress(ByteString.copyFrom(new byte[21])); + String logged = new HelloMessage(builder.build().toByteArray()).toString(); + Assert.assertTrue(logged.contains("address:")); + Assert.assertFalse(logged.contains("from:")); + } + + @Test + public void testMissingHelloNodeIsAllowed() throws Exception { + Protocol.HelloMessage.Builder builder = getTestHelloMessageBuilder(); + builder.clearFrom(); + + HelloMessage message = new HelloMessage(builder.build().toByteArray()); + + Assert.assertTrue(message.valid()); + Assert.assertFalse(message.getHelloMessage().hasFrom()); + } + + private void assertInvalidHello(Protocol.HelloMessage.Builder builder) throws Exception { + try { + new HelloMessage(builder.build().toByteArray()); + Assert.fail("Expected invalid HELLO to be rejected during construction"); + } catch (org.tron.core.exception.P2pException e) { + Assert.assertEquals(org.tron.core.exception.P2pException.TypeEnum.BAD_MESSAGE, e.getType()); + } + } + @Test public void testRelayHelloMessage() throws NoSuchMethodException { InetSocketAddress a1 = new InetSocketAddress("127.0.0.1", 10001); @@ -285,33 +317,12 @@ public void testLowAndGenesisBlockNum() throws NoSuchMethodException { } @Test - public void testProcessHelloMessage() { - InetSocketAddress a1 = new InetSocketAddress("127.0.0.1", 10001); - Channel c1 = mock(Channel.class); - Mockito.when(c1.getInetSocketAddress()).thenReturn(a1); - Mockito.when(c1.getInetAddress()).thenReturn(a1.getAddress()); - PeerManager.add(ctx, c1); - PeerConnection p = PeerManager.getPeers().get(0); - - try { - Node node = new Node(NetUtil.getNodeId(), a1.getAddress().getHostAddress(), - null, a1.getPort()); - Protocol.HelloMessage.Builder builder = - getHelloMessageBuilder(node, System.currentTimeMillis(), - ChainBaseManager.getChainBaseManager()); - BlockCapsule.BlockId hid = ChainBaseManager.getChainBaseManager().getHeadBlockId(); - Protocol.HelloMessage.BlockId invalidBlockId = Protocol.HelloMessage.BlockId.newBuilder() - .setHash(ByteString.copyFrom(new byte[31])) - .setNumber(hid.getNum()) - .build(); - builder.setHeadBlockId(invalidBlockId); - - HelloMessage helloMessage = new HelloMessage(builder.build().toByteArray()); - HandshakeService handshakeService = new HandshakeService(); - handshakeService.processHelloMessage(p, helloMessage); - } catch (Exception e) { - Assert.fail(); - } + public void testInvalidHeaderRejectedDuringConstruction() throws Exception { + Protocol.HelloMessage.Builder builder = getTestHelloMessageBuilder(); + builder.setHeadBlockId(Protocol.HelloMessage.BlockId.newBuilder() + .setHash(ByteString.copyFrom(new byte[31])) + .build()); + assertInvalidHello(builder); } private Protocol.HelloMessage.Builder getHelloMessageBuilder(Node from, long timestamp, diff --git a/framework/src/test/java/org/tron/core/services/ratelimiter/adaptor/AdaptorTest.java b/framework/src/test/java/org/tron/core/services/ratelimiter/adaptor/AdaptorTest.java index 5ab85a42bbf..0903b5ce6a7 100644 --- a/framework/src/test/java/org/tron/core/services/ratelimiter/adaptor/AdaptorTest.java +++ b/framework/src/test/java/org/tron/core/services/ratelimiter/adaptor/AdaptorTest.java @@ -199,6 +199,17 @@ public void testQpsRateLimiterAdapter() throws Exception { flag = strategy.tryAcquire(); Assert.assertFalse(flag); } -} - + @Test + public void testDefaultQpsValueHasDeclaredType() { + QpsStrategy strategy = new QpsStrategy(""); + Object value = ReflectUtils.getFieldObject(strategy.getMapParams().get("qps"), "value"); + Assert.assertTrue(value instanceof Double); + Assert.assertEquals((double) QpsStrategy.DEFAULT_QPS, (Double) value, 0.0); + + QpsStrategy fallback = new QpsStrategy("qps=invalid"); + Object fallbackValue = ReflectUtils.getFieldObject( + fallback.getMapParams().get("qps"), "value"); + Assert.assertEquals((double) QpsStrategy.DEFAULT_QPS, (Double) fallbackValue, 0.0); + } +}