1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// Manages the packet entropy calculation for both sent and received packets
// for a connection.
#ifndef NET_QUIC_QUIC_PACKET_ENTROPY_MANAGER_H_
#define NET_QUIC_QUIC_PACKET_ENTROPY_MANAGER_H_
#include "net/base/linked_hash_map.h"
#include "net/quic/quic_framer.h"
#include "net/quic/quic_protocol.h"
namespace net {
// Records all sent and received packets by a connection to track the cumulative
// entropy of both sent and received packets separately. It is used by the
// connection to validate an ack frame sent by the peer as a preventive measure
// against the optimistic ack attack. Also, called by the framer when it
// truncates an ack frame to get the correct entropy value for the ack frame
// being serialized.
class NET_EXPORT_PRIVATE QuicPacketEntropyManager :
public QuicReceivedEntropyHashCalculatorInterface {
public:
QuicPacketEntropyManager();
virtual ~QuicPacketEntropyManager();
// Record the received entropy hash against |sequence_number|.
void RecordReceivedPacketEntropyHash(QuicPacketSequenceNumber sequence_number,
QuicPacketEntropyHash entropy_hash);
// Record |entropy_hash| for sent packet corresponding to |sequence_number|.
void RecordSentPacketEntropyHash(QuicPacketSequenceNumber sequence_number,
QuicPacketEntropyHash entropy_hash);
// QuicReceivedEntropyHashCalculatorInterface
// Called by QuicFramer, when the outgoing ack gets truncated, to recalculate
// the received entropy hash for the truncated ack frame.
virtual QuicPacketEntropyHash ReceivedEntropyHash(
QuicPacketSequenceNumber sequence_number) const OVERRIDE;
QuicPacketEntropyHash SentEntropyHash(
QuicPacketSequenceNumber sequence_number) const;
QuicPacketSequenceNumber LargestReceivedSequenceNumber() const;
// Recalculate the received entropy hash and clears old packet entropies,
// now that the sender sent us the |entropy_hash| for packets up to,
// but not including, |peer_least_unacked|.
void RecalculateReceivedEntropyHash(
QuicPacketSequenceNumber peer_least_unacked,
QuicPacketEntropyHash entropy_hash);
// Returns true if |entropy_hash| matches the expected sent entropy hash
// up to |sequence_number| removing sequence numbers from |missing_packets|.
bool IsValidEntropy(QuicPacketSequenceNumber sequence_number,
const SequenceNumberSet& missing_packets,
QuicPacketEntropyHash entropy_hash) const;
// Removes not required entries from |sent_packets_entropy_| before
// |sequence_number|.
void ClearSentEntropyBefore(QuicPacketSequenceNumber sequence_number);
QuicPacketEntropyHash sent_packets_entropy_hash() const {
return sent_packets_entropy_hash_;
}
QuicPacketEntropyHash received_packets_entropy_hash() const {
return received_packets_entropy_hash_;
}
private:
typedef linked_hash_map<QuicPacketSequenceNumber,
std::pair<QuicPacketEntropyHash,
QuicPacketEntropyHash> > SentEntropyMap;
typedef std::map<QuicPacketSequenceNumber,
QuicPacketEntropyHash> ReceivedEntropyMap;
// Linked hash map from sequence numbers to the sent entropy hash up to the
// sequence number in the key.
SentEntropyMap sent_packets_entropy_;
// Cumulative hash of entropy of all sent packets.
QuicPacketEntropyHash sent_packets_entropy_hash_;
// TODO(satyamshekhar): Can be optimized using an interval set like data
// structure.
// Map of received sequence numbers to their corresponding entropy.
// Every received packet has an entry, and packets without the entropy bit set
// have an entropy value of 0.
// TODO(ianswett): When the entropy flag is off, the entropy should not be 0.
ReceivedEntropyMap received_packets_entropy_;
// Cumulative hash of entropy of all received packets.
QuicPacketEntropyHash received_packets_entropy_hash_;
// The largest sequence number cleared by RecalculateReceivedEntropyHash.
// Received entropy cannot be calculated for numbers less than it.
QuicPacketSequenceNumber largest_received_sequence_number_;
};
} // namespace net
#endif // NET_QUIC_QUIC_PACKET_ENTROPY_MANAGER_H_
|
