private HandshakeMessage createClientHandshakeMessage(
HandshakeType type, byte[] buffer)
{
switch (type)
{
case HandshakeType.ClientHello:
return(new TlsClientHello(this.context, buffer));
case HandshakeType.Certificate:
return(new TlsClientCertificate(this.context, buffer));
case HandshakeType.ClientKeyExchange:
return(new TlsClientKeyExchange(this.context, buffer));
case HandshakeType.CertificateVerify:
return(new TlsClientCertificateVerify(this.context, buffer));
case HandshakeType.Finished:
return(new TlsClientFinished(this.context, buffer));
default:
throw new TlsException(
AlertDescription.UnexpectedMessage,
String.Format(CultureInfo.CurrentUICulture,
"Unknown server handshake message received ({0})",
type.ToString()));
}
}
private HandshakeMessage createClientHandshakeMessage(
HandshakeType type, byte[] buffer)
{
var last = context.LastHandshakeMsg;
switch (type)
{
case HandshakeType.ClientHello:
return(new TlsClientHello(context, buffer));
case HandshakeType.Certificate:
if (last != HandshakeType.ClientHello)
{
break;
}
cert = new TlsClientCertificate(context, buffer);
return(cert);
case HandshakeType.ClientKeyExchange:
if (last == HandshakeType.ClientHello || last == HandshakeType.Certificate)
{
return(new TlsClientKeyExchange(context, buffer));
}
break;
case HandshakeType.CertificateVerify:
if (last == HandshakeType.ClientKeyExchange && cert != null)
{
return(new TlsClientCertificateVerify(context, buffer));
}
break;
case HandshakeType.Finished:
// Certificates are optional, but if provided, they should send a CertificateVerify
var hasCert = cert != null && cert.HasCertificate;
var check = hasCert
? last == HandshakeType.CertificateVerify
: last == HandshakeType.ClientKeyExchange;
// ChangeCipherSpecDone is not an handshake message (it's a content type) but still needs to be happens before finished
if (check && context.ChangeCipherSpecDone)
{
context.ChangeCipherSpecDone = false;
return(new TlsClientFinished(context, buffer));
}
break;
default:
throw new TlsException(AlertDescription.UnexpectedMessage, string.Format(
CultureInfo.CurrentUICulture,
"Unknown server handshake message received ({0})",
type.ToString()));
}
throw new TlsException(AlertDescription.HandshakeFailiure,
string.Format("Protocol error, unexpected protocol transition from {0} to {1}", last, type));
}
private HandshakeMessage createServerHandshakeMessage(
HandshakeType type, byte[] buffer)
{
ClientContext context = (ClientContext)this.context;
switch (type)
{
case HandshakeType.HelloRequest:
if (context.HandshakeState != HandshakeState.Started)
{
context.HandshakeState = HandshakeState.None;
// re-negotiation will occur at next read/write
// (i.e. not during an existing encode/decode op)
}
else
{
this.SendAlert(
AlertLevel.Warning,
AlertDescription.NoRenegotiation);
}
return(null);
case HandshakeType.ServerHello:
return(new TlsServerHello(this.context, buffer));
case HandshakeType.Certificate:
return(new TlsServerCertificate(this.context, buffer));
case HandshakeType.ServerKeyExchange:
return(new TlsServerKeyExchange(this.context, buffer));
case HandshakeType.CertificateRequest:
return(new TlsServerCertificateRequest(this.context, buffer));
case HandshakeType.ServerHelloDone:
return(new TlsServerHelloDone(this.context, buffer));
case HandshakeType.Finished:
return(new TlsServerFinished(this.context, buffer));
default:
throw new TlsException(
AlertDescription.UnexpectedMessage,
String.Format(CultureInfo.CurrentUICulture,
"Unknown server handshake message received ({0})",
type.ToString()));
}
}
private HandshakeMessage createServerHandshakeMessage(HandshakeType type, byte[] buffer)
{
ClientContext clientContext = (ClientContext)this.context;
switch (type)
{
case HandshakeType.Certificate:
return(new TlsServerCertificate(this.context, buffer));
case HandshakeType.ServerKeyExchange:
return(new TlsServerKeyExchange(this.context, buffer));
case HandshakeType.CertificateRequest:
return(new TlsServerCertificateRequest(this.context, buffer));
case HandshakeType.ServerHelloDone:
return(new TlsServerHelloDone(this.context, buffer));
default:
switch (type)
{
case HandshakeType.HelloRequest:
if (clientContext.HandshakeState != HandshakeState.Started)
{
clientContext.HandshakeState = HandshakeState.None;
}
else
{
base.SendAlert(AlertLevel.Warning, AlertDescription.NoRenegotiation);
}
return(null);
case HandshakeType.ServerHello:
return(new TlsServerHello(this.context, buffer));
}
throw new TlsException(AlertDescription.UnexpectedMessage, string.Format(CultureInfo.CurrentUICulture, "Unknown server handshake message received ({0})", new object[]
{
type.ToString()
}));
case HandshakeType.Finished:
return(new TlsServerFinished(this.context, buffer));
}
}
/// <summary>
/// Handshake with the Audioscrobbler service
/// </summary>
/// <returns>True if the connection was successful, false otherwise</returns>
private static void DoHandshake(bool forceNow_, HandshakeType ReasonForHandshake)
{
if (_useDebugLog)
{
Log.Debug("AudioscrobblerBase: Attempting {0} handshake", ReasonForHandshake.ToString());
}
// Handle uninitialized username/password.
if (username.Length < 1 || password.Length < 1)
{
Log.Error("AudioscrobblerBase: {0}", "user or password not defined");
workerFailed(ReasonForHandshake, DateTime.MinValue, new Exception("Account details insufficent"));
return;
}
if (!forceNow_ || ReasonForHandshake != HandshakeType.Recover)
{
// Check whether we had a *successful* handshake recently.
if (DateTime.Now < lastHandshake.Add(handshakeInterval))
{
string nexthandshake = lastHandshake.Add(handshakeInterval).ToString();
string logmessage = "Next handshake due at " + nexthandshake;
if (_useDebugLog)
{
Log.Debug("AudioscrobblerBase: {0}", logmessage);
}
workerSuccess(ReasonForHandshake, lastHandshake);
return;
}
}
if (ReasonForHandshake != HandshakeType.Init)
{
if (ReasonForHandshake == HandshakeType.PreRadio)
{
Log.Warn("AudioscrobblerBase: Disconnected - nevertheless trying radio handshake to listen without submits");
AttemptRadioHandshake();
return;
}
//else
//{
// Log.Warn("AudioscrobblerBase: Disconnected - not attempting {0} handshake", ReasonForHandshake.ToString());
// workerFailed(ReasonForHandshake, DateTime.MinValue, new Exception("Disconnected!"));
// return;
//}
}
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += new DoWorkEventHandler(Worker_TryHandshake);
worker.RunWorkerAsync(ReasonForHandshake);
}
private HandshakeMessage createServerHandshakeMessage(
HandshakeType type)
{
switch (type)
{
case HandshakeType.HelloRequest:
this.SendRecord(HandshakeType.ClientHello);
return(null);
case HandshakeType.ServerHello:
return(new TlsServerHello(this.context));
case HandshakeType.Certificate:
return(new TlsServerCertificate(this.context));
case HandshakeType.ServerKeyExchange:
return(new TlsServerKeyExchange(this.context));
case HandshakeType.CertificateRequest:
return(new TlsServerCertificateRequest(this.context));
case HandshakeType.ServerHelloDone:
return(new TlsServerHelloDone(this.context));
case HandshakeType.Finished:
return(new TlsServerFinished(this.context));
default:
throw new InvalidOperationException("Unknown server handshake message type: " + type.ToString());
}
}
private HandshakeMessage createClientHandshakeMessage(
HandshakeType type,
byte[] buffer)
{
HandshakeType handshakeType = type;
switch (handshakeType)
{
case HandshakeType.CertificateVerify:
return((HandshakeMessage) new TlsClientCertificateVerify(this.context, buffer));
case HandshakeType.ClientKeyExchange:
return((HandshakeMessage) new TlsClientKeyExchange(this.context, buffer));
case HandshakeType.Finished:
return((HandshakeMessage) new TlsClientFinished(this.context, buffer));
default:
if (handshakeType == HandshakeType.ClientHello)
{
return((HandshakeMessage) new TlsClientHello(this.context, buffer));
}
if (handshakeType == HandshakeType.Certificate)
{
return((HandshakeMessage) new TlsClientCertificate(this.context, buffer));
}
throw new TlsException(AlertDescription.UnexpectedMessage, string.Format((IFormatProvider)CultureInfo.CurrentUICulture, "Unknown server handshake message received ({0})", (object)type.ToString()));
}
}
private HandshakeMessage createServerHandshakeMessage(
HandshakeType type, byte[] buffer)
{
ClientContext context = (ClientContext)this.context;
switch (type)
{
case HandshakeType.HelloRequest:
if (context.HandshakeState != HandshakeState.Started)
{
context.HandshakeState = HandshakeState.None;
// re-negotiation will occur at next read/write
// (i.e. not during an existing encode/decode op)
}
else
{
this.SendAlert(
AlertLevel.Warning,
AlertDescription.NoRenegotiation);
}
return null;
case HandshakeType.ServerHello:
return new TlsServerHello(this.context, buffer);
case HandshakeType.Certificate:
return new TlsServerCertificate(this.context, buffer);
case HandshakeType.ServerKeyExchange:
return new TlsServerKeyExchange(this.context, buffer);
case HandshakeType.CertificateRequest:
return new TlsServerCertificateRequest(this.context, buffer);
case HandshakeType.ServerHelloDone:
return new TlsServerHelloDone(this.context, buffer);
case HandshakeType.Finished:
return new TlsServerFinished(this.context, buffer);
default:
throw new TlsException(
AlertDescription.UnexpectedMessage,
String.Format(CultureInfo.CurrentUICulture,
"Unknown server handshake message received ({0})",
type.ToString()));
}
}
private HandshakeMessage createClientHandshakeMessage(HandshakeType type)
{
switch (type)
{
case HandshakeType.ClientHello:
return new TlsClientHello(this.context);
case HandshakeType.Certificate:
return new TlsClientCertificate(this.context);
case HandshakeType.ClientKeyExchange:
return new TlsClientKeyExchange(this.context);
case HandshakeType.CertificateVerify:
return new TlsClientCertificateVerify(this.context);
case HandshakeType.Finished:
return new TlsClientFinished(this.context);
default:
throw new InvalidOperationException("Unknown client handshake message type: " + type.ToString() );
}
}
private HandshakeMessage createClientHandshakeMessage(
HandshakeType type, byte[] buffer)
{
var last = context.LastHandshakeMsg;
switch (type)
{
case HandshakeType.ClientHello:
return new TlsClientHello(this.context, buffer);
case HandshakeType.Certificate:
if (last != HandshakeType.ClientHello)
break;
cert = new TlsClientCertificate(this.context, buffer);
return cert;
case HandshakeType.ClientKeyExchange:
if (last == HandshakeType.ClientHello || last == HandshakeType.Certificate)
return new TlsClientKeyExchange(this.context, buffer);
break;
case HandshakeType.CertificateVerify:
if (last == HandshakeType.ClientKeyExchange && cert != null)
return new TlsClientCertificateVerify(this.context, buffer);
break;
case HandshakeType.Finished:
// Certificates are optional, but if provided, they should send a CertificateVerify
bool check = (cert == null) ? (last == HandshakeType.ClientKeyExchange || last == HandshakeType.ClientHello) : (last == HandshakeType.CertificateVerify);
// ChangeCipherSpecDone is not an handshake message (it's a content type) but still needs to be happens before finished
if (check && context.ChangeCipherSpecDone) {
context.ChangeCipherSpecDone = false;
return new TlsClientFinished(this.context, buffer);
}
break;
default:
throw new TlsException(AlertDescription.UnexpectedMessage, String.Format(CultureInfo.CurrentUICulture,
"Unknown server handshake message received ({0})",
type.ToString()));
break;
}
throw new TlsException (AlertDescription.HandshakeFailiure, String.Format ("Protocol error, unexpected protocol transition from {0} to {1}", last, type));
}
private HandshakeMessage createServerHandshakeMessage(
HandshakeType type)
{
switch (type)
{
case HandshakeType.HelloRequest:
this.SendRecord(HandshakeType.ClientHello);
return null;
case HandshakeType.ServerHello:
return new TlsServerHello(this.context);
case HandshakeType.Certificate:
return new TlsServerCertificate(this.context);
case HandshakeType.ServerKeyExchange:
return new TlsServerKeyExchange(this.context);
case HandshakeType.CertificateRequest:
return new TlsServerCertificateRequest(this.context);
case HandshakeType.ServerHelloDone:
return new TlsServerHelloDone(this.context);
case HandshakeType.Finished:
return new TlsServerFinished(this.context);
default:
throw new InvalidOperationException("Unknown server handshake message type: " + type.ToString() );
}
}
private HandshakeMessage createServerHandshakeMessage(
HandshakeType type, byte[] buffer)
{
ClientContext context = (ClientContext)this.context;
var last = context.LastHandshakeMsg;
switch (type)
{
case HandshakeType.HelloRequest:
if (context.HandshakeState != HandshakeState.Started)
{
context.HandshakeState = HandshakeState.None;
// re-negotiation will occur at next read/write
// (i.e. not during an existing encode/decode op)
}
else
{
this.SendAlert(
AlertLevel.Warning,
AlertDescription.NoRenegotiation);
}
return(null);
case HandshakeType.ServerHello:
if (last != HandshakeType.HelloRequest)
{
break;
}
return(new TlsServerHello(this.context, buffer));
// Optional
case HandshakeType.Certificate:
if (last != HandshakeType.ServerHello)
{
break;
}
return(new TlsServerCertificate(this.context, buffer));
// Optional
case HandshakeType.CertificateRequest:
if (last == HandshakeType.ServerKeyExchange || last == HandshakeType.Certificate)
{
return(new TlsServerCertificateRequest(this.context, buffer));
}
break;
case HandshakeType.ServerHelloDone:
if (last == HandshakeType.CertificateRequest || last == HandshakeType.Certificate || last == HandshakeType.ServerHello)
{
return(new TlsServerHelloDone(this.context, buffer));
}
break;
case HandshakeType.Finished:
// depends if a full (ServerHelloDone) or an abbreviated handshake (ServerHello) is being done
bool check = context.AbbreviatedHandshake ? (last == HandshakeType.ServerHello) : (last == HandshakeType.ServerHelloDone);
// ChangeCipherSpecDone is not an handshake message (it's a content type) but still needs to be happens before finished
if (check && context.ChangeCipherSpecDone)
{
context.ChangeCipherSpecDone = false;
return(new TlsServerFinished(this.context, buffer));
}
break;
default:
throw new TlsException(
AlertDescription.UnexpectedMessage,
String.Format(CultureInfo.CurrentUICulture,
"Unknown server handshake message received ({0})",
type.ToString()));
}
throw new TlsException(AlertDescription.HandshakeFailiure, String.Format("Protocol error, unexpected protocol transition from {0} to {1}", last, type));
}
private HandshakeMessage createClientHandshakeMessage(HandshakeType type)
{
switch (type)
{
case HandshakeType.ClientHello:
return(new TlsClientHello(this.context));
case HandshakeType.Certificate:
return(new TlsClientCertificate(this.context));
case HandshakeType.ClientKeyExchange:
return(new TlsClientKeyExchange(this.context));
case HandshakeType.CertificateVerify:
return(new TlsClientCertificateVerify(this.context));
case HandshakeType.Finished:
return(new TlsClientFinished(this.context));
default:
throw new InvalidOperationException("Unknown client handshake message type: " + type.ToString());
}
}
private HandshakeMessage createClientHandshakeMessage(
HandshakeType type, byte[] buffer)
{
switch (type)
{
case HandshakeType.ClientHello:
return new TlsClientHello(this.context, buffer);
case HandshakeType.Certificate:
return new TlsClientCertificate(this.context, buffer);
case HandshakeType.ClientKeyExchange:
return new TlsClientKeyExchange(this.context, buffer);
case HandshakeType.CertificateVerify:
return new TlsClientCertificateVerify(this.context, buffer);
case HandshakeType.Finished:
return new TlsClientFinished(this.context, buffer);
default:
throw new TlsException(
AlertDescription.UnexpectedMessage,
String.Format(CultureInfo.CurrentUICulture,
"Unknown server handshake message received ({0})",
type.ToString()));
}
}
private HandshakeMessage createServerHandshakeMessage(
HandshakeType type, byte[] buffer)
{
ClientContext context = (ClientContext)this.context;
var last = context.LastHandshakeMsg;
switch (type)
{
case HandshakeType.HelloRequest:
if (context.HandshakeState != HandshakeState.Started)
{
context.HandshakeState = HandshakeState.None;
// re-negotiation will occur at next read/write
// (i.e. not during an existing encode/decode op)
}
else
{
this.SendAlert(
AlertLevel.Warning,
AlertDescription.NoRenegotiation);
}
return null;
case HandshakeType.ServerHello:
if (last != HandshakeType.HelloRequest)
break;
return new TlsServerHello(this.context, buffer);
// Optional
case HandshakeType.Certificate:
if (last != HandshakeType.ServerHello)
break;
return new TlsServerCertificate(this.context, buffer);
// Optional
case HandshakeType.CertificateRequest:
if (last == HandshakeType.ServerKeyExchange || last == HandshakeType.Certificate)
return new TlsServerCertificateRequest(this.context, buffer);
break;
case HandshakeType.ServerHelloDone:
if (last == HandshakeType.CertificateRequest || last == HandshakeType.Certificate || last == HandshakeType.ServerHello)
return new TlsServerHelloDone(this.context, buffer);
break;
case HandshakeType.Finished:
// depends if a full (ServerHelloDone) or an abbreviated handshake (ServerHello) is being done
bool check = context.AbbreviatedHandshake ? (last == HandshakeType.ServerHello) : (last == HandshakeType.ServerHelloDone);
// ChangeCipherSpecDone is not an handshake message (it's a content type) but still needs to be happens before finished
if (check && context.ChangeCipherSpecDone) {
context.ChangeCipherSpecDone = false;
return new TlsServerFinished (this.context, buffer);
}
break;
default:
throw new TlsException(
AlertDescription.UnexpectedMessage,
String.Format(CultureInfo.CurrentUICulture,
"Unknown server handshake message received ({0})",
type.ToString()));
}
throw new TlsException (AlertDescription.HandshakeFailiure, String.Format ("Protocol error, unexpected protocol transition from {0} to {1}", last, type));
}