public static void ReadApplicationProtocolExtension(ReadableBuffer buffer, IConnectionState connectionState)
{
buffer = BufferExtensions.SliceVector <ushort>(ref buffer);
//if(connectionState.Listener.ServerNameProvider.MatchServerName(buffer))
//buffer.Equals()
}
public void RegisterSessionTicket(ReadableBuffer buffer)
{
//slice off the head first
buffer = buffer.Slice(HandshakeProcessor.HandshakeHeaderSize);
uint ticketAge, ageRandom;
buffer = buffer.SliceBigEndian(out ticketAge);
buffer = buffer.SliceBigEndian(out ageRandom);
var ticketData = BufferExtensions.SliceVector <ushort>(ref buffer);
if (buffer.Length > 0)
{
//Extensions
buffer = BufferExtensions.SliceVector <ushort>(ref buffer);
if (buffer.Length > 0)
{
//seems we can resume data
ExtensionType type;
buffer = buffer.SliceBigEndian(out type);
if (type != ExtensionType.ticket_early_data_info)
{
Alerts.AlertException.ThrowAlert(Alerts.AlertLevel.Fatal, Alerts.AlertDescription.illegal_parameter, "Early session ticket received had an invalid extension");
}
}
}
}
public static void ReadCertificates(ReadableBuffer buffer, SecurePipelineListener listener)
{
buffer = buffer.Slice(HandshakeProcessor.HandshakeHeaderSize);
//ignore context
BufferExtensions.SliceVector <byte>(ref buffer);
//slice the list
buffer = BufferExtensions.SliceVector24Bit(ref buffer);
X509Certificate2Collection collection;
if (listener.CertificateValidation == null)
{
collection = null;
}
else
{
collection = new X509Certificate2Collection();
}
while (buffer.Length > 0)
{
var cert = BufferExtensions.SliceVector24Bit(ref buffer);
var ext = BufferExtensions.SliceVector <ushort>(ref buffer);
if (cert.Length > 0 && collection != null)
{
var x509 = new X509Certificate2(cert.ToArray());
collection.Add(x509);
}
}
if (collection != null)
{
if (!listener.CertificateValidation(collection))
{
Alerts.AlertException.ThrowAlert(Alerts.AlertLevel.Fatal, Alerts.AlertDescription.bad_certificate, "Failed to verify the certificate chain via the callback");
}
}
}
public static void ReadServerHello(ReadableBuffer readable, IConnectionStateTls13 connectionState)
{
var original = readable;
ushort version, cipherCode;
readable = readable.Slice(HandshakeProcessor.HandshakeHeaderSize);
readable = readable.SliceBigEndian(out version);
//skip random
readable = readable.Slice(RandomLength);
readable = readable.SliceBigEndian(out cipherCode);
connectionState.CipherSuite = connectionState.CryptoProvider.GetCipherSuiteFromCode(cipherCode, connectionState.Version);
if (connectionState.CipherSuite == null)
{
Alerts.AlertException.ThrowAlert(Alerts.AlertLevel.Fatal, Alerts.AlertDescription.illegal_parameter, "Could not get a cipher suite during server hello");
}
connectionState.StartHandshakeHash(original);
readable = BufferExtensions.SliceVector <ushort>(ref readable);
ExtensionType ext;
readable = readable.SliceBigEndian(out ext);
if (ext != ExtensionType.key_share)
{
Alerts.AlertException.ThrowAlert(Alerts.AlertLevel.Fatal, Alerts.AlertDescription.illegal_parameter, "There was no keyshare on the server hello");
}
readable = BufferExtensions.SliceVector <ushort>(ref readable);
NamedGroup group;
readable = readable.SliceBigEndian(out group);
if (group != connectionState.KeyShare.NamedGroup)
{
Alerts.AlertException.ThrowAlert(Alerts.AlertLevel.Fatal, Alerts.AlertDescription.illegal_parameter, "The named group didn't match the keyshare during server hello");
}
readable = BufferExtensions.SliceVector <ushort>(ref readable);
connectionState.KeyShare.SetPeerKey(readable);
}
public static void ReadSupportedGroups(ReadableBuffer buffer, IConnectionStateTls13 connectionState)
{
if (connectionState.KeyShare != null)
{
return;
}
buffer = BufferExtensions.SliceVector <ushort>(ref buffer);
connectionState.KeyShare = connectionState.CryptoProvider.GetKeyshareFromNamedGroups(buffer);
}
public static void ReadKeyshare(ReadableBuffer buffer, IConnectionStateTls13 connectionState)
{
if (connectionState.KeyShare?.HasPeerKey == true)
{
return;
}
buffer = BufferExtensions.SliceVector <ushort>(ref buffer);
var ks = connectionState.CryptoProvider.GetKeyshareFromKeyshare(buffer);
connectionState.KeyShare = ks ?? connectionState.KeyShare;
}
public void MatchServerName(ReadableBuffer buffer, IConnectionState state)
{
buffer = BufferExtensions.SliceVector <ushort>(ref buffer);
while (buffer.Length > 0)
{
var nameType = buffer.ReadBigEndian <byte>();
buffer = buffer.Slice(sizeof(byte));
var nameBuffer = BufferExtensions.SliceVector <ushort>(ref buffer);
if (nameType == 0)
{
state.ServerName = nameBuffer.GetUtf8String();
}
}
}
public static void ReadSignatureScheme(ReadableBuffer buffer, IConnectionState connectionState)
{
buffer = BufferExtensions.SliceVector <ushort>(ref buffer);
while (buffer.Length > 1)
{
SignatureScheme scheme;
buffer = buffer.SliceBigEndian(out scheme);
var cert = connectionState.CertificateList.GetCertificate(connectionState.ServerName, scheme);
if (cert != null)
{
connectionState.Certificate = cert;
connectionState.SignatureScheme = scheme;
return;
}
}
Alerts.AlertException.ThrowAlert(Alerts.AlertLevel.Fatal, Alerts.AlertDescription.handshake_failure, "Failed to find a signature scheme that matches");
}
public static void ReadPskKeyExchangeMode(ReadableBuffer buffer, IConnectionStateTls13 connectionState)
{
buffer = BufferExtensions.SliceVector <byte>(ref buffer);
while (buffer.Length > 0)
{
PskKeyExchangeMode mode;
buffer = buffer.SliceBigEndian(out mode);
if (connectionState.PskKeyExchangeMode == PskKeyExchangeMode.none)
{
connectionState.PskKeyExchangeMode = mode;
}
else
{
connectionState.PskKeyExchangeMode |= mode;
}
}
}
public static void ReadClientHello(ref ReadableBuffer readable, IConnectionState connectionState)
{
readable = readable.Slice(HandshakeProcessor.HandshakeHeaderSize);
readable = readable.Slice(sizeof(ushort));
connectionState.SetClientRandom(readable.Slice(0, RandomLength));
readable = readable.Slice(RandomLength);
//We don't support sessions via id so slice and throw
BufferExtensions.SliceVector <byte>(ref readable);
//Slice Cipher Suite
var ciphers = BufferExtensions.SliceVector <ushort>(ref readable);
if (connectionState.CipherSuite == null)
{
connectionState.CipherSuite = connectionState.CryptoProvider.GetCipherSuiteFromExtension(ciphers, connectionState.Version);
}
//Skip compression
BufferExtensions.SliceVector <byte>(ref readable);
}
public static TlsVersion ReadSupportedVersion(ReadableBuffer buffer, TlsVersion[] supportedVersions)
{
TlsVersion returnVersion = 0;
buffer = BufferExtensions.SliceVector <byte>(ref buffer);
while (buffer.Length > 1)
{
TlsVersion version;
buffer = buffer.SliceBigEndian(out version);
if (supportedVersions.Contains(version))
{
if (version > returnVersion)
{
returnVersion = version;
}
}
}
return(returnVersion);
}
private static TlsVersion GetVersion(ref ReadableBuffer buffer)
{
//Jump the version header and the randoms
buffer = buffer.Slice(HandshakeProcessor.HandshakeHeaderSize);
TlsVersion version;
buffer = buffer.SliceBigEndian(out version);
if (!_supportedVersion.Contains(version))
{
Alerts.AlertException.ThrowAlert(Alerts.AlertLevel.Fatal, Alerts.AlertDescription.protocol_version, $"The version was not in the supported list {version}");
}
//Slice out the random
buffer = buffer.Slice(Hello.RandomLength);
//No sessions slice and dump
BufferExtensions.SliceVector <byte>(ref buffer);
//Skip the cipher suites if we find a version we are happy with
//then the cipher suite is dealt with by that version
BufferExtensions.SliceVector <ushort>(ref buffer);
//Skip compression, we don't care about that either, we just want to get to the end
BufferExtensions.SliceVector <byte>(ref buffer);
//And here we are at the end, if we have no extensions then we must be the header version that
//we accepted earlier
if (buffer.Length == 0)
{
return(version);
}
buffer = BufferExtensions.SliceVector <ushort>(ref buffer);
while (buffer.Length >= 8)
{
ExtensionType type;
buffer = buffer.SliceBigEndian(out type);
var ext = BufferExtensions.SliceVector <ushort>(ref buffer);
if (type == ExtensionType.supported_versions)
{
//Scan the version for supported ones
return(ExtensionsRead.ReadSupportedVersion(ext, _supportedVersion));
}
}
return(version);
}
public static void ReadPskKey(ReadableBuffer pskBuffer, IConnectionStateTls13 connectionState)
{
var identities = BufferExtensions.SliceVector <ushort>(ref pskBuffer);
while (identities.Length > 0)
{
var identity = BufferExtensions.SliceVector <ushort>(ref identities);
long serviceId, keyId;
identity = identity.SliceBigEndian(out serviceId);
identity = identity.SliceBigEndian(out keyId);
int ticketAge;
identities = identities.SliceBigEndian(out ticketAge);
if (!connectionState.ResumptionProvider.TryToResume(serviceId, keyId, identity, connectionState))
{
continue;
}
if ((connectionState.PskKeyExchangeMode & PskKeyExchangeMode.psk_dhe_ke) == 0)
{
connectionState.KeyShare?.Dispose();
connectionState.KeyShare = null;
}
return;
}
}
