private void AddFinished(OutgoingMessageBag outgoingMessages)
{
m_localHash.TransformFinalBlock(EmptyArray <byte> .Instance, 0, 0);
byte[] seed = m_localHash.Hash;
m_localHash.Dispose();
m_localHash = null;
var label = SecurityParameters.Entity == ConnectionEnd.Server ? ServerFinishedLabel : ClientFinshedLabel;
var finishedMessage = new FinishedMessage
{
VerifyData = PRF.Get(SecurityParameters.MasterSecret, label, seed, FinishedMessage.VerifyDataLength)
};
NetMQMessage outgoingMessage = finishedMessage.ToNetMQMessage();
outgoingMessages.AddHandshakeMessage(outgoingMessage);
m_lastSentMessage = HandshakeType.Finished;
if (SecurityParameters.Entity == ConnectionEnd.Client)
{
HashRemote(outgoingMessage);
}
}
public HandleClientFinishedState(
IServiceProvider serviceProvider,
ICipherSuitesProvider cipherSuitesProvider,
Connection connection,
HandshakeWriter writer,
HandshakeFinishedService handshakeFinishedService,
VersionConfig versionConfig,
CipherSuiteConfig cipherSuiteConfig,
FinishedMessage handshake)
{
_serviceProvider = serviceProvider;
_cipherSuitesProvider = cipherSuitesProvider;
_connection = connection;
_writer = writer;
_handshakeFinishedService = handshakeFinishedService;
_versionConfig = versionConfig;
_cipherSuiteConfig = cipherSuiteConfig;
_handshake = handshake;
}
private void AddFinished(OutgoingMessageBag outgoingMessages)
{
m_localHash.TransformFinalBlock(new byte[0], 0, 0);
byte[] seed = m_localHash.Hash;
m_localHash.Dispose();
m_localHash = null;
string label;
if (SecurityParameters.Entity == ConnectionEnd.Server)
{
label = ServerFinishedLabel;
}
else
{
label = ClientFinshedLabel;
}
FinishedMessage finishedMessage = new FinishedMessage();
finishedMessage.VerifyData =
PRF.Get(SecurityParameters.MasterSecret, label, seed, FinishedMessage.VerifyDataLength);
NetMQMessage outgoingMessage = finishedMessage.ToNetMQMessage();
outgoingMessages.AddHandshakeMessage(outgoingMessage);
m_lastSentMessage = HandshakeType.Finished;
if (SecurityParameters.Entity == ConnectionEnd.Client)
{
HashRemote(outgoingMessage);
}
}
/// <summary>
/// Play audio and display text.
/// </summary>
/// <returns></returns>
private IEnumerator RayTextSequence()
{
// Disable interaction until Ray has left the player a puddle of emotions.
InteractWithSelectedObject interactionScript = Camera.main.GetComponent <InteractWithSelectedObject>();
if (interactionScript != null && scanningCam != null)
{
interactionScript.enabled = false;
scanningCam.SetActive(false);
}
// Clear text.
textWriter.DisplayText("");
// Play audio clip.
rayAudioSource.Play();
#region print Ray's sentimental message. :(
// Adjust text speed to match audio clip (we are hardcoding this because Becca's talking speed changes from line to line).
textWriter.ChangeTypingSpeed(17);
textWriter.DisplayText(endingLines);
yield return(new WaitForSeconds(18));
// Adjust text speed to match audio clip (we are hardcoding this because Becca's talking speed changes from line to line).
textWriter.ChangeTypingSpeed(18);
textWriter.DisplayText(endingLines2);
yield return(new WaitForSeconds(17));
// Adjust text speed to match audio clip (we are hardcoding this because Becca's talking speed changes from line to line).
textWriter.ChangeTypingSpeed(20);
textWriter.DisplayText(endingLines3);
#endregion
while (rayAudioSource.isPlaying)
{
yield return(null);
}
// Enable interaction, so that the player can kill themself.
if (interactionScript != null)
{
interactionScript.enabled = true;
scanningCam.SetActive(true);
}
if (FinishedMessage != null)
{
FinishedMessage.Invoke();
}
}
private void OnFinished(NetMQMessage incomingMessage, OutgoingMessageBag outgoingMessages)
{
if (
(SecurityParameters.Entity == ConnectionEnd.Client &&
(!m_secureChannel.ChangeSuiteChangeArrived ||
m_lastReceivedMessage != HandshakeType.ServerHelloDone || m_lastSentMessage != HandshakeType.Finished)) ||
(SecurityParameters.Entity == ConnectionEnd.Server &&
(!m_secureChannel.ChangeSuiteChangeArrived ||
m_lastReceivedMessage != HandshakeType.ClientKeyExchange || m_lastSentMessage != HandshakeType.ServerHelloDone)))
{
throw new NetMQSecurityException(NetMQSecurityErrorCode.HandshakeUnexpectedMessage, "Finished received when expecting another message");
}
if (SecurityParameters.Entity == ConnectionEnd.Server)
{
HashLocal(incomingMessage);
}
FinishedMessage finishedMessage = new FinishedMessage();
finishedMessage.SetFromNetMQMessage(incomingMessage);
m_remoteHash.TransformFinalBlock(new byte[0], 0, 0);
byte[] seed = m_remoteHash.Hash;
m_remoteHash.Dispose();
m_remoteHash = null;
string label;
if (SecurityParameters.Entity == ConnectionEnd.Client)
{
label = ServerFinishedLabel;
}
else
{
label = ClientFinshedLabel;
}
byte[] verifyData =
PRF.Get(SecurityParameters.MasterSecret, label, seed, FinishedMessage.VerifyDataLength);
if (!verifyData.SequenceEqual(finishedMessage.VerifyData))
{
throw new NetMQSecurityException(NetMQSecurityErrorCode.HandshakeVerifyData, "peer verify data wrong");
}
if (SecurityParameters.Entity == ConnectionEnd.Server)
{
AddFinished(outgoingMessages);
}
m_done = true;
}
public HandleServerFinishedState(
IServiceProvider serviceProvider,
HandshakeFinishedService handshakeFinishedService,
FinishedMessage handshake)
{
_serviceProvider = serviceProvider;
_handshakeFinishedService = handshakeFinishedService;
_handshake = handshake;
}
public bool Verify(FinishedMessage message)
{
if (_keyConfig.Master is null)
{
throw new InvalidOperationException("Key config is not initialized");
}
var prfDigest = _cipherSuitesProvider.ResolvePRFHash(_cipherSuiteConfig.CipherSuite);
var prf = new PRF(prfDigest);
var label = _endConfig.End == ConnectionEnd.Server ? "client finished" : "server finished";
var expectedData =
prf.Digest(_keyConfig.Master, label, message.VerifyExpectedHash)
.Take(FinishedMessage.VerifyDataLength)
.ToArray();
return(expectedData.SequenceEqual(message.VerifyActual));
}
public static HandleClientFinishedState New(IServiceProvider serviceProvider, FinishedMessage handshake)
{
return(new HandleClientFinishedState(
serviceProvider,
serviceProvider.GetRequiredService <ICipherSuitesProvider>(),
serviceProvider.GetRequiredService <Connection>(),
serviceProvider.GetRequiredService <HandshakeWriter>(),
serviceProvider.GetRequiredService <HandshakeFinishedService>(),
serviceProvider.GetRequiredService <VersionConfig>(),
serviceProvider.GetRequiredService <CipherSuiteConfig>(),
handshake
));
}
private void SetIsRunningToFalse(ServiceProxy sut)
{
var message = new FinishedMessage();
sut.FinishedHandler(message);
}
internal void FinishedHandler(FinishedMessage message)
{
IsRunning = false;
IsColonyCreated = false;
IsFinished = true;
m_MemoryBus.PublishAsync(new ColonyFinishedMessage());
}
public static HandleServerFinishedState New(IServiceProvider serviceProvider, FinishedMessage handshake)
{
return(new HandleServerFinishedState(
serviceProvider,
serviceProvider.GetService <HandshakeFinishedService>(),
handshake));
}
private void OnFinishedMessage(FinishedMessage message)
{
_processingMessage = false;
}
