#pragma once

#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

#if HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC

#include <memory_tracker.h>

#include <ngtcp2/ngtcp2_crypto.h>

#include <node_internals.h>

#include <node_sockaddr.h>

#include "cid.h"

#include "defs.h"

namespace node::quic {

// TokenSecrets are used to generate things like stateless reset tokens,

// retry tokens, and token packets. They are always QUIC_TOKENSECRET_LEN

// bytes in length.

//

// In the default case, token secrets will always be generated randomly.

// User code will be given the option to provide a secret directly

// however.

class TokenSecret final : public MemoryRetainer {

};

// A stateless reset token is used when a QUIC endpoint receives a QUIC packet

// with a short header but the associated connection ID cannot be matched to any

// known Session. In such cases, the receiver may choose to send a subtle opaque

// indication to the sending peer that state for the Session has apparently been

// lost. For any on- or off- path attacker, a stateless reset packet resembles

// any other QUIC packet with a short header. In order to be successfully

// handled as a stateless reset, the peer must have already seen a reset token

// issued to it associated with the given CID. The token itself is opaque to the

// peer that receives is but must be possible to statelessly recreate by the

// peer that originally created it. The actual implementation is Node.js

// specific but we currently defer to a utility function provided by ngtcp2.

//

// QUIC leaves the generation of stateless session tokens up to the

// implementation to figure out. The idea, however, is that it ought to be

// possible to generate a stateless reset token reliably even when all state

// for a connection has been lost. We use the cid as it is the only reliably

// consistent bit of data we have when a session is destroyed.

//

// StatlessResetTokens are always kStatelessTokenLen bytes,

// as are the secrets used to generate the token.

class StatelessResetToken final : public MemoryRetainer {

};

// A RETRY packet communicates a retry token to the client. Retry tokens are

// generated only by QUIC servers for the purpose of validating the network path

// between a client and server. The content payload of the RETRY packet is

// opaque to the clientand must not be guessable by on- or off-path attackers.

//

// A QUIC server sends a RETRY token as a way of initiating explicit path

// validation in response to an initial QUIC packet. The client, upon receiving

// a RETRY, must abandon the initial connection attempt and try again with the

// received retry token included with the new initial packet sent to the server.

// If the server is performing explicit validation, it will look for the

// presence of the retry token and attempt to validate it if found. The internal

// structure of the retry token must be meaningful to the server, and the server

// must be able to validate that the token is correct without relying on any

// state left over from the previous connection attempt. We use an

// implementation that is provided by ngtcp2.

//

// The token secret must be kept private on the QUIC server that generated the

// retry. When multiple QUIC servers are used in a cluster, it cannot be

// guaranteed that the same QUIC server instance will receive the subsequent new

// Initial packet. Therefore, all QUIC servers in the cluster should either

// share or be aware of the same token secret or a mechanism needs to be

// implemented to ensure that subsequent packets are routed to the same QUIC

// server instance.

class RetryToken final : public MemoryRetainer {

};

// A NEW_TOKEN packet communicates a regular token to a client that the server

// would like the client to send in the header of an initial packet for a

// future connection. It is similar to RETRY and used for the same purpose,

// except a NEW_TOKEN is used in advance of the client establishing a new

// connection and a RETRY is sent in response to the client trying to open

// a new connection.

class RegularToken final : public MemoryRetainer {

};

} // namespace node::quic

#endif // HAVE_OPENSSL && NODE_OPENSSL_HAS_QUIC

#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS