public static bool TryParseProtected(IAead aead, ICipher cipher, MemoryCursor cursor, out InitialPacket result)
{
result = new InitialPacket();
var startOffset = cursor.AsOffset();
var firstByte = PacketFirstByte.Parse(cursor.Peek(1).Span[0]);
if (!firstByte.IsInitialType())
{
return(false);
}
cursor.Move(1);
var version = PacketVersion.Parse(cursor);
var destinationConnectionId = PacketConnectionId.Parse(cursor);
var sourceConnectionId = PacketConnectionId.Parse(cursor);
var token = PacketToken.Parse(cursor);
var payload = PacketPayload.SliceLongProtectedPacketBytes(cursor, aead, cipher, startOffset, firstByte, null, out var packetNumber);
result = new InitialPacket(version,
destinationConnectionId,
sourceConnectionId,
token,
packetNumber,
payload);
return(true);
}
public static bool TryParseEncrypted(MemoryCursor cursor, IAead aead, ulong sequenceNumber, out Record result)
{
var startOffsetOfMessage = cursor.AsOffset();
result = new Record();
if (!RecordType.TrySlice(cursor, RecordType.ApplicationData))
{
return(false);
}
var legacyVersion = ProtocolVersion.Parse(cursor);
if (legacyVersion != ProtocolVersion.Tls12)
{
throw new EncodingException();
}
var body = RecordLength.DecryptBytes(cursor, startOffsetOfMessage, aead, sequenceNumber);
using var bodyContext = body.SetCursor(cursor);
var startOffsetOfBody = cursor.AsOffset();
cursor.MoveEnd();
var actualType = RecordType.ParseReverse(cursor);
result = new Record(actualType, legacyVersion, new MemoryBuffer(startOffsetOfBody, cursor - startOffsetOfBody));
return(true);
}
public static bool TryParseProtectedByConnectionId(IAead aead,
ICipher cipher,
MemoryCursor cursor,
PacketConnectionId connectionId,
PacketNumber largestAcknowledgedPacketNumber,
out ShortPacket result)
{
result = new ShortPacket();
var startOffset = cursor.AsOffset();
var firstByte = PacketFirstByte.Parse(cursor.Peek(1).Span[0]);
if (!firstByte.IsShortHeader())
{
return(false);
}
cursor.Move(1);
if (!connectionId.TrySliceValue(cursor))
{
return(false);
}
var payload = PacketPayload.SliceShortProtectedPacketBytes(cursor, aead, cipher, startOffset, firstByte, largestAcknowledgedPacketNumber, out var packetNumber);
result = new ShortPacket(connectionId, packetNumber, payload);
return(true);
}
public static LongProtectedWritingContext StartLongProtectedPacketWriting(
MemoryCursor cursor,
IAead aead,
ICipher cipher,
int startPacketOffset,
PacketFirstByte firstByte,
PacketNumber packetNumber,
PacketNumber?largestAcknowledgedPacketNumber)
{
return(new LongProtectedWritingContext(aead, cipher, cursor, startPacketOffset, cursor.AsOffset(), packetNumber, largestAcknowledgedPacketNumber, firstByte));
}
public static EncryptedWritingContext StartEncryptedWriting(
MemoryCursor cursor,
int startLengthOfMessage,
RecordType type,
IAead aead,
ulong sequenceNumber)
{
var lengthBytes = cursor.Move(2);
var startLengthOfBody = cursor.AsOffset();
return(new EncryptedWritingContext(cursor, lengthBytes.Span, startLengthOfBody, startLengthOfMessage, type, aead, sequenceNumber));
}
public EncryptedWritingContext(
MemoryCursor cursor,
Span <byte> lengthBytes,
int startLengthOfBody,
int startLengthOfMessage,
RecordType type,
IAead aead,
ulong sequenceNumber)
{
this.cursor = cursor;
this.lengthBytes = lengthBytes;
this.startLengthOfBody = startLengthOfBody;
this.startLengthOfMessage = startLengthOfMessage;
this.type = type;
this.aead = aead;
this.sequenceNumber = sequenceNumber;
}
public LongProtectedWritingContext(
IAead aead,
ICipher cipher,
MemoryCursor cursor,
int startPacketOffset,
int startPayloadOffset,
PacketNumber packetNumber,
PacketNumber?largestAcknowledgedPacketNumber,
PacketFirstByte packetFirstByte)
{
this.aead = aead;
this.cipher = cipher;
this.cursor = cursor;
this.startPacketOffset = startPacketOffset;
this.startPayloadOffset = startPayloadOffset;
this.packetNumber = packetNumber;
this.largestAcknowledgedPacketNumber = largestAcknowledgedPacketNumber;
this.packetFirstByte = packetFirstByte;
}
public static MemoryBuffer SliceShortProtectedPacketBytes(
MemoryCursor cursor,
IAead aead,
ICipher cipher,
int startPacketOffset,
PacketFirstByte firstByte,
PacketNumber largestAcknowledgedPacketNumber,
out PacketNumber packetNumber)
{
var startPacketNumberOffset = cursor.AsOffset();
cursor.Move(SkipToSampleLength);
var sample = cursor.Move(SampleLength);
var mask = cipher.CreateMask(sample.Span);
cursor.Set(startPacketOffset);
firstByte.Mask(mask).Write(cursor);
cursor.Set(startPacketNumberOffset);
var packetNumberBytes = firstByte.Mask(mask).SlicePacketNumberBytes(cursor);
var headerLength = cursor - startPacketOffset;
var headerBytes = cursor.Peek(-headerLength);
var startPayloadOffset = cursor.AsOffset();
cursor.MoveEnd();
var tagBytes = cursor.Move(-aead.TagLength);
var payloadLength = cursor - startPayloadOffset;
var payloadBytes = cursor.Peek(-payloadLength);
var payload = cursor.Slice(-payloadLength);
var encodedPacketNumber = PacketNumber.Parse(packetNumberBytes.Span, mask);
encodedPacketNumber.Fill(packetNumberBytes.Span);
packetNumber = encodedPacketNumber.DecodeByLargestAcknowledged(largestAcknowledgedPacketNumber);
packetNumber.Decrypt(aead, payloadBytes.Span, tagBytes.Span, headerBytes.Span);
cursor.MoveEnd();
return(payload);
}
public static RecordLength.EncryptedWritingContext StartEncryptedWriting(MemoryCursor cursor, RecordType type, IAead aead, ulong sequenceNumber)
{
var startLengthOfMessage = cursor.AsOffset();
RecordType.ApplicationData.WriteBytes(cursor);
ProtocolVersion.Tls12.WriteBytes(cursor);
return(RecordLength.StartEncryptedWriting(cursor, startLengthOfMessage, type, aead, sequenceNumber));
}
public static PacketPayload.LongProtectedWritingContext StartProtectedWriting(IAead aead,
ICipher cipher,
MemoryCursor cursor,
PacketVersion version,
PacketConnectionId destinationConnectionId,
PacketConnectionId sourceConnectionId,
PacketNumber packetNumber,
PacketToken token)
{
var startPacketOffset = cursor.AsOffset();
var firstByte = new PacketFirstByte()
.SetInitial()
.SetMaxPacketNumberLength();
firstByte.Write(cursor);
version.WriteBytes(cursor);
destinationConnectionId.WriteBytes(cursor);
sourceConnectionId.WriteBytes(cursor);
token.WriteBytes(cursor);
return(PacketPayload.StartLongProtectedPacketWriting(cursor, aead, cipher, startPacketOffset, firstByte, packetNumber, null));
}
public static MemoryBuffer DecryptBytes(MemoryCursor cursor, int startOffsetOfMessage, IAead aead, ulong sequenceNumber)
{
var headerLength = cursor - startOffsetOfMessage + 2;
var lengthBytes = cursor.Move(2);
var headerBytes = cursor.Peek(-headerLength);
var length = (int)NetworkBitConverter.ParseUnaligned(lengthBytes.Span);
if (length > MaxLength)
{
throw new EncodingException();
}
if (length < aead.TagLength)
{
throw new EncodingException();
}
var startOffsetOfBody = cursor.AsOffset();
var encryptedLength = length - aead.TagLength;
var encryptedBytes = cursor.Move(encryptedLength);
var tag = cursor.Move(aead.TagLength);
aead.Decrypt(encryptedBytes.Span, tag.Span, sequenceNumber, headerBytes.Span);
return(new MemoryBuffer(startOffsetOfBody, encryptedLength));
}
public EncryptedUserDefaults(string name, NSUserDefaults defaults, IAead provider)
{
_name = name;
UserDefaults = defaults;
_provider = provider;
}
public static PacketPayload.ShortProtectedWritingContext StartProtectedWriting(IAead aead,
ICipher cipher,
MemoryCursor cursor,
PacketConnectionId destinationConnectionId,
PacketNumber packetNumber,
PacketNumber largestAcknowledgedPacketNumber)
{
var startOffset = cursor.AsOffset();
var firstByte = new PacketFirstByte().SetShort();
firstByte.Write(cursor);
destinationConnectionId.WriteValueBytes(cursor);
return(PacketPayload.StartShortProtectedPacketWriting(cursor, aead, cipher, startOffset, firstByte, packetNumber, largestAcknowledgedPacketNumber));
}
