/// <param name="connectionToNeighbor">is null for A->EP mode</param>
public byte[] Encode_OptionallySignNeighborHMAC(ConnectionToNeighbor connectionToNeighborNullable)
{
BinaryProcedures.CreateBinaryWriter(out var ms, out var writer);
writer.Write((byte)PacketTypes.RegisterAck2);
byte flags = 0;
if (connectionToNeighborNullable == null)
{
flags |= Flag_AtoEP;
}
writer.Write(flags);
if (connectionToNeighborNullable != null)
{
NeighborToken32 = connectionToNeighborNullable.RemoteNeighborToken32;
NeighborToken32.Encode(writer);
}
GetSharedSignedFields(writer, true, true);
ReqP2pSeq16.Encode(writer);
if (connectionToNeighborNullable != null)
{
connectionToNeighborNullable.GetNeighborHMAC(this.GetSignedFieldsForNeighborHMAC).Encode(writer);
}
return(ms.ToArray());
}
/// <param name="reqReceivedFromInP2pMode">is not null for packets between registered peers</param>
public byte[] Encode_OpionallySignNeighborHMAC(ConnectionToNeighbor reqReceivedFromInP2pMode)
{
BinaryProcedures.CreateBinaryWriter(out var ms, out var writer);
writer.Write((byte)PacketTypes.RegisterAck1);
byte flags = 0;
if (reqReceivedFromInP2pMode == null)
{
flags |= Flag_EPtoA;
}
writer.Write(flags);
if (reqReceivedFromInP2pMode != null)
{
NeighborToken32 = reqReceivedFromInP2pMode.RemoteNeighborToken32;
NeighborToken32.Encode(writer);
}
GetSharedSignedFields(writer, true, true);
if (reqReceivedFromInP2pMode != null)
{
ReqP2pSeq16.Encode(writer);
this.NeighborHMAC = reqReceivedFromInP2pMode.GetNeighborHMAC(this.GetSignedFieldsForNeighborHMAC);
this.NeighborHMAC.Encode(writer);
}
else
{
BinaryProcedures.EncodeIPEndPoint(writer, RequesterEndpoint);
}
return(ms.ToArray());
}
/// <param name="reqReceivedFromInP2pMode">is not null for packets between registered peers</param>
public byte[] Encode_OpionallySignNeighborHMAC(ConnectionToNeighbor reqReceivedFromInP2pMode)
{
BinaryProcedures.CreateBinaryWriter(out var ms, out var writer);
writer.Write((byte)PacketTypes.Failure);
byte flags = 0;
if (reqReceivedFromInP2pMode == null)
{
flags |= Flag_EPtoA;
}
writer.Write(flags);
if (reqReceivedFromInP2pMode != null)
{
NeighborToken32 = reqReceivedFromInP2pMode.RemoteNeighborToken32;
NeighborToken32.Encode(writer);
}
ReqP2pSeq16.Encode(writer);
writer.Write((byte)ResponseCode);
if (reqReceivedFromInP2pMode != null)
{
this.NeighborHMAC = reqReceivedFromInP2pMode.GetNeighborHMAC(this.GetSignedFieldsForNeighborHMAC);
this.NeighborHMAC.Encode(writer);
}
return(ms.ToArray());
}
/// <param name="connectionToNeighbor">is not null for packets between registered peers</param>
public byte[] Encode_OptionallySignNeighborHMAC(ConnectionToNeighbor connectionToNeighbor)
{
BinaryProcedures.CreateBinaryWriter(out var ms, out var writer);
writer.Write((byte)PacketTypes.RegisterConfirmation);
Flags = 0;
if (connectionToNeighbor == null)
{
Flags |= Flag_AtoEP;
}
writer.Write(Flags);
if (connectionToNeighbor != null)
{
NeighborToken32 = connectionToNeighbor.RemoteNeighborToken32;
NeighborToken32.Encode(writer);
}
writer.Write(ReqTimestamp64);
RequesterRegistrationId.Encode(writer);
ResponderRegistrationConfirmationSignature.Encode(writer);
RequesterRegistrationConfirmationSignature.Encode(writer);
ReqP2pSeq16.Encode(writer);
if (connectionToNeighbor != null)
{
this.NeighborHMAC = connectionToNeighbor.GetNeighborHMAC(this.GetSignedFieldsForNeighborHMAC);
this.NeighborHMAC.Encode(writer);
}
return(ms.ToArray());
}
internal void GetSignedFieldsForNeighborHMAC(BinaryWriter w)
{
GetSharedSignedFields(w);
RequesterRegistrationSignature.Encode(w);
w.Write(NumberOfHopsRemaining);
ReqP2pSeq16.Encode(w);
}
/// <param name="connectionToNeighborNullable">is not null for packets between registered peers. if set, the procedure sets NeighborToken32 and NeighborHMAC</param>
public byte[] Encode_OptionallySignNeighborHMAC(ConnectionToNeighbor connectionToNeighborNullable)
{
PacketProcedures.CreateBinaryWriter(out var ms, out var writer);
writer.Write((byte)PacketTypes.RegisterReq);
byte flags = 0;
if (connectionToNeighborNullable == null)
{
flags |= Flag_AtoEP;
}
if (DirectionVectorNullable != null)
{
flags |= Flag_DirectionVectorExists;
}
writer.Write(flags);
if (connectionToNeighborNullable != null)
{
NeighborToken32 = connectionToNeighborNullable.RemoteNeighborToken32;
NeighborToken32.Encode(writer);
}
GetSharedSignedFields(writer, true);
if (connectionToNeighborNullable == null)
{
if (ProofOfWork2.Length != 64)
{
throw new ArgumentException();
}
writer.Write(ProofOfWork2);
}
writer.Write(NumberOfHopsRemaining);
writer.Write(NumberOfRandomHopsRemaining);
ReqP2pSeq16.Encode(writer);
if (connectionToNeighborNullable != null)
{
NeighborHMAC = connectionToNeighborNullable.GetNeighborHMAC(this.GetSignedFieldsForNeighborHMAC);
NeighborHMAC.Encode(writer);
}
return(ms.ToArray());
}
/// <summary>
/// creates a scanner that finds ACK1 that matches to REQ
/// </summary>
/// <param name="connectionToNeighborNullable">
/// peer that responds to REQ with ACK1
/// if not null - the scanner will verify ACK1.NeighborHMAC
/// </param>
public static LowLevelUdpResponseScanner GetScanner(Logger logger, RequestP2pSequenceNumber16 reqP2pSeq16, ConnectionToNeighbor connectionToNeighborNullable = null)
{
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($">> FailurePacket.GetScanner() reqP2pSeq16={reqP2pSeq16}");
}
BinaryProcedures.CreateBinaryWriter(out var ms, out var w);
w.Write((byte)PacketTypes.Failure);
w.Write((byte)0);
if (connectionToNeighborNullable != null)
{
connectionToNeighborNullable.LocalNeighborToken32.Encode(w);
}
reqP2pSeq16.Encode(w);
var r = new LowLevelUdpResponseScanner
{
ResponseFirstBytes = ms.ToArray(),
IgnoredByteAtOffset1 = 1 // ignore flags
};
if (connectionToNeighborNullable != null)
{
r.OptionalFilter = (responseData) =>
{
if (logger.WriteToLog_detail_enabled)
{
logger.WriteToLog_detail($"filtering FAILURE @scanner: hash={MiscProcedures.GetArrayHashCodeString(responseData)}");
}
if (connectionToNeighborNullable.IsDisposed)
{
logger.WriteToLog_needsAttention("ignoring FAILURE: connection is disposed");
return(false);
}
var failure = DecodeAndOptionallyVerify(responseData, reqP2pSeq16);
if (failure.NeighborHMAC.Equals(connectionToNeighborNullable.GetNeighborHMAC(failure.GetSignedFieldsForNeighborHMAC)) == false)
{
logger.WriteToLog_attacks("ignoring FAILURE: received HMAC is invalid");
return(false);
}
return(true);
};
}
return(r);
}
internal void GetSignedFieldsForNeighborHMAC(BinaryWriter w)
{
GetSharedSignedFields(w);
ResponderRegistrationSignature.Encode(w);
ReqP2pSeq16.Encode(w);
}
static void EncodeHeader(BinaryWriter w, RequestP2pSequenceNumber16 reqP2pSeq16)
{
w.Write((byte)PacketTypes.NeighborPeerAck);
reqP2pSeq16.Encode(w);
}