public void Serialize() { var crypto = new RSACryptoServiceProvider(); var p = new RSAAsymmetricKey(crypto.ExportCspBlob(true)); byte[] buffer = new byte[20480]; var writer = new BufferValueWriter(buffer); p.Serialize(null, writer); int len = writer.Length; writer.Flush(); var reader = new BufferValueReader(buffer); var key = new RSAAsymmetricKey(null, reader); Assert.AreEqual(len, reader.Position); Assert.IsNull(key.D); Assert.IsNull(key.DP); Assert.IsNull(key.DQ); AssertArrayMatches(p.Exponent, key.Exponent); Assert.IsNull(key.InverseQ); AssertArrayMatches(p.Modulus, key.Modulus); Assert.IsNull(key.P); Assert.IsNull(key.Q); Assert.IsNotNull(key.PublicSignature); }
public void ConnectedWithKey() { this.provider.Start(MessageTypes); RSAAsymmetricKey key = null; var test = new AsyncTest(e => { var ce = (ConnectionMadeEventArgs)e; Assert.IsNotNull(ce.ClientPublicKey); Assert.AreEqual(key, ce.ClientPublicKey); }); this.provider.ConnectionMade += test.PassHandler; var c = GetNewClientConnection(out key); if (key == null) { Assert.Ignore(); } c.ConnectAsync(Target, MessageTypes); test.Assert(10000); }
static void Main(string[] args) { Console.WriteLine("Getting server key..."); RSAAsymmetricKey key = GetKey("server.key"); Console.WriteLine("Got it."); var provider = new NetworkConnectionProvider( new[] { SocialProtocol.Instance }, new Target(Target.AnyIP, 42912), 10000, key); SocialServer server = new SocialServer(new MemoryWatchListProvider(), IdentityProvider); server.ConnectionMade += OnConnectionMade; server.AddConnectionProvider(provider); server.Start(); Console.WriteLine("Server ready."); while (true) { Thread.Sleep(1000); } }
public UdpConnectionProvider(int port, Protocol protocol, RSAAsymmetricKey authKey) : base(new[] { protocol }, port) { if (protocol == null) { throw new ArgumentNullException("protocol"); } if (authKey == null) { throw new ArgumentNullException("authKey"); } if (port <= 0) { throw new ArgumentOutOfRangeException("port"); } this.crypto = new RSACrypto(); this.crypto.ImportKey(authKey); this.pkEncryption = new RSACrypto(); this.pkEncryption.ImportKey(authKey); this.authKey = authKey; ValidateProtocols(this.protocols.Values); }
protected NetworkConnection(IEnumerable <Protocol> protocols, RSAAsymmetricKey authKey, bool generateKey) { if (protocols == null) { throw new ArgumentNullException("protocols"); } this.authenticationKey = authKey; this.requiresHandshake = protocols.Any(p => p.id != 1 && p.RequiresHandshake); if (this.requiresHandshake) { ThreadPool.QueueUserWorkItem(s => { this.pkAuthentication = new RSACrypto(); if (this.authenticationKey == null) { if (generateKey) { this.publicAuthenticationKey = this.pkAuthentication.ExportKey(false); this.authenticationKey = this.pkAuthentication.ExportKey(true); } } else { this.pkAuthentication.ImportKey(authKey); this.publicAuthenticationKey = this.pkAuthentication.ExportKey(false); } this.authReady = true; }); } this.protocols = new Dictionary <byte, Protocol>(); foreach (Protocol p in protocols) { if (p == null) { throw new ArgumentNullException("protocols", "protocols contains a null protocol"); } if (this.protocols.ContainsKey(p.id)) { throw new ArgumentException("Only one version of a protocol may be specified"); } this.protocols.Add(p.id, p); } this.protocols[1] = TempestMessage.InternalProtocol; //this.sendArgs.SetBuffer (new byte[1024], 0, 1024); //this.sendArgs.Completed += ReliableSendCompleted; #if TRACE this.connectionId = Interlocked.Increment(ref nextConnectionId); this.typeName = GetType().Name; Trace.WriteLineIf(NTrace.TraceVerbose, String.Empty, this.typeName + ":" + this.connectionId + " Ctor"); #endif }
public UdpClientConnection(Protocol protocol, RSAAsymmetricKey key) : this(new[] { protocol }, key) { if (protocol == null) { throw new ArgumentNullException("protocol"); } }
internal UdpConnection(IEnumerable <Protocol> protocols, RSACrypto remoteCrypto, RSACrypto localCrypto, RSAAsymmetricKey localKey) : this(protocols) { this.remoteCrypto = remoteCrypto; this.localCrypto = localCrypto; this.localCrypto.ImportKey(localKey); LocalKey = localKey; }
static UdpConnectionProviderTests() { var crypto = new RSACrypto(); serverKey = crypto.ExportKey (true); crypto = new RSACrypto(); localKey = crypto.ExportKey (true); }
protected override IClientConnection SetupClientConnection(out RSAAsymmetricKey k) { var c = new NetworkClientConnection(p); k = (RSAAsymmetricKey)c.LocalKey; return(c); }
public GablarskiClient(RSAAsymmetricKey key) { if (key == null) { throw new ArgumentNullException("key"); } Setup(new UdpClientConnection(GablarskiProtocol.Instance, key), null, null, null, null); }
static UdpConnectionProviderTests() { var crypto = new RSACrypto(); serverKey = crypto.ExportKey(true); crypto = new RSACrypto(); localKey = crypto.ExportKey(true); }
public NetworkClientConnection(IEnumerable<Protocol> protocols, RSAAsymmetricKey authKey) : base(protocols, authKey, false) { if (NetworkConnection.AutoSizeSendBufferLimit) Interlocked.Add (ref sendBufferLimit, AutoSizeFactor); if (authKey == null) throw new ArgumentNullException ("authKey"); }
protected IClientConnection GetNewClientConnection(out RSAAsymmetricKey key) { var c = SetupClientConnection(out key); lock (this.connections) this.connections.Add(c); return(c); }
public UdpClientConnection (IEnumerable<Protocol> protocols, RSAAsymmetricKey key) : base (protocols, new RSACrypto(), new RSACrypto(), key) { if (protocols == null) throw new ArgumentNullException ("protocols"); if (key == null) throw new ArgumentNullException ("key"); this.serializer = new ClientMessageSerializer (this, protocols); }
public GablarskiSocialClient(Person person, RSAAsymmetricKey key) : base(new NetworkClientConnection(new [] { SocialProtocol.Instance, GablarskiProtocol.Instance }, key), person) { if (key == null) { throw new ArgumentNullException("key"); } this.RegisterMessageHandler <JoinVoiceMessage> (OnJoinVoiceMessage); InvitedToGroup += (sender, args) => args.AcceptInvite = true; }
public NetworkClientConnection(IEnumerable <Protocol> protocols, RSAAsymmetricKey authKey) : base(protocols, authKey, false) { if (NetworkConnection.AutoSizeSendBufferLimit) { Interlocked.Add(ref sendBufferLimit, AutoSizeFactor); } if (authKey == null) { throw new ArgumentNullException("authKey"); } }
protected override void Recycle() { if (AutoSizeSendBufferLimit) { Interlocked.Add(ref sendBufferLimit, AutoSizeFactor * -1); } this.serverEncryption = null; this.serverEncryptionKey = null; this.serverAuthenticationKey = null; base.Recycle(); }
internal UdpServerConnection (int connectionId, EndPoint remoteEndpoint, UdpConnectionProvider provider, RSACrypto remoteCrypto, RSACrypto localCrypto, RSAAsymmetricKey key) : base (provider.protocols.Values) { this.remoteCrypto = remoteCrypto; this.localCrypto = localCrypto; LocalKey = key; ConnectionId = connectionId; IPEndPoint = (IPEndPoint)remoteEndpoint; RemoteTarget = remoteEndpoint.ToTarget(); this.provider = provider; this.socket = this.provider.GetSocket (remoteEndpoint); }
public UdpClientConnection(IEnumerable <Protocol> protocols, RSAAsymmetricKey key) : base(protocols, new RSACrypto(), new RSACrypto(), key) { if (protocols == null) { throw new ArgumentNullException("protocols"); } if (key == null) { throw new ArgumentNullException("key"); } this.serializer = new ClientMessageSerializer(this, protocols); }
internal UdpServerConnection(int connectionId, EndPoint remoteEndpoint, UdpConnectionProvider provider, RSACrypto remoteCrypto, RSACrypto localCrypto, RSAAsymmetricKey key) : base(provider.protocols.Values) { this.remoteCrypto = remoteCrypto; this.localCrypto = localCrypto; LocalKey = key; ConnectionId = connectionId; IPEndPoint = (IPEndPoint)remoteEndpoint; RemoteTarget = remoteEndpoint.ToTarget(); this.provider = provider; this.socket = this.provider.GetSocket (remoteEndpoint); }
static async Task SetupAsync() { var app = (AppDelegate)UIApplication.SharedApplication.Delegate; RSAAsymmetricKey key = await app.key.ConfigureAwait(false); string id = key.PublicSignature.Aggregate(String.Empty, (s, b) => s + b.ToString("X2")); var person = new Person(id) { Nickname = Settings.Nickname, Avatar = Settings.Avatar, Status = Status.Online }; SocialClient = new GablarskiSocialClient(person, key); SocialClient.SetTarget(new Target("192.168.1.6", SocialProtocol.DefaultPort)); }
public void ImportPrivateCspBlob() { var crypto = new RSACryptoServiceProvider(); RSAParameters p = crypto.ExportParameters(true); byte[] csp = crypto.ExportCspBlob(true); var key = new RSAAsymmetricKey(csp); AssertArrayMatches(p.D, key.D); AssertArrayMatches(p.DP, key.DP); AssertArrayMatches(p.DQ, key.DQ); AssertArrayMatches(p.Exponent, key.Exponent); AssertArrayMatches(p.InverseQ, key.InverseQ); AssertArrayMatches(p.Modulus, key.Modulus); AssertArrayMatches(p.P, key.P); AssertArrayMatches(p.Q, key.Q); Assert.IsNotNull(key.PublicSignature); }
public UdpConnectionProvider(int port, Protocol protocol, RSAAsymmetricKey authKey) : base(new[] { protocol }, port) { if (protocol == null) throw new ArgumentNullException ("protocol"); if (authKey == null) throw new ArgumentNullException ("authKey"); if (port <= 0) throw new ArgumentOutOfRangeException ("port"); this.crypto = new RSACrypto(); this.crypto.ImportKey (authKey); this.pkEncryption = new RSACrypto(); this.pkEncryption.ImportKey (authKey); this.authKey = authKey; ValidateProtocols (this.protocols.Values); }
public static async Task <QueryResults> QueryAsync(RSAAsymmetricKey key, Target target, TimeSpan timeout) { if (key == null) { throw new ArgumentNullException("key"); } if (target == null) { throw new ArgumentNullException("target"); } var tcs = new TaskCompletionSource <QueryResults>(); var connection = new UdpClientConnection(GablarskiProtocol.Instance, key); connection.Start(MessageTypes.Unreliable); var cancelSources = new CancellationTokenSource(timeout); cancelSources.Token.Register(() => { tcs.TrySetCanceled(); connection.Dispose(); }); connection.ConnectionlessMessageReceived += (sender, args) => { var results = args.Message as QueryServerResultMessage; if (results == null) { return; } tcs.TrySetResult(new QueryResults(results.ServerInfo, results.Channels, results.Users)); connection.Dispose(); }; await connection.SendConnectionlessMessageAsync(new QueryServerMessage(), target).ConfigureAwait(false); return(await tcs.Task.ConfigureAwait(false)); }
protected override bool VerifyMessage(string hashAlg, Message message, byte[] signature, byte[] data, int moffset, int length) { if (HMAC == null) { var msg = (FinalConnectMessage)message; byte[] resized = new byte[length]; Buffer.BlockCopy(data, moffset, resized, 0, length); RSAAsymmetricKey key = (RSAAsymmetricKey)Activator.CreateInstance(msg.PublicAuthenticationKeyType); key.Deserialize(new BufferValueReader(msg.PublicAuthenticationKey), this.connection.Encryption); this.connection.RemoteKey = key; this.connection.RemoteCrypto.ImportKey(key); return(this.connection.RemoteCrypto.VerifySignedHash(hashAlg, resized, signature)); } else { return(base.VerifyMessage(hashAlg, message, signature, data, moffset, length)); } }
public UdpConnectionProvider(int port, IEnumerable <Protocol> protocols, RSAAsymmetricKey authKey) : base(protocols, port) { if (protocols == null) { throw new ArgumentNullException("protocols"); } if (authKey == null) { throw new ArgumentNullException("authKey"); } if (port <= 0) { throw new ArgumentOutOfRangeException("port"); } this.crypto = new RSACrypto(); this.crypto.ImportKey(authKey); this.authKey = authKey; ValidateProtocols(this.protocols.Values); }
private static RSAAsymmetricKey GetKey(string keypath) { if (!File.Exists(keypath)) { var rsa = new RSACrypto(); RSAParameters parameters = rsa.ExportKey(true); using (var stream = File.OpenWrite(keypath)) { var writer = new StreamValueWriter(stream); RSAParametersSerializer.Serialize(writer, parameters); } } RSAAsymmetricKey key; using (var stream = File.OpenRead(keypath)) { var reader = new StreamValueReader(stream); RSAParameters parameters = RSAParametersSerializer.Deserialize(reader); key = new RSAAsymmetricKey(parameters); } return(key); }
public static Task <RSAAsymmetricKey> GetCryptoKeyAsync(CancellationToken cancelToken = default(CancellationToken)) { return(Task.Run(() => { RSAAsymmetricKey key = null; if (KeyFile.Exists) { try { using (var stream = File.OpenRead(KeyFile.FullName)) { var reader = new StreamValueReader(stream); RSAParameters parameters = RSAParametersSerializer.Deserialize(reader); key = new RSAAsymmetricKey(parameters); } } catch (Exception ex) { Trace.TraceWarning("Failed to read key: {0}", ex); KeyFile.Delete(); } } cancelToken.ThrowIfCancellationRequested(); if (!KeyFile.Exists) { var rsa = new RSACrypto(); RSAParameters parameters = rsa.ExportKey(true); key = new RSAAsymmetricKey(parameters); cancelToken.ThrowIfCancellationRequested(); using (var stream = File.OpenWrite(KeyFile.FullName)) { var writer = new StreamValueWriter(stream); RSAParametersSerializer.Serialize(writer, parameters); } } return key; }, cancelToken)); }
protected override IClientConnection SetupClientConnection(out RSAAsymmetricKey k) { var c = new NetworkClientConnection (p); k = (RSAAsymmetricKey) c.LocalKey; return c; }
protected override void Recycle() { if (AutoSizeSendBufferLimit) Interlocked.Add (ref sendBufferLimit, AutoSizeFactor * -1); this.serverEncryption = null; this.serverEncryptionKey = null; this.serverAuthenticationKey = null; base.Recycle(); }
public NetworkConnectionProvider(IEnumerable<Protocol> protocols, Target target, int maxConnections, RSAAsymmetricKey authKey, IEnumerable<string> enabledHashAlgorithms = null) : this(protocols, target, maxConnections, enabledHashAlgorithms) { if (authKey == null) throw new ArgumentNullException ("authKey"); this.authenticationKey = authKey; }
protected override IClientConnection SetupClientConnection(out RSAAsymmetricKey key) { key = localKey; return SetupClientConnection(); }
protected override void OnTempestMessageReceived(MessageEventArgs e) { switch (e.Message.MessageType) { case (ushort)TempestMessageType.Ping: var ping = (PingMessage)e.Message; if (PingFrequency == 0 || this.activityTimer == null) { if (this.activityTimer != null) this.activityTimer.Dispose(); if (ping.Interval != 0) { this.activityTimer = new Tempest.Timer (100); this.activityTimer.TimesUp += OnActivityTimer; this.activityTimer.Start(); } } else if (ping.Interval != PingFrequency) this.activityTimer.Interval = ping.Interval; base.OnTempestMessageReceived (e); break; case (ushort)TempestMessageType.AcknowledgeConnect: var msg = (AcknowledgeConnectMessage)e.Message; this.protocols = this.protocols.Values.Intersect (msg.EnabledProtocols).ToDictionary (pr => pr.id); ConnectionId = msg.ConnectionId; this.serverEncryption = new RSACrypto(); this.serverEncryption.ImportKey (msg.PublicEncryptionKey); this.serverEncryptionKey = msg.PublicEncryptionKey; var encryption = new AesManaged { KeySize = 256 }; encryption.GenerateKey(); BufferValueWriter authKeyWriter = new BufferValueWriter (new byte[1600]); this.publicAuthenticationKey.Serialize (authKeyWriter, this.serverEncryption); this.serializer.AES = encryption; this.serializer.HMAC = new HMACSHA256 (encryption.Key); SendAsync (new FinalConnectMessage { AESKey = this.serverEncryption.Encrypt (encryption.Key), PublicAuthenticationKeyType = this.publicAuthenticationKey.GetType(), PublicAuthenticationKey = authKeyWriter.ToArray() }); break; case (ushort)TempestMessageType.Connected: var connected = (ConnectedMessage) e.Message; ConnectionId = connected.ConnectionId; OnConnected (new ClientConnectionEventArgs (this)); var tcs = Interlocked.Exchange (ref this.connectCompletion, null); if (tcs != null) tcs.TrySetResult (new ClientConnectionResult (ConnectionResult.Success, this.serverAuthenticationKey)); break; default: base.OnTempestMessageReceived(e); break; } }
public static Task StartAsync(RSAAsymmetricKey key) { return(Task.Factory.StartNew(Start, key, TaskCreationOptions.HideScheduler)); }
protected override void OnTempestMessageReceived(MessageEventArgs e) { switch (e.Message.MessageType) { case (ushort)TempestMessageType.Ping: var ping = (PingMessage)e.Message; if (PingFrequency == 0 || this.activityTimer == null) { if (this.activityTimer != null) { this.activityTimer.Dispose(); } if (ping.Interval != 0) { this.activityTimer = new Tempest.Timer(100); this.activityTimer.TimesUp += OnActivityTimer; this.activityTimer.Start(); } } else if (ping.Interval != PingFrequency) { this.activityTimer.Interval = ping.Interval; } base.OnTempestMessageReceived(e); break; case (ushort)TempestMessageType.AcknowledgeConnect: var msg = (AcknowledgeConnectMessage)e.Message; this.protocols = this.protocols.Values.Intersect(msg.EnabledProtocols).ToDictionary(pr => pr.id); ConnectionId = msg.ConnectionId; this.serverEncryption = new RSACrypto(); this.serverEncryption.ImportKey((RSAAsymmetricKey)msg.PublicEncryptionKey); this.serverEncryptionKey = (RSAAsymmetricKey)msg.PublicEncryptionKey; var encryption = new AesManaged { KeySize = 256 }; encryption.GenerateKey(); BufferValueWriter authKeyWriter = new BufferValueWriter(new byte[1600]); this.publicAuthenticationKey.Serialize(this.serializer.SerializationContext, authKeyWriter, this.serverEncryption); this.serializer.AES = encryption; this.serializer.HMAC = new HMACSHA256(encryption.Key); SendAsync(new FinalConnectMessage { AESKey = this.serverEncryption.Encrypt(encryption.Key), PublicAuthenticationKeyType = this.publicAuthenticationKey.GetType(), PublicAuthenticationKey = authKeyWriter.ToArray() }); break; case (ushort)TempestMessageType.Connected: var connected = (ConnectedMessage)e.Message; ConnectionId = connected.ConnectionId; OnConnected(new ClientConnectionEventArgs(this)); var tcs = Interlocked.Exchange(ref this.connectCompletion, null); if (tcs != null) { tcs.SetResult(new ClientConnectionResult(ConnectionResult.Success, this.serverAuthenticationKey)); } break; default: base.OnTempestMessageReceived(e); break; } }
public UdpClientConnection (Protocol protocol, RSAAsymmetricKey key) : this (new[] { protocol }, key) { if (protocol == null) throw new ArgumentNullException ("protocol"); }
protected override IClientConnection SetupClientConnection(out RSAAsymmetricKey key) { key = localKey; return(SetupClientConnection()); }
static NetworkProviderTests() { var rsa = new RSACrypto(); key = rsa.ExportKey (true); }
public UdpConnectionProvider(int port, IEnumerable<Protocol> protocols, RSAAsymmetricKey authKey) : base(protocols, port) { if (protocols == null) throw new ArgumentNullException ("protocols"); if (authKey == null) throw new ArgumentNullException ("authKey"); if (port <= 0) throw new ArgumentOutOfRangeException ("port"); this.crypto = new RSACrypto(); this.crypto.ImportKey (authKey); this.authKey = authKey; ValidateProtocols (this.protocols.Values); }
public static void Main() { Trace.Listeners.Add(new ConsoleTraceListener()); log4net.Config.XmlConfigurator.Configure(); var serverConfig = (BarrelConfiguration)ConfigurationManager.GetSection("barrel"); if (serverConfig == null) { LogManager.GetLogger("Barrel").Fatal("Section 'barrel' not found in configuration."); return; } var log = LogManager.GetLogger(serverConfig.Name.Remove(" ")); log.Info("Checking configuration"); if (!serverConfig.CheckConfiguration(log)) { log.Fatal("Errors found in configuration, shutting down."); return; } ServerProviders providers = serverConfig.GetProviders(log); if (providers == null) { log.Fatal("Errors loading server configuration, shutting down."); return; } log.Info("Setting up"); GablarskiServer server = new GablarskiServer(new ServerSettings { Name = serverConfig.Name, Description = serverConfig.Description, ServerPassword = serverConfig.Password, ServerLogo = serverConfig.LogoURL }, providers.Users, providers.Permissions, providers.Channels); if (serverConfig.Network) { var keyFile = new FileInfo("server.key"); RSAAsymmetricKey key = null; if (keyFile.Exists) { try { using (var stream = File.OpenRead(keyFile.FullName)) { var reader = new StreamValueReader(stream); RSAParameters parameters = RSAParametersSerializer.Deserialize(reader); key = new RSAAsymmetricKey(parameters); } } catch (Exception ex) { Trace.TraceWarning("Failed to read key: {0}", ex); keyFile.Delete(); } } if (!keyFile.Exists) { var rsa = new RSACrypto(); RSAParameters parameters = rsa.ExportKey(true); key = new RSAAsymmetricKey(parameters); using (var stream = File.OpenWrite(keyFile.FullName)) { var writer = new StreamValueWriter(stream); RSAParametersSerializer.Serialize(writer, parameters); } } server.AddConnectionProvider(new UdpConnectionProvider(serverConfig.Port, GablarskiProtocol.Instance, key), ExecutionMode.GlobalOrder); } foreach (IConnectionProvider provider in providers.ConnectionProviders) { server.AddConnectionProvider(provider, ExecutionMode.GlobalOrder); } server.Start(); log.Info("Server started"); while (true) { Console.ReadKey(); } }
/// <summary> /// Initializes a new instance of the <see cref="NetworkConnectionProvider" /> class. /// </summary> /// <param name="target">The target to listen to.</param> /// <param name="maxConnections">Maximum number of connections to allow.</param> /// <param name="protocols">The protocols to accept.</param> /// <param name="enabledHashAlgs"> /// The signature hash algorithms (in order of preference) to enable. /// <c>null</c> or an empty collection will enable all of the signature hash algorithms. /// </param> /// <exception cref="ArgumentNullException"><paramref name="target"/> or <paramref name="protocols" /> is <c>null</c>.</exception> /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxConnections"/> is <= 0</exception> public NetworkConnectionProvider(IEnumerable<Protocol> protocols, Target target, int maxConnections, IEnumerable<string> enabledHashAlgs = null) { if (protocols == null) throw new ArgumentNullException ("protocols"); if (target == null) throw new ArgumentNullException ("target"); if (maxConnections <= 0) throw new ArgumentOutOfRangeException ("maxConnections"); this.protocols = protocols; this.target = target; MaxConnections = maxConnections; this.serverConnections = new List<NetworkServerConnection> (maxConnections); if (protocols.Any (p => p != null && p.RequiresHandshake)) { ThreadPool.QueueUserWorkItem (s => { Task encryptKeyGen = Task.Factory.StartNew (() => { this.pkEncryption = new RSACrypto(); this.publicEncryptionKey = this.pkEncryption.ExportKey (false); }); Task authKeyGen = Task.Factory.StartNew (() => { this.authentication = new RSACrypto(); if (this.authenticationKey == null) this.authenticationKey = this.authentication.ExportKey (true); else this.authentication.ImportKey (this.authenticationKey); this.publicAuthenticationKey = this.authentication.ExportKey (false); if (enabledHashAlgs == null || !enabledHashAlgs.Any()) this.enabledHashAlgorithms.AddRange (this.authentication.SupportedHashAlgs); else // Need to maintain preference order this.enabledHashAlgorithms.AddRange (enabledHashAlgs.Where (a => this.authentication.SupportedHashAlgs.Contains (a))); }); authKeyGen.Wait(); encryptKeyGen.Wait(); this.keyWait.Set(); }); } else this.keyWait.Set(); }
protected virtual IClientConnection SetupClientConnection(out RSAAsymmetricKey key) { key = null; return(SetupClientConnection()); }
public NetworkConnectionProvider(IEnumerable <Protocol> protocols, Target target, int maxConnections, RSAAsymmetricKey authKey, IEnumerable <string> enabledHashAlgorithms = null) : this(protocols, target, maxConnections, enabledHashAlgorithms) { if (authKey == null) { throw new ArgumentNullException("authKey"); } this.authenticationKey = authKey; }
static NetworkProviderTests() { var rsa = new RSACrypto(); key = rsa.ExportKey(true); }