/// <summary>
/// Called when an application request to send a file
/// </summary>
/// <param name="client"></param>
private void AcceptFile(Socket client)
{
try
{
HandshakeData data = this._receiver.Handshake(client);
if (data == null)
{
return;
}
DialogResult result = UIMessage.Ask(this, "A computer " + data.MachineName +
" wishes to transfer a file " + data.FileName +
" of size" + this.ToSize(data.FileLen) +
"\r\nAccept?", "Receive file");
this._receiver.HandshakeResponse(client, result == DialogResult.Yes);
///If user decided to not receive the file
if (result == DialogResult.No)
{
return;
}
///Fire the delegate that will call the ShowReceiveFileForm method
this.BeginInvoke(new OpenReceiveFormCallback(this.ShowReceiveFileForm), client, data);
}
catch (Exception)
{
}
}
public void Handshake()
{
LogManager.SetupLogManager();
var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
log.Info("Start");
HandshakeData handshake_data = null;
var socket = new Socket(CreateOptionsSecure());
socket.On(Socket.EVENT_HANDSHAKE, (data) =>
{
log.Info(Socket.EVENT_HANDSHAKE + string.Format(" data = {0}", data));
handshake_data = data as HandshakeData;
});
socket.Open();
System.Threading.Thread.Sleep(TimeSpan.FromSeconds(4));
socket.Close();
Assert.IsNotNull(handshake_data);
Assert.IsNotNull(handshake_data.Upgrades);
Assert.IsTrue(handshake_data.Upgrades.Count > 0);
Assert.IsTrue(handshake_data.PingInterval > 0);
Assert.IsTrue(handshake_data.PingTimeout > 0);
}
public void Call(params object[] args)
{
var log = LogManager.GetLogger(Global.CallerName());
log.Info(string.Format("open args[0]={0} args.Length={1}", args[0], args.Length));
HandshakeData = args[0] as HandshakeData;
}
public void Handshake()
{
LogManager.SetupLogManager();
var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
log.Info("Start");
_manualResetEvent = new ManualResetEvent(false);
HandshakeData handshake_data = null;
var socket = new Socket(CreateOptions());
socket.On(Socket.EVENT_HANDSHAKE, (data) =>
{
log.Info(Socket.EVENT_HANDSHAKE + string.Format(" data = {0}", data));
handshake_data = data as HandshakeData;
_manualResetEvent.Set();
});
socket.Open();
_manualResetEvent.WaitOne();
socket.Close();
Assert.IsNotNull(handshake_data);
Assert.IsNotNull(handshake_data.Upgrades);
Assert.IsTrue(handshake_data.Upgrades.Count > 0);
Assert.IsTrue(handshake_data.PingInterval > 0);
Assert.IsTrue(handshake_data.PingTimeout > 0);
}
public void Handshake()
{
_manualResetEvent = new ManualResetEvent(false);
HandshakeData handshake_data = null;
var socket = new Socket(CreateOptionsSecure());
socket.On(Socket.EVENT_HANDSHAKE, (data) =>
{
//log.Info(Socket.EVENT_HANDSHAKE + string.Format(" data = {0}", data));
handshake_data = data as HandshakeData;
_manualResetEvent.Set();
});
socket.Open();
_manualResetEvent.WaitOne();
socket.Close();
Assert.NotNull(handshake_data);
Assert.NotNull(handshake_data.Upgrades);
Assert.True(handshake_data.Upgrades.Count > 0);
Assert.True(handshake_data.PingInterval > 0);
Assert.True(handshake_data.PingTimeout > 0);
}
public async Task <Handshake> GetHandshakeAsync()
{
var chain = await _blockchainService.GetChainAsync();
var handshakeData = new HandshakeData
{
ChainId = chain.Id,
Version = KernelConstants.ProtocolVersion,
ListeningPort = _networkOptions.ListeningPort,
Pubkey = ByteString.CopyFrom(await _accountService.GetPublicKeyAsync()),
BestChainHash = chain.BestChainHash,
BestChainHeight = chain.BestChainHeight,
LastIrreversibleBlockHash = chain.LastIrreversibleBlockHash,
LastIrreversibleBlockHeight = chain.LastIrreversibleBlockHeight,
Time = TimestampHelper.GetUtcNow()
};
var signature = await _accountService.SignAsync(Hash.FromMessage(handshakeData).ToByteArray());
var handshake = new Handshake
{
HandshakeData = handshakeData,
SessionId = ByteString.CopyFrom(GenerateRandomToken()),
Signature = ByteString.CopyFrom(signature)
};
return(handshake);
}
public void Call(params object[] args)
{
LogManager.SetupLogManager();
var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
log.Info(string.Format("open args[0]={0} args.Length={1}", args[0], args.Length));
HandshakeData = args[0] as HandshakeData;
}
public void Call(params object[] args)
{
var log = LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod());
log.Info(string.Format("open args[0]={0} args.Length={1}", args[0], args.Length));
HandshakeData = args[0] as HandshakeData;
serverConnectionTest._manualResetEvent.Set();
}
public AlphaWebSocketConnection(AlphaContext context, WebSocket webSocket, string ip)
: base(context, webSocket, ip, 1024, 64 * 1024)
{
var hd = new HandshakeData();
hd.Randomize();
HandshakeData = hd;
_ = SendMessage(new HandshakeInit {
HandshakeData = hd
});
}
public AlphaWebSocketConnection(WebSocket webSocket, string ip)
: base(webSocket, ip)
{
var hd = new HandshakeData();
hd.Randomize();
HandshakeData = hd;
_ = SendMessage(new HandshakeInit {
HandshakeData = hd
});
#if !DEBUG
InitTimer();
#endif
}
public Handshake CreateValidHandshake(ECKeyPair producer, long bestChainHeight, int chainId = NetworkTestConstants.DefaultChainId)
{
var data = new HandshakeData
{
BestChainHead = CreateFakeBlockHeader(chainId, bestChainHeight, producer),
LibBlockHeight = 1,
Pubkey = ByteString.CopyFrom(producer.PublicKey)
};
var signature = CryptoHelper.SignWithPrivateKey(producer.PrivateKey, Hash.FromMessage(data).ToByteArray());
return(new Handshake {
HandshakeData = data, Signature = ByteString.CopyFrom(signature)
});
}
public Handshake CreateHandshake(ECKeyPair initiatorPeer, int chainId = NetworkTestConstants.DefaultChainId)
{
var data = new HandshakeData
{
ChainId = _blockchainService.GetChainId(),
Version = KernelConstants.ProtocolVersion,
Pubkey = ByteString.CopyFrom(initiatorPeer.PublicKey),
Time = TimestampHelper.GetUtcNow()
};
var signature = CryptoHelper.SignWithPrivateKey(initiatorPeer.PrivateKey, Hash.FromMessage(data).ToByteArray());
return(new Handshake {
HandshakeData = data, Signature = ByteString.CopyFrom(signature)
});
}
public void Test()
{
var json = @"{
sid: 'nne323',
upgrades: ['u1','u2'],
pingInterval: 12,
pingTimeout: 23
}";
var handshakeData = new HandshakeData(json);
Assert.Equal("u1", handshakeData.Upgrades[0]);
Assert.Equal("u2", handshakeData.Upgrades[1]);
Assert.Equal(12, handshakeData.PingInterval);
Assert.Equal(23, handshakeData.PingTimeout);
}
public void HandshakeInvalidDataTest()
{
Global.AppState.State = ApplicationState.Ready;
var clientConnection = new AlphaWebSocketConnection(new FakeWebSocket(), "127.0.0.1");
var handshake = new HandshakeData();
handshake.Randomize();
var envelope = new HandshakeInit {
HandshakeData = handshake
}.CreateEnvelope();
envelope.Sign(TestEnvironment.Client1KeyPair);
Assert.ThrowsAsync <ConnectionCloseException>(async() => await MessageHandlers <AlphaWebSocketConnection> .HandleMessage(clientConnection, envelope));
}
public async Task HandshakeTest()
{
Global.AppState.State = ApplicationState.Running;
var clientConnection = new AuditorWebSocketConnection(new FakeWebSocket(), null);
var hd = new HandshakeData();
hd.Randomize();
var envelope = new HandshakeInit {
HandshakeData = hd
}.CreateEnvelope();
envelope.Sign(TestEnvironment.AlphaKeyPair);
var isHandled = await MessageHandlers <AuditorWebSocketConnection> .HandleMessage(clientConnection, envelope);
Assert.IsTrue(isHandled);
}
public void TestMethod1()
{
string b64InputKey = "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEVQxN/wFsMiYihwv1psUgKRIhgX02OPBQl0aKYNtKXoCk67hE/lsR8UC77Fqm1HPuMALWG8RcihSHoZwx2HfOz11QkwvlKEf8UuMrbp0yt/mQNJx6QQm6CiZ7e63sYqdV";
ECPublicKeyParameters asyKey = (ECPublicKeyParameters)
PublicKeyFactory.CreateKey(b64InputKey.DecodeBase64Url());
ECParameters param = new ECParameters();
param.Curve = ECCurve.NamedCurves.nistP384;
param.Q.X = asyKey.Q.AffineXCoord.GetEncoded();
param.Q.Y = asyKey.Q.AffineYCoord.GetEncoded();
var ecPublicKey = ECDiffieHellman.Create(param).PublicKey;
var effi = ECDiffieHellman.Create(ECCurve.NamedCurves.nistP384);
ECParameters privateKey = effi.ExportParameters(true);
var secretPrepend = Encoding.UTF8.GetBytes("RANDOM SECRET");
byte[] secret = effi.DeriveKeyFromHash(ecPublicKey, HashAlgorithmName.SHA256, secretPrepend, new byte[0]);
IBufferedCipher decryptor = CipherUtilities.GetCipher("AES/CFB8/NoPadding");
IBufferedCipher encryptor = CipherUtilities.GetCipher("AES/CFB8/NoPadding");
decryptor.Init(false, new ParametersWithIV(new KeyParameter(secret), secret.Take(16).ToArray()));
encryptor.Init(true, new ParametersWithIV(new KeyParameter(secret), secret.Take(16).ToArray()));
string b64PublicKey = effi.PublicKey.ToDerEncoded().EncodeBase64();
var handshakeJson = new HandshakeData()
{
salt = secretPrepend.EncodeBase64()
};
var signKey = ECDsa.Create(privateKey);
string val = JWT.Encode(handshakeJson, signKey, JwsAlgorithm.ES384, new Dictionary <string, object> {
{ "x5u", b64PublicKey }
});
//Log.Warn($"Headers: {string.Join(";", JWT.Headers(val))}");
//Log.Warn($"Return salt:\n{JWT.Payload(val)}");
}
public async Task <Handshake> GetHandshakeAsync()
{
var chain = await _blockchainService.GetChainAsync();
var nd = new HandshakeData
{
Pubkey = ByteString.CopyFrom(await _accountService.GetPublicKeyAsync()),
BestChainHead = await _blockchainService.GetBestChainLastBlockHeaderAsync(),
LibBlockHeight = chain?.LastIrreversibleBlockHeight ?? 0
};
byte[] sig = await _accountService.SignAsync(Hash.FromMessage(nd).ToByteArray());
var hsk = new Handshake
{
HandshakeData = nd,
Signature = ByteString.CopyFrom(sig)
};
return(hsk);
}
private async Task <Handshake> BuildHandshakeAsync()
{
var nd = new HandshakeData
{
ListeningPort = _networkOptions.ListeningPort,
PublicKey = ByteString.CopyFrom(await _accountService.GetPublicKeyAsync()),
Version = KernelConstants.ProtocolVersion,
ChainId = _blockchainService.GetChainId()
};
byte[] sig = await _accountService.SignAsync(Hash.FromMessage(nd).ToByteArray());
var hsk = new Handshake
{
HskData = nd,
Sig = ByteString.CopyFrom(sig),
Header = await _blockchainService.GetBestChainLastBlockHeaderAsync()
};
return(hsk);
}
public static Handshake CreateValidHandshake(ECKeyPair producer, long bestChainHeight, int chainId = NetworkTestConstants.DefaultChainId, int port = 0)
{
var data = new HandshakeData
{
ChainId = chainId,
Version = KernelConstants.ProtocolVersion,
ListeningPort = port,
Pubkey = ByteString.CopyFrom(producer.PublicKey),
BestChainHash = Hash.FromString("BestChainHash"),
BestChainHeight = bestChainHeight,
LastIrreversibleBlockHash = Hash.FromString("LastIrreversibleBlockHash"),
LastIrreversibleBlockHeight = 1,
Time = TimestampHelper.GetUtcNow()
};
var signature = CryptoHelper.SignWithPrivateKey(producer.PrivateKey, Hash.FromMessage(data).ToByteArray());
return(new Handshake {
HandshakeData = data, Signature = ByteString.CopyFrom(signature)
});
}
public void HandshakeInvalidDataTest()
{
context.AppState.State = ApplicationState.Ready;
var clientConnection = new AlphaWebSocketConnection(context, new FakeWebSocket(), "127.0.0.1");
var handshake = new HandshakeData();
handshake.Randomize();
var envelope = new HandshakeInit {
HandshakeData = handshake
}.CreateEnvelope();
envelope.Sign(TestEnvironment.Client1KeyPair);
using var writer = new XdrBufferWriter();
var inMessage = envelope.ToIncomingMessage(writer);
Assert.ThrowsAsync <ConnectionCloseException>(async() => await context.MessageHandlers.HandleMessage(clientConnection, inMessage));
}
public async Task HandshakeTest()
{
context.AppState.State = ApplicationState.Running;
var clientConnection = new AuditorWebSocketConnection(context, new FakeAuditorConnectionInfo(new FakeWebSocket()));
var hd = new HandshakeData();
hd.Randomize();
var envelope = new HandshakeInit {
HandshakeData = hd
}.CreateEnvelope();
envelope.Sign(TestEnvironment.AlphaKeyPair);
using var writer = new XdrBufferWriter();
var inMessage = envelope.ToIncomingMessage(writer);
var isHandled = await context.MessageHandlers.HandleMessage(clientConnection, inMessage);
Assert.IsTrue(isHandled);
}
private Handshake CreateHandshake(ECKeyPair initiatorPeer = null, int port = 0)
{
if (initiatorPeer == null)
{
initiatorPeer = CryptoHelper.GenerateKeyPair();
}
var data = new HandshakeData
{
ChainId = _blockchainService.GetChainId(),
Version = KernelConstants.ProtocolVersion,
Pubkey = ByteString.CopyFrom(initiatorPeer.PublicKey),
Time = TimestampHelper.GetUtcNow(),
ListeningPort = port
};
var signature =
CryptoHelper.SignWithPrivateKey(initiatorPeer.PrivateKey, HashHelper.ComputeFrom(data).ToByteArray());
return(new Handshake {
HandshakeData = data, Signature = ByteString.CopyFrom(signature)
});
}
/// <summary> /// /// </summary> /// <param name="handshakeData"></param> /// <returns></returns> protected abstract bool CheckSignKey(HandshakeData handshakeData);
/// <summary>
///
/// </summary>
/// <param name="handshakeData"></param>
/// <returns></returns>
protected override bool CheckSignKey(HandshakeData handshakeData)
{
byte[] secAccept;
byte[] signKey;
if (handshakeData.ParamItems.TryGet(HandshakeHeadKeys.SecAccept, out secAccept) &&
handshakeData.ParamItems.TryGet(HandshakeHeadKeys.SecSignKey, out signKey))
{
return secAccept.IndexOf(signKey) != -1;
}
return false;
}
private string GenreateKey(HandshakeData handshakeData)
{
string key;
if (handshakeData.ParamItems.TryGet(HandshakeHeadKeys.SecKey, out key))
{
return GenreateKey(key);
}
return string.Empty;
}
/// <summary>
///
/// </summary>
/// <param name="socket"></param>
/// <param name="handshakeData"></param>
/// <returns></returns>
protected override bool ResponseHandshake(ExSocket socket, HandshakeData handshakeData)
{
if (handshakeData.WebSocketVersion < _version)
{
return base.ResponseHandshake(socket, handshakeData);
}
string secKeyAccept = GenreateKey(handshakeData);
StringBuilder response = new StringBuilder();
response.AppendLine(HandshakeHeadKeys.RespHead_10);
response.AppendLine(HandshakeHeadKeys.RespUpgrade);
response.AppendLine(HandshakeHeadKeys.RespConnection);
response.AppendLine(string.Format(HandshakeHeadKeys.RespAccept, secKeyAccept));
if (!string.IsNullOrEmpty(handshakeData.Protocol))
{
response.AppendLine(string.Format(HandshakeHeadKeys.RespProtocol, handshakeData.Protocol));
}
response.AppendLine();
Handler.SendMessage(socket, response.ToString(), Encoding, result => { });
return true;
}
/// <summary>
///
/// </summary>
/// <param name="handshakeData"></param>
/// <returns></returns>
protected override bool CheckSignKey(HandshakeData handshakeData)
{
if (handshakeData.WebSocketVersion < _version)
{
return base.CheckSignKey(handshakeData);
}
string signKey;
string accecpKey;
if (handshakeData.ParamItems.TryGet(HandshakeHeadKeys.SecAccept, out accecpKey) &&
handshakeData.ParamItems.TryGet(HandshakeHeadKeys.SecSignKey, out signKey))
{
return string.Equals(signKey, accecpKey);
}
return false;
}
/// <summary> /// /// </summary> /// <param name="socket"></param> /// <param name="handshakeData"></param> protected abstract bool ResponseHandshake(ExSocket socket, HandshakeData handshakeData);
/// <summary>
///
/// </summary>
/// <param name="handshake"></param>
/// <param name="cookieStr"></param>
/// <returns></returns>
protected void ParseCookies(HandshakeData handshake, string cookieStr)
{
if (handshake == null) return;
if (handshake.Cookies == null)
{
handshake.Cookies = new Dictionary<string, string>();
}
var array = cookieStr.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var item in array)
{
var kvs = item.Split('=');
if (kvs.Length == 2 && !string.IsNullOrEmpty(kvs[0]))
{
handshake.Cookies[Uri.UnescapeDataString(kvs[0])] = Uri.UnescapeDataString(kvs[1].Trim());
}
}
}
/// <summary>
/// Called when handshake is completed
/// </summary>
/// <param name="client"></param>
/// <param name="data"></param>
private void ShowReceiveFileForm(Socket client, HandshakeData data)
{
ReceiveFile_Form receiveForm = new ReceiveFile_Form(this._receiver, client, data);
receiveForm.Show(this);
}
/// <summary>
///
/// </summary>
/// <param name="socket"></param>
/// <param name="handshakeData"></param>
/// <returns></returns>
protected override bool ResponseHandshake(ExSocket socket, HandshakeData handshakeData)
{
string secKey1;
string secKey2;
byte[] secKey3;
if (handshakeData.ParamItems.TryGet(HandshakeHeadKeys.SecKey1, out secKey1) &&
handshakeData.ParamItems.TryGet(HandshakeHeadKeys.SecKey2, out secKey2) &&
handshakeData.ParamItems.TryGet(HandshakeHeadKeys.SecKey3, out secKey3))
{
//The minimum version support
StringBuilder response = new StringBuilder();
response.AppendLine(HandshakeHeadKeys.RespHead_00);
response.AppendLine(HandshakeHeadKeys.RespUpgrade00);
response.AppendLine(HandshakeHeadKeys.RespConnection);
string origin;
if (handshakeData.ParamItems.TryGet(HandshakeHeadKeys.Origin, out origin))
{
response.AppendLine(string.Format(HandshakeHeadKeys.RespOriginLine, origin));
}
response.AppendLine(string.Format(HandshakeHeadKeys.SecLocation, handshakeData.UriSchema, handshakeData.Host, handshakeData.UrlPath));
if (!string.IsNullOrEmpty(handshakeData.Protocol))
{
response.AppendLine(string.Format(HandshakeHeadKeys.RespProtocol, handshakeData.Protocol));
}
response.AppendLine();
Handler.SendMessage(socket, response.ToString(), Encoding, result => { });
//Encrypt message
byte[] securityKey = GetResponseSecurityKey(secKey1, secKey2, secKey3);
Handler.SendMessage(socket, securityKey, result => { });
return true;
}
return false;
}
public void Call(params object[] args)
{
//log.Info(string.Format("open args[0]={0} args.Length={1}", args[0], args.Length));
HandshakeData = args[0] as HandshakeData;
serverConnectionTest._manualResetEvent.Set();
}
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="handshakeData"></param>
/// <param name="error"></param>
/// <returns></returns>
protected virtual bool TryParseHandshake(string message, HandshakeData handshakeData, out string error)
{
using (var reader = new StringReader(message))
{
error = string.Empty;
string headData = reader.ReadLine() ?? "";
var headParams = headData.Split(' ');
if (headParams.Length < 3 ||
(headParams[0] != HandshakeHeadKeys.Method && headParams[0] != HandshakeHeadKeys.HttpVersion))
{
return false;
}
bool isResponse = headParams[0] == HandshakeHeadKeys.HttpVersion;
if (!isResponse)
{
if (Handler.IsSecurity) handshakeData.UriSchema = "wss";
handshakeData.Method = headParams[0];
handshakeData.UrlPath = headParams[1];
handshakeData.HttpVersion = headParams[2];
}
string paramStr;
while (!string.IsNullOrEmpty(paramStr = reader.ReadLine()))
{
//ex: Upgrade: WebSocket
var paramArr = paramStr.Split(':');
if (paramArr.Length < 2)
{
continue;
}
string key = paramArr[0].Trim();
//value includ spance char
string value = string.Join("", paramArr, 1, paramArr.Length - 1);
if (value.Length > 1) value = value.Substring(1); //pre char is spance
if (string.IsNullOrEmpty(key))
{
continue;
}
if (string.Equals(HandshakeHeadKeys.Host, key))
{
handshakeData.Host = value;
continue;
}
if (string.Equals(HandshakeHeadKeys.SecVersion, key))
{
handshakeData.WebSocketVersion = value.ToInt();
continue;
}
if (string.Equals(HandshakeHeadKeys.SecProtocol, key))
{
handshakeData.Protocol = GetFirstProtocol(value);
continue;
}
if (string.Equals(HandshakeHeadKeys.Cookie, key))
{
ParseCookies(handshakeData, value);
continue;
}
handshakeData.ParamItems[key] = value;
}
if (handshakeData.ParamItems.ContainsKey(HandshakeHeadKeys.Upgrade) &&
handshakeData.ParamItems.ContainsKey(HandshakeHeadKeys.Connection))
{
return true;
}
error = "not support websocket ";
}
return false;
}
